CUFP

Some of the biggest growing pains we’ve experienced with our microservice architecture at Jet is in preparing for system outages. I’ll start with an overview of the benefits of choosing F# specifically, and functional programming in general, as well as Azure, for a chaos program. I’ll follow up with a discussion of why your team needs to implement a chaos testing program, and finish with showing off our methods and code in depth.

Rachel Reese

Jet.com

Niconico is a video sharing and a live streaming platform operated by Dwango. Dwango uses Scala widely for foundation systems such as an account system, a billing system and an event bus for inter-services. In this talk, we will introduce how to build web applications by using continuation monads. This approach is mainly used in the Niconico account system.

The Niconico account system has the following requirements:

• Various requests
• Various user registration leads
• OAuth logins (Google, Facebook, Twitter, etc.)
• Multi-factor authentication

• Various responses

• HTML Pages (in Japanese, English and Chinese)
• JSON and XML
• Redirects

• Various filterings

• CSRF check
• Add CORS headers
• User tracking

The Niconico account system is developed with Play framework which is one of the most popular web framework in Scala. Play framework has component technologies for building web applications. But the composition functionality of Play framework is insufficient to our requirements. Therefore, we decided to use components of continuation monads instead of the standard technique of Play framework. We believe that our approach can also be applied to other languages, because a web framework often has similar nested structures such as Java Servlet, Python WSGI, and so on.

This talk will be a detailed explanation of the topic presented at ScalaMatsuri 2016.

Our prototype implementation has been published on GitHub.

Seitaro Yuki

Dwango

At Fugue, we built our own statically typed DSL, Ludwig, to configure cloud infrastructure in a declarative way.

The DSL relates to the Haskell language in two ways. First, the language’s compiler and toolchain are written in Haskell. Secondly, the DSL is heavily inspired by Haskell. It also borrows interesting features from other languages, such as extensible records with row-type polymorphism and an intuitive YAML-like syntax.

Having a Haskell-inspired functional language certainly made it possible to build powerful abstractions. However, this often come at a price. Many of our prospective users in DevOps have little or no experience in functional programming. This means that they frequently have a hard time understanding how these languages work.

This is a problem for adoption: we want people to look at our examples and immediately feel at home. This talk will focus on how we are trying to achieve that. We will talk about how we constructed the different aspects of the DSL (syntax, type system…) in such a way that anyone who is comfortable editing YAML can pick up the language easily.

Jasper Van der Jeugt

Fugue

So, you’ve written a DSL, it’s a work of art! It so perfectly models the problem at hand that even a trained house cat could generate business value. You just have one problem, your interpreter runs 100x slower than a shell script launching JVMs in a loop.

Domain specific languages (DSLs) are able to offer the abstraction benefits of a high-level language, while when compiled, competing with low-level languages on performance. Because DSLs have a much smaller problem area, many specialised optimisations can be performed which are not feasible for a general purpose language.

In this talk, we will explain a number of optimisations which are useful for DSLs, and show our solutions to the practical issues we faced when implementing them in our query language, Icicle.

Icicle is a query language for processing large amounts of time-series data. Its type system enforces that queries require only a single pass over the data, and that multiple queries over the same data can be fused together. By using a combination of high level optimisations such as partial evaluation and common subexpression elimination, and low level optimisations such as parsing code which is specialised for the given input, our queries are faster than the equivalent hand-written C code.

From this talk, the audience will learn how the focused point of view that DSLs provide can be useful in performance critical systems, as well as a number of concrete techniques for optimising their own DSLs.

Target

Anyone who is interested in domain specific languages (DSLs), embedded or external, and wants to know how to make them beat the pants off hand written C/C++.

The techniques presented are applicable to DSLs written in any language, although a familiarity with Haskell syntax would be a plus.

Jacob Stanley

Ambiata

Australia

Consider what it means to be a cache. You need to be able to (1) associate a key with a value and (2) get some value given a key if such a value exists. That’s basically it. Caches tend to appear in layers. In a CPU, memory reads check L1, then L2, then L3, then RAM. When we want to load an image, we first check RAM, then disk, and finally network.

In a mobile app, if you don’t nail your cache code, your users will suffer. Excessive networking causes both battery and data-plan drain. We can help ensure a clean correct implementation by combining caches. Given two caches A and B, A on-top-of B means first check A, fallthrough to B, then write back to A. Now we can define a monoid for caches. Monoids imply easy composition. Easy composition means reasoning about our code becomes easy.

Such an abstraction isn’t possible to express both statically and generically in languages like Objective-C and Java, but we can with Swift’s strong type system. The caching library Carlos provides the foundation upon which we can build prefetching and other useful transformations. In our app, adopting such a system simplified our codebase: Caches became reusable legos. But the complexity doesn’t just all go away, it’s just hidden. With an abstraction so nice, it’s tempting to think of the actual caches and cache glue as black-boxes. One problem we ran into was a reference cycle that led to large bitmaps leaking and phones running out of memory. It’s important to actually think about the implementation details in detail, since these are your building blocks for the rest of the system. When your building blocks are stable, your building is stable.

Caching and prefetching are necessary for mobile apps. In this talk, I will explain how to think about caches as monoids, how a monoidal caching system can simplify our jobs as software engineers, and what real-world problems we ran into when putting such a system into production.

Brandon Kase

Pinterest

GNU Guix is a tool implementing the functional package management paradigm pioneered by Nix. It is rooted in the free software world where it has a growing user and contributor community. Guix and the Guix System Distribution (GuixSD) put an emphasis on providing a unified Scheme environment to deal with package management, container and virtual machine provisioning, operating system deployment, configuration, services, and associated activities.

In this talk I will describe the techniques we use to achieve this unified interface, with the intent to blur the user/developer distinction, and our early experience. The oft-discussed advantages of embedding domain-specific languages (DSLs) have allowed us to develop tools and a programming environment that many envy. Our use of Scheme covers domains traditionally associated with C, Perl, or Python: “build scripts”, system initialization code, service management, Linux containers, and more. Pervasive use of Scheme leads to a “multi-tier” programming environment; I will describe our staging techniques, implemented as mere Scheme syntax extensions.

Ludovic Courtès

INRIA

Unikernels are an exciting new take on applications design and deployment. OCaml has been quietly forging ahead in the area with libraries like Mirage, whereby we can generate apps that operate at such a low level we don’t even need operating systems on the backend anymore (removing 15 million lines of memory-unsafe code) - while at the same time, maintaining more reliable software with less effort through lightweight type-checked code sharing between server, browser clients, & native mobile apps.

While much theory and effort has been put into building the basis of Mirage, deploying unikernels into production (whether on public clouds or private servers) remains a very artisanal experience. In the talk we’ll look at how the properties of Mirage unikernel enable us to rethink large sections of the app development lifecycle (apps that are MBs in size and boot in 50 milliseconds!), and also look at a case study of what it takes to move said unikernels to production with reliable testing, deployment, monitoring, and debug tooling.

Sean Grove

What, in the end, distinguishes the functional programmer from the OO developer? Much effort is spent on arguing how FP is more efficient. More significant, however, is that functional programmers produce different models from their OO and relational counterparts, which enable more powerful software architecture. The talk traces this observation through 13 years of functional programming applied in industrial projects, in a variety of languages. I’ll touch on projects in stage lighting (““stage lighting has algebraic structure””), financial derivatives (““market data is compositional””), semiconductor manufacturing (““hope is a monad””, ““scheduling is an arrow””), social pedagogy (““the GUI is a function””), and others, as time permits.

While a number of lessons from these experiences may seem obvious, they were hard-won:

• purely functional is better
• look for compositionality
• monads can be found in unexpected places

(Not among them: Static types are better.)

Michael Sperber

Active Group GmbH