Creating iOS Apps without Storyboard – Part 1

July 28, 2019August 7, 2019 / Arun Patwardhan / 2 Comments

What are “nibless” apps?

Apps which are designed without the help of Storyboard are called as “Nibless” apps. Normally we design an app with the help of a Storyboard file. Earlier they were called Xib files or Nib files. Hence the term “Nibless”.

Why should we create Apps without storyboard?

There are a number of reasons.

It makes for a better experience when implementing along with version control.
Allows us to create UI elements dynamically.
Makes reusable UI Components easier to distribute and reuse.

How can we create Apps without Storyboard?

There are a couple of things that need to be done. Firstly the Main.storyboard file needs to be removed and the project settings need to be updated to reflect this change.. We are doing this since we won’t be using the storyboard file.
Everything will now have to be started up by us manually. Many of these tasks were taken care of by storyboard, but since that was removed we will have to do it. This means we have to manually create the window, create the view controller set it as a the root view controller.
We also have to manually create each and every component on our own. That is the very thing we were trying to achieve.

This example is implemented on Xcode 10.3 on macOS 10.14.5. We are not implementing auto layout in this article. We will look at implementing that programmatically in the next article.

Let us start with an empty project. Open Xcode.
Select File > New > Project
Give it any name. Select the language as Swift & leave the checkboxes unchecked.
Once the project loads select the Main.storyboard file and delete it.
Switch to the Project settings file.
Remove the entry for the main interface.
It is a good idea to leave the LaunchScreen.storyboard file. The reason for this is to give the launch process a reference of the screen size it needs to produce. Else it will default down to the 0,0,320,480 which is the old iPhone size.
Switch to the AppDelegate.swift file.

Add the following property below the UI Window declaration.

  
let mainScreenController : ViewController = ViewController()

Add the code to create the window and set root view controller in the didFinishLaunchingWithOptions method

   
//1. Create the UIWindow object   
self.window = UIWindow(frame: UIScreen.main.bounds)   

//2. Set the root view controller   
self.window?.rootViewController = self.mainScreenController   

//3. Make the window key and visible  
self.window?.makeKeyAndVisible()

Switch to the ViewController.swift file.

Declare the following variables

  
//UI Variables  
var labelDemo   : UILabel?  
var imageDemo   : UIImageView?  
var buttonDemo  : UIButton = UIButton(type: UIButton.ButtonType.roundedRect) 
var dataField   : UITextField?

Implement the function to create labels. The process of creating a view programmatically is fairly straightforward. Barring a few variations depending on the view component nothing is drastically different.

  
func createLabel() 
{      
     //1. Specify the dimensions      
     let labelRect : CGRect   = CGRect(x: 100.0, y: 50.0, width: self.view.frame.size.width - 130.0, height: 60.0)     

     //2. Create the view object      
     labelDemo                = UILabel(frame: labelRect)      

     //3. Customise the view attributes      
     labelDemo?.text          = "This is my first Programmatic App."                
     labelDemo?.textColor     = UIColor.yellow      
     labelDemo?.textAlignment = NSTextAlignment.left  
     labelDemo?.numberOfLines = 0      
     labelDemo?.font          = UIFont.boldSystemFont(ofSize: 20.0)      

     //4. Add the view to the subview      
     self.view.addSubview(labelDemo!) 
}

Let us examine the steps one by one.

 
//1. Specify the dimensions 
let labelRect : CGRect = CGRect(x: 100.0, y: 50.0, width: self.view.frame.size.width - 130.0, height: 60.0)

This will define the dimensions of the view. As we are not implementing auto layout we will need to do this manually.

 
//2. Create the view object
labelDemo = UILabel(frame: labelRect)

Now that we have the dimensions we can go ahead and instantiate an instance of the label object using those dimensions. These 2 parts are the same as dragging a label from the object library onto the storyboard and placing it onto the storyboard per our requirements.

//3. Customise the view attributes 
labelDemo?.text          = "This is my first Programmatic App."     
labelDemo?.textColor     = UIColor.yellow 
labelDemo?.textAlignment = NSTextAlignment.center      
labelDemo?.numberOfLines = 0 
labelDemo?.font          = UIFont.boldSystemFont(ofSize: 20.0)

This part is the same as changing the attributes in the attributes inspector. This is where we customise the label.

 
//4. Add the view to the subview 
self.view.addSubview(labelDemo!)

This last part also forms one part of dragging the label on to the storyboard. When we drag a view on to the storyboard it is placed within the main view that belongs to the ViewController. This statement completes the above process.

Repeat the above steps for showing an image.

func createImage()
{
     //1. Specify the dimensions
     let imageRect  : CGRect  = CGRect(x: 30.0, y: 50.0, width: 60.0, height: 60.0)

     //2. Create the image model
     let imageModel : UIImage = UIImage(named: "logo.png")!

     //3. Create the view object
     imageDemo                = UIImageView(frame: imageRect)

     //4. Customise the view attributes
     imageDemo?.image         = imageModel
     imageDemo?.contentMode   = UIView.ContentMode.scaleAspectFit

     //5. Add the view to the subview
     self.view.addSubview(imageDemo!)
}

The code above is almost similar to the one created for labels except for the fact that we had to explicitly create a model object for the view. Images being different from strings, require this process to be done explicitly.

Similarly let us implement the code for creating buttons

func createButton()
{
     //1. Specify the dimensions
     let buttonRect : CGRect = CGRect(x: 30.0, y: 220.0, width: 100.0, height: 50.0)

     //2. Provide the frame to the button
     buttonDemo.frame = buttonRect

     //3. Customise the view attributes
     buttonDemo.setTitle("Click Me", for: UIControl.State.normal)
     buttonDemo.addTarget(self, action: #selector(ViewController.clickMeTapped), for: UIControl.Event.touchDown)

     //4. Add the view to the subview
     self.view.addSubview(buttonDemo)
}

@objc func clickMeTapped(
{
     print("Click me tapped!")
}

Again just minor variations here. Mainly the step to add a target function to be invoked when the button is tapped. We also need to write the target function itself.

We will also implement the code to create a text field.

func createTextField()
{
    //1. Provide dimensions for the view
    let tfRect : CGRect             = CGRect(x: 30.0, y: 140.0, width: self.view.frame.size.width - 60.0, height: 50.0)
        
    //2. Create the view object
    dataField                       = UITextField(frame: tfRect)
        
    //3. Customise the attributes of the view
    dataField?.placeholder          = "Enter Name"
    dataField?.borderStyle          = UITextField.BorderStyle.roundedRect
    dataField?.keyboardType         = UIKeyboardType.namePhonePad
    dataField?.keyboardAppearance   = UIKeyboardAppearance.dark
    dataField?.returnKeyType        = UIReturnKeyType.go
        
    //4. Add the view to the subview
    self.view.addSubview(dataField!)
}

Next we need to call all these functions. I have implemented a single creator function for that.

func createUIElements()
{
     self.createLabel()
     self.createImage()
     self.createButton()
     self.createTextField()
}

Lastly we will call this function in the viewDidLoad method. Add the following lines to the viewDidLoad method.
```
self.view.backgroundColor = UIColor.lightGray
self.createUIElements()
```
I have also added code to change the background colour so that we can see the background clearly.
Run the project. Everything should appear normally.

Are there any benefits of creating apps without storyboard?

The points mentioned in the “why should we make programmatic apps?” section are some of the advantages. Beyond that there aren’t too many.
If you are looking at a team based project development then this approach is good.
There is no difference in terms of memory or performance when it comes down to apps design with or without storyboard.

Are there any drawbacks?

As can be seen from the example above, there are a couple of drawbacks

The main drawback is that you can’t get a quick preview of how your app looks. You have to run the simulation every time you wish to see the end result.
There is a lot more coding involved. Which can be daunting to those who are overly accustomed to designing with the help of storyboards

Note

A small point. I have left the LaunchScreen.storyboard file. I did not delete it. The reason I did that was to allow the app to allow the system to determine the dimensions on the device. If we do delete the file then the UIScreen.main.bounds return (0.0, 0.0, 320.0, 480.0) which are the old iPhone screen size settings.
While you can go ahead and make changes programmatically it is a lot easier to just leave the LaunchScreen.storyboard file there.

Carrying on from the previous point. It actually is okay if you leave the Main.storyboard file as is too. In which case you will have to skip steps 5,6,8,9,10. The code is still running programmatically but you do not have to create the main ViewController manually.

Download the Source Code

You can download the Xcode Project from this link.

Creating reusable UI Components for iOS App Development

December 8, 2018December 19, 2018 / Arun Patwardhan / Leave a comment

In an earlier article I had discussed how we can create our own frameworks to easily share reusable code. In this article we will take this a little further and create our own reusable UI Components.

Points to Note:

The reusable component we will be creating is based on UIKit. For that reason this component can only be used in iOS Apps. However, you can follow the same steps to create a reusable component for macOS using Cocoa.
UI Components, distributed through a framework, do not render in the project storyboard file.
You should be familiar with creating Embedded Binaries (your own Framework). If you aren’t then please read this article first.
These projects are created on Xcode 10 with Swift 4.2

Getting Started

We will complete the implementation as a 2 step process. Here is the screen that we are planning to implement.

Creating the Reusable Framework

Open Xcode and create a new Framework project.
Name the project “UIVIdentityCard”.
Save the project in any folder.
Create a new Swift file File > New > File > Swift.
Name the file “GenderType.swift”. This is where we will declare the enum that holds the Gender type that we are creating.

Add the following code to the file.

 
import Foundation 
/** Possible scores that can be given. 
*values* 
`Male` 

`Female` 

`NotSpecified` 

*functions* 
`func toString() -> String` 
Used to get the `String` version of the value 

- Author: Arun Patwardhan 
- Version: 1.0 
*/ 
public enum GenderType 
{      
     case Male      
     case Female      
     case NotSpecified 
} 

/** This extension adds the Enum to String converions capability 
- Author: Arun Patwardhan 
- Version: 1.1 
*/ 
extension GenderType 
{      
     /** This function converts from enum value to `String`         
     - important: This function does not do validation         
     - returns: `String`.         
     - requires: iOS 11 or later         
     - Since: iOS 11         
     - author: Arun Patwardhan         
     - copyright: Copyright (c) Amaranthine 2015         
     - version: 1.0 */      
     @available(iOS, introduced: 11.0, message: "convert to String")      
     func toString() -> String      
     {           
          switch self           
          {                
               case .Male:                     
                    return "Male"                
               case .Female:                     
                    return "Female"                
               case .NotSpecified:                     
                    return "Not Specified"           
          }      
     } 
}

Create a new Swift file called “PersonDetailsModel.swift”.

Add the following code to the file.

import Foundation

/**  This struct represents the data that is to be shown in the ID card  
**Variables**  
`personName`  

`personIcon`  

`personDob`  
Date of Birth  

`personAddress` 
 
`personPhone` 
 
`personEmail` 
 
`personCompany`
  
`personHeight`
  
`personWeight`  

`personGender`  

**Important**  There is a variable with the name `entryCount`. This variable keeps tracks of the number of stored properties that exist. The value of this variable will be used to determine the number of rows in the table.The computed property `numberOfRows` is the property used to access the value of `entryCount`.  

- Author: Arun Patwardhan  
- Version: 1.0
*/
public struct PersonDetailsModel
{     
     internal var entryCount : Int = 7     
     public var personName   : String = ""     
     public var personIcon   : UIImage     
     public var personDob    : Date     
     public var personAddress: String = ""     
     public var personPhone  : String = ""     
     public var personEmail  : String = ""     
     public var personCompany: String = ""     
     public var personHeight : Double? = 0.0     
     {          
          willSet          
          {               
               if newValue == nil & personHeight != nil               
               {                    
                    entryCount -= 1               
               }               
               else if newValue != nil & personHeight == nil               
               {                    
                    entryCount += 1               
               }          
          }     
     }     

     public var personWeight : Double? = 0.0     
     {          
          willSet(newValue)          
          {               
               if newValue == nil & personWeight != nil               
               {                    
                    entryCount -= 1               
               }               
               else if newValue != nil & personWeight == nil               
               {                    
                    entryCount += 1               
               }          
          }     
     }     

     public var personGender : GenderType?     
     {          
          willSet          
          {               
               if newValue == nil & personGender != nil               
               {                    
                    entryCount -= 1               
               }               
               else if newValue != nil & personGender == nil               
               {                    
                    entryCount += 1               
               }          
          }     
     }     

     public var numberOfRows : Int     
     {          
          return entryCount     
     }     

     public init(withName newName : String, icon newIcon : UIImage, birthday newDob : Date, address newAddress : String, phone newPhone : String, email newEmail : String, Company newCompany : String, height newHeight : Double?, weight newWeight : Double?, andGender newGender : GenderType?)     
     {          
          personName = newName          
          personIcon = newIcon          
          personDob  = newDob          
          personAddress = newAddress          
          personPhone = newPhone          
          personEmail = newEmail          
          personCompany = newCompany  
        
          if newGender != nil          
          {               
               entryCount += 1          
          }          
          if newWeight != nil          
          {               
               entryCount += 1          
          }          
          if newHeight != nil          
          {               
               entryCount += 1          
          }          

          personHeight = newHeight          
          personWeight = newWeight          
          personGender = newGender     
     }
}

/**     This extension adds protocol conformance for the `CustomStringConvertible` protocol.     

- Author: Arun Patwardhan     
- Version: 1.1
*/
extension PersonDetailsModel : CustomStringConvertible
{     
     public var description: String     
     {          
          return """               
               NAME: \(self.personName)               
               DATE OF BIRTH:\(self.personDob)               
               ADDRESS: \(self.personAddress)               
               EMAIL:\(self.personEmail)               
               PHONE:\(self.personPhone)          
          """     
     }
}

Now we will focus out attention on the View. Create a new file File > New > File > View.
Name the view “UIVIdentityCard.swift”.
Design the view as shown in the screenshot below.
Create the corresponding“UIVIdentityCard.swift” file.
Make the IBOutlet & IBAction connections for the different UI elements.

Add the following code. This is how your file should look after its completed.

/**     The UIVIdentityCard class     
**Functions**     
`public func load(data newPerson : PersonDetailsModel)`     
Used to load the data for the view.     

- Author: Arun Patwardhan     
- Version: 1.0
*/
@IBDesignableopen class UIVIdentityCard: UIView, UITableViewDelegate, UITableViewDataSource
{     
     //IBOutlets --------------------------------------------------     
     @IBOutlet public weak var personIcon : UIImageView!     
     @IBOutlet public weak var personName : UILabel!     
     @IBOutlet public weak var personDetails : UITableView! 

     //Variables --------------------------------------------------     
     public var localTableData : PersonDetailsModel!     
     let nibName : String = "UIVIdentityCard"     
     var view: UIView!     
     let cellIdentifier : String = "IDCard"     
     //Functions --------------------------------------------------     
     /**     This function does the initial setup of the view. There are multiple things happening in this file.     
     1) The first thing that we do is to load the Nib file using the `nibName` we saved above. The UNIb object contains all the elements we have within the Nib file. The UINib object loads the object graph in memory but does not unarchive them. To unarchive them and get the ibjects loaded completely for use we have to instatiate the object and get the arry of top level objects. We are however interested in the first object that is there in the array which is of type `UIView`. The reference to this view is assigned to our local `view` variable.     
     2) Next we specify the bounds of our view     
     3) Finally we add this view as a subview     

     - important: This function does not do validation     
     - requires: iOS 11 or later, the varibale that contains the name of the nib file.     
     - Since: iOS 11     
     - author: Arun Patwardhan     
     - copyright: Copyright (c) Amaranthine 2015     
     - version: 1.0     
     */     
     @available(iOS, introduced: 11.0, message: "setup view")     
     func setup()     
     {          
          //1)          
          self.view = UINib(nibName: self.nibName, bundle: Bundle(for: type(of: self))).instantiate(withOwner: self, options: nil)[0] as! UIView          
     
          //2)          
          self.view.frame = bounds          
          
          //3)          
          self.addSubview(self.view)     
     }     

     public func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int     
     {          
          if let count = localTableData?.entryCount          
          {               
               return count - 2          
          }          
          return 0     
     }     

     public func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -&amp;gt; UITableViewCell     
     {          
          var cell : UITableViewCell? = tableView.dequeueReusableCell(withIdentifier: cellIdentifier)          

          if nil == cell          
          {               
               cell = UITableViewCell(style: .default, reuseIdentifier: cellIdentifier)          
          }          

          switch indexPath.row          
          {               
               case 0:                    
                    let formatter = DateFormatter()                    
                    formatter.dateStyle = .medium                         
                    cell?.textLabel?.text = "Birthday\t: "+ formatter.string(from: (localTableData?.personDob)!)      

               case 1:                    
                    cell?.textLabel?.text = "Email\t: " + localTableData.personEmail               

               case 2:                    
                    cell?.textLabel?.text = "Phone\t: " + localTableData.personPhone               

               case 3:                    
                    cell?.textLabel?.text = "Address\t: " + localTableData.personAddress               

               case 4:                    cell?.textLabel?.text = "Company\t: " + localTableData.personCompany               

               case 5:                    
                    cell?.textLabel?.text = "Gender\t: " + \(localTableData.personGender?.toString())!               

               case 6:                    
                    cell?.textLabel?.text = "Height\t: \((localTableData.personHeight)!)"               

               case 7:                    
                    cell?.textLabel?.text = "Weight\t: \((localTableData.personWeight)!)"               
               default:                    
                    print("error")          
          }          

          cell?.textLabel?.font = UIFont.boldSystemFont(ofSize: 12.0)          
          cell?.textLabel?.setContentCompressionResistancePriority(.defaultHigh, for: .horizontal)          
          return cell!     
     }     

     //Inits --------------------------------------------------                    
     override public init(frame: CGRect)     
     {          
          super.init(frame: frame)          
          self.setup()     
     }     
     
     required public init?(coder aDecoder: NSCoder)     
     {          
          super.init(coder: aDecoder)          
          self.setup()     
     }     

     override open func layoutSubviews()     
     {          
     super.layoutSubviews()     
     }
}

/**     This extension adds the function to load data     
- Author: Arun Patwardhan     
- Version: 1.1
*/
extension UIVIdentityCard
{     
     /**          
     This function loads the data for the view          
     - important: This function does not do validation          
     - parameter newPerson: This is the object representing the person whose information will be displayed on the screen.          
     - requires: iOS 11 or later          
     - Since: iOS 11          
     - author: Arun Patwardhan          
     - copyright: Copyright (c) Amaranthine 2015          
     - version: 1.0     
     */    
     @available(iOS, introduced: 11.0, message: "load data")     
     public func load(data newPerson : PersonDetailsModel)     
     {          
          self.localTableData = newPerson          
          self.personIcon.image = localTableData.personIcon          
          self.personName.text = localTableData.personName          
          self.personDetails.reloadData()     
     }
}

Add the placeholder image for the image view.
Select any of the simulators from the list.
Press ⌘ + B to build the project.
From the Project navigator select the Framework file.
Control click and select “Show in Finder”.
Copy the framework to the “Desktop”.

We are done creating the reusable framework. We will not shift our focus towards testing this framework.

Using the Framework in a project

Let us now test the framework we created. We will do this by incorporating the code in our iOS App.

Create a new project. Call it “IdentityCardTest”.
Save the file in a folder of your choice.
Select the Project file and Embed the Framework into your project.
Add an image to your project, this will be the image that will be displayed in your custom view.
Switch to the Main.storyboard file. Drag a UIView into the ViewControllers view.
Set its identity to the UIVIdentityCard in the identity inspector. Also set its module to UIVIdentityCard.
Create an IBOutlet for this custom view.
Switch to the ViewController.swift file. Import the UIVIdentityCard framework at the top of the file.

Add the following code to the file. We will be creating test data and displaying it on the screen using the Custom view we just designed.

//Functions --------------------------------------------------
/**
    This function prepares and loads the data that is to be shown in the custom view


    - important: This function does not do validation
    - requires: iOS 11 or later, the UIVIdentityCard framework.
    - Since: iOS 11
    - author: Arun Patwardhan
    - copyright: Copyright (c) Amaranthine 2015
    - version: 1.0
*/
@available(iOS, introduced: 11.0, message: "prepares data to be shown on the ID card")
func prepareIDCard()
{
     let displayData : PersonDetailsModel = PersonDetailsModel(withName: "Arun Patwardhan", icon: UIImage(named: "iconHolder.png")!, birthday: Date(timeIntervalSince1970: 44_97_12_000), address: "Mumbai, Maharashtra, India", phone: "91-22-26486461", email: "arun@amaranthine.co.in", Company: "Amaranthine", height: 5.11, weight: nil, andGender: GenderType.Male)

     myIDCard.load(data: displayData)
}

Your completed ViewController.swift should look like this.
Run the project. See if the view loads the way we wish.

Link to Sample Code

https://github.com/AmaranthineTech/ReusuableUIFramework

Video

Creating Reusable UI

Programming Style Guide: Command Query Separation

July 20, 2018 / Arun Patwardhan / 1 Comment

An important aspect of programming, and one that people don’t think of to often, is being able to express the intentions of the code clearly.

Most of the times we programmers get lost in the code we write. It is important to step back and take a look at the code we have written from another person’s perspective. One can say, “But that’s what documentation is supposed to do right? Provide information to others!”. Yes, but that’s not the only way. A good example of that is a situation we often face with functions.

Command Query Separation

Most functions can be generalised into 2 categories.

Command Functions

Functions that act on instructions sent to it and make changes to the underlying data/model. These are commands given to a function and the callee is not expecting a response.

Query Functions

Functions that are used as queries to examine the underlying data/model. The callee is most certainly expecting a response. The function should not modify the underlying model in any way.

It is not common to find a function that does both. In fact, to be consistent command functions must never return a response and a query function must only return a response. This is how ideal separation happens. This way programmers can easily distinguish between Commands & Queries and the objective of the function becomes clear.

The real world however is quite different. Most functions we write are not guaranteed to work the way we want. The likelyhood of an error occurring while a function is being run is very high. This can happen during data validation or some underlying process. Hence, most functions are very likely to return a response indicating the success of a function. This is done using a variety of techniques. It is this feature that throws Command Query Separation for a toss.

In this article we are going to look at some ways in which we can achieve Command Query Separation while still retaining error handling capabilities.

Let us start by looking at the example written below.

//Division function
/*
Argument 1: Holds the numerator of type double
Argument 2: Holds the denominator of type double
Returns: Value of type double. The result of the division is returned. If the denominator is 0 the function returns 0
*/
double division(const double &firstNumber, const double &secondNumber)
{
     if (!floating_point_equality(firstNumber, secondNumber))
     {
          return firstNumber / secondNumber;
     }
     return 0.0;
}

The function is a rather simple implementation of division written in C++. It is meant to be a Query function. It immediately becomes clear that we are trying to do 2 things here:

We are trying to perform a division
We are trying to check if the division succeeded with the help of a return value

The problem is the fact that the function returns error codes and the result the same way. Any programmer using this function will have to write the code to distinguish between the two.

In this case the error is represented by the value ‘0’. There is no way for the caller to tell if the result of the division was 0 or if there was an error. It gets even worse if the function is a pure command function. A pure command function ideally should not return anything. However we will have to return a value to account for errors.

Here is an example of a Command Function:

//Division function
/*
Argument 1: Holds the numerator of type double
Argument 2: Holds the denominator of type double
Returns: An error code in the form of an integer. A '0' indicates success. '-1' indicates division by Zero error.
*/
int display_division_of_numbers(const double &amp;firstNumber, const double &amp;secondNumber)
{
     if (!floating_point_equality(secondNumber, ZERO))
     {
          std::cout&lt;&lt;firstNumber&lt;&lt;&quot; divided by &quot;&lt;&lt;secondNumber&lt;&lt;&quot; = &quot;&lt;&lt;(firstNumber / secondNumber)&lt;<span id="mce_SELREST_start" style="overflow:hidden;line-height:0;"></span>&lt;std::endl;
          return 0;
     }
     else
     {
          return -1;
     }
}

As we can see the function is a command function. It shouldn't be returning a value. But we are forced to return a value to communicate success.

Let us look at some alternatives.

Returning Error Codes

This approach is the one that was implemented above & has the obvious short comings.

Passing An Error Code variable

This is the next best approach. Instead of returning an error code pass in an object that represents error. After the call is completed, check to see if the error object is nil/NULL. This ensures that the return value always corresponds to an answer and nothing else.

//Potential Error Codes

typedef enum ErrorCodes
{
DIVIDE_BY_ZERO, NaN, NEGATIVE_NUMBER
} ErrorCodes;

//ErrorCode struct. This is the object that contains error information
typedef struct ErrorCode
{
public:
     ErrorCode(const ErrorCodes &code, const std::string &description)
     :errCode(code), errDescription(description)
     {

     }

     std::string description() const
     {
          return errDescription;
     }

private:
     //Holds the code
     ErrorCodes errCode;

     //holds additional information
     std::string errDescription;
} ErrorCode;

//Division function
/*
Argument 1: Holds the numerator of type double
Argument 2: Holds the denominator of type double
Argument 3: Holds a pointer to the error code object. If the object is nil then there was no error.
Returns: Value of type double. The result of the division is returned.
*/

double division_of_numbers(const double &firstNumber, const double &secondNumber, ErrorCode **error)
{
     if (!floating_point_equality(secondNumber, ZERO))
     {
          return firstNumber / secondNumber;
     }
     else
     {
          *error = new ErrorCode(DIVIDE_BY_ZERO, "Attempting to divide by zero");
     }
     return 0.0;
}

As is obvious from the code above, the return value always corresponds to the answer of the computation. All we have to do is check the ErrorCode pointer to see if it is NULL.

Here is the implementation for the Command Function.

//Division function
/*
Argument 1: Holds the numerator of type double
Argument 2: Holds the denominator of type double
Argument 3: Holds a pointer to the error code object. If the object is nil then there was no error.
*/
void display_division_of_numbers(const double &firstNumber, const double &secondNumber, ErrorCode **err = NULL)
{
if (!floating_point_equality(secondNumber, ZERO))
{
std::cout<<firstNumber<<" divided by "<<secondNumber<<" = "<<(firstNumber / secondNumber)<<std::endl;
}
else
{
*err = new ErrorCode(DIVIDE_BY_ZERO, "Attempting to divide by Zero.");
}
}

As you can see the function looks like a true Command Function. There is no value being returned. However, the caller still has to check if the Error object is NULL.

Another implementation of this is to use a complex response.

//Potential Error Codes
typedef enum ErrorCodes
{
     DIVIDE_BY_ZERO, NaN, NEGATIVE_NUMBER, NO_ERROR
} ErrorCodes;

//Response struct. It will hold either the error or a response.
typedef struct Response
{
public:
     Response(ErrorCodes err)
     : errCode(err), value(0.0)
     {

     }

     Response(double answer)
     : errCode(NO_ERROR), value(answer)
     {

     }

     ErrorCodes getError() const
     {
          return errCode;
     }

     double getValue() const
     {
          if (NO_ERROR == errCode)
          {
               return value;
          }
          return 0.0;
     }

private:
     ErrorCodes errCode;
     double value;
} Response;

//Division function
/*
Argument 1: Holds the numerator of type double
Argument 2: Holds the denominator of type double
Returns: A struct of type Response that either contains the value or the error. The caller must examine the struct before probing the value.
*/
Response* division_of_numbers(const double &firstNumber, const double &secondNumber)
{
     if (!floating_point_equality(secondNumber, ZERO))
     {
          Response *answer = new Response(firstNumber/secondNumber);
          return answer;
     }
     else
     {
          Response *error = new Response(DIVIDE_BY_ZERO);
          return error;
     }
}

This approach is a combination of the first 2 approaches. It immediately sends information to the caller that he/she must examine the object for errors before probing for the value. In the earlier example, there is no guarantee that the caller will examine the error. There is no guarantee with this approach either. But at least it simplifies the implementation for the caller and provides an easier mechanism to handle errors without having to manually create error objects.

Something similar is achieved in Swift using Associated Enums.


//Response Enum. It will hold either the error or a response.

enum Response
{
     case Error(String)
     case Value(Double)
}

//Division function
/*
Argument 1: Holds the numerator of type double
Argument 2: Holds the denominator of type double
Returns: An Enum Response that either contains the value or the error. The caller must examine the struct before probing the value.
*/

func division_of_numbers(firstNumber : Double, by secondNumber : Double) -> Response
{
     if (!floating_point_equality(firstNumber : secondNumber, Equals: ZERO))
     {
          let answer : Response = Response.Value(firstNumber/secondNumber)
          return answer;
     }
     else
     {
          let error : Response = Response.Error("Dividing by Zero")
          return error;
     }
}

Of course the Swift implementation does not need a struct as enums allow us to encapsulate a value in them.

Exceptions & Exception Handling

This is a much better approach. The idea is that you write you function to work as it is normally supposed to. If something goes wrong throw an exception. This approach completely eliminates the need to examine the return value or check to see if there are errors in the response object.

In exception based programming, your code will follow the correct path if there is no problem. If an issue occurs then your code jumps to the part where the error needs to be handled.

Here is an example:

#ifndef MathException_hpp
#define MathException_hpp

#include
#include
#include 

namespace MathematicalExceptions {
     class MathException : public std::exception
     {
          public:
               virtual const char * what() const throw ();
               MathException(const std::string &information);

          private:
               std::string description;
     };
}
#endif /* MathException_hpp */

The next file:

#include "MathException.hpp"

const char * MathematicalExceptions::MathException::what() const throw ()
{
     return description.c_str();
}

MathematicalExceptions::MathException::MathException(const std::string &information)
: description(information)
{

}

the next file.

#include <span id="mce_SELREST_start" style="overflow:hidden;line-height:0;"></span>
#include
#include "MathException.hpp"

const double ZERO = 0.0;

//Floating point equality checker
/*
Argument 1: Holds the LHS value of type double
Argument 2: Holds the RHS value of type double
Returns: Boolean value
*/
bool floating_point_equality(const double &amp;firstNumber, const double &amp;secondNumber)
{
     return fabs(firstNumber - secondNumber) &lt; std::numeric_limits::epsilon();
}

//Division function
/*
Argument 1: Holds the numerator of type double
Argument 2: Holds the denominator of type double
Returns: A struct of type Response that contains the value.
This function throws an exception of type MathematicalExceptions::MathException
*/
double division_of_numbers(const double &amp;firstNumber, const double &amp;secondNumber)
{
     if (!floating_point_equality(secondNumber, ZERO))
     {
          double answer = firstNumber / secondNumber;
          return answer;
     }
     else
     {
          MathematicalExpections::MathException exception = MathematicalExceptions::MathException(&quot;Attempting to divide by zero&quot;);
          throw exception;
     }
}

int main(int argc, const char * argv[]) {
     double numerator = 32.1;
     double denominator = 0.0;
     double answer = 0.0;

     try
     {
          answer = division_of_numbers(numerator, denominator);
     }
     catch (MathematicalExceptions::MathException &amp;err)
     {
          std::cout&lt;&lt;err.what()&lt;&lt;std::endl;
     }
     return 0;
}

Exceptions are about the closest we can come to achieving Command Query Separation. Anyone using functions that implement the Exception throwing and handling capability is clear as to whether it is a Command function or a query function without compromising on safety and error handling in any way.

Here is an example with Swift.

//Exception Enum. Will be used to throw an exception for mathematical operations
enum MathExceptions : Error
{
     case Divide_by_Zero(String)
     case NaN(String)
     case NegativeNumber(String)
}

//Division function
/*
Argument 1: Holds the numerator of type double
Argument 2: Holds the denominator of type double
Returns: The value of type Double. The caller must handle any exceptions that might be thrown.
*/
func division_of_numbers(firstNumber : Double, by secondNumber : Double) throws -> Double
{
     if (!floating_point_equality(firstNumber : secondNumber, Equals: ZERO))
     {
          let answer : Double = firstNumber / secondNumber
          return answer;
     }
     else
     {
          throw MathExceptions.Divide_by_Zero("Attempting to Divide by zero.")
     }
}

let ans : Double = 0.0

do
{
     ans = try division_of_numbers(firstNumber: 22.3, by: 0.0)
}
catch let err
{
     print(err.localizedDescription)
}

Again, the Swift implementation is rather Straightforward thanks to Associated Enums which conform to the Error protocol.

Here is how the Command function would look with exceptions.

//Division function
/*
Argument 1: Holds the numerator of type double
Argument 2: Holds the denominator of type double
*/
void display_division_of_numbers(const double &amp;firstNumber, const double &amp;secondNumber)
{
     if (!floating_point_equality(secondNumber, ZERO))
     {
          std::cout&lt;&lt;firstNumber&lt;&lt;&quot; divided by &quot;&lt;&lt;secondNumber&lt;&lt;&quot; = &quot;&lt;&lt;(firstNumber / secondNumber)&lt;<span id="mce_SELREST_start" style="overflow:hidden;line-height:0;">&#65279;</span>&lt;std::endl;
     }
     else
     {
          MathematicalExceptions::MathException exception = MathematicalExpections::MathException(&quot;Attempting to divide by zero&quot;);
          throw exception;
     }
}

This produces a much better implementation of the function, while maintaining the error handling capabilities.

Conclusion

As we can see implementing perfect Command Query Separation is not easy. But by writing our functions properly and by using better error handling such as exceptions it becomes a lot easier to achieve that. Programmers should be able to look at a function & tell if it is a ‘Command’ or a ‘Query’ knowing that error handling is not part of the function signature in any way.

Migrating to Swift from Objective-C

July 16, 2018 / Arun Patwardhan / Leave a comment

This article explores some of the advantages and challenges faced by developers while migrating to Swift from Objective-C.

1. Do we want to migrate?

Before you start the migration process remove the old adage:

If it isn’t broken, don’t fix it!

Start by identifying the reasons why you wish to migrate. Here are some possible reasons why.

The code is old and not updated for a very long time. You now wish to add new features.
The frameworks/libraries you are using in your project have upgraded to modern Swift and no longer support your old Objective-C syntax. *You may still want to just update to modern Objective-C, but this would be a good time to jump onto swift.
You see potential for improvement in code size/speed/performance by using new Swift features not available in Objective-C. For example: Generic Programming.
The developers who developed the app in Objective-C have left and the new employees are proficient at Swift. *Again not a strong reason, but a valid reason if there is no other alternative. Asking people to sit down and learn Objective-C may not be practical, especially if they don’t have a background in C Programming.
The app is due for a performance, stability, & bug fix update. This is a good time to consider migration to Swift.

Factors to keep in mind before considering migration.

The cost of migration. This is the cost of keeping a certain number of developers occupied in migrating the code. The cost is in terms of time as well as money.
Potential risks. Any change to the code increases the risk of bugs. The chances of introducing limits on backward compatibility also increase.
Benefits gained. An assessment needs to be done as to whether there are any benefits of migrating to Swift. The Return on Investment needs to be figured out.
Compatibility with 3rd Party or in house libraries that you might use.

After having thought through all this you are ready for the next step: “Prepare to Migrate”

2. Preparing to Migrate

This is where you actually begin to work on the migration of the App.

As a first step perform a full code review of the app.
The next step is a major decision. Should you rebuild your entire app from scratch or do a piece by piece migration. We will explore the advantages a little later in the article.
Look for Swift versions of 3rd frameworks/libraries you use. This is not strictly required, however, this is a good time to check for new APIs.
Identify parts of the project to migrate. This is to be done if it is a piecemeal migration. This marks you as ready for the next step: “Starting the Migration”.

3. Starting the Migration

Once you have everything in place you are ready to begin.

Migrations happen class by class. Select an Objective-C class to migrate and start working on converting it to Swift.

If you have any pure C functions then you can either choose to make them work with Swift or rewrite them in Swift.

While migrating pay special attention to your code. Here are some conversions that you can make.

See if you can make it simpler by using Generic Programming instead of usingVoid *
Replace the use of NSError * with exceptions.
Use extensions to give types new capabilities.
Consider creating your own Data structures. You may use Swift Arrays, Dictionaries if you wish. But this might be a good time to improve performance by building your own data structures.
Embrace closures and protocols a lot more.
Make extensive use of the @available attribute to describe your changes and mark availability
Start incorporating Swift Markup to make the comments from your Objective-C code more readable.
Enums pulled in from Objective-C can be made more powerful in Swift by adding methods which work with enums as a part of the enum itself.
Use property observers to make code more reactive. In some situations this might be easier than setting observers.

Migration Steps

Here are some general steps you can follow. The steps below are for both a full app conversion or a piece meal conversion.

Note: The steps mentioned below are sample steps and not necessarily the only way to achieve this.

If its a full app conversion then create a new project. Else duplicate the existing project.
Start by looking for the frameworks you need and importing them in the necessary Swift files.
Identify class(es) that you have in your Objective-C project. Start by creating empty versions of those in your Swift project. It is very likely that you may not need all the classes as you might be optimising or reworking your App’s architecture. Also it is possible that you may need new classes.
Next identify data structures used in the class. Either convert them to their swift equivalents or explore other options.
Migrate the functions directly associated with the data structures.
Migrate the variables used in the Objective-C class.
Lastly migrate the remaining functions to Swift.
Do this till you have converted all the classes that you wish to convert.

One point left to talk about is testing. Thoroughly test you app after each step you complete. If you are using XCTests, migrate a single Unit test at a time. Corresponding to the changes that you have made above.

5. Things to watch out for

There are many things to keep in mind while migrating your code.

In a mixed language project (Swift and Objective-C) Swift only features won’t be supported. So Generic Programming cannot be implemented.
Blind copying of the code from Objective-C to Swift may not result in the best output. Try to examine each line for potential optimisation opportunities.
Watch out for OS version compatibility. You may have to choose your Swift version accordingly.

6. Full Conversion versus Part by Part Conversion

Full Conversion

PROS:

The advantage of building the app from scratch is that your overall development time is less as different parts of the app can be refactored at development time.
You also have the advantage of adopting new development approaches or architectures such as Model View View Model (MVVM) or Test Driven Development (TDD).
You are in a better position to take advantage of all the Swift features as there won’t be any challenges with compatibility.
The advantages of Swift viz: Speed, Safety, and compact code are more easily achieved
If you want to support older versions of iOS then having a pure Swift and pure Objective-C version helps.

CONS:

Of course this means that your development time is large.
There is a potential for writing duplicate code in Swift especially if it is being reused in Objective-C projects. You may end up with 2 code bases for the same feature.

Part Conversion

PROS:

The advantage of migrating parts of your app is that you can split the migration over a larger period and use your resources on other projects.
In terms of cost this is less expensive and more resource friendly
The potential for duplicate code is reduced

CONS:

But on the flip side every time you take a new part to migrate you will have to make changes to the Swift code written earlier. This increases the development time and may affect the quality of the app in the long run.
You cannot take advantages of all the Swift features.
There is a chance that once the migration is complete the App may have to undergo an overhaul to take advantage of the Swift features & improve on Speed, Safety & Size.

This article just talks about some of the advantages and challenges with Migration to Swift. There are multiple approaches available and you will have to pick and choose the approach based on your needs or situation. I had written an article some time back about choosing between Swift & Objective-C, you can have a look at that too. Here is an article, for your reference, written by Apple on Migrating to Swift. Good luck & Happy Programming! Do feel free to share your experience migrating to Swift.

Using Swift Package Manager

April 9, 2018 / Arun Patwardhan / Leave a comment

About Swift Package Manager

The Swift Package Manager is the tool used to build Applications and Libraries. it streamlines the process of managing multiple Modules & Packages. Before we go ahead and learn to use Swift Package Manager we need to get familiar with some basic terminology.

Modules

Modules are used to specify a namespace and used to control access to that particular piece of code. Everything in Swift is organised as a module. An entire app can fit into a module or an app can be made using multiple modules. The fact that we can build modules using other modules means that reusing code becomes a lot easier. So, when we make an iOS App with Xcode and Swift. The entire app is considered a single module.

Targets

Targets are the end product that we want to make. So an app for iOS is a separate target. A library is a target. An app for macOS is a separate target. You can have many targets. Some can be for testing purposes only.

Packages

Packages group the necessary source files together. A package can contain more than one target. Normally one would create a package for a family of products. For example: you want to make a photo editing app that runs on macOS & iOS. You would create one package for it. That package would have 2 targets: an iOS App & a macOS App.

Products

This is a categorisation of your packages. There are 2 types of products. Executables or Libraries. A library contains the module which can be reused elsewhere. Executables are application that run & may make use of other modules.

Dependencies

Dependencies are the modules or the pieces of code that are required to make the different targets within the package. These are normally provided as URLs.

End Products

*NOTE: Before you get started you must be familiar with Setting up Swift on Linux. If you haven’t done that then please go through the updated article: UPDATE: Swift on Linux. This also makes use of Swift Package Manager.

Example

So let us get started with an example. We are going to learn how to create:

a library package called ErrorTypes
a library package, called MathOperations, that uses the ErrorTypes library package
an executable package called Calc that makes use of the MathOperations package.

We will see how to create all three elements. Also I have uploaded the ErrorTypes & MathOperations packages to the http://www.github.com repository to demonstrate the use of dependencies. You can also create your own local git repositories if you wish.

To illustrate the folder hierarchy: I have created a folder called “Developer” in my Ubuntu linux home folder. Within that I have created a folder called “SPMDEMO“. All the paths that I will be using will be with reference to these folders. You should see a structure like this:

/home/admin/Developer/SPMDEMO/ErrorTypes
/home/admin/Developer/SPMDEMO/MathOperations
/home/admin/Developer/SPMDEMO/Calc

You are free to follow this exercise using your own folder locations. Just modify the paths accordingly.

swift package init
swift package init --type executable
swift build

If you need help with the commands run:

swift package --help
swift --help

Creating a Package

First let us start off by creating the ErrorTypes package.
```
mkdir ErrorTypes
```
Navigate to the folder and create the package:
```
cd ErrorTypes
swift package init
```
By default init will create a library package type.
Navigate to the folder containing the source files:
```
cd ./Sources/ErrorTypes/
```

Open the ErrorTypes.swift file and write the following code

public enum ErrorCodes : Error
{
     case FileNotFound(String)
     case DivideByZero(String)
     case UnknownError(String)
}

public struct MathConstants
{
     static let pi : Float = 3.14159
     static let e  : Float = 2.68791
}

Feel free to add some code of your own. The above is just an example.

Run the command to build to make sure that there aren’t any issues. You shouldn’t have any as there are no dependencies of any kind. Its a simple straightforward piece of code.
```
swift build
```
If everything is fine check your code into a git repository. This can be local or on the web. Remember that we will need the URL to this repository.
Navigate back to the SPMDEMO folder.
```
cd ~/Developer/SPMDEMO/
```
Create a folder called MathOperations.
```
mkdir MathOperations
```
Navigate to the newly created folder and run the command to create a library package.
```
cd MathOperations
swift package init
```
Navigate to the sources folder:
```
cd ./Sources/MathOperations/
```

Open the MathOperations.swift file and write the following code.

import ErrorTypes

public struct MathOperations
{
     public static func add(Number num1 : Int, with num2 : Int) -> Int
     {
          return num1 + num2
     }

     public static func mult(Number num1 : Int, with num2 : Int) -> Int
     {
          return num1 * num2
     }

     public static func div(Number num1 : Int, by num2 : Int) throws -> Int
     {
          guard num2 > 0
          else
          {
          throw ErrorCodes.DivideByZero("You are dividing by zero. The second argument is incorrect.")
          }

          return num1 / num2
     }

     public static func sub(_ num1 : Int, from num2 : Int) -> Int
     {
          return num2 - num1
     }
}

Before we build we need to modify the Packages.swift file to indicate there is a dependency.
Notice that in the MathOperations.swift file we are importing a module called ErrorTypes. We just created it. But just because we created it doesn’t mean it will be added automatically. We need to pull that module into our own

Also notice that I have provided access specifiers “public” everywhere. This ensures that the code written in one module is accessible in the other.

Navigate to the MathOperations parent folder.
```
cd ~/Developer/SPMDEMO/MathOperations/
```

Open the Packages.swift file and make the changes as shown below:

// swift-tools-version:4.0
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(name: "MathOperations",
     products: [
          // Products define the executables and libraries produced by a package, and make them visible to other packages.
          .library(name: "MathOperations", targets: ["MathOperations"]),
     ],

     dependencies: [
          // Dependencies declare other packages that this package depends on.
          .package(url:"https://github.com/AmaranthineTech/ErrorTypes.git", from:"1.0.0"),
     ],

     targets: [
          // Targets are the basic building blocks of a package. A target can define a module or a test suite.
          // Targets can depend on other targets in this package, and on products in packages which this package depends on.
          .target(name: "MathOperations", dependencies: ["ErrorTypes"]),
          .testTarget(name: "MathOperationsTests", dependencies:   ["MathOperations"]),]
)

Once these changes are made save the file and run the command
```
swift build
```
If you typed everything correctly then you should see the source code for the ErrorTypes module being pulled in and the build being successful.Here are some common mistakes:
– Forgetting to write the import ErrorTypes statement
– Error in the URL
– The from tag not matching the tag in the repository
– Access specifiers are incorrect or missing
– Not mentioning the dependencies in the target
Just like with the ErrorTypes module create a git repository for the MathOperations module.
Now let us make the Calc executable that will use the MathOperations library. First navigate back to the SPMDEMO folder and create a folder called Calc.
```
cd ~/Developer/SPMDEMO/
mkdir Calc
```
This time we are going to create an executable package. Run the command:
```
swift package init --type executable
```
This also creates a similar folder structure as in the case of the library.
Navigate to the folder containing the main.swift file.
```
cd ./Sources/Calc/
```

Modify the main.swift file as shown below:

import MathOperations

//testing addition
var result : Int = MathOperations.add(Number: 33, with: 29)
print("Result of adding 33 with 29 is: \(result)")

//testing multiplication
result = MathOperations.mult(Number: 33, with: 29)
print("Result of multiplying 33 with 29 is: \(result)")

//testing division
do
{
     result = try MathOperations.div(Number: 33, by: 0)
     print("Result of dividing 33 by 29 is: \(result)")
}
catch let error
{
     print("ERROR: \(error)")
}

//testing subtraction
result = MathOperations.sub(3, from: 29)print("Result of subtracting 3 from 29 is: \(result)")

Navigate back to the main Calc folder.
```
cd ~/Developer/SPMDEMO/Calc/
```

Modify the Packages.swift file as shown below:

// swift-tools-version:4.0
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(name: "Calc",
dependencies: [
     // Dependencies declare other packages that this package depends on.
     .package(url: "https://github.com/AmaranthineTech/MathOperations.git", from: "1.0.1"),
],
targets: [
     // Targets are the basic building blocks of a package. A target can define a module or a test suite.
     // Targets can depend on other targets in this package, and on products in packages which this package depends on.
     .target(name: "Calc", dependencies: ["MathOperations"]),
]
)

Save the file and run the build command:
```
swift build
```
Like before you should see both the MathOperations & ErrorType module being pulled in. We are ready to run the executable. Navigate to the debug folder which contains the executable. Make sure you are in the main Calc folder when you run this command.
```
cd ./build/debug/
```
You should see an executable file called Calc. Run it.
```
./Calc
```
If everything went okay then you should see the output on the console.

As you can see it is pretty straightforward to develop Applications written in Swift on Linux.

Adding System Modules

In the previous example we saw how to import our own custom made modules. However, there are some modules provided by the system which offers functionality we may wish to use. For example if we wanted to use the random number generator in our application we would need to use the random() method. This is in the glib module.

Quickly create a package called SystemLibs. This is an executable.

Write the following code in the main.swift.

#if os(Linux)
import Glibc
#else
import Darwin.C
#endif
extension Int
{
     func toString() -> String
     {
          return "\(self)"
     }
}

var luckyNumber : Int = Int(random())

var luckyNumberStr : String = luckyNumber.toString()

print("The lucky number is \(luckyNumberStr)")

Build the code and run the executable.

Adding system modules is direct and simple. The glibc module contains aspects of the standard library. The condition check is to make sure that we are importing the correct module based on the system that we are developing the application on.

Handling Sub-dependencies

As we saw in the earlier example, sub dependencies are handled automatically. So when our Calc application marked the MathOperations module as a dependency it was pulled during the build. However, the MathOperations module itself marked ErrorTypes module as a dependency. We did not have to modify the Packages.swift file belonging to Calc to indicate that ErrorTypes module also needs to be pulled. This was handled automatically by Swift Package Manager.

Conclusion

In this article we have seen:

How to create a library package
How to create a library package that depends on another library package
How to create an executable that depends on a library package
How to import the system Glibc module into our executables.

The Swift Package Manager simplifies many aspects of the development process for us. Many of the things we have discussed also work on macOS. Going forward reusing code and planning for the same should be done keeping Swift Package Manager in mind.

UPDATE: Swift on Linux

March 27, 2018April 9, 2018 / Arun Patwardhan / 1 Comment

This article is an UPDATE for Writing Swift Programs on Linux

This article uses Command Line Interface(CLI) to write Swift Programs. If you are new to CLI then you should read the following articles: Terminal Commands for OS X – Basic, Terminal Commands for OS X – Part 2.

This article has been written using Ubuntu version 16.04 LTS

For the best part the process is still the same.

Download the Swift tools for Linux from: Swift Download Page
Untar the downloaded files
Copy them to a folder of your choice. I have created a folder called “Developer” in my home folder. So I copied the untarred contents there. This is important because we will be needing the location later.
Switch to Terminal on your Ubuntu System.
First we will install clang. Run the command
```
sudo apt-get install clang
```
Next we will make sure we set the PATH to the path where we copied the Swift tools. For example if the Untarred swift folder is called “swift-4.0-DEVELOPMENT-SNAPSHOT-2017-12-04-a-ubuntu16.04/usr/bin:”${PATH}” and it is in the Developer folder I created earlier then the command would be:
```
export PATH=/home/admin/Developer/swift-4.0-DEVELOPMENT-SNAPSHOT-2017-12-04-a-ubuntu16.04/
```
The folder name will vary from system to system. The path above is just an example.
Let us check to make sure that everything installed okay. We can do this with 2 commands:
```
which swift
```
This should show you the path to the folder.
or
```
swift --version
```
This should print out the swift version.

Next let us test the REPL. Run the command:

swift

This will result in a prompt that looks like:

Welcome to Swift version 4.0.3-dev (2dedb62a0b, Clang ab7472e733, Swift 64ab6903b2). Type :help for assistance.
 1>

Type some of the commands mentioned below:

12 * 8
let hello = "Welcome to Swift in Linux"
print(hello)

Now that we know that the REPL is working well, let us move on to the next stage. Let us quit from the REPL:
```
:q
```

Creating Single File Projects

Next let us use Swift Package Manager to create a single file project. I will be creating the project in the Developer folder. So I will navigate to it:cd ~/Developer/
Create a folder of your choice, lets call it Hello World:
```
HelloWorld
```
Enter the folder:
```
cd HelloWorld
```
Create a manifest file for the Package with the command:
```
swift package init
```
This will create some content for you. The structure should look as shown below.
If we run the command to build it will simply create a module for us. To do that type and run:
```
swift build
```
But we would like to create an executable application. In the sources folder create a file called main.swift. You can use the command:
```
touch main.swift
```
to quickly create a new swift file.

Open the main.swift file. Write the following code in there:

let object : HelloWorld = HelloWorld()
print(object.text)
print("End of program...!")

To create the executable we will first build our code:
```
swift build
```
Now we will run the executable, assuming that you are still in the HelloWorld folder within the sources folder navigate to a hidden build folder. To do that first we will navigate to our main HelloWorld package folder.
```
cd ../..
```
To view all the folders including the hidden folders run the list command:
```
ls -la
```
Navigate to the hidden folder and the debug folder inside it to locate the executable:
```
cd .build/debug/
```
To run the executable:
```
./HelloWorld
```
If you want to build and directly run & avoid doing steps 9-13 repeatedly the command is:
```
swift run
```

Next we will see how to create multi file projects

Create Multi File Projects

In the previous project go back to the HelloWorld folder within the Sources folder. Create a file called converter.swift:
```
touch converter.swift
```

Write the following code in that file:

//note the code below is for demonstrating multi file projects & may not necessarily be accurate or correct

//note the code below is for demonstrating multi file projects & may not necessarily be accurate or correct
func centigrade_to_fahrenheit(temperatureInCentigrade : Float) -> Float
{
     return ((temperatureInCentigrade*9.0/5.0)+32.0)
}

func string_to_float(input : String) -> Float
{
     var number : Float = 0.0;
     var result : Float = 0.0
     var decimalFound : Bool = false
     var numberOfDigitsAfterDecimal : UInt8 = 0

     for charac in input
     {
          switch charac
          {
               case "0":
                    number = 0.0;
                    result = (result * 10.0) + number;
               case "1":
                    number = 1.0;
                    result = (result * 10.0) + number;
               case "2":
                    number = 2.0;
                    result = (result * 10.0) + number;
               case "3":
                    number = 3.0;
                    result = (result * 10.0) + number;
               case "4":
                    number = 4.0;
                    result = (result * 10.0) + number;
               case "5":
                    number = 5.0;
                    result = (result * 10.0) + number;
               case "6":
                    number = 6.0;
                    result = (result * 10.0) + number;
               case "7":
                    number = 7.0;
                    result = (result * 10.0) + number;
               case "8":
                    number = 8.0;
                    result = (result * 10.0) + number;
               case "9":
                    number = 9.0;
                    result = (result * 10.0) + number;
               default:
                    decimalFound = true
                    break
          }
          if decimalFound
          {
               numberOfDigitsAfterDecimal += 1
          }
     }

     for _ in 0..<numberOfDigitsAfterDecimal-1
     {
          result = result / 10.0
     }
     return result
}

Write the following code in the main.swift file:

let object : HelloWorld = HelloWorld()
if CommandLine.arguments.count != 2
{
        print("USAGE: centigradeToFahrenheit 33.4")
        print("You are missing an argument")
}
else
{
        let temperatureInCentigrade = string_to_float(input: CommandLine.arguments[1]) 

        print("\(temperatureInCentigrade) is equal to \(centigrade_to_fahrenheit(temperatureInCentigrade: temperatureInCentigrade))")
}
print(object.text)
print("End....!")

Build and run the code. To run it while passing arguments in:
```
./HelloWorld 33.4
```

So that is how you can build single file & multi file Swift applications on Linux.

Automation on the Mac

March 22, 2018July 28, 2019 / Arun Patwardhan / 1 Comment

Automating tasks on the Mac is very useful for a wide variety of reasons. In this article we are going to look at the different technologies available for automating tasks.

TOOLS

Automator

The simplest way of achieving automation. Automator which is a built in application allows you to create task workflows by simply dragging in a set of predefined routines into a specified sequence. Let us explore how it works by creating a watermarking print plugin

Let us look at how we can create a print plugin that automatically adds a watermark to the pdf file.

First get hold of an image that you will use as a watermark.
Open Automator.
Click on “New Document”
Choose Print Plugin as the type of task to create
From the left hand side drag the “Watermark PDF Documents” option. You will be able to locate this from the PDF library on the extreme right.
Add the image that will be used as a watermark. Customise the settings to your desired level. You may have to use trial and error till you get the desired output.
Similarly drag the Move finder Items to the right. You will be able to locate this from the Files & Folders library.
Save the task as WatermarkCreator.
Open a text file.
Select File > Print
Click on the PDF drop down in the print dialog.
Select the newly created task.
You have now successfully setup your own watermark creator.

Shell Scripting

For those coming from a Linux/Unix background this might be a familiar option. Very often users need to run a series of terminal commands repeatedly. While it is not difficult to do this, wouldn’t it be nice if we could write all the commands in a single file? Shell Scripts help users do just that.

To create a shell script:

Open TextEdit

Write the following code in there (We will write code to create a series of files and folders in our home folder for a user called admin):

#! /bin/sh
cd /Users/admin/
if [ -d "/Users/admin/Applications/" ]; then
echo "Applications Folder Exists"
else
mkdir Applications
fi
if [ -d "/Users/admin/Sites/" ]; then
echo "Sites Folder Exists"
else
mkdir Sites
fi
if [ -d "/Users/admin/Developer/" ]; then
echo "Developer Folder Exists"
else
mkdir Developer
fi
cd Developer
if [ -d "/Users/admin/Developer/iOSProjects/" ]; then
echo "iOSProjects Folder Exists"
else
mkdir iOSProjects
fi
if [ -d "/Users/admin/Developer/macOSProjects/" ]; then
echo "macOSProjects Folder Exists"
else
mkdir macOSProjects
fi

Save the file with the name FolderCreator on the Desktop.
Open the Terminal Application
Let us make the script executable. To do that, run the commands:
```
cd ~/Desktop
chmod 777 FolderCreator
```
Now run the command:
```
./FolderCreator
```

You have now easily created your own shell script. For more information about terminal commands you can read the following articles: Terminal Commands for OS X – Basic, Terminal Commands for OS X – Part 2, Terminal Commands – Part 3, & Configuring/Troubleshooting OS X Using Command Line

AppleScript

AppleScript is Apple’s proprietary scripting technology. It comes bundled as a part of macOS. To create AppleScript tasks we need to use the built in AppleScript editor.

Here is an example of a small AppleScript

tell application “Finder” to set the view for all Finder Windows as column view
tell application “Finder” to close every Finder Window
tell application “Safari”
open location “<a href="http://www.arunpatwardhan.com">http://www.arunpatwardhan.com</a>
open location “<a href="http://www.amaranthine.in/feedback">http://www.amaranthine.in/feedback</a>
open location “<a href="http://www.amaranthine.in/gallery">http://www.amaranthine.in/gallery</a>
end tell

Copy that block of commands in your AppleScript editor and see what comes up.

There are many more things that can be done with AppleScript. You can have popup windows asking users for commands, turn off the computer. Change the settings for different parts of the OS and for different applications. All this with commands written in a single file. All the user has to do is double click the file.

For more information about AppleScript visit Apple’s Developer site.

Launch Agents, Launch Daemons

NOTE: Scheduling Launch Agents/Launch Daemons improperly may leave your computer in an unusable state. Always test this on a computer that does not contain important data. If you are unsure, please consult someone with knowledge of the same before proceeding ahead.

Launch Agents/Launch Daemons allow you to schedule tasks which are to be performed at intervals. You can also use them to ensure that tasks are kept running and that the user does not have the possibility to quit them. To setup a launch daemon:

First create a Plist file that looks like the one below. I have created a script called echoer and placed it in the /Users/admin/Applications folder where admin is the user.
Place the file in the ~/Library/LaunchAgents folder. Name it in.amaranthine.demod.plist

Run the command in terminal to load the Launch Agent.

launchctl load ~/Library/LaunchAgent/in.amaranthine.demod.plist

That’s it you have just setup a simple launch agent which will ensure that your script runs every 6 seconds.

For more information or to create detailed Launch Agents/Launch Daemons visit:Creating Launch Agents & Launch Daemons

Login Items

An easy way to automatically load, Applications/Files/Folder, as soon as well login is to use Login Items. This is very easy to do.

Open System Preferences > Users & Groups
Switch to the Login Items tab.
Click on the ‘+’ sign at the bottom to add new Applications. Let’s add Maps so that it launches as soon as we login. You should see it appear in the list.

That’s it. You have setup login items. You can repeat this process for as many applications as you wish.

Others

PHP, Perl, Python, Javascript, Swift allow you to create custom automated tasks and routines. These require knowledge of programming.

Choosing the right approach

Which one to choose depends on a lot of factors but we can break it down to 2:

You are a technically qualified person and understand things like programming, scripting and command line
You are an end user working either at home or in office.

End User

If you are an End user then you should really stick to Automator and Login Items. These are the ones that are the easiest to implement and least likely to cause any issues. You could venture and explore other options if you have a good understanding of them. Or you can ask the IT or Tech Support teams to help you with scripting and other technologies.

Tech Support or IT Person

Any of the tools mentioned above can be used by you. Make sure that you have a good command over the tools and are able to troubleshoot issues arising out of their usage.

Note: The programs/applications/tools and languages mentioned in this article may not cover all the available options. Also, anyone who uses or implements the items mentioned in the article does so at their own risk. The author does not take responsibility for any loss or damage that may arise from the use of the programs/applications/tools and languages mentioned above.

Programming Style Guide: Documentation

December 24, 2017 / Arun Patwardhan / 1 Comment

Now we will shift our attention to that part of programming which is often ignored. Documentation.

Documentation is a key part of programming. In fact, some might go as far as saying that Documentation is the most important aspect of Programming. Let us understand what we mean by documentation by looking at some key points. Later we will look at different ways of documenting our code.

We document our code so that:

Anyone who is reading our code can understand what we are trying to achieve.
Anyone who wishes to make changes to our code knows where to make the changes.
Anyone who issuing our code can easily find out its capabilities and limitations.
Other programmers can figure out how to use our code.
Developers can find out when and where changes were made to a code. This is useful to understand the evolution of our code.
We can easily recollect what, why, when, where & how something was done by us. This is necessary if we are revisiting code that we have written a long time back.
We can add warnings and disclaimers

There may be some other reasons why we may want to document our code, but the list above summaries the most common reasons. This can easily be seen from a simple example.

func fahr_to_cent(Centigrade temp : Float) -&amp;gt; Float
{
return (32 + (temp * 1.8))
}

It is clear to use what the function does simply from its name. However, there is a lot more information that we can provide. Let us modify the implementation a little bit to make it more informative and readable.

/**
This function takes temperature in Centigrade and converts it to Fahrenheit.
- important: This function does not do data validation
- parameter temp: This is the temperature in Centigrade. It can be a negative value too.
- returns: This is the temperature in Fahrenheit.
- requires: `temp > -273.0 && temp < 1000.0`
- Note: The requirement mentioned is not enforced.
- Since: iOS 11
- author: Arun Patwardhan
- copyright: Copyright (c) Amaranthine 2015
- version: 1.0
*/
func convert_to_fahrenheit_from(Centigrade temp : Float) -&amp;gt; Float
{
     return ((temp * 9.0 / 5.0) + 32.0)
}

The code above looks a lot better now. We made the function name better, but more importantly we have added documentation that better describes the function. This includes range of permitted values, version number, important notes. The comments haven’t been written randomly. They have been formatted in a way that will make them appear in quick help. So now if we have to use the function we know what to watch out for.

Now that we know why we need to document our code let us look at some of the ways this can be done.

Comments

The most common form of documentation is by using comments. Most programming languages support comments. Comments are text which is ignored by the compiler. As such they are not used to build the actual software. The sole reason why they exist is because there has to be some mechanism to write notes.

Single Line Comments

// This is a comment

A single line comment as the name says is a piece of text that can fit in one line.

Good when a short description is required. Normally this is placed before or after a variable as most variables would need a short description.

You can have multiple lines using the Single comment mechanism too.

// This is a comment
// This is a comment on the next line

Multi Line Comments

There is a better way to implement multi line comments. We can enclose the text in a /* */ range.

/* This is a comment
   This is a comment on the next line
   Useful when we have to write really large pieces of comments&amp;amp;amp;lt;span 				data-mce-type="bookmark" 				id="mce_SELREST_start" 				data-mce-style="overflow:hidden;line-height:0" 				style="overflow:hidden;line-height:0" 			&amp;amp;amp;gt;&amp;amp;amp;lt;/span&amp;amp;amp;gt;
*/

Use Case

Here are some examples of when comments can or should be used.

/*
        File Name.   : main.cpp
        Date Created : 13th February 2017
        Created By   : Arun Patwardhan
        Project Name : String Parser
        File Contents:
                - Command Line Option selector
                - Different entry points for the remaining code
        Contact      : arun@amaranthine.co.in
*/

This is a classic example of a multi line comment. This comment provides useful information about the name of the file, when it was created, who created it, contact information, the code that is found in this file.

/*
    Exception Possibilities while Reading/Writing from/to Database
    write_error : This is thrown when there is duplicate data that is being
                  written into the database.
    db_empty.   : This is thrown when you attempt to read from an empty data
                  base.
                  Use the func is_empty() method.
    invalid_data: This is thrown when the data to be written is not valid.
    data_missing: This is thrown when insufficient data is passed. If the write
                  operation requires mandatory data an exception is thrown
                  instead of writing default values.
*/
enum DBExceptions : Error
{
    case write_error(String)
    case db_empty(String)
    case invalid_data(String)
    case data_missing(String)
}

This example shows the necessary documentation while declaring a new type. In short its purpose and situations when different values might be used.

Here is an example of code for functions.

@interface Converter : NSObject
/*!
    @brief This is a temperature conversion function

    @discussion This functions takes floating point values and does a floating point conversion to make sure that we get a precise conversion.

    @param temperature This is the value in centigrade that is passed in. Note, negative values can also be passed in. Values whose results exceed the range supported by float will produce un predictable results.

    @return float Returns a floating point value
*/
-(float) convert_to_fahrenheit_from_centigrade:(float) temperature;
@end

The comment gives information about different aspects of the function. Including the rage of values supported. Note that it also uses special markup to allow for the code description to show up in the Help menu bar or when you option click the method.

This is how the comments with markup look like. They appear in the ⌥ click menu as well as the help menu on the right hand side.

Read Me Files

Another thing one can do along with comments is to create Read Me files. Read Me files are plain text files that are bundled as a part of the project. Unlike comments which give information about a specific piece of code or an entire file, Read Me files give information about the entire project as a whole. Since they are text files we actually treat them as text.

Here is some typical information that is found in a Read Me file:

Project Name : String Parser
Project Request/Ticket Code: 13788
Orignal Project Author : Arun Patwardhan
Contact Details :
– arun@amaranthine.co.in
– http://www.amaranthine.in

Platforms on which Application Can Run
– macOS 10.10 or later
– Windows 7 or later
– Linux (Ubuntu 14 or later)

Compiler Supported – g++

Building the Application

make

Testing

strParser -f Test1 -o myOutput1
strParser -f Test2 -o myOutput2

Files
– makefile
This is the file used to build the Application.

– main.cpp
This is the entry point file. The selection of execution path on the basis of command line options is done here.

– Parser.h
This file contains the declaration for the Parser class as well as its internal structure.

– Parser.cpp
This file contains the implementation of the Parser class

– DataStructure.h
This file contains the declaration of the internal structure of the data structure.

– DataStructure.cpp
This file contains the implementation of the internal structure of the data structure.

– Validator.h
This file contains the declaration of the internal structure of the data structure.

– Validator.cpp
This file contains the implementation of the internal structure of the data structure.

– Test1
Runs a basic set of strings as input.

– Output1
Expected output after running Test1. Compare your results with the results of this file.

Libraries Required – Standard Template Library

The above is just a sample Read Me file. In real world implementations these can get a lot bigger with references to links and future developments. Some of the other things that can be mentioned are:

Future additions
Bugs fixed (potentially with the bug fix request ticket)
Limitations
Tools that are required to make this code
Additional tools that need to be installed
Project Status

Naming Conventions

Documentation becomes a lot easier if we follow good naming conventions. Variables, functions, types, files… which are well named in itself become self explanatory and at the very least reduce the amount of documentation required.

Additional Tools Documentation in C++, Objective-C

Doxygen

HeaderDoc – retired You may come across some projects that use this.

Additional References for Documentation for Swift

Here is an article on Markups for Swift.

Adding formatted text to Swift in Xcode

November 9, 2017 / Arun Patwardhan / 1 Comment

Formatting in Playgrounds and Xcode projects is achieved using Markups in comments. The following article describes some of the things that you can do. Note that there are many more ways of acheiving some of the effects shown here.

The idea behind markups is to make your code more readable whether you are using Playgrounds or Xcode.

If you can only see the commented code in playgrounds and not the rendered markup then click on Editor > Show Rendered Markup to view the rendering. You can use this option to toggle back and forth.

Formatting in Playgrounds

Plain Text

There are different kinds of text you can place in a Playground. Let us look at the code below to see what all is achieved.

//: # Documentation
//: ## Contents
//: * Text Description
//: * Documentation for Functions
//: * Documentation for Types
//: * Formatting Text
//:  - Code
//:  - Italics
//:  - Bold
//: * Inserting Items
//: * Links
//: * Assets
//: * Callouts

The comments here are in the format //:.

This is how the rendered output looks.

Line 1 shows how to render a Title Text. This is achieved using the # before the text.
Line 2 shows how to get a lower sized text by using ## instead of #. We can achieve more levels if we wish.

For multi line text with bullets use the *, +, – symbols. This is seen on lines 7-13.

It is also possible to create numbered lists too. Simply type the numbered list & it renders accordingly.

//: * Inserting Items
//: 1. Links
//: 2. Assets
//: 3. Callouts

This renders as:

Playground Pages

It is possible to have multiple pages in Playgrounds. This way we can create a more readable experience that makes the code structured, compartmentalised and easier to understand.

To do that open a playground and then simply add a playground by clicking File > New > Playground Page.

To move from one page to the next simply write the comment.

//: [Next Topic](@next)

This will automatically place a link to jump to the next page.

Similarly you can add a link to move to the previous page.

//: [Previous](@previous)

Code block

We can even show a code block in the text. It is formatted in a different manner to tell the user that it is a code block.

//: ### Code block
/*:
Loop to print characters
````
for char in "Arun Patwardhan"
{
    print(char)
}
*/

This is how it appears:

Function Help

There is also some formatting that can be done for functions, types and other pieces of code written in a playground. This also appears on the quick help of the sidebar.

We will look at how to create formatted markup for playgrounds.

/*:
## This function takes temperature in Centigrade and converts it to Fahrenheit.
- important: This function does not do data validation
*/
/*:
- Note: "Please refer to Quick Help for more information."
*/
/*:
- Callout(Custom Callout): This is how you create a custom callout ` - Callout(Custom Callout):`
*/
/*:
- Example: `convert_to_fahrenheit_from(Centigrade: 32.0)`
*/

This renders as:

Formatted Markup for Functions.

We will look at formatting the comments to appear in Quick Help in the Formatting for Xcode section.

Inserting Links

The last bit is related to inserting links. We have already seen how to insert links for moving between Playground pages.

Redirecting to URL

/*:
For more articles on Programming, see [Programming articles @ arunpatwardhan.com](https://arunpatwardhan.com/category/programming/)
*/

This renders as:

Formatting for Xcode

Function Help

As we saw in the earlier section we can create a lot of documentation for Functions. The approach is similar to the one we used in Playgrounds. We will be using callouts to provide information. We will use some callouts for Playgrounds, however, there are many more callouts available for Xcode Symbol Documentation as compared to Playground. The main difference here is the fact that the comments begin with /** instead of /*:.

“The code shown below will work in both, regular Xcode projects as well as Playgrounds.”

/**
This function takes temperature in Centigrade and converts it to Fahrenheit.
- important: This function does not do data validation
- parameter temp: This is the temperature in Centigrade. It can be a negative value too.
- returns: This is the temperature in Fahrenheit.
- requires: `temp > -273.0 && temp < 1000.0` - Note: The requirement mentioned is not enforced. - Since: iOS 11 - author: Arun Patwardhan - copyright: Copyright (c) Amaranthine 2015 - version: 1.0 */
func convert_to_fahrenheit_from(Centigrade temp : Float) -> Float
{
    return ((temp * 9.0 / 5.0) + 32.0)
}

This renders as:

Formatted Markup for Playgrounds as well as Quick Help

Note that the quick help appears in the Right hand side sidebar. That too only after you select the function.

As we can see this makes the function a lot more readable. The real advantage of Quick Help comes in the fact that the documentation is now easily accessible no matter which file we are in within the project. The also helps the developer put in the right kind of information, required for proper usage of the function, in the help section.

Note that the rendered markup for Playgrounds will only appear in Playgrounds.

Inserting Links

Just like in the previous section where we introduced links we can add links to the symbol documentation.

/**
   For more articles on Programming [Programming articles @ arunpatwardhan.com (https://arunpatwardhan.com/category/programming/)
*/
func recursiveFunction(count : inout Int)
{
   while 0 <= count
   {
      count -= 1
      recursiveFunction(count: &count)
   }
}

This renders in Quick Help as:

Callouts supported by Playgrounds

Custom Callout
Example

Callouts supported by Symbol Documentation

Attention
Author
Authors
Bug
Complexity
Copyright
Date
Invariant
Precondition
Postcondition
Remark
Requires
See Also
Since
Version
Warning

Callouts supported by both Playgrounds & Symbol Documentation

Experiment
Important
Note

Programming Style Guide: Code Refactoring

October 17, 2017 / Arun Patwardhan / 1 Comment

One of the key attributes towards code that is readable and easy on the eyes is code that is split into appropriately sized pieces. Code refactoring is does exactly that. It is very easy to write a program as one big piece of code. Of course, any program that grows becomes increasingly complicated and highly inefficient. If not controlled, it will soon reach a point where it is highly unreadable, extremely difficult to maintain & filled with bugs. Not to mention that it is inefficient too.

Refactoring code and breaking it down into smaller reusable chunks is the key. The objective is:

To make code easier to read
To make reusable components so that we can save on duplication of code. This will reduce the code count and make sure that any changes to the reused code are available everywhere.
To lend a structure to the application. Tasks now have their own space.
Build scalable and maintainable code.
Build bug free code.

Let us look at an example.

Bad Code

This code is clearly written poorly. Its difficult to read. There aren’t good whitespaces. No consistency. Even the naming conventions are poor.

The fix would be :

Break it down into different functions
Separate tasks into their own files
Name the different elements of the code properly.

This is how the code looks now. It has been broken down into different files.

main.cpp

#include <iostream>
#include "MathOperations.hpp"
#include "Choices.hpp"

int main(int argc, const char * argv[])
{
     float number1           = 0.0;
     float number2           = 0.0;
     Choices selectedOption  = CLEAR;
     float answer            = 0;
     float integralAnswer    = 0;

     while(EXIT != selectedOption)
     {
          //Welcome message
          std::cout<<"Welcome to Calculator Program"<<std::endl;
          std::cout<<"Choose between the following options"<<std::endl;
          std::cout<<"1. Add\n2. Subtract\n3. Multiply\n4. Divide\n5. Remainder\n6. Percentage"<<std::endl;

          //User choice
          std::cout<<"Choice: ";                               std::cin>>selectedOption;

          //Chance to enter first number
          std::cout<<"Number 1: ";                               std::cin>>number1;

          //Chance to enter second number
          std::cout<<"Number 2: ";                               std::cin>>number2;

          switch (selectedOption)
          {
               case ADDITION:
                    answer = addition(number1, number2);
                    std::cout<<"The addition of "<<number1<<" & "<<number2<<" = "<<answer<<std::endl;
                    break;
               case SUBTRACTION:
                    answer = subtraction(number1, number2);
                    std::cout<<"The subtraction of "<<number1<<" & "<<number2<<" = "<<answer<<std::endl;
                    break;
               case MULTIPLICATION:
                    answer = multiplication(number1, number2);
                    std::cout<<"The multiplication of "<<number1<<" & "<<number2<<" = "<<answer<<std::endl;
                    break;
               case DIVISION:
                    answer = division(number1, number2);
                    std::cout<<"The division of "<<number1<<" & "<<number2<<" = "<<answer<<std::endl;
                    break;
               case REMAINDER:
                    integralAnswer = remainder((int)number1, (int)number2);
                    std::cout<<"The remainder of "<<number1<<" divided by "<<number2<<" = "<<integralAnswer<<std::endl;
                    break;
               case PERCENTAGE:
                    answer = percentage(number1, number2);
                    std::cout<<"The percentage of "<<number1<<" out of "<<number2<<" = "<<answer<<span 				data-mce-type="bookmark" 				id="mce_SELREST_start" 				data-mce-style="overflow:hidden;line-height:0" 				style="overflow:hidden;line-height:0" 			></span><std::endl;
                    break;
               default:
                    break;
          }
     }
     return 0;
}

Choices.hpp

#ifndef Choices_hpp
#define Choices_hpp

#include <stdio.h>
#include <iostream>

enum Choices : unsigned short int { ADDITION = 1, SUBTRACTION, MULTIPLICATION, DIVISION, REMAINDER, PERCENTAGE, CLEAR, EXIT};

typedef enum Choices Choices;

std::istream& operator >>(std::istream &is, Choices& enumVar);

#endif

Choices.cpp

#include "Choices.hpp"

std::istream& operator >>(std::istream &is, Choices& enumVar)
{
    unsigned short int intVal;
    is>>intVal;
    switch (intVal) {
        case 1:
            enumVar = ADDITION;
            break;
        case 2:
            enumVar = SUBTRACTION;
            break;
        case 3:
            enumVar = MULTIPLICATION;
            break;
        case 4:
            enumVar = DIVISION;
            break;
        case 5:
            enumVar = REMAINDER;
            break;
        case 6:
            enumVar = PERCENTAGE;
            break;
        default:
            enumVar = EXIT;
            break;
    }
    return is;
}

MathOperations.hpp

#ifndef MathOperations_hpp
#define MathOperations_hpp

#include <stdio.h>

//Addition
float addition(float number1, float number2);

//Subtraction
float subtraction(float number1, float number2);

//Multiplication
float multiplication(   float number1, float number2);

//Division
float division(float number1, float number2);

//Remainder
int remainder(int number1, int number2);

//Percentage
float percentage(float number1, float number2);

#endif

MathOperations.cpp

#include "MathOperations.hpp"

//Addition
float addition(float number1, float number2)
{
    return number1 + number2;
}

//Subtraction
float subtraction(float number1, float number2)
{
    return number1 - number2;
}

//Multiplication
float multiplication(   float number1, float number2)
{
    return number2 * number1;
}

//Division
float division(float number1, float number2)
{
    if (number2 > 0) {
        return number1 / number2;
    }
    return 0.0;
}

//Remainder
int remainder(int number1, int number2)
{
    return number1 % number2;
}

//Percentage
float percentage(float number1, float number2)
{
    if (number2 > 0) {
        return (number1 / number2) * 100.0;
    }
    return 0.0;
}

Let us look at how this looks for Swift.
main.swift

import Foundation

var number1 : Float             = 0.0
var number2 : Float             = 0.0
var selectedOption : Choices    = Choices.CLEAR
var answer : Float              = 0.0
var integralAnswer : Int        = 0

func readNumbers(One firstNumber : inout Float, Two secondNumber : inout Float)
{
     //Chance to enter first number
     print("Number 1: \n")
     firstNumber = Choices.inputNumbers()

     //Chance to enter second number
     print("Number 2: \n")
     secondNumber = Choices.inputNumbers()
}

while(Choices.EXIT != selectedOption)
{
     //Welcome message
     print("Welcome to Calculator Program")
     print("Choose between the following options")
     print("1. Add\n2. Subtract\n3. Multiply\n4. Divide\n5. Remainder\n6. Percentage")

     //User choice
     print("Choice: \n")
     selectedOption = Choices.inputChoices()
     switch (selectedOption)
     {
          case Choices.ADDITION:
               readNumbers(One: &number1, Two: &number2)
               answer = addition_of(_value: number1, with_value: number2)
               print("The addition of \(number1) & \(number2) = \(answer)")
               break
          case Choices.SUBTRACTION:
               readNumbers(One: &number1, Two: &number2)
               answer = subtraction_of(_value: number1, from_value: number2)
               print("The subtraction of \(number1) & \(number2) = \(answer)")
               break
          case Choices.MULTIPLICATION:
               readNumbers(One: &number1, Two: &number2)
               answer = multiplication_of(_value: number1, with_value: number2)
               print("The multiplication of \(number1) & \(number2) = \(answer)")
               break
          case Choices.DIVISION:
               readNumbers(One: &number1, Two: &number2)
               answer = division_of(_value: number1, by_value: number2)
               print("The division of \(number1) & \(number2) = \(answer)")
               break
          case Choices.REMAINDER:
               readNumbers(One: &number1, Two: &number2)
               integralAnswer = remainder_of(_value: Int(exactly:number1)!, <span 				data-mce-type="bookmark" 				id="mce_SELREST_start" 				data-mce-style="overflow:hidden;line-height:0" 				style="overflow:hidden;line-height:0" 			></span>divided_by_value: Int(exactly: number2)!)
               print("The remainder of \(number1) divided by \(number2) = \(integralAnswer)")
               break
          case Choices.PERCENTAGE:
               readNumbers(One: &number1, Two: &number2)
               answer = percentage_of(_value: number1, with_respect_to_value: number2)
               print("The percentage of \(number1) out of \(number2) = \(answer)")
               break
          default:
               selectedOption = .EXIT
               break
     }
}

Choices.swift

import Foundation

enum Choices { case ADDITION, SUBTRACTION, MULTIPLICATION, DIVISION, REMAINDER, PERCENTAGE, CLEAR, EXIT}

//CLI Reading Capability
extension Choices
{
    static func inputChoices() -> Choices
    {
        let ip : String? = readLine()
        let choice : String = String(ip!)

        switch choice {
        case "1":
            return .ADDITION
        case "2":
            return .SUBTRACTION
        case "3":
            return .MULTIPLICATION
        case "4":
            return .DIVISION
        case "5":
            return .REMAINDER
        case "6":
            return .PERCENTAGE
        default:
            return .EXIT
        }
    }

    static func inputNumbers() -> Float
    {
        let ip : String? = readLine()

        let numberFormatter = NumberFormatter()
        let number = numberFormatter.number(from: ip!)

        let num : Float? = number?.floatValue
        return num!
    }
}

MathOperations.swift

import Foundation

//Addition
func addition_of(_value number1 : Float, with_value number2 : Float) -> Float
{
    return number1 + number2;
}

//Subtraction
func subtraction_of(_value number2 : Float, from_value number1 : Float) -> Float
{
    return number1 - number2;
}

//Multiplication
func multiplication_of(_value number1 : Float, with_value number2 : Float) -> Float
{
    return number2 * number1;
}

//Division
func division_of(_value number1 : Float, by_value number2 : Float) -> Float
{
    if (number2 > 0) {
        return number1 / number2;
    }
    return 0.0;
}

//Remainder
func remainder_of(_value number1 : Int, divided_by_value number2 : Int) -> Int
{
    return number1 % number2;
}

//Percentage
func percentage_of(_value number1 : Float, with_respect_to_value number2 : Float) -> Float
{
    if (number2 > 0) {
        return (number1 / number2) * 100.0;
    }
    return 0.0;
}

Discussion on Swift Extensions

As we can see that most of the code in Swift is very similar to C++. Most of the differences are basic syntactic differences. However, there is 1 feature of Swift that greatly aids code refactoring that I would like to talk about, Extensions.

Extensions allow us to add new functionality to the existing type. As the name says the type is extended. This allows us to add changes to a type in a consistent & clearly demarcated way. Developers can now neatly separate newly added components. This greatly helps in understanding the evolution of types.

“This is often referred to as versioning.”

Extensions can be used in the following ways to implement code refactoring:

Different sections of a type reside in their own extensions
Changes made to a type are made by keeping them in their own extensions
Step by step build up of code is done by representing each step as an independent extension. This gives clarity on how a certain end result was achieved.

Conclusion

As we can see from the sample code above (for both C++ & Swift) the program is much more readable. Code is carefully compartmentalised. Its a lot easier to read. It is a lot easier to scale too.

The reader may point out that the amount of code to achieve the same result is significantly higher, that however is a small price to pay in the long run. The biggest advantage is the scalability & the ease with which it can be done. Simply breaking code down into separate files & functions makes a huge difference. Here are some other benefits:

Individual files can be modified. This means one can now have a team working on different parts of the code.
Code is less cluttered. Changes are now spread across files & are easier to track.

What are “nibless” apps?

Why should we create Apps without storyboard?

How can we create Apps without Storyboard?

Are there any benefits of creating apps without storyboard?

Are there any drawbacks?

Note

Download the Source Code

Share this:

Like this:

Points to Note:

Getting Started

Creating the Reusable Framework

Using the Framework in a project

Link to Sample Code

Video

Share this:

Like this:

Command Query Separation

Command Functions

Query Functions

Returning Error Codes

Passing An Error Code variable

Exceptions & Exception Handling

Conclusion

Share this:

Like this:

1. Do we want to migrate?

2. Preparing to Migrate

3. Starting the Migration

Migration Steps

5. Things to watch out for

6. Full Conversion versus Part by Part Conversion

Full Conversion

Part Conversion

Share this:

Like this:

About Swift Package Manager

Modules

Targets

Packages

Products

Dependencies

End Products

Example

Creating a Package

Adding System Modules

Handling Sub-dependencies

Conclusion

Share this:

Like this:

Creating Single File Projects

Create Multi File Projects

Share this:

Like this:

TOOLS

Automator

Shell Scripting

AppleScript

Launch Agents, Launch Daemons

Login Items

Others

Choosing the right approach

End User

Tech Support or IT Person

Share this:

Like this:

Comments

Single Line Comments

Multi Line Comments

Use Case

Read Me Files

Naming Conventions

Additional Tools Documentation in C++, Objective-C

Additional References for Documentation for Swift

Share this:

Like this:

Formatting in Playgrounds

Plain Text

Playground Pages

Code block