Introduction about Swift Programming Language

 About Swift

                Swift is a fantastic way to write software, whether it’s for phones, desktops, servers, or anything else that runs code. It’s a safe, fast, and interactive programming language that combines the best in modern language thinking with wisdom from the wider Apple engineering culture and the diverse contributions from its open-source community. The compiler is optimized for performance and the language is optimized for development, without compromising on either.

                Swift is friendly to new programmers. It’s an industrial-quality programming language that’s as expressive and enjoyable as a scripting language. Writing Swift code in a playground lets you experiment with code and see the results immediately, without the overhead of building and running an app.

The Basics of Swift :

                    Swift is a new programming language for iOS, macOS, watchOS, and tvOS app development. Nonetheless, many parts of Swift will be familiar from your experience of developing in C and Objective-C.

                    Swift provides its own versions of all fundamental C and Objective-C types, including Int for integers, Double and Float for floating-point values, Bool for Boolean values, and String for textual data. Swift also provides powerful versions of the three primary collection types, Array, Set, and Dictionary, as described in Collection Types.

                    Like C, Swift uses variables to store and refer to values by an identifying name. Swift also makes extensive use of variables whose values can’t be changed. These are known as constants, and are much more powerful than constants in C. Constants are used throughout Swift to make code safer and clearer in intent when you work with values that don’t need to change.

                    In addition to familiar types, Swift introduces advanced types not found in Objective-C, such as tuples. Tuples enable you to create and pass around groupings of values. You can use a tuple to return multiple values from a function as a single compound value.

                    Swift also introduces optional types, which handle the absence of a value. Optionals say either “there is a value, and it equals x” or “there isn’t a value at all”. Using optionals is similar to using nil with pointers in Objective-C, but they work for any type, not just classes. Not only are optionals safer and more expressive than nil pointers in Objective-C, they’re at the heart of many of Swift’s most powerful features.

                    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. Type safety helps you catch and fix errors as early as possible in the development process.

Swift defines away large classes of common programming errors by adopting modern programming patterns:

• Variables are always initialized before use.

• Array indices are checked for out-of-bounds errors.

• Integers are checked for overflow.

• Optionals ensure that nil values are handled explicitly.

• Memory is managed automatically.

• Error handling allows controlled recovery from unexpected failures.

Version Compatibility in Swift :

                This book describes Swift 5.4, the default version of Swift that’s included in Xcode 12.5. You can use Xcode 12.5 to build targets that are written in either Swift 5.4, Swift 4.2, or Swift 4.

                When you use Xcode 12.5 to build Swift 4 and Swift 4.2 code, most Swift 5.4 functionality is available. That said, the following changes are available only to code that uses Swift 5.4 or later:

                Functions that return an opaque type require the Swift 5.1 runtime.

The try? expression doesn’t introduce an extra level of optionality to expressions that already return optionals.

                Large integer literal initialization expressions are inferred to be of the correct integer type. For example, UInt64(0xffff_ffff_ffff_ffff) evaluates to the correct value rather than overflowing.

                A target written in Swift 5.4 can depend on a target that’s written in Swift 4.2 or Swift 4, and vice versa. This means, if you have a large project that’s divided into multiple frameworks, you can migrate your code from Swift 4 to Swift 5.4 one framework at a time.