Scala exhibits quite an expressive type system, and we should leverage this type system to it’s full extent. In doing so, we gain the ability to statically and provably reason about our programs. In this talk we will explore various methods on how we can use types to our advantage, as well as some hoops we must jump through to not lose this advantage in the Scala language. We will also see examples of these methods in practice by delving into some Typelevel (http://typelevel.org/) projects.
Adelbert Chang is currently a Software Engineer on the Search and Analytics team at the cloud storage company Box. He is a recent graduate from the University of California, Santa Barbara where he studied Computer Science and conducted three years of research on graph querying and modeling. Adelbert’s recent interests consist of functional, logic, and dependently typed programming.
Where do we have to break abstractions (slightly) so that they can deal with real world demands? Better: where can we use FP’s strengths to make the whole situation more manageable? How do we build systems that are at the same time functional — built from simple parts we can combine together, simple to reason about, and reusable — and functional — they stand a chance of being usable in our real, messy environments? I’m going to talk about our experiences with functional programming (using Scala) at Twitter. Where and how we’ve made productive use of functional techniques; and also where we’ve failed. We’ll examine the development of a few core abstractions, paying particular attention to how they’ve held up to real world demands. Finally, we’ll talk a little about how the language has scaled with our organization — how our people scale informs our use of Scala.
Marius is a Principal Engineer in Twitter’s systems infrastructure group. His interests include large-scale distributed systems, storage systems, indexing systems, data management, distributed coordination, runtimes, profiling tools, networks, network protocols, and functional programming.
Jim Brikman, formerly of LinkedIn, shows how to deliver components of a page in parallel, decreasing latency dramatically and improving user experience, especially on mobile. This is effectively an equivalent of Facebook’s BigPipe in Play. Nitro was a great meetup host, with more to come!
Martin Odersky is the creator of Scala, and in his SF Scala talk at Workday, “Scala — the Simple Parts,” he distills the core set of components which comprise Scala, are simple, and together form a solid basis to reason about programming. As we found out before, Scala developers form tribes, from semi-imperative to Idris, and cores can be thought of as sets corresponding to the tribes’ core beliefs. The core which Martin outlines serves the same role as Effective Scala serves for style. It helps beginners to approach Scala in a simple and efficient way, lets practitioners think formally about complexity, and enables teachers with a clear presentation sequence.
Bruce Eckel is the author of Thinking in C++, Thinking in Java, still the best book on Java, and most recently Atomic Scala. He comes to SF Scala to talk about his philosophy of working with reasoning about programming languages. Should we argue about the language choice now as we used to? What are the questions you have to ask yourself about your programming and the tools you choose? Bruce was there and done that, and he shares his ideas for dealing with it all.
Jay Kreps is the tech lead for Kafka, the high-performance queue written in Scala and powering data pipelines at LinkedIn and now many other big data companies. In this talk, Jay provides an overview of distributed systems at LinkedIn which lead to Kafka, and key design decisions which went into it. This is a great overview of distributed systems use cases and how data pipelines are emerging at scale, in the real world.
Alex and Ryan unveil c5, the fast, simple, open-source cloud-optimized compatible successor to HBase. c5 has sensible defaults and no configuration necessary except for the cluster name to work and ensures sub second failover. It is developed in a fully testable and TDD way, guaranteeing data integrity and allowing clear reasoning about failover behaviors.
Jonas provides an excellent first-principles rationale for key requirements for production distributed systems and reviews how Akka satisfies them. A great introduction to Akka.
James builds on yesterday’s introduction of SBT-Web and shows how to build a reactive application with Play 2.3, using the new SBT plugins and web asset pipeline, to make it even easier to debug a Play application.
James Ward introduces SBT-Web, a new toolchain which is used to manage web assets from within SBT. Webjars allow to package the dependencies from SBT, and Play 2.3 uses it all. However you can use SBT-Web on its own for all kinds of web flows.