Robots are exciting. Lots of progress in robotics in terms of research, tools, and state-of-the-art libraries that we see in modern robots became possible due to Robot Operating System (ROS). It is the most popular open-source robotics middleware that enables roboticists from both academia and industry to collaborate and relatively easy get robots up and running. However, ROS is neither scalable, nor fault-tolerant, and these are areas in which the Erlang programming language has lots to offer.

In this talk, we'll introduce ROSiE (Robot Operating System integrating Erlang) that merges togetherness and state-of-the-art of the open-source robotics world with expertise in scalability and fault-tolerance of Erlang. We'll talk about our vision, finds, and progress so far

Direct URL:

Gradual typing is a bit like static typing, because it provides error messages if your code has types and specs - and any errors, obviously. Gradual typing is also a bit like dynamic typing, because it doesn't require all the functions to have specs and just agrees when you say: "Trust me, I'm an engineer!"

Gradualizer, introduced at Code Beam Stockholm by Josef Svenningsson, is a gradual typechecker for Erlang. I'll describe some changes, improvements, and challenges we faced and managed to overcome in 2021. I'll also show how to type check not only Erlang, but also Elixir code.

Direct URL:

The Aeternity Core blockchain system has been using mnesia with the mnesia_rocksdb backend plugin since it went live in 2017, and now handles a 100 GB database. In this talk, we talk about our experiences and present an evolution of the mnesia_rocksdb plugin. In the new version, we introduce a new API, allowing applications to use the fast RocksDb low-level API and its advanced features, while respecting Mnesia metadata and even indexing support. Mnesia-level and rocksdb-level access can coexist in the same system, with a bit of care.

Direct URL:

Have you ever experienced vendor lock-in from your observability tooling? Don't you wish you could instrument your code once and send telemetry data to multiple vendors to see what their platforms have to offer before signing a contract and investing a lot of engineering time?

The future is now, with OpenTelemetry!

OpenTelemetry has finally reached general availability, with the Erlang and Elixir library leading the way as one of the first official implementations to be compliant with this new industry specification. Now is the time to start thinking about how to get your services instrumented using this exciting new vendor-neutral instrumentation.

This talk will quickly cover the basics you need to know to get started and send data to both open-source tooling and vendor platforms, so that you can get the observability you need, without being locked into a specific vendor's instrumentation library!

Direct URL:

Direct URL:

Quantum Computing is all the rage these days, but, as an emerging technology, it's difficult to find practical applications right away. One area which allows us to invest in a quantum future is to use quantum- and nature- inspired optimization algorithms, which can run on classical computing infrastructure today and leverage quantum hardware when it is available.

In this talk, I'd like to give a short overview of the state of the art in quantum computing, and introduce two widely used optimization algorithms made better in F# with functional principles.

Direct URL:

OCaml - a functional programming language from the ML family, recently celebrated its 25th year. For a language to be around for that long is an achievement in itself. Furthermore, people are actively working on adding exciting features to the language and its ecosystem.

Thanks to efforts from various developers and maintainers, the OCaml developer platform has come a long way and continues to evolve at a rapid phase. My talk will cover all the existing tooling that makes a OCaml developer's life easy.

The talk will demonstrate end-to-end state-of-the-art developer tooling, right from installing a OCaml compiler, using VSCode and vscode-ocaml-platform which provides IDE like features, to publishing a library and its documentation.

Direct URL:

The biggest power of functional programming comes from the ability to treat functions as first class objects and the power to compose them incrementally to evolve larger functions out of smaller ones. Designing such functions as referentially transparent enables us to treat functions in programming just like functions in mathematics - side-effects are carefully abstracted through “effects” and delayed till the algebra of our program gets submitted to the run time system.

In this talk I will discuss a few idioms and patterns on how using the power of composition can lead to development of modular abstractions. Instead of committing to an implementation prematurely we can define abstractions that focus on “what” it does deferring the “how” part to later stages of the lifecycle. In functional programming terminology we call the “what” part the algebra of our abstraction, and the “how” part the interpreter. Decoupling the two is one of the basic recommendations in functional programming. 

I will use Haskell and Scala for the examples. I will discuss common functionalities that we use everyday in programming our domain models like validations, database interactions, managing exceptions, talking to external services etc. and show how to use the power of typed functional programming to make them more compositional.

Direct URL:

Fable is an F# to JS compiler that has been successfully used in production by thousands of developers for more than 5 years. Thanks to steady improvements and a great community and ecosystem, including the SAFE stack, the Elmish architecture and the Feliz React API, it has become one of the best options to write robust, succinct and performant web applications nowadays.

Fable was originally designed to integrate F# with the JS ecosystem instead of trying it to hide it. With this same philosophy, the Fable team is working now to target other languages beyond .NET and JS. There are already working prototypes to compile F# into Php, Python and Rust code, and we expect to release a beta in the upcoming months. Let's see how Fable 4 will further empower F# and functional programmers!

Direct URL:

This talk will introduce the audience to algorithmic trading, the design of an algorithmic trading system, and various snippets written in Kotlin that fulfil specific tasks that collectively contribute towards a full trading system. The rough sketch will be as follows

Direct URL:

In the front-end world, we finally can take an important decision: Familiarity or Guarantees?

Do we keep using frameworks that are familiar to JavaScript (bringing with them all JS idiosyncrasies) or do we embrace a world of guarantees where functions are pure, data is immutable, types are correct, and runtime exceptions don’t exist?

In Rakuten, we went the way of guarantees three years ago, choosing Elm.

In this talk, I am going to explain what are the benefits of Elm in the front-end, and what was our experience.

I will showcase examples, best practices, things that we liked, and things that we didn't like.

Direct URL:

FizzBuzz is back in fashion! Everybody is doing it again (and again, and again). So I figured why should I miss out on the action?

Why not use (and abuse) as many features as possible, of my favourite FP language Clojure, to FizzBuzz in as many ways as I can possibly muster?

Why not up the ante by leaking the four other ways I discovered so far? And why not make it harder on myself by committing to spectacular public failure if I can't find more? Why. Not?!

So here we are...

(def range-of-fizzbuzzees (range 1 101))

(def fizbuzz map)

(= (fizzbuzz canonical-fizbuzzer
             range-of-fizzbuzees)
   (fizzbuzz or-fizbuzzer
             range-of-fizzbuzees)
   (fizzbuzz juxt-fizbuzzer
             range-of-fizzbuzees)
   (fizzbuzz lookup-fizbuzzer
             range-of-fizzbuzees)
   (fizzbuzz (fn [f n] (f n))
             cyclical-fizbuzzer
             range-of-fizzbuzees))

The chase has begun! Who knows what will happen?

(Edit: 2022-03-05: Well. What happened was demofail due to networkfail.

But, Plan B is live... the blog post is up with even more detail than the talk (see also, links below)).

Direct URL:

Many Java developers believe that FP arrived in Java 8, with the addition of first-class lambda expressions and the Streams API. But is this really true? In this talk, Ben Evans will talk about what FP really is, examine whether Java can really be said to be FP or not - and consider whether things have improved with more recent versions, as well as some possibilities of how we could have done things differently (in another world).

Direct URL:

WebSharper is an open-source full-stack, functional-first web framework for F# and C# that runs on top of ASP.NET Core. It features F# and C# transpilers to JavaScript, extensible bindings to JavaScript libraries, and various server and client-side abstractions (MVU, reactive HTML, etc.) for type-safe web development. In this session, I’ll walk through some of the basics that make WebSharper an immensely productive tool to develop microservices, SPAs, and full-stack client-server applications in your favourite .NET language, and cover how you can combine and/or migrate some of your WebSharper apps to run in WebAssembly with Bolero, a set of F# web abstractions for Blazor. Functional-first .NET web development has never been easier!

Direct URL:

Typescript has gained a lot of traction with majority of javascript frameworks adopting it and gaining the power of static types.

Given the Typescript types are a language themselves and they are Turing complete, lets put our type flavoured favourite language of the web to test - for fun & profit.

With the advent of fp-ts, typescript's boundary to statically type FP algebras like Functor, Monoid & Monad are just a import away!.

But why restrict ourselves when we can achieve more with almost "Dependent types" in typescript - Like solving logical puzzles to proving properties of the program (like type level regex check, indexed list & matrices etc) for correctness.

Direct URL:

Program correctness has always been an important topic in computer science, and is only showing growth as software becomes more complex. Statically typed functional programming provides compiler guidance and guarantees. Advanced typing features can provide additional ways to restrict and formally prove properties within the constraints of the original program.

This has even (half-seriously) popularized remarks about how it's enough to get a program to compile to be sure it is correct. While there is some degree of truth to this (Haskell programs can escape some classes of bugs by merely enabling all warnings and having a reasonable coding standard in place), this is obviously not true for all but most trivial software.

Formal verification can help whenever that is not possible, but it is still impractical for all but small and critical systems. We still rely on writing automated unit, property, and integration tests to ensure our programs behave in the way we expect them.

At Hasura, we run these tests automatically in continuous integration (CI) services, and they often take up the majority of CI time. We dedicate a significant amount of time writing and maintaining these tests.

What is a good test? How do we write good tests? How do we organize them? What's important to consider when writing tests?

I describe common patterns and recommended style guides for writing tests that optimize for ease of reading and understanding rather than writing or modifying. It should be apparent what it is that we're testing, what are the assumptions of the test, what is being set up or arranged before the test, as well as what it is we are testing and what is the expected response. We should strive to maximize the domain information and minimize accidental complexity, such as particularities of the testing framework or programming language we're using.

In a language as expressive as Haskell, we should be able to write unit and integration tests that are understandable and modifiable by domain experts (such as power users or product owners), not only Haskell developers.

This can generally be achieved by focusing on getting the domain-specific data together in a record, thus making the test-relevant information easily readable and understandable.

Direct URL:

Type classes are a powerful tool in functional programming to enable ad-hoc polymorphism without using object orientated programming based constructs like sub typing. In this talk we look at how to create type classes using Scala 3 constructs such as ‘Givens’ and ‘Extension’ methods.

Direct URL:

“A language that doesn't affect the way you think about programming, is not worth knowing.” ― Alan Perlis, in “Epigrams in Programming”

Following Alan Perlis's words, this talk will show why APL is a language worth knowing. In other words, I will devote the talk to showcasing characteristics of APL that are likely to, on the one hand, influence the way you use other programming languages, and, on the other hand, understand concepts of computer science.

By listening to this talk, I hope to convince you that learning a language that is radically different from all the other languages you know isn't harmful. Learning a language that is radically different from all other languages you know won't scatter your knowledge or spread your brain too thin. In fact, learning a language that is radically different from all other languages you know will cement your programming  knowledge, helping you build bridges between topics you didn't even know were connected.

To drive my point home, we take a closer look at two characteristics of APL: the fact that Boolean values are represented by the integers 0 and 1, and the fact that APL is an array-oriented language. In studying these two things, we draw connections to the traditional if statement and to list comprehensions, deepening our understanding of those.

Direct URL:

Don't ask what you can do for your testing library, ask what it can do for you! So what can it do? It turns out that much more than displaying a nice green and red report. What if we make the library generate the test data? And while we're at it, maybe it could also think of the edge cases for which our code is wrong? Oh, and when it finds them, it should simplify them a bit before returning to us, so that we can quickly identify the root cause of the problem. And repeat that a thousand times, just to be sure. Sounds good? That's exactly what property-based testing has to offer. I'll show how to get started with this kind of testing, using jqwik (https://jqwik.net/) as an example. But isn't it all too good to be true, surely there's some fine print? Of course there is. I'll cover that as well.

Direct URL:

When I say "Multiplayer online game development in Clojure" 2 questions probably pop right up : WHY? HOW?
Why? because you can do it in under 100 lines of code, and it is pure FUN.
How? Well that's exactly what we'll talk about in this session.
I will present a simple MOG written in Clojure and go through each line of code - so you'll understand how you can do that yourself, even if you've never written a single line of Clojure before.
Whether you’re a real Clojurian at heart or just interested in hearing a talk about Clojure from a sworn star wars fan - this talk is for you :)

Direct URL:

Concrete monads or monad classes? I’ll tell you why it often makes sense to jump around between these options, and where this comes from.

Monads are the central notion to encode a program with effects in Haskell. Nowadays, we often combine several monad transformers to create the desired effect stack, relying on mmorph to juggle effects as required. But in fact, monad transformers and monad morphisms are just as old as monads in functional programming, an idea first published in 1989.

We can still benefit from that old work. The core of this talk is to discuss monads which are initial objects in the sense of category theory. Practically, this means that such monads can be interpreted in a class of other monads. Perhaps the most well-known example of such initial monads is Either e, which can be interpreted in any monad that instantiates MonadError e, through the use of liftEither.

This general principle of monad interpretation is exactly what allows us to jump around between concrete monads and monad classes. Monad interpretation can sometimes give a free performance boost, and can be used to easily write Haskell Arrows code without Arrow syntax.

Direct URL:

You may be familiar with what map, filter, and reduce do. But have you ever heard how these functions sound?

The Alda language is centered around the idea that music can be represented as data. alda-clj is a Clojure library that maps Clojure data structures to the music theory concepts in the Alda language, including notes and chords. The library serves as an interface that takes Clojure code as input and produces music as output.

In addition to the basic functions that you will find in the standard libraries of most functional programming languages, Clojure's standard library offers a wealth of interesting and useful functions that facilitate working with immutable data. In this talk, we will explore the Clojure standard library by applying interesting functions like cycle, mapcat, partition and reductions to transform data that represents music. Using the alda-clj library, we will not only see the result of each function call, we will also hear the results and observe how they can help us understand how each function works.

Direct URL:

Direct URL:

Mathematical optimization has vast applications, e.g., image processing, machine learning. It has a huge impact on the current state of computer science and software engineers.

Solving optimization problems involves many challenges. First, we need to build and encode the models correctly. Second, almost all useful models are computationally expensive and we need to speed them up. Finally, we need to be able to feed the model to optimization solvers to get the final numerical results.

Fortunately, we find that Haskell, with its powerful type system and abstraction power, is perfect for this type of problem.

We introduce HashedExpression, a Haskell-embedded domain-specific language that allows us to build and solve optimization problems. It provides users with a type-safe, correct-by-construction interface that uses Haskell type-level programming to express constraints on correctness which the compiler uses to flag many modeling errors as type errors (at compile time).

The library implements symbolic expressions with the "hash consing" technique to achieve common subexpression elimination. We will show how using monadic type class instances help us abstract away details of the underlying lookup table and implement symbolic reverse-mode differentiation on top of it.

For high-performance purposes, we generate low-level C/C++ code for symbolic expressions and provide bindings to open-source optimization solvers such as Ipopt or L-BFGS-B.

Direct URL:

Direct URL:

At Juspay, we heavily use Functional languages across all the teams and compilation has been a major challenge since most of our codebase are more than 100k lines. Mainly for frontend projects where we use Purescript, generally the changes are value based. Hence the idea of “no change in function’s type signature” shouldn’t trigger compilation on dependent files (Most of the scenarios, when inline optimisation is disabled)  was implemented into in-house compilers, this saved the compilation time from 10 minutes to few seconds (average). We are looking forward to doing more optimisations to achieve these numbers in the rest of the scenarios too.

Direct URL:

Web services are typically stateless entities, that need to operate at scale at large. Functional paradigm can be used to model these web services work and offer several benefits like scalability, productivity, and correctness. This talk describes how to implement Event-Driven Microservices in functional programming languages with examples in F#.

Immutability allows infinite scalability as it eliminates the need to worry about a mutex, a lock, or a race. As functional code is much more terse compared to object-oriented code, it provides productivity benefits. Its strict typing makes writing correct code easy as mismatches of types are caught at compile time.

The objective of the talk is to show how to create a scalable & highly distributed web service in F#, and demonstrate how various characteristics of functional paradigm captures the behavior of such services architecture very naturally.

Direct URL:

Haskell (and the kind of Statically Typed Functional Programming that it promotes) is notoriously hard to learn. I have struggled with the learning curve. I have seen others struggle with it. And I have seen developers struggling to wield the language effectively even after months of learning.

But it is not necessary to jump into the weird world of Monad, Monoid, and Endofunctors. There are neighbouring languages that can be immediately put to good use and introduce some of the Typed FP concepts more gradually.

We'll talk about one of them - Dhall: A Typed FP language specifically for configuration management.

Direct URL:

Some people even say names don't matter. While it is widely held that good naming is one of the most important aspects of programming, is there such a thing as an objectively good name?

As part of a discussion of the philosophy of programming, we'll look at what are the real aims of naming things well, and what considerations we should have in mind when discussing them. We'll have a look at alternatives and what they bring that names do not.

Direct URL:

_As a Dev, I need to Refactor, to make codebase Refactorable_. Refactorability as defined by Martin Fowler is, "Ability to alter internal structure without changing its external behavior". This applies to each atomic component of an app. Let's achieve our dev story through a unique, yet most effective Method, **Component Isolation**.

Direct URL:

In this presentation, we will see coding problems, similar to those which can be found at https://github.com/system-f/fp-course/ using the Haskell programming language.

Solving problems such as these can be daunting for many reasons and especially for beginners. A common stumbling block to these types of problems is coming up against unfamiliar problem-solving methods. For example, everyone knows how to add up the numbers in a list with a for-loop. This is a well-understood method of solving this particular coding problem.

And then you hear the functional programmers, "just use the types" and "well you just do the only obvious thing to solve it." While true, this is not particularly helpful to someone who is not already fluent with this approach to problem-solving.

You may have heard of using type-holes to solve coding problems. We'll be using type-holes, and a few other techniques, with the Haskell programming language to live-solve coding problems. We will solve both trivial and not-so-trivial problems while "thinking out aloud." Feel free to follow along! You'll just need Glasgow Haskell Compiler (GHC) and a text editor installed.

Direct URL:

PureScript is a Haskell-like language that compiles to JavaScript. If you like Haskell, you will find yourself completely at home with PureScript. However there are a few interesting typelevel things from Haskell that are not provided by the PureScript compiler. The Type reification machinery is one of them.

In this talk, we'll understand the concept of type reification and its implementation using the Typeable typeclass. Essentially, using Typeable we can take a runtime value and get a value level representation of its type called a Typeref, this process is called type reification, which we can then compare with other known typerefs. We'll discuss indexed and unindexed typerefs and some real world problems that can be solved by this sort of type reification.

A significant part of the talk will involve details of how Typeable is implemented in Haskell, and how it can be approximated in PureScript even without compiler support (available as a library https://github.com/ajnsit/purescript-typeable/). We'll also discuss some alternatives approaches and their pros/cons.

Direct URL:

Programming language may share much in common, but each language has its own particular syntactic and semantic features. For example, a function application in Haskell can be an operator section, while in Erlang it can be an application of the apply function. This talk presents generic, language-independent refactoring schemes that are realised in each language by a particular set of rewrites, and is illustrated by examples from Erlang, Haskell and OCaml.

Direct URL:

At Zeotap, we manage over 1000 data pipelines, many interlinked, across its 1st and 3rd party data assets, both in batch and streaming mode. These data pipelines were written using various compute engines like Apache Spark, Dataflow(Apache Beam), BigQuery, etc. At times, many of these pipelines would run on clusters that would face performance bottlenecks or would block due to resource unavailability(spot nodes). At those times we wished we could take a framework code and run it using another, say Spark onto Bigquery. But alas, the coupling of the domain with the platform at the code level would preempt this. We saw value in a unifying language, more precisely DSL, to combine all these data processes and make them interoperable.. Zeoflow is the result of creating such a unified data processing DSL. It is based on Free Monads and works as a high-level programming model and hence compute engines like Spark, Beam or any other can become plug-and-play interpreters. Additionally, data pipelines have other requirements it has to address like  data read/write, data quality & metric reporting, and writing easily testable & debuggable code. Hence, we went ahead and created an ensemble of applications to better manage and decouple all of the above aspects based on Free Monads and Applicatives. 

The presentation will take you through the journey of what started as a small library with reusability and ease of modeling business rules in mind and the design principles, requirements, and functional domain modeling we followed while choosing constructs like Free and State Monads. This helped it grow into an extensible DSL-based application suite that can operate over simple SQL engines to complex Beam-based pipelines. This is a production system at zeotap and the project is in its final stages of getting open-sourced. We try to show the beauty of pure FP constructs which have been used to solve a complex real-world use case of data pipelines and data processing, in general. 

Direct URL:

What do you do with a multi-step function with different kinds of user input that may be required at different steps? 

I'm using Elm to build a game client for Codex, a complex strategy board game by David Sirlin with lots of interesting side effects in the game design. The pure functional programming of Elm is very powerful for managing these side effects, but how should I handle when there are many different kinds of user input required to complete the behaviour of a single feature?

There’s a “railway oriented programming” metaphor to understand how to handle multiple-steps of errors. I’ll extend this metaphor – with stations – to show how to make what looks like a complex functional problem into a simple pattern of abstraction.

Some familiarity with functional programming idioms is recommended, though the examples themselves are easy to follow. Attendees will walk away seeing functional programming applied in a fresh way, perhaps opening their mind to alternative perspectives to approach the complicated problems in their projects.

Direct URL:

An oft overlooked aspect of programming language development process is benchmarking. While popular CI/CD tools such as Azure pipelines, Gitlab CI, Circle CI, Drone.io and Github Actions are regularly used for continuous testing and deployment, there is a dearth of such tools for continuous benchmarking. This is because benchmarking well is challenging due to the care needed to choose appropriate benchmarks, the complexity of modern OSes and hardware that makes it hard to obtain reproducible results, and a powerful dashboard needed to surface resultant metrics in a useful manner that can be explored interactively by the developer.

For benchmarking the compiler of the OCaml [1] programming language, we have developed Sandmark [2]. Sandmark is a (a) suite of well chosen benchmarks aimed at exercising different performance axes including CPU, memory and IO (b) a tool to run the benchmarks, building the compiler and its dependencies under varying configuration settings and (c) a dashboard [3] to interactively explore the results of the benchmark runs. Sandmark was originally developed for supporting the Multicore OCaml [4] project, which aims to add native support for concurrency and parallelism to OCaml, and has undergone significant improvements since the initial release [5]. 

We have learnt several useful lessons in building a continuous benchmarking infrastructure that we would like to share in this talk, which may benefit developers who work on projects where performance is critical. In this talk, I will describe the Sandmark tool, illustrate the quirks of modern OSes and hardware and how we overcame them, highlighting useful takeaways for setting up continuous benchmarking for your own projects.

References:

[1] OCaml: https://ocaml.org/
[2] Sandmark: https://github.com/ocaml-bench/sandmark
[3] sandmark-nightly: https://github.com/ocaml-bench/sandmark-nightly
[4] Multicore OCaml: https://github.com/ocaml-multicore/ocaml-multicore/
[5] Tom Kelly. Benchmarking the OCaml compiler: our experience, OCaml Workshop 2019, https://icfp19.sigplan.org/details/ocaml-2019-papers/3/Benchmarking-the-OCaml-compiler-our-experience

Direct URL:

Satisfiability modulo theories (SMT) solvers are extremely powerful tools that are indispensable in a number of applications of functional programming from mathematical analysis and optimization to computer security to program verification. SMT solvers allow you to determine if certain logical and mathematical formulas are satisfiable or (just as importantly) unsatisfiable in the context of theories like real arithmetic or set theory, and can provide definitive answers to commonly encountered programming problems involving logic, arithmetic, equations, and constraints.

Z3 is one of the most popular SMT solvers available today with APIs available for many different programming languages. Although Z3 is most commonly used from Python, functional languages like F# provide powerful metaprogramming facilities that make it very easy to translate F# code and expressions to Z3 expressions without the need for custom types or operators.

This presentation describes how the Z3 solver can be used from F# via quotations to quickly and easily solve common programming problems from Boolean formula satisfiability to arithmetic expression equality to linear programming to verifying fragments of source code.

Direct URL:

We each follow similar paths into the forest of functional programming. Some languages are better suited than others but we all hit a wall on our way to mastering monads. In this talk, I'll use examples from the Swift programming language to trace our understanding from types  that feel like containers such as Array and Optional to types that definitely don’t such as Reader and State Monads. We’ll learn to perform many magic tricks along the way.

Direct URL:

Beginning functional and APL programmers often express confusion about how to structure large software projects or larger pieces of code. Both APL and FP have a tendency to highlight their low-level features and de-emphasize system architecture patterns. This can leave programmers with a strong sense of how to write a set of small functions, but with less confidence or skill in designing, recognizing, and implementing more cohesive implicit system architectures that hold these lower level functions together. System architectures serve as a method for constraining the overall design of a system to give direction and focus to lower level implementation requirements. Especially in APL, where system architecture is often best implemented implicitly, it behooves the programmer to understand the ramifications of architecture and to implement them in their own systems. This talk unpacks a number of these "architecture level" questions within the framework of the APL programming language by exploring the same topic through 3 different architectural approaches, each of which has a very distinct flavor, presentation, and impact on the resulting source code. Particular attention is paid to the question of domain-specific languages, their design, and how they can interact with APL as tools for architectural exploration and guidance in APL source trees. 

Direct URL:

The Chunk data structure powers the fs2 (Functional Streams for Scala) streaming library. In this talk, we’ll look at the design of Chunk and in particular, how design constraints guided its evolution.

Direct URL: