Mobile app development in Salt Lake City is a rapidly growing field due to Utah’s strong background in the technology industry. Nearly 20 years ago, a group of 17 software developers met at Snowbird Resort and signed the Manifesto for Agile Software Development, laying the foundation for a tech boom in the last two decades. 
The stretch of land beside I-15, once largely undeveloped, is now home to many of the thousands of tech and start-up companies in Utah, earning it the nickname “Silicon Slopes.” Various start-ups have emerged from what was once farmland, nurturing technology leaders and developers as well as transforming the landscape to the now highly recognizable sea of buildings that comprises Silicon Slopes.

Software Technology Group’s Beginning

However, before the flood of tech companies, before the Manifesto for Agile Software Development, Jeff Sodeberg and his wife Camille started Software Technology Group (STG) at their kitchen table in 1996. 
STG takes a different approach because while Jeff began his career in software development, he fell in love with the business aspect of the work, even going back to school to earn a Master’s degree in business. His early career experiences inspired him to combine what he enjoyed about software development with a business model that maximized professional development for employees along with talent and skill for clients. Now, nearly 30 years later, STG employs over 200 people and is at the forefront of the technology scene and mobile app development in Utah.

How STG Leads Mobile App Development in Salt Lake City

STG’s edge all comes back to our unique model: The company matches clients with app developers to complete projects. Depending on the need of the client, developers may work with the client’s pre-existing team to bring in new ideas and provide support or a team of STG developers may take full responsibility for the project. No matter the team structure, this approach leads to some of the best mobile app development solutions in Utah.
With STG, any client can count on a deep well of knowledge and creative solutions because the STG team has seen projects across a broad range of industries, technologies, and project types and we bring all of that experience to bear no matter the project. We also prioritize professional growth for our developers between projects to ensure they can always bring their best. When clients choose to work with STG, they gain access to the knowledge and expertise we’ve been building for decades.
With this broad scope of experience gained by working with a diverse range of clients, STG has a unique view into the industry trends, which allows us to steer clients toward technologies that will work for the long-term. We’ve experienced the ups and downs of the field and have seen what works and what doesn’t. Because of this, STG provides powerful perspectives and skilled service delivery, driving mobile app development in Utah that is both functional for the client as well as fresh and interesting for the developers. Our model provides strong benefits to all participants in a project, both the client and the employee.Areas of STG Expertise
Regardless of the scope of the project, STG provides clients and team members the tools to solve problems and provide unique perspectives. With a wide variety of practices, STG offers focused expertise to many areas of mobile app development in Utah: We emphasize full-stack development, which includes front-end, business logic, and database functionality along with developer certifications in Java Spring REST, React (full-stack component), and Angular (full-stack component).STG developers are current with Microsoft technologies, including .Net Core, .Net Framework, Azure, and cloud services. Certifications are offered in Azure Fundamentals, with forthcoming additional certifications in Azure Intermediate and .Net Core.Scripted development is a rapidly changing field, and STG works to lead app development in Utah with a focus on these evolving practices. Certifications offered include React and Angular (full-stack component), with additional certifications in Vue and Express coming soon.STG is passionate about user-centered software. Developers work to make programs profitable, accessible, and effectively designed. Certifications include UX Master, Front End Coding, and Certified PortfolioSTG has an exclusive team dedicated to producing software for iOS and Android applications. Certifications include iOS Level 1, with Android Level 1 coming soon.STG uses both scripted and automated technologies to achieve the quality expected of app development leaders in Utah. Certifications are offered in Python / Webdriver / Unittest, Node / Webdriver / Mocha / Chai, and Java / Webdriver / TestNG at both the associate engineer and solution engineer levels.

Benefits to Clients

STG’s leadership in the Salt Lake City technology space, both in mobile app development and beyond, offers a number of benefits to clients.
Broad Experience & Unique Perspectives
STG clients have the unique opportunity to pull from a pool of developers with broad experience. Because STG works on projects across a wide variety of industries and technologies, developers have a deep well of knowledge to draw from as well as unique and varied perspectives as they seek innovative solutions. The STG model promotes creativity and ingenuity, preventing companies from getting stuck in the rut of doing things the same old way and keeping clients ahead of technology trends.The Best Developers
Within the technology space it’s all too easy for developers to get comfortable doing things the way they’ve always been done. STG makes sure to shake it up with ongoing professional development for team members to ensure clients always get cutting-edge expertise from STG. Between projects, STG employees spend time in the Development Center, learning new technologies, practicing new skills, and applying new thought processes. This is an STG priority because the more experience a developer has, the more perspective and talent they bring to solving clients’ unique issues.Varied Teams & Consistent Resources 
Teams can be built or supplemented depending on clients’ needs. STG offers developers along with project managers, business analysts, quality assurance providers, and user experience professionals. Whether clients need only one or two team members to supplement their own teams or whether they need to build a team from the ground up, STG can assign people with the skill set that exactly matches the need. And if a client is particularly impressed by a developer, they’re welcome to request a certain team member on future projects! STG employees are always learning and growing, and each additional project adds another layer to their expertise, resulting in multi-faceted, qualified professionals to help clients succeed no matter the project.
Broad experience, a focus on professional development, and consistency due to employee retention all make STG an attractive choice for any Utah company’s app development needs.
If you’re interested in having STG help you on a project, schedule a meeting to discuss your needs. After we’re clear on exactly what you’re looking for, you’ll be paired with the team that will be the best fit for your project—along with the assurance that you’re working with the top talent in the field. Interested? Contact STG for additional information.

Benefits to Job-Seekers

In addition to being a leader in mobile app development for clients, STG also appeals to those looking to build their careers—as attested by our long-term employees who stick with us year after year in an industry notorious for short employee tenure. Here’s why:
Project Variety with Job Stability
All too often developers get stuck in a rut of doing the same thing over and over again, day in and day out. In all honesty, it’s a large driver of the frequent job hopping we see in the tech space—which means that if professionals can enjoy project variety without requiring a job change, you’re approaching the holy grail of tech jobs. STG offers just that with the opportunity to work on projects across industries and companies, giving employees the experience needed to become leaders in app development in Utah and beyond. And professional opportunities don’t end at work experience. The time spent in the Development Center makes it easy for developers to stay relevant, grow their expertise, and avoid getting pigeonholed in a particular niche. Professional Development
STG provides our software developers with unique opportunities for professional development, going above and beyond standard work experience. Typical projects last about 12-18 months, and there is often a little bit of time in between wrapping up a project and starting a new one. We’ve solved this problem by shifting our developers to the Development Center when a project ends. The Development Center provides the opportunity to focus on building skills that support the employees’ passions and career goals, as well as the chance to apply these new skills through pro-bono work for non-profit organizations such as The Road Home, an organization helping individuals and families experiencing homelessness in the greater Salt Lake area, and Best Friends Animal Society, a no-kill animal rescue. The combination of practicing new skills and serving charitable causes in the Development Center empowers STG developers to reach pinnacle levels of expertise, which in turn benefits clients. Mentorship Opportunities
All STG employees are vetted through a thorough hiring process, including a screening interview over the phone, face-to-face interview, technical proficiency test, and reference checks. As a company that prides itself on a long history of meeting Salt Lake City’s app development needs, STG is committed to hiring only the best—individuals who are passionate about software, committed to their own professional development, and creative in finding solutions. STG takes that one level further by providing mentorship opportunities for newer developers to ensure the very best results for everyone involved. In this program, veteran employees and career guides help direct new employees down the path that will lead to the fulfillment of their career goals. This shared knowledge escalates the talent each developer brings to the table, helping build their confidence and capability. The engagement and fulfillment on the part of the employees leads to client satisfaction—two primary goals of the company that work hand-in-hand. Are you looking to be a leader in mobile app development in Utah? Contact STG for more information about careers.A History of Leadership
STG’s decades of experience in Salt Lake City’s technology industry makes them a clear leader of mobile app development in Utah. Clients are satisfied with their experienced developers and innovative results, while employees are consistently gaining new skills and broadening their expertise—all clear signs that STG will continue to contribute to mobile app development in Utah as a major player in the industry.

Delegation on iOS

This tutorial is a simple basic idea to show the concept of delegation on iOS, using Objective-C.
Delegation is usually not something a beginner would use, so this tutorial would be targeting intermediate users, which also means it assumes you know your way around Xcode and Objective-c at a reasonable level.
Final result – So here’s what the final app looks like: 

The app has 2 views, first view and second view. The first view has a label and a button, and the second view has a textField and a button. When you push the button on the second view, the text inside the textField gets placed in the label of the first view.
Pretty simple, but its a great demo of how delegation works.
Let’ start by setting up the UI.
Setting up the UI

  • Create a new single view project in Xcode using storyboards, objective-c and for iPhone.
  • Delete the default ViewController class (so “ViewController.h” and “ViewController.m”).
  • In the storyboard, make the single ViewController you have be embedded in a navigation controller. Add a second ViewController on your storyboard. Your storyboard should now have 3 elements: 1 NavigationController and 2 ViewControllers. Also, the first ViewController should be linked to the navigationController.
  • In the first ViewController add 2 labels and 1 button.
  • In the second ViewController add 1 label, 1 textField and 1 button.
  • I changed the color in the background of each ViewController to make it more obvious in this demo.
  • Create a new push segue between the first view controller and the second view controller (not the buttons but the controllers themselves) and name it “segueSecondView”.
  • At this point your UI should look something like this:

Create the classes for the ViewControllers

Create 2 new classes: FirstViewController and SecondViewController, both being a subclass of UIViewController. In your storyboard, make your first view controller be of custom class FirstViewController and your second view controller be of custom class SecondViewController.
Link the IBActions and IBOutlets from the UI to the classes as normal.
Create the protocol
After all the initial setup has been done, its time to start with the actual delegation.
In the SecondViewController.h, we need to do 2 things:

    • Declare a protocol
  • Create a variable of the newly created protocol

Here’s what the code looks like. I will explain it below:

//  SecondViewController.h
//  Test_Delegate
//  Created by Eduardo Flores on 3/20/15.
//  Copyright (c) 2015 Eduardo Flores. All rights reserved.
#import <UIKit/UIKit.h>
// declare the delegate
@protocol SecondViewDelegate
(void) textFromSecondView🙁NSString *)text;
@end // end protocol
// Declare the created delegate into our class
@interface SecondViewController : UIViewController
// Original declaration in our header
@property (nonatomic, weak) id<SecondViewDelegate>  delegate;
@property (weak, nonatomic) IBOutlet UITextField *textField_enterSomeText;
@end //end interface

The code above has 2 main sections: the protocol and the interface.

The protocol declares methods that whoever will use this protocol will have to implement. This is pretty much like interfaces in Java. Just declare what the “delegate” has to do, but don’t implement it.
The name of the protocol usually, by convention, uses the word “Delegate” and it usually has the name of the class where it is declared.

The interface should look very common to you, with the exception of this line
@property (nonatomic, weak) id<SecondViewDelegate> delegate;
In here we’re just declaring a varilable to the protocol created above so we can refer to it from another class.

Passing the data back using the new delegate
What we want to happen is to take the text that’s inside the textfield and pass it back to the FirstViewController, and this will happen when we push the button we created in the SecondViewController. After we pass the data back to the FirstViewController, we’re going to pop the view to return the UI to the FirstViewController.

So with that idea, code for the button in the SecondViewController.m looks like this:

   // Send the data to whatever class implements the delegate
   [self.delegate textFromSecondView:textField_enterSomeText.text];
   // pop the view controller
   [[self navigationController]popViewControllerAnimated:YES];

So that’s all we have to do to declare a delegate in out SecondViewController, and to send data back to whoever or whatever class decides to declare itself as a delegate for the SecondViewDelegate.
At this point we’re done with SecondViewController.h and SecondViewController.m 
Implementing the delegate
Now that we have a class declaring it has a delegate, it is time to have another class declaring itself as delegate of the SecondViewDelegate.

In the FirstViewController.h we need to import the SecondViewController.h and say our class implements the SecondViewDelegate.
Here’s what the FirstViewController.h looks like:

//  FIrstViewController.h
//  Test_Delegate
//  Created by Eduardo Flores on 3/20/15.
//  Copyright (c) 2015 Eduardo Flores. All rights reserved.
#import “SecondViewController.h”
@interface FIrstViewController : UIViewController <SecondViewDelegate>
@property (weak, nonatomic) IBOutlet UILabel *label_receivedText;

Now we have declared the FirstViewController class is a delegate of SecondViewDelegate, so what’s the logic in FirstViewController?

    1. We need to push our view from FirstViewController to SecondViewController 
    1. We need to get a reference to the SecondViewController
    1. We have to get a reference then to the “delegate” variable in the SecondViewController
    1. Since we’re a delegate of SecondViewDelegate, we need to implement all of the methods in SecondViewDelegate. This means we have to implement the “- (void)textFromSecondView: (NSString *)text” method
  1. And finally, we need to set the text in the label of the FirstViewController with whatever text is “coming” from the SecondViewDelegate. This won’t be visible or applied until we see the FirstViewController the second time, after we return from SecondViewController

Step 1.
We’re going to push to the SecondViewController when we push the 1 button in our FirstViewController, so the implementation of the button would look like this:

   [self performSegueWithIdentifier:@“segueSecondView” sender:nil];

Steps 2 and 3.
Since we’re using storyboard we can take advantage of the “prepareForSegue” method. In here we get a reference to the SecondViewController and we declare the FirstViewController as the delegate of the SecondViewDelegate. This is what it looks like:

(void)prepareForSegue🙁UIStoryboardSegue *)segue sender🙁id)sender
   SecondViewController *svc = (SecondViewController *)[segue destinationViewController];
   svc.delegate = self;

Steps 4 and 5.
Since we’re now the delegate of SecondViewDelegate we need to implement the “- (void)textFromSecondView:(NSString *)text”method, and in here we’re going to set our label from the FirstViewController with the String coming from the delegate.
So it looks like this:

(void)textFromSecondView🙁NSString *)text
   label_receivedText.text = text;

So there you have it. The SecondViewController now takes some text and sends it to the FirstViewController through the SecondViewDelegate.

The complete source code of this demo can be found on github, right here.

In-App purchases on iOS

The purpose of this tutorial is to teach how to create an extremely simple and basic iOS application, but enabling it to purchase non-consumable items from iTunes using Apple’s in-app purchase system.
I have found a large number of tutorials online about this subject, but most of them use large or existing applications to show this subject, making it harder to understand.
This app is targeted for intermediate level programmers, but it is written in a way that even a beginner programmer can do it. 

What you need for this tutorial

    • A mac with Xcode
    • A physical iOS device (iPhone/iPad/iPod Touch)
    • A paid iOS developer account on You should also have access to create new apps, products and sandbox users in iTunesConnect (this is enabled by default with paid iOS developer accounts)
  • Basic understanding of Objective-C

The final result
Let’s begin by showing you what the app is going to do. Remember, this is a dummy app and the Level 2 doesn’t do anything. I will also be using an iPad for this demo, but will work on all iOS devices.

    • The app has a single view with 2 buttons and 1 label. The single label shows which items you have already purchased:
    • When you click on the “Buy level 2” item you will be prompt to login (with your sandbox account), and you will be asked to confirm your purchase:
    • The app will then display a “Thank you for your purchase” type of message, and the second button (“Go to level 2”) will be enabled:

That’s all. Super simple but it works to illustrate the point of in-app purchases.
So, let’s get started.
Setup iTunesConnect
Before start writing a single line of code, or even open Xcode, we will setup iTunesConnect first for our application. This tutorial was created on March 2015, so iTunesConnect might look different for whenever you read this. The concept should remain the same.

    • Go to “Users and Roles”
  • Then go to “Sandbox Testers” and create a new account

Note: creating the sandbox tester account turned out to be a lot more difficult than what it should be. iTunesConnect doesn’t seem to like to use your own email address or any email address that has already been used on iTunesConnect. My best luck was to use a new email address that was not associated or used to log into iCloud, so when the “confirm email address” came, I just logged into the iCloud page with the password created for the Sandbox tester.

After the sandbox tester is created and the account has been verified, you need to log into your physical iOS device with this sandbox login you created. You need to do this in the “Settings -> iTunes & App Store” section of the iOS device.
Start creating the app on Xcode
While we still need to create the app and in-app purchase items in iTunesConnect, begin the creation of the app on Xcode, and running it on a device, helps to get the bundle id setup automatically on iTunesConnect.

    • Start Xcode
  • Create a new single view project

What really matters here in this view is the “bundle identifier.” You can modify it later if you want to, but for this demo we will just use something generic that should be available.

Note: iTunesConnect does not like dashes, so avoid them if you can.

Save the app and you will now have a “clean” (only boiler plate code) new project.
We will leave this code “as-is” for now, and we will continue setting up things on iTunesConnect and the iOS developer portal with the information we used on Xcode for our application.
Create the Bundle ID
The first thing we need to do for our application to  be added in iTunesConnect is create the application’s bundle id in the developer portal. So:

    • To the “Certificates, Identifiers & Profiles” section on the right
  • Under iOS, select “Identifiers”

At this point, you should be looking at something like this:

On the top right corner, click on the “+” button to create a new iOS app ID.
The name is what iTunesConnect will display, and the App ID Prefix is what Apple assigned for your Team ID. What really matters here is what you enter for App ID Suffix.
You could select a wildcard option, but in my experience that makes things get messy once you have multiple apps.

Select “Explicit App ID” and enter the bundle ID, created in Xcode as bundle identifier, exactly the same way it was entered in Xcode.

Scroll down and make sure In-App purchase is selected (it is by default at this time), and click on Continue. Review the information and click on Submit.
Create the App in iTunesConnect
With the bundle ID created, we are done with the developer portal (so you can close it) and we will be going back to iTunesConnect.

    • Go to “My Apps”
  • Click on the “+” sign on the top left, and create a new iOS app

In the next window, we will enter the name of the app, a language, the new Bundle ID we just created, the version of the app and a fake SKU. For real applications you might want to get a better SKU.

Note: iTunesConnect will treat this as a real app that you intend to release on the App Store. Because of this iTunesConnect will actually check to see if the bundle id is valid and if the name has been taken. If the name has been already taken, just change the name of the app to something else.

Since we’re not going to submit this app to the App Store, we won’t worry about screenshots, description, keyword or anything like that.
Setup your In-App products
Still not a single line of code!
In iTunesConnect, under your app go to “In-App purchases” and “Create a new” in-app purchase (note how I had to change the name of my app since DemoInApp was already taken)


Word on the street is that “Non-Consumable” is the most popular type of in-app purchase, since that’s what the cool kids use, we will use it as well.

Once we select the Non-Consumable type, we need to enter some information for our in-app product.

    • Reference name: Something internal that only you will see. Could be anything
    • Product ID: this is how we will refer to our in-app product from our code. Make it something relevant to your app, like adding the bundle prefix and the reference name
  • Price Tier: Could be anything, but selected Free since this is just a demo
    • Language: You are required to enter at least 1 language.
    • Display name and description: These will be a localized name and description of your in-app product and it will be visible to the end-user so make something appropriate.
  • Hosting with Apple: No. We’re not uploading content to apple at this time as the purpose of this simple demo is to enable things that already exist within the app but are hidden or disabled.

Save your in-app purchase product, and you should have something like this:

We are now finally and officially done with iTunesConnect, although we will need the “Product ID” to be called from our code.
Let’s move to Xcode now!
Create the UI for the application
The UI will be super simple. 2 buttons and 1 label. Organize them anywhere you want.

    • Button_buyLevel2: This button is what triggers the purchase of the in-app purchase. This button is visible and enabled
    • Button_goToLevel2: This button uses the in-app purchase. In practice this button will open a new window or access the new material the user just purchased. This button is hidden and disabled until the level 2 gets purchased.
  • Label_status: This is just a status line to tell you if the level 2 has been purchased

Notice how the Button_goToLevel2 is declared as both an IBAction and an IBOutlet. The reason for this is because we want to reference the Button_goToLevel2 and be able to hide it and disable it at runtime.

With the UI done, it’s time to setup the library we will use, and the code we will write.
Add StoreKit to the application
The application will use an Apple provided library called StoreKit to handle all in-app related transactions. You can add the StoreKit as part of the Capabilities of the app, or manually.
I will add it manually.

    • Select your application project in the Navigator
    • Go to “Build Phases”
    • Expand “Link Binary with Libraries”
    • Click the “+” to add a library
  • Select “StoreKit.framework” and add it

Congratulations. You just added StoreKit to your application.
Now it’s time to finally write some code!
Write the code for in-app purchases
When we created the project in Xcode, Xcode generated several files for us. We’re only going to work with 2 files. ViewController.h and ViewController.m.

In the header file (ViewController.h) we need to:

    • Import the StoreKit framework we just linked
    • Declare that our code will implement the SKPaymentTransactionObserver and the SKProductRequestDelegate delegates
    • Create a variable for the SKPaymentQueue
  • Create a variable for the SKProduct we will purchase

After this, your ViewController.h file should look like this:

//  ViewController.h
//  DemoInApp
//  Created by Eduardo Flores on 3/19/15.
//  Copyright (c) 2015 Eduardo Flores. All rights reserved.
@interface ViewController : UIViewController <SKPaymentTransactionObserver, SKProductsRequestDelegate>
   SKPaymentQueue *defaultQueue;
   SKProduct *product;
@property (weak, nonatomic) IBOutlet UILabel *Label_status;
@property (weak, nonatomic) IBOutlet UIButton *Button_goToLevel2;

We’re done with our header file. We will now work on our implementation file (ViewController.m)
The first thing I always like to do is synthesize the IBOutlets I have. This is no longer necessary, but I still prefer this method over the self.variable option. 

In viewDidLoad, we will:

    • Initialize the SKPaymentQueue variable
    • Make the notify the defaultQueue that we will be the observer for transactions
    • Disable and hide the “Go to level 2” button since it hasn’t been purchased yet 
  • Call our method “getProductInfo” which will be created in a minute.

Our viewDidLoad looks like this now:

    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    defaultQueue = [SKPaymentQueue defaultQueue];
    [defaultQueue addTransactionObserver:self];
    Button_goToLevel2.enabled = NO;
    Button_goToLevel2.hidden = YES;
    [self getProductInfo];

We will then create our “getProductInfo” method.
This method first checks if the application’s SKPaymentQueue is able to make payments. If it is, it creates a product ID with an NSSet of 1 single object using the Product ID we created in iTunesConnect for the in-app purchase product.
After that it creates a request, makes the delegate of the request look at this class for callbacks, and starts the request.
Our getInfoProduct method would then look like this:

(void) getProductInfo
   if ([SKPaymentQueue canMakePayments])
       // This object comes from iTunesConnect
       // This is the in-app purchase item created
       NSSet *productID = [NSSet setWithObject:@“com.eduardoflores.level2”];   // From iTunesConnect in-app product
       SKProductsRequest *request = [[SKProductsRequest alloc]initWithProductIdentifiers:productID];
       request.delegate = self;
       [request start];

Since we’re the delegate for the StoreKit transactionObserver and productRequest, we need to implement 2 methods to get the information from the StoreKit.
These methods are “paymentQueue:updatedTransactions” and “productsRequest:didReceiveResponse”

Here’s what the “paymentQueue:updatedTransactions” would look like:

(void)paymentQueue🙁SKPaymentQueue *)queue updatedTransactions🙁NSArray *)transactions
   for (SKPaymentTransaction *transaction in transactions)
       switch (transaction.transactionState)
           case SKPaymentTransactionStatePurchased:
               [self openLevel2];
               [defaultQueue finishTransaction:transaction];
           case SKPaymentTransactionStateFailed:
               [defaultQueue finishTransaction:transaction];
           case SKPaymentTransactionStateRestored:
               [defaultQueue restoreCompletedTransactions];

In here the paymentQueue:updatedTransactions we’re looping for a the transactions we’re getting from the paymentQueue. For each transaction we’re doing a switch based on the state of the transaction. If the SKPaymentTransactionState is “Purchased” we will then call a new method (which we will create in a minute) to open or enable the level 2 that has been purchased, and finish the transaction. If the transaction failed, finish the transaction. And finally, if the transaction was restored, let the queue restore the completed transactions.

Now here’s the “productsRequest:didReceiveResponse”:

(void)productsRequest🙁SKProductsRequest *)request didReceiveResponse🙁SKProductsResponse *)response
   NSArray *products = response.products;
   if ([products count] != 0)
       product = [products objectAtIndex:0];
       NSLog(@“product Title = %@”, product.localizedTitle);
       NSLog(@“product Description = %@”, product.localizedDescription);
       Label_status.text = [NSString stringWithFormat:@“%@\n%@”, product.localizedTitle, product.localizedDescription];

This one is super simple, and gets called at startup and gets all of the products that exist in our in-app inventory in iTunesConnect.
The delegate receives an array of responses, which we then call it products for simplicity.
For each product, we get the localized name and localized description which we added manually in iTunesConnect (remember, something appropriate in English only for now). Then we set these elements in the label to display it to the user, and in this case I’m also outputting them to the log just for fun.

There’s one more method mentioned in this tutorial, which is to open the level 2. In my case, all this method does is enable the button to use the level 2 and make it visible, like this:

(void) openLevel2
   NSLog(@“in openLevel2”);
   Button_goToLevel2.enabled = YES;
   Button_goToLevel2.hidden = NO;

Finally, pushing the “buy level 2” button triggers the purchase:
   NSLog(@“in button_buyLevel2” );
   if (product)
       SKPayment *payment = [SKPayment paymentWithProduct:product];
       [defaultQueue addPayment:payment];
       NSLog(@“Can’t handle payment. Product is null”);

I hope this tutorial helps! Below are some resources about about app development:
History of App Development
Mobile Development at Software Technology Group

Lastly, the source code for this project can be found here: Source Code

Author: Ray Hunter

How to get your business up to snuff with the latest technology!

As Pete Townshend said, “Goin’ mobile…Keep me movin…Mobile, mobile, mobile yeah’”. Pete sure was a head of his time with those lyrics.
Let me ask, where do you feel you are at with mobile technology? Is it a technology that keeps you movin’ or is your business lacking mobile traction?
As you think about those two questions, I wanted to outline a few key areas where you can focus to help your business take advantage of the latest mobile technology.
Going Mobile with your business

Know your users and their habits

As I have worked with many different companies to help them with their mobile development strategy, I share this every time we have a discussion. Knowing your users and their habits are key data points that must be reviewed to determine where and how to implement mobile solutions in your business.
Recently, I had a great conversation with a potential client about creating a couple mobile applications for their business. They have had steady growth and heard that going mobile is a must. We sat down over lunch and had a discussion about his current user base and how those users are interacting with his current website. In our discussion, there were only about 3% to 5% users accessing his site with mobile devices and the majority of them were tablets running iOS. From just that simple amount of data, we determined that Android at this time was not a high priority and perhaps even a mobile application at this time is not in huge demand.  My recommendation was to follow what the data is telling about users and their habits. It would be advantages to look at making their website mobile responsive first, before heading down the path to get a mobile application completed.
What is your data saying about your users and their habits?
It is important to have analytical data about your product and/or website and how it is being used. If you do not have this type of data, I recommend gathering this data before moving forward with an mobile implementation. Allow the data to help direct and guide where to implement the latest mobile technology.

Understand Mobile Technologies

It is imperative that we have some understanding of the current mobile technologies that are available. There is so much talk in the industry about different tools and technologies that it becomes overwhelming. Take the time to research key elements in mobile technology and understand the differences between them.
I want to list 4 key elements that I talk about with every client as we discuss how they can go mobile. By understanding the elements, it can help save time and money as you implement your mobile development strategy.
4 key elements in mobile application development:

  • Native Application Development – Native applications are written with the platform specific languages, APIs and development tools. These applications usually use the most recent software development kits (SDKs) and perform the best. Each platform will use its own language and development tools.
  • HTML5 Application Development –  HTML5 applications are written using standard web technologies like HTML5 and Javascript. Responsive design falls under this type of application development. These applications have limitations with regards to utilizing all the capabilities that the device has to offer. For example, it is hard to work with many of the APIs that are available, like access the camera and working with the recording APIs.
  • Hybrid Application Development – allow developers to use HTML5 and Javascript technologies and deploy them on the device with a “native wrapper” around the application. This does allow the device to access some of the native features like the camera and gps location. This allows the developer to write an application with web technologies and have it look and behave similar to a native application.
  • Mobile Application Development Platforms – There are companies that create development platforms that generate mobile applications that might be one of the types above. There are many different platforms and tools that can be used. Here are a couple: Xamarin, Appcelerator (Titanium), Apache Cordova, and Adobe PhoneGap.

Now that we have some understanding about the different mobile application types and mobile development platforms, how might we use this information in helping our business?
So how do we start introducing new mobile technologies and get “going mobile”?

Going Mobile

After analyzing your data you will be able to make the decisions on what type of mobile application and what type of development platform to use. This will also allow you to target the device types that your users are using daily. One thing to mention is that with mobile and its ever changing landscape, it is beneficial to constantly review your data and find out where improvements need to be made. This should be an agile process that allows responsive change to the data on hand. For example, if you decided to go with a hybrid solution and performance is an issue; a new direction might be to introduce a native application and push the boundaries of performance. I worked with a client when this was the case. We had developed a hybrid application and had some serious performance problems with some of the data that was processed on the device. After reviewing performance metrics, analyzing the data and creating a simple prototype, it was clear that a native solution was the key to success.
With all the discussion out there on the different mobile application types, it is imperative to take the time and find the solution that works best for your users and organization.
What might be some of the requirements that you have for your mobile application?
How might the analytics help point you in the right direction with your mobile strategy?
Contact us with mobile development questions you may have. We’d love to hear from you!
Author: Ray Hunter