updated 3 days ago; latest suggestion 7 days ago
Some of us elder developers might look back with melancholic feelings to the good-old Objective C times, when it was fun to code - at least once you deeply understood of how it's all connected inside the runtime. Playing around with method swizzling, tagged pointers and other interesting stuff maybe never was essential to do, but surely more then just nice to know.
But The Times They Are a-Changin' and numerous of us just do not want to go back again in time - so it's time to get some insights of how things are done in Swift.
This talk is a loosely coupled collection of some interesting features and implementation details of the Swift programming language. It's not intended to be used literally in your every day programming work - maybe never - but it will give you some nice insights of how and why some of the language and SDK features have been implemented by people much more clever than (put in the authors name here).
We'll take a look at assembly code, language implementation files and other stuff, including (but not limited to):
- Swift type system anomalies
- Type Erasure
- Existential Containers
- Swift method dispatch
- Mix'n'Match issues
In a way, this is a "non-architectural" talk; it will look just a little closer, into generated code and some unexpected behavior and how to deal with it.
Sounds a bit flat. Could you flesh it out a bit and relate it to a bigger picture?