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 :-)