Altabel Group's Blog

Swift: 7 reasons why Objective-C could be left behind

Posted on: June 13, 2015

Last year Apple introduced Swift, its own programming language, which was focused on making it easier to build apps. Many reviews have praised Swift as the strong alternative of Objective C and even it will replace ‘C’ for embedded coding on entire Apple platform including Mac, iOS handheld devices, and wearable devices in near future. There must be some valid reasons behind. Let’s explore that why Swift is praised more.


  1. Ease in Code and Comprehend

Swift isn’t built on C so it is free from all C class languages related warts:

  • If you want to introduce new Objective C type or object-related keyword in Objective C, you have to use @ symbol in each case. Swift is capable to unify all keywords by removing extra @ symbols to de-clutter the code documents.
  • Swift doesn’t follow legacy conventions therefore programmers can easily avoid excessive semicolons that need to indicate end of line.
  • You can avoid use of parenthesis to surround conditional expressions particularly inside if/else statements.
  • Swift uses industry standard comma-separated list of parameters within parenthesis.
  • Swift is a natural type language so its readability resembles to the English so modern programmers certainly love it.
  1. Ease in Maintenance
  • Swift fundamentally avoid double file creation in order to improve the build time and programming efficiencies.
  • Xcode and the LLVM compiler are capable to figure out dependencies as well as perform incremental builds automatically for Swift programming
  • Swift programmers don’t have to follow C paradigm to create two files by separating table of content and body because (.swift) combines both (.h) and (.m).
  • In Swift, you don’t need to synchronize method names and comments between files.
  • Xcode and the LLVM compiler can reduce the work load of programmers behind the scene because it demand less bookkeeping to cuts out boilerplate work and improves the quality of Swift code along with productivity.
  1. Swift requires less code 
  • Swift reduces the amount of code that is required for repetitive statements and string manipulation. In Objective-C, working with text strings requires many steps to combine two pieces of information. Swift adopts modern programming language features like adding two strings together with a “+” operator. Support for combining characters and strings like this is fundamental for any programming language that displays text to a user on a screen.
  • The type system in Swift reduces the complexity of code statements — as the compiler can figure out types. As an example, Objective-C requires programmers to memorize special string tokens (%s, %d, %@) and provide a comma-separated list of variables to replace each token. Swift supports string interpolation, which eliminates the need to memorize tokens and allows programmers to insert variables directly inline to a user-facing string, such as a label or button title. The type inferencing system and string interpolation mitigate a common source of crashes that are common in Objective-C.
  • Swift relieves you from bookkeeping work, translating into less code to write (code that is now less error prone) because of its inline support for manipulating text strings and data.
  1. Ease in Memory Management

Memory management is quick and without memory leakage:

  • Swift unifies the language in a way that Objective-C never has. The support for Automatic Reference Counting (ARC) is complete across the procedural and object-oriented code paths. In Objective-C, ARC is supported within the Cocoa APIs and object-oriented code; it isn’t available, for procedural C code and APIs like Core Graphics. This means it becomes the programmer’s responsibility to handle memory management when working with the Core Graphics APIs and other low-level APIs available on iOS. The huge memory leaks that a programmer can have in Objective-C are impossible in Swift.
  • Because ARC handles all memory management at compile time, the brainpower that would have gone toward memory management can instead be focused on core app logic and new features. Because ARC in Swift works across both procedural and object-oriented code, it requires no more mental context switches for programmers, even as they write code that touches lower-level APIs – a problem with the current version of Objective-C.
  1. Ease in Debugging
  • Debugging process is instant and rapid, because Swift allows generating a compiler error along with ongoing writing of the code in document.
  1. Fast Performance

Swift has memory-bound GEMM algorithm with sequential access of large arrays. Therefore, along with FFT and Mandelbrot algorithm, it improves overall performance many folds:

  • According to Primate Labs (GeekBench performance tool), Swift was approaching the performance characteristics of C++ for compute-bound tasks in December 2014 using the Mandelbrot algorithm.
  • In February 2015 the Xcode 6.3 Beta improved Swift’s performance of the GEMM algorithm – a memory-bound algorithm with sequential access of large arrays – by a factor of 1.4. The initial FFT implementation – a memory-bound algorithm with random access of large arrays – had a 2.6-fold performance improvement.
  • Further improvements were observed in Swift by applying best practices, resulting in an 8.5-fold boost for FFT algorithm performance (leaving C++ with only a 1.1-time performance gain). The enhancements also enabled Swift to outperform C++ for the Mandelbrot algorithm by a factor of a mere 1.03.
  • Swift is nearly on par with C++ for both the FFT and Mandelbrot algorithms. According to Primate Labs, the GEMM algorithm performance suggests the Swift compiler cannot vectorize code the C++ compiler can – an easy performance gain that could be achieved in the next version of Swift.
  1. Encouraging Interactive Coding
  • Swift has highly interactive tool for seasoned /experienced programmers in form of Playground so programmers can write an algorithm while instantly obtaining feedback.
  • The Playgrounds were partially inspired by the work of former Apple employee Brett Victor. Playgrounds enable programmers to test out a new algorithm or graphics routine, say 5 to 20 lines of code, without having to create an entire iPhone app.
  • Apple has added inline code execution to Playgrounds to help programmers create a chunk of code or write an algorithm while getting feedback along the way. This feedback loop can improve the speed at which code can be written because the mental model that a traditional programmer needs can be replaced with data visualizations in Playgrounds. Programming is an iterative process, and any strain that can be reduced or used to complement the creative process will make programmers more productive and free them to solve bigger problems, rather than focusing on boring details that traditional compilers have imposed on programmers.

To draw the conclusion, one can say that, Swift is full-featured and  highly approachable  programming language to allow iPhone developers to create next generation iPhone apps as well as iPhone apps that supporting solely the Apple Watch and other wearable devices applications in cost-effective  and with ease ways. If you have any app idea for such next generation iPhone application developmentAltabel Group has solid team of iPhone app developers with expertise in Swift and other latest modern iOS development techniques, tools and technologies.


Svetlana Pozdnyakova 
Skype ID: Svetlana.pozdnyakova
Business Development Manager (LI page)
Altabel Group – Professional Software Development


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: