I was thinking of writing an article this week about the switch statement but i almost fell asleep half way through the article. that’s super boring. to write it even! so I thought I’ll do something more exciting and that is looking at how the
switch statement and its complementary
case statement works.
Click here to read the full article on Swift Weekly’s GitHub page…
I thought I’d write about operators a bit in this issue. I don’t like to teach how operators work, but rather show you some cool things that we can do with operators. but then again, many websites do that already. you can just search online and find hundreds, if not thousands of blogs/websites that can teach you how to use operators and how to create your own in Swift. so how can i be different and offer something else? well, we will talk about operators in this issue and how to write your own, but, i will also show you how custom operators are compiled by the Swift compiler.
Continue reading this article on GitHub by clicking here.
I was informed today by O’Reilly that my title “iOS 8 Swift Programming Cookbook” videos is 50% off for a week
Here is a direct link to the video including the discount code
If you have no luck with the above link, just go to O’Reilly’s website and purchase the book with the discount code of VDWK
Generics are pretty cool. They let us do complicated stuff that many programmers don’t want to deal with sometimes and want to stick with traditional means of achieving the same goals but using basic ideas in OOP. In this edition of Swift Weekly, I won’t teach you about generics eventhough you may just see the examples and learn generics anyways. What I will teach you however is how generics are compiled at the assembly level buy the Swift compiler.
I am going to use the release version of the code to make sure the output assembly is as optimized as possible so that the optimization level is set to
-O in the output when your Swift files are being compiled. Also my
swift -versionshows this:
Swift version 1.1 (swift-600.0.54.20)
I am using the latest beta of Xcode, aka
Version 6.2 (6C86e). Let’s get started.
Note: I am going to get rid of some of the assembly code that is not relevant to the main point of this week’s objective.
Continue reading this article on GitHub.
A few weeks ago I started checking out some Wikipedia articles about various s/e design patterns and came across theBuilder pattern which is a Creational GoF pattern. Then as you know, I cannot just read one article in one sitting. I have to click every link that the article leads to, so I stumbled upon the article about Fluent Interfaces and I could then see the possibilities.
Note: Fluent Interfaces have nothing to do with IB or a visual interface that is displayed on the screen at all. Fluent interfaces are the way that we can write our software to ensure they are… well… fluent. Read on to understand how this works.
I don’t think fluent interfaces are the same as the builder pattern. I don’t really think fluent interface is actually a pattern at all. I believe that fluent interfaces are a concept, and a kick ass one at that. I think mixing fluent interfaces and the builder pattern will allos us to build Swift classes that are amazingly simple to use, instead of the classic OOP designs that we see on pretty much every Apple class these days. I wish Apple could read this article and (ehem), just update their iOS SDK classes for instance to use fluent interfaces and the builder pattern.
If you want to write your Swift apps in the most kick ass way, continue reading. I think this article will help you a lot not only in learning more about Swift, but also writing some really crazy code that will make your life and those around you much easier.
Click here to read the full article on GitHub.
I have always been interested in finding out how different compilers work with basic operators such as +, -, % and so on. This week on the train I was thinking that it would be nice if somebody could explore how Swift deals with operators so, long story short, I decided to do it myself.
In this edition of Swift Weekly, I will show you how the Swift compiler works deals with (system and your own) operators and how to use operators to ensure you get the maximum performance.
Note: in this edition of Swift Weekly, I’m going to change things a little bit and instead of building for the debug configuration, I am going to build for Release to ensure that the assembly code that we are going to analyze is as optimized as what you will get when you release the app for the App Store. Optimization is hence enabled and the assembly output is long. That means setting the
Optimization Level in your build settings to
Fastest, Smallest [-Os] to ensure you get the
export GCC_OPTIMIZATION_LEVEL=s export when you build your project.
Note: to ensure that the assembly code which we will look at is clean and nice without too much unnecessary code, I will remove bits and pieces of it but will keep all the assembly code that is relevant.
Continue reading this article on Swift Weekly’s home page here.
This is the second article in the Swift Runtime series of the Swift Weekly. In this article, we will dig deeper into the Swift Runtime and how the compiler deals with producing code for enumerations. Saturday morning writings are always fun! Let’s get this show started.
If you are an Objective-C or Swift programmer and have not done any Assembly programming or are simply not concerned with the low-level details of this article, jump right into the Conclusion section at the end to get the juice of this article.
Continue reading this Swift Weekly issue on Github.