Category: iOS

February 27th, 2017 by admin

As much as Apple tries to make programming easier, the complexity of programming usually means Apple’s efforts actually wind up making programming harder. In the early days, programming was easy for anyone to master using a simple tool like HyperCard, which helped pave the way for visual interface design tools known as rapid application development (RAD) such as Visual Basic.

When Apple abandoned HyperCard, they offered Xcode in its place, which is a professional tool that novices will likely find way too intimidating. On top of trying to learn Xcode, you also have to learn a programming language such as Objective-C (way too confusing) or Swift, which is much easier to learn.

The huge problem with Swift isn’t the language but working with the cocoa frameworks that form the foundation of macOS, iOS, tvOS, and watchOS. You need to understand object-oriented programming along with protocols, and delegates. If all this sounds confusing, it is.

Perhaps one of the clumsiest solutions for solving problems lies with Core Graphics, Apple’s software framework designed to make animation possible. Learning to animate objects in a program means writing tedious Swift code to do the simplest things. Fortunately, there’s a tool that automates much of this process.

Called Core Animator, this program (ranging in cost up to $100 depending on the sales the company may offer at the moment) lets you visually animate objects using graphic files and timelines. Once you create the animation in Core Animator, you can export it into a Swift or Objective-C class file to add into a macOS or iOS project.

Because Core Animator lets you visually design animation and see it work, you don’t have to fumble with creating animation using mathematical formulas in Swift or Objective-C. Just as in the old days when programmers used to hand code user interfaces by writing commands, so does Core Graphics require you to write exhaustive Swift or Objective-C code to create animation.

RAD development tools let you design user interfaces visually and connect it to code. Core Animator lets you design animation visually and create code to add to an Xcode project.

Once you try Core Animator, you’ll never want to go back to hand-coding animation again in Swift or Objective-C because it’s too painful and tedious. Just watch the video below to see how simple it can be to use Core Animator.

While every project can use animation in its user interface, not everyone needs a program like Core Animator. However, animation can make your program stand out and add a little extra polish to your program and that may be worth the cost of Core Animator all by itself.

Posted in iOS, macOS, Programming

February 18th, 2017 by admin

One of the reasons why artificial intelligence (AI) failed during the early days was because it required humans to program intelligence into a program. That meant exhaustively writing instructions for every possible outcome.

One of the earliest and more limited successes of AI were expert systems that consisted of a series of if-then rules to mimic the thinking process of a human expert. The reason why expert systems worked was because they could tackle a narrow niche with limited and known variables. The reason why expert systems ultimately failed is because they couldn’t advance beyond narrow niches and required humans to exhaustively write if-then rules for every possibility.

Even worse, when conditions changed, human programmers had to go back into the expert system to reprogram it and update it. This constantly meant consulting with a human expert and a human programmer, which made the expert system cumbersome to modify to the point where it wasn’t worth it at all.

That’s all changed with machine learning. The whole idea behind machine learning is to let a program teach and update itself. Not only is this far faster, but it’s far more accurate allowing the program to adapt to changing conditions. If you’re interested in machine learning with Swift, download the open source, Swift AI library.

This Swift AI library lets you create neural networks for both macOS and iOS. By incorporating machine learning in your apps, you can create more adaptive video games or smarter programs that can recognize handwriting or user behavior.

Trying to create machine learning tools on your own in Swift is possible, but clumsy. It’s so much easier to use a tested machine learning framework instead, so that’s why you might want to experiment with Swift AI.

As Swift gains popularity, it’s likely that others will create machine learning frameworks for Swift but until that day comes when we can choose from a variety of machine learning tools, Swift AI offers the best way to experiment with machine learning using Swift.

At the very least, dig through the sample programs in the Swift AI library and give yourself a rudimentary understanding of how machine learning works and how to implement it in Swift.

To download the Swift AI library for adding machine learning to iOS and macOS programs, click here.

 

Posted in Algorithms, iOS, macOS

February 3rd, 2017 by admin

In any programming language, you can choose arbitrary names for your functions and parameters. For example, you could create a completely valid but confusing function like this:

func x239(jke: String) {
    
}

Notice that the function name (x239) and parameter name (jke) provides no clue what they do. Although this code is perfectly valid, it’s confusing so it’s always best to choose descriptive function names and parameter names such as:

func printGreeting(name: String) {
    
}

This function name (printGreeting) and parameter name (name) is much clearer as to the functions purpose, which is to take a name and print a greeting. Of course, this function could actually calculate a differential equation so it’s generally best to choose descriptive function and parameter names that actually describe the purpose of the function.

To call this function, you could use code like this:

func printGreeting(name: String) {
    print ("Hello there, \(name)")
}

printGreeting (name: "Sam")

The function call uses the printGreeting name and identifies the name (“Sam”). This is perfectly fine but in Swift, you have the option to use external parameter names. This means you can have two parameter names, an external and an internal parameter name.

The internal parameter name is what the function actually uses while the external parameter name is what you use to call the function. So to make the function call read more like an actual sentence, you could use an external parameter name like this:

func printGreeting(for name: String) {
    print ("Hello there, \(name)")
}

Notice that the function uses “name” as a variable for the actual code, but when you’re calling the function, you use the external parameter name like this:

printGreeting (for: "Sam")

Now the function call reads like a complete sentence such as “Print greeting for Sam.”

You may not want to do this for your own function declarations and calls, but you’ll find that many Swift API calls use external parameter names specifically to make function calls seem more like a sentence, typically using external parameter names of “in,”, “for”, and “with”.

External parameter names simply help make code more readable although at the expense of also making function declarations more cumbersome to write. You can choose to use external parameter names or not, but whether you use them or ignore them, you’ll at least better understand why so many of Apple’s API functions look the way they do using external parameter names.

Posted in Algorithms, iOS, macOS

December 7th, 2016 by admin

Many people want to create an iOS app. While there are many companies and programs that promise to make this task easy, they all have tradeoffs. Either they cost a lot of money or they’re too limited to create any but the simplest apps.

The free solution is to learn Xcode, which is Apple’s free editor/compiler. Unfortunately, learning Xcode isn’t as straightforward as you might think.

First, you have to learn a programming language. Xcode supports Apple’s two official programming languages, Objective-C and Swift. Of these two choices, learn Swift and ignore Objective-C if you can. Objective-C is far more confusing, convoluted, and complicated than Swift. In fact, Apple created Swift specifically to fix all the problems of Objective-C while still being equal or even better than Objective-C.

So if you ant to create iOS apps, you must first learn the Swift programming language. This by itself isn’t that difficult because Xcode offers a feature called playgrounds that lets you practice writing Swift code without the hassle of writing complete programs. With Swift playgrounds, you can test your ideas out quickly and easily, so Swift is the best programming language to learn and use for iOS development.

Once you learn Swift, you have a second task in learning how to use Xcode. Xcode contains multiple commands for professionals, which means novices will often feel intimidated by the program. Fortunately you can sue Xcode without knowing or using all of its features. However, this means you must learn both Swift and Xcode.

Now to make matters more confusing, you not only need to learn Swift and Xcode, but you also need to learn Apple’s Cocoa Touch framework that provides commonly used code to create iOS apps.

So if you want to learn iOS programming, you have to learn Swift, Xcode, and the Cocoa Touch framework. That’s three different topics you must master before you can even start writing an iOS app.

If you have a burning idea for an app, the first step is never to start writing a program, but to figure out if your idea is any good in the first place.

First, ask what problem your app will solve. Next, ask other people if they might find your app useful. Finally, ask yourself why you want to create an app in the first place. If your only goal is to make money, chances are good you won’t make money because obstacles will appear and frustrate you long before you can complete your app and start making money. Unless you actually enjoy programming, don’t think creating an app will suddenly make you rich.

In fact, most app developers don’t make money. There are so many apps in the App Store that new apps get lost in the crowd everyday. That makes it hard for potential customers to find your app and even if they do find it, they’ll be far less likely to pay for an unknown app. That means you must find ways to convince people to try and eventually buy your app.

In other words, that requires taking time to learn how to market your app. If you thought learning Swift, Xcode, and the Cocoa Touch framework were enough, now learning marketing is a fourth task you must master as well. Without marketing, your app won’t attract many sales and you won’t make a lot of money (if any).

It’s still possible to make money selling apps, but it’s not easy, simple, or fast for anyone to do so. If you’re creating an app, be prepared to market and support it for years. In other words, create an app because it will solve your own problem or because it’s fun. Don’t try creating an app just to get rich because chances are good you won’t.

Creating an app isn’t difficult but is tedious and time-consuming. Unless you’re willing to put in the time to learn, then spend your time more productively doing something you really enjoy. If you really enjoy programing, then start learning Swift, Xcode, the Cocoa Touch framework, and marketing.

Who knows? You might wound up having fun and making money, but that’s only if you enjoy learning and mastering all these tasks simultaneously.

Creating an app isn’t any harder than mastering any skill such as learning to rebuild a car engine or knitting a quilt. It just takes time and desire. If you don’t have the desire, you won’t make the time. If you do have the desire, you will make the time and then you’ll find the world of app creation can be far more rewarding than just the financial rewards alone.

Posted in iOS, Xcode

May 27th, 2016 by admin

If you look at the apps that come with an iPhone or iPad, you’ll notice that one common feature is the use of rows of data such as viewing a list of email messages in the Mail app. Whenever you see multiple rows of data that you can scroll up or down on the screen, chances are good it’s a table view.

The basic idea behind a table view is to create a dynamic list of information on the screen that users can scroll through and tap to select. The first step is to put a table view (not a table view controller) on a view (the user interface).

Once you have a table view on your user interface, the next step is to write the actual code to store data in that table view. First, you must make sure your class adds the UITableViewDelegate and UITableViewDataSource as follows:

                                        // 1. Add UITableViewDelegate and UITableViewDataSource to the class file
class ViewController: UIViewController, UITableViewDelegate, UITableViewDataSource {

Second, you need to define your data. The simplest example is to use an array such as:

    // 2. Define data to display in the table such as an array
    var cats = ["Bo", "Scraps", "Tasha", "Nuit", "Oscar", "Mayer"]

To physically access and display data in a table view, you need to create an IBOutlet between the table view on the user interface and your actual Swift class file like this:

    // 3. Create an IBOutlet for the table view on the user interface
    @IBOutlet weak var tableOfCats: UITableView!

Fourth, you need to define which file will act as the table view’s delegate and data source. If you store everything in a class file, you can just make the class file the delegate and data source. One way to do this is by control-dragging from the table view on the user interface to the view controller icon. However a more visible way to do this is to define this in Swift code like this:

        // 4. Define the Swift view controller file as the table view's delegate and data source
        tableOfCats.delegate = self
        tableOfCats.dataSource = self

Now you need to define how many items will appear in the table view. Since this number can vary, you need code that will automatically count the number of items to display. If you’re storing data in an array, you can use the array count method to define the total number of items to display in a table view like this:

    // 5. Define how many items will appear in the table view
    func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return cats.count
    }

Finally, you need to give the cell, in your table view, a unique identifier name such as “myCell” so you can identify it. Then the final step is to use this cell to fill with data. The first line of the following function tells the table view to use the cell identified by its name.

The second line says to store an array element into the text property of the cell.

The third line says to show that data in the cell of the table view, so the whole function looks like this:

   // 6. Define the actual data that appears in each row of the table view
    func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
        // "myCell" below is the identifier name of the table view's prototype cell
        let showData = tableView.dequeueReusableCellWithIdentifier("myCell")
        
        showData?.textLabel!.text = cats[indexPath.row]
        
        return showData!
        
    }

If you want to identify which table row the user tapped on, you need to write another function like this:

    // 7. Identifies which table row the user selected
    func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
        
        let currentCell = tableView.cellForRowAtIndexPath(indexPath)! as UITableViewCell
        
        print(currentCell.textLabel!.text!)
    }

So if you put a table view on your user interface and name the cell in that table view as “myCell”, the whole code looks like this:

import UIKit

                                        // 1. Add UITableViewDelegate and UITableViewDataSource to the class file
class ViewController: UIViewController, UITableViewDelegate, UITableViewDataSource {
    
    
    // 2. Define data to display in the table such as an array
    var cats = ["Bo", "Scraps", "Tasha", "Nuit", "Oscar", "Mayer"]

    
    // 3. Create an IBOutlet for the table view on the user interface
    @IBOutlet weak var tableOfCats: UITableView!
    
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // 4. Define the Swift view controller file as the table view's delegate and data source
        tableOfCats.delegate = self
        tableOfCats.dataSource = self
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

    // 5. Define how many items will appear in the table view
    func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return cats.count
    }
    
    // 6. Define the actual data that appears in each row of the table view
    func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
        // "myCell" below is the identifier name of the table view's prototype cell
        let showData = tableView.dequeueReusableCellWithIdentifier("myCell")
        
        showData?.textLabel!.text = cats[indexPath.row]
        
        return showData!
        
    }
    
    // 7. Identifies which table row the user selected
    func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
        
        let currentCell = tableView.cellForRowAtIndexPath(indexPath)! as UITableViewCell
        
        print(currentCell.textLabel!.text!)
    }

}

Posted in iOS, Xcode

May 5th, 2016 by admin

if you’ve ever used the appointment feature of the iOS calendar, you’ve seen a spinning dial that lets you choose among multiple options such as the names of different months and days. A PickerView simply displays options that the user can choose. To fill a PickerView with data, you can use an array and place that PickerView on the user interface.

Next, you have to add the UIPickerViewDelegate and UIPickerViewDataSource to the class linked to the view (user interface) like this:

                                        // 1. Add UIPickerViewDelegate and UIPickerViewDataSource to the class
class ViewController: UIViewController, UIPickerViewDelegate, UIPickerViewDataSource {

Then you have to get data to place in the PickerView, which can be an array like this:

    // 2. Create an array of data to display in the picker view
    var pickerArrayItems = ["Cat", "Dog", "Hamster", "Goldfish", "Parrot", "Lizard"]

You also need to create an IBOutlet for your PickerView so you can refer to it in Swift code like this:

    // 3. Create an IBOutlet for the picker view on the user interface
    @IBOutlet weak var pickerViewUI: UIPickerView!

Once you’ve created an IBOutlet for your PickerView, you can then set its delegate to the view controller Swift file like this:

        // 4. Set the delegate of the picker view control to the view controller
        pickerViewUI.delegate = self

Now you need to define the number of parts or components in your PickerView. The simplest PickerView displays just one type of data so you can define just 1 using the numberOfComponentsInPickerView function:

    // 5. Define the number of parts or components of the picker view
    func numberOfComponentsInPickerView(pickerView: UIPickerView) -> Int {
        return 1
    }

You must also define how many items to display in the PickerView. If your data is an array, you can just count the number of items in the array using the pickerView function:

    // 6. Define the number of items to appear in the picker view
    func pickerView(pickerView: UIPickerView, numberOfRowsInComponent component: Int) -> Int {
        return pickerArrayItems.count
    }

Finally, you need to actually fill the PickerView with your data using another pickerView function:

    // 7. Define the title of each row of the picker view with the array items (Step 2 above)
    func pickerView(pickerView: UIPickerView, titleForRow row: Int, forComponent component: Int) -> String? {
        return pickerArrayItems[row]
    }

Your entire ViewController.swift file can look like this when linked to a view (user interface) that contains a picker view control:

import UIKit

                                        // 1. Add UIPickerViewDelegate and UIPickerViewDataSource to the class
class ViewController: UIViewController, UIPickerViewDelegate, UIPickerViewDataSource {
    
    // 2. Create an array of data to display in the picker view
    var pickerArrayItems = ["Cat", "Dog", "Hamster", "Goldfish", "Parrot", "Lizard"]

    // 3. Create an IBOutlet for the picker view on the user interface
    @IBOutlet weak var pickerViewUI: UIPickerView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // 4. Set the delegate of the picker view control to the view controller
        pickerViewUI.delegate = self
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

    // 5. Define the number of parts or components of the picker view
    func numberOfComponentsInPickerView(pickerView: UIPickerView) -> Int {
        return 1
    }
    
    // 6. Define the number of items to appear in the picker view
    func pickerView(pickerView: UIPickerView, numberOfRowsInComponent component: Int) -> Int {
        return pickerArrayItems.count
    }

    // 7. Define the title of each row of the picker view with the array items (Step 2 above)
    func pickerView(pickerView: UIPickerView, titleForRow row: Int, forComponent component: Int) -> String? {
        return pickerArrayItems[row]
    }
    
}

Posted in iOS, User Interface

April 29th, 2016 by admin

if you’re creating an iOS app that requires typing text, your app will need to display the iOS virtual keyboard that slides up from the bottom of the screen. The problem with the virtual keyboard is that although it pops up automatically, you have to write code to make it go away.

There are basically four steps you need to follow to write code that makes the virtual keyboard go away. First, you’ll likely need a text field to allow the user to type text on the virtual keyboard, so you need to add the UITextFieldDelete to your class file like this in Swift:

import UIKit

//  1. Add UITextFieldDelegate to the ViewController class

class ViewController: UIViewController, UITextFieldDelegate {

Second, you’ll need to set the text field to the UITextFieldDelegate. You can do through the Connections Inspector on Xcode or just use code like this in Swift:

        //  2. Set text field to delegate
        textFieldEntry.delegate = self

Third, you need to create a function called textFieldShouldReturn to end editing. This function hides the virtual keyboard if the user taps the Return key:

    func textFieldShouldReturn(textField: UITextField) -> Bool {
        self.view.endEditing(true)
        return true
    }

Fourth, you need to create a second function called touchesBegan to tell the text field to let the virtual keyboard disappear if the user taps anywhere away from the text field:

   //  4. Create a touchesBegan function to dismiss keyboard if the user taps outside of the text field or keyboard
    override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        textFieldEntry.resignFirstResponder()
    }

So if you create a simple iOS, single view app in Xcode using Swift, just place a text field on the view (user interface) and link it to your view controller file as an IBOutlet such as naming the text field “textFieldEntry”. Then your entire Swift class would look like this:

//  ViewController.swift
//  KeyboardRemoval
//

import UIKit

//  1. Add UITextFieldDelegate to the ViewController class

class ViewController: UIViewController, UITextFieldDelegate {
   
    @IBOutlet weak var textFieldEntry: UITextField!

    override func viewDidLoad() {
        super.viewDidLoad()

        //  2. Set text field to delegate
        textFieldEntry.delegate = self
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }

    //  3. Create a textFieldShouldReturn function that will dismiss the keyboard when the user is done editing the text field
    func textFieldShouldReturn(textField: UITextField) -> Bool {
        self.view.endEditing(true)
        return true
    }

    //  4. Create a touchesBegan function to dismiss keyboard if the user taps outside of the text field or keyboard
    override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        textFieldEntry.resignFirstResponder()
    }

}

Now if the user taps the Return key on the virtual keyboard or taps away from the text field and the virtual keyboard, the virtual keyboard will tuck itself out of sight.

Posted in iOS, Programming, Xcode

December 7th, 2015 by admin

If you’re involved in programming, you know how important it can be to learn the right programming languages. Every programmer should learn the basics of C along with object-oriented programming because those two topics can help you learn Java, Objective-C, and C#. If instead of learning C and object-oriented programming, you decided to focus solely on FORTH and Modula-2, would you think you would have as many opportunities available to you as another programmer versed in C and object-oriented programming?

If you want to learn the most important new programming language in recent years, you absolutely must learn Swift. Not only is Swift used to create iOS (iPhone and iPad) apps, but it can be used to create watchOS app for the Apple Watch and tvOS for Apple TV. That’s four major platforms you can support with Swift.

Stick with C# and you’re basically stuck in the stagnant world of PCs. Stick with Java and you can do web programming along with Android programming. Whether you learn C# or Java is far less important than learning Swift because Swift is now moving to Linux and other platforms such as Linux servers.

To help programmers learn Swift, IBM has created a site called the IBM Swift Sandbox, which lets you practice running Swift in a browser. Right now the only way to learn Swift is by using Xcode on a Macintosh. For anyone who doesn’t have a Macintosh, get one and start learning to use Xcode and Swift.

If you can’t afford a Macintosh right now, use IBM’s Swift Sandbox to learn Swift on your browser. This can be especially useful for iPad users. Since you can’t write programs using an iPad, you can use IBM’s Swift Sandbox to learn Swift on your iPad’s browser. Now you can learn Swift on any device you want as long as it has a browser.

Knowledge of Swift is crucial for any programmer’s future so the sooner you start learning, the better off you’ll be. As long as the iPhone, iPad, Macintosh, Apple Watch, and Apple TV continue making profits and grabbing market share, they’ll always be a demand for Swift programmers.

Now that Swift will migrate to servers along with platforms like Linux and eventually Windows, Swift could be the universal programming language like C that every programmer must learn.

Start learning Swift today. Your future as a programmer literally depends on it.

Posted in iOS, Programming, Xcode

December 4th, 2015 by admin

Just as Apple had promised earlier this year, the Swift programming language is now open source. The reason for making Swift open source is to speed up Swift’s adoption on servers and on other platforms such as Linux and Windows in ways that Apple’s own programmers would never have the time to do on their own.

If you’re learning programming, Swift is going to be one of the most important programming languages to master. When Swift successfully ports to Linux and Windows, you should be able to write Swift programs for all major platforms.

Of course, you can already use Swift to write programs for all of Apple’s platforms that are either dominating their markets or steadily gathering market share. With  Swift you can write programs for the following Apple platforms:

  • OS X to create Macintosh programs for the steadily growing Macintosh market (while the PC market steadily declines)
  • iOS to create iPhone and iPad apps for the dominant mobile computing market defined by the iPhone and iPad
  • watchOS to create Apple Watch apps for the wearable computing market that the Apple Watch is helping define
  • tvOS to create Apple TV apps for a new TV market that Apple is shaping

Right now with Swift you can support four major Apple platforms. With Swift going open source, you’ll soon be able to write server programs in Swift, running on Linux. You may eventually be able to write Windows programs and even Android apps in Swift as well. When that happens, you’ll be able to port your iOS programs to Android.

The future clearly belongs to Swift. If you’re learning any programming language, your school may have forced you to learn C++ and Java since both languages run on all major platforms and form the basis for other popular programming languages such as Objective-C.

However, you must learn Swift. Windows developers may focus on C# but C# has never migrated beyond Windows so it’s a dead end. With Windows PCs steadily declining, C# can’t help but decline at the same time.

On the other hand, Swift has a far brighter future ahead of it. If your school doesn’t teach Swift, learn Swift on your own. Swift will be the most important programming language of tomorrow (and even today) so if you don’t learn Swift, you might as well stick with archaic programming languages like FORTH and LISP and then wonder why you don’t have as many opportunities available to you.

To learn more about open source Swift, click here.

Posted in iOS, Programming

November 3rd, 2015 by admin

Back in the early days of the PC, VisiCalc dominated in the spreadsheet market. Two rivals soon appeared called Context MBA and Lotus 1-2-3. The biggest advantage of Context MBA was that it was written in UCSD-Pascal, which gave it cross-platform capabilities. That meant you could run Context MBA on MS-DOS or CP/M-80. Since nobody knew which operating system would dominate, this seemed like a smart bet.

On the other hand, Lotus 1-2-3 only ran on MS-DOS. That seemed like a huge limitation except that Lotus 1-2-3 was optimized for MS-DOS so it ran extremely quickly while Context MBA ran much slower on every operating system. As history shows, the world chose Lotus 1-2-3 and left Context MBA in the dustbin of history.

That’s the difference between coding for cross-platforms or coding for a single platform and optimizing your app to run on that one platform. Use a cross-platform tool like Xojo or LiveCode and you’ll get suboptimal performance on every operating system. Use Xcode and Swift to create iOS or OS X apps and you’ll get optimal performance along with the ability to take advantage of every feature offered by Apple’s frameworks.

What’s the drawback? With Xcode and Swift, you can’t make cross-platform programs that might run on Windows, Linux, or Android. That means you have to bet that iOS and OS X will be the platforms of growth just like Lotus 1-2-3 bet that MS-DOS would be the platform of growth.

In hindsight, Lotus 1-2-3 made the right choice. Today, it’s easy to see that iOS dominates the mobile market with the iPhone and iPad, and OS X is steadily growing as Macintosh sales steadily creep upwards while PC sales gradually decline.

Windows and Android represent huge markets, but iOS and OS X represent growing markets. Remember, at one time CP/M-80 was the dominant operating system and MS-DOS was the upstart. Obviously Lotus 1-2-3 bet on the upstart and won big, while Context MBA hedged their bets and lost all the way around.

The lesson of Context MBA and Lotus 1-2-3 is that native apps optimized for a specific operating system will give you greater performance. You just have to make sure your’e betting on the right platform.

Since iOS dominates the mobile market with the iPhone and iPad, it’s obvious that iOS will remain lucrative. Although Windows dominates the desktop computer market, it’s also easy to see that OS X growth is continuing, so there will be a steadily growing market for OS X programs.

Since mobile computing is growing rapidly and represents the future, it seems safe to say that iOS is the future. So decide what’s more important to you: cross-platform or native and optimized performance. Judging from the past of Context MBA and Lotus 1-2-3, it seems likely the answer will always be native, optimized apps.

To read a short history of Context MBA, click here.

Posted in iOS, LiveCode, Programming, Xcode, Xojo

HTML Snippets Powered By : XYZScripts.com