Generics are one of the features of Swift that set it apart from many other languages. Since Swift debuted, developers have been wondering when to use them and what to use them for. By looking at the standard library, which is the first piece of software to use generics, we can better understand their purpose and utility.
In this talk, Karoly describes several ways to implement the same simple ordered set protocol in Swift, demonstrating how the language supports a number of surprisingly different approaches to programming. At every step, we trade extra complexity for improved runtime performance, ending on an implementation that is ludicrously fast but also quite difficult to handle.
In the Objective-C kingdom, the evil Queen NSObject was reigning over her people by keeping them under the control of the inheritance chains. But one day, a Swift wizard named Christobald came to create a new kingdom next to the Queen’s. The war between the two kingdoms was ongoing for several years when the wizard suddenly left...
Swift introduces new ways to model data through value types like structs and enums. Drew discusses his experiences rewriting the data model of the vector graphics app Sketch to use value trees, and finishes off pondering whether future data modelling frameworks could be based on value trees, rather than entities and relationships. To that end, he also introduces the experimental project Impeller https://github.com/mentalfaculty/impeller.
As we all know, everything rendered out of CSS is in a box model. That is why not many people are as enthusiastic as Wenting is about using CSS to draw, since everything has to be some sort of rectangles. In this talk, Wenting works inside of the box and transforms a single div to this mustache icon, all this live!
Sure, everyone uses WebFonts now. But are you using the full capabilities of modern OpenType fonts, with your CSS? Did you know how to get tabular or lining numerals, how to avoid fake smallcaps? Are you up to speed on chromatic fonts? And what is coming in the future, like Variation Fonts? Are you ready to power up on webfonts?
What does the future of code execution look like on the web? 2017 will be the year for native implementations of ES modules and WebAssembly, representing a huge shift from the execution model we have in place today. Guy looks at the native adoption path for web modules based on the current specifications and upcoming proposals, imagining how this might affect the web runtime and tooling.
Go's tools can help you diagnose problems with your applications—if you can wield them effectively. The Execution Tracer provides great visibility into the scheduler, to help solve timing dependent bugs and track down latency problems. Rhys argues you should learn how to use the tools before you have a time-critical need.
Go is a great general purpose programming language and it is thus no surprise it can be a great fit for science work. But Go could be an even better fit for all kind of exploratory work, such as data analysis, if it had an interactive interpreter, also known as a Read-Eval-Print Loop (a REPL). Sébastien introduces pygo, a very first step in that direction.
We learn new stuff when we work on our projects. Let us use linters together with version control to enforce the changes we want to see in our code base. However, at times it might be too much work to change the configuration of our linters. Rolf Erik proposes a way to make that easier so that we can make sure we utilise what we learn.
This story sums up Varya's experience in developing modular web solutions and pattern libraries. She is currently doing exactly the same as what she was doing 8 years ago, but in a very different way. In fact, the reasoning of choices for methods and tools to apply goes directly from grasping human nature, no less. Hint: BEM, living style guides and visual regression tests are involved.
Prototyping remains an underappreciated technique in software design. In this talk, Robert develops a functioning prototype for a specific Go language extension, multi-dimensional index expressions. He explains how implementing and playing with the prototype informs the existing design, which ultimately may lead to a better final design.
The past decade has seen an explosion of new programming languages, many of them bringing exciting ideas from the research community into the world of mainstream programming. And then there is Go. John looks at why Go is so frequently criticised by the programming languages community, why that might not matter, and how we can all learn from this.
The tried-and-true approach to sharing memory in Go is via communication. Yet there are scenarios where the amount of data is prohibitively expensive to pass around. Instead of falling back to locks, immutable data structures provide an alternative way, where we can achieve concurrent access to shared memory while at the same time make reasoning about complexity much easier.
First class functions, sometimes known as anonymous functions or closures, are a powerful concept that let Go programmers pass around behaviour to be executed, rather than data to be interpreted. In this presentation Dave explains what first class functions are, shows how to use them, and concludes with an observation that first class functions are something that all Go programmers can become comfortable using with just a little practice.
Erlang is a programming language dedicated to building robust and scalable services. It has matured for many years and finally reached a point where it is one of the secret weapons used by many prominent companies to build large-scale systems. Mickaël walks you through computing history to understand the concepts behind Erlang and explains how they influenced the design of modern languages.
Computing isn't physics. But as we add scale to computing systems, we can begin to reason from simple principles to detailed understanding of how our systems must work. These constraints, in turn, shape our entire industry in predictable ways. Ted gives two examples: the deep reason big data is big right now and how messaging systems must work.
Developing a modern application oftern means composing it with several services, many of them third-party. While this offers many benefits, it also traps your data in silos, preventing a holistic view. Eliot presents the cross-service-join: a means of querying across multiple services from a central database.
Privilege separation is a programming technique which splits a program into distrinct units. Each unit then performs part of the task, but in a distinct security domain. Theo presents the recent development of the pledge(2) subsystem in OpenBSD which led to some surprising advances in this technique.
Scaling up machine learning techniques to keep pace with "big data" is its own interesting engineering problem. Recently, Apache Spark has become a popular framework for large-scale ML. Sean introduces the intuition behind modern large-scale recommenders and highlights four ways ML algorithms are engineered to scale.
Developers usually come to Go for the concurrency patterns and the simplicity, but not everybody out there is looking tools for distributed and concurrent systems, at least in the beginning. Yet, they still use Go for their specific problems, which is a key for adoption worldwide. Veronica presents two such interesting use cases.
The open source release of Swift was much more than we might have hoped for, enabling an unprecedentel level of dialogue with Apple. TJ discusses the stated goals of the upcoming 2.2 and 3.0 releases, what will not be included and how we can take this information to foster the most fruitful discussion.
Tailoring apps to users from over 150 countries with different languages, cultures and formatting rules is hard and often overlooked by developers. Roy takes us on a journey around the world in search of the strange and wonderful, uncovering many tools provided by iOS to make global users feel at home.
CSS was designed with boundaries in place to make it simple and accessible to “non-programmers”. Those boundaries have benefits as well as drawbacks that affect us in technical and non-technical ways. Recent developments in web tooling and technologies are expanding the boundaries of CSS -- hopefully for the better.
100% uptime is impossible. Modern architectures are designed around failure but what does that mean for the human aspect of incident management? David's talk considers how to prepare for outages, how to structure the response, and how those experiences and techniques differ for small and large companies.
As developers we tend to neglect the importance of the academic research on distributed systems. Sam reminds us to spend some time into diving into the details and the formal theory behind many of our distributed data stores, grasp the trade-offs they make, and avoid getting fooled by their marketing.
Paul delves into some of the challenges involved in building a distributed database specifically for time series data. High write throughput, even higher read throughput, large range scans of data to answer queries, and large range deletes all conspire to make time series data both the worst and best use case to build for in distributed databases.
Convergent Replicated Data Types offer a principled approach to eventually consistent data modelling, with defined data types always converging to single correct values. CRDTs are one of the key building blocks of a distributed system, enabling strong eventual consistency and highly available, low latency applications.
Curious how to design an SDK with Swift developers in mind? Twitter recently launched Fabric, a modular platform which makes it easy to build great apps. Romain takes us through Twitter’s experience building Fabric with seamless Swift support at launch, and shares some of his stories and insights working with the language.
Usually, functional programming is taught by abstract functional techniques. Instead this talk goes for a different approach showing examples of unfunctional, imperative code people may have written in the past and how that can be improved with a functional style to write clearer, declarative and testable code.
This is an early beta of The dot Post and we need your feedback :-)