How would you describe a Swift language?

 Swift:

Language was developed by ‘Chris Lattner‘ with an aim to resolve difficulties existed in Objective C. It was introduced at Apple’s 2014 Worldwide Developers Conference (WWDC) with version Swift 1.0. 

Swift is a type safe Multi-paradigm: protocol-oriented, object-oriented, functional, imperative, block structured, declarative programming.

Type-safe: 

Swift is a type-safe language, which means the language helps you to be clear about the types of values your code can work with. If part of your code requires a String, type safety prevents you from passing it an Int by mistake. Likewise, type safety prevents you from accidentally passing an optional String to a piece of code that requires a non-optional String.

Object-oriented:

Object-Oriented Programming ( OOP ) helps you structure your Swift code with so-called classes. These classes have properties and functions, and classes can inherit attributes from each other.We'll dive into classes, objects, properties, functions, and a concept called inheritance.

  • Reusability of code through inheritance.
  • Polymorphism flexibility.
  • Encapsulation

Drawbacks

  • Swift is a single inheritance language, and we can have only one superclass for the animal classes, that superclass will need to contain the code required for each of the three categories.
  • Inheritance of functionalities that a type does not need. It can lead to bloated superclasses because we may need to include functionality that is needed by only a few of the subclasses.
  • We can’t create constants in our superclass that can be set by the subclasses.
  • In Swift, Value types cannot use inheritance, only Reference types.


    Protocol-oriented: 

    • Protocol-oriented design allows us to work with classes, structures and enumerations.
    • We can use protocol extensions to add functionality to types that conform to our protocols.
    • Ability to define any of the properties as constants.
    • Protocol composition allows a data structure to implement multiple requirements.
    • Cleaner code.
    •  Instead Swift Protocols have a rule changer feature: Protocol Extensions.
    • Drawback: Abuse of protocol inheritance and protocol extensions could lead to a complex system.
    the protocol-oriented design focuses on implementing a protocol that’s concerned about the requirements other than the details as designed in the objected-oriented design. 


    Functional Programming:

    • In functional programming, data cannot be stored in objects and it can only be transformed by creating functions. In object-oriented programming, data is stored in objects.
    • In other words, functional programming promotes code with no side effects, no change of value in variables.

    Declarative programming:

    Declarative programming is a non-imperative style of programming in which programs describe their desired results without explicitly listing commands or steps that must be performed. 
    e.g.
    func filter(array: [Person], name: String) -> [Person] {
    return array.filter({ $0.name == name })
    }

    Imperative Programming:

    func filter(array: [Person], name: String) -> [Person] {
    var result = [Person]()
    for item in array {
    if item.name == name {
    result.append(item)
    }
    }
    return result
    }

    Same defiance between SwiftUI(declarative) and UIKit(imperative)



    Comments

    Post a Comment

    Popular posts from this blog

    iOS Questions (Swift Programming Language)

    Image
      1. What’s the difference between  var  and  let ?  Both var and let are references, therefore let is a const reference. let is used to declare a constant value - you won't change it after giving it an initial value. Its a immutable variable. let theAnswer = 42 The theAnswer cannot be changed afterwards. This is why anything weak can't be written using let. They need to change during runtime and you must be using var instead. The var defines an ordinary variable. What is interesting: The value of a constant doesn’t need to be known at compile time, but you must assign the value exactly once. Another strange feature: You can use almost any character you like for constant and variable names, including Unicode characters: let 🐶🐮 = "dogcow" let defines a "constant". Its value is set once and only once, though not necessarily when you declare it. For example, you use let to define a property in a class that must be set during initialization: var is used to dec...
    Read more

    Dispatch techniques: Dynamic dispatch and Static Dispatch

    4 types of dispatch techniques — Inline  (Fastest) Static Dispatch Virtual Dispatch Dynamic Dispatch  (Slowest) Dynamic dispatch Swift  allows a class to override methods and properties declared in its superclasses. ... This technique, called  dynamic dispatch , increases language expressivity at the cost of a constant amount of runtime overhead for each indirect usage. Method Dispatch is the mechanism that helps to decide which operation should be executed, or more specifically, which method implementation should be used. Dynamic Dispatch  is supported only by  reference types ( i.e.  Class). The reason for this is that, for  dynamism , or  dynamic dispatch,  in short, we need  inheritance  and our  value types  do not support inheritance. To achieve  Dynamic Dispatch , we use inheritance, subclass a base class and then override an existing method of the base class. Also, we can make use of  dynamic  k...
    Read more

    What’s the difference between var and let? Which one would you choose for properties in a struct and Class why?

    Image
    Let is an immutable variable, meaning that it cannot be changed, other languages call this a constant. Var is a mutable variable, meaning that it can be changed.   “Use let to make a constant and var to make a variable” let aPerson = Person (name: Foo , first: Bar ) //< data of aPerson are changeable, not the reference var aPerson = Person (name: Foo , first: Bar ) //< both reference and data are changeable. var aPersonA = Person (name: A , first: a) var aPersonB = Person (name: B , first: b) aPersonA = aPersonB //aPersonA now refers to Person (name: B , first: b) Value and Reference Type Reference Type(Class) Swift's  classes  are  mutable  a-priory var  +  class It can be  reassigned  or  changed let  +  class  =  constant of address It can  not  be  reassigned  and can be  changed Value(Struct, Enum) Swift's  struct  can change th...
    Read more