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