Let's live-code some effect systems in Scala. We'll begin by describing
an effectful program that we would like to write as a pure value. Then
we will write a toy effect system to be able to run it.
In this talk, we learn about how linear types can be used in Scala
programs to prevent runtime errors caused by variable underuse or
overuse by detecting them at compile time.
In this workshop, we learn about the basics of functional programming in
Scala by building simple algebraic data types and implementing common
patterns from category theory.
In this talk, we explore the implementation and evolution of a set of
microservices that have expanded and integrated over time to provide
weather information for Web clients and IoT devices.
In this talk, we use GNU Radio to examine digital signal processing
systems, and explore how we can use our understanding of functional
programming to reason about unfamiliar systems such as software-defined
radio by looking through the lens of category theory.
Working with a database means juggling connections and managing
transactions. With functional programming, we can abstract it away for
cleaner, safer, and more maintainable code.
In this workshop, you will learn to use Nix, NixOS, and NixOps as a
declarative toolbox for reliable, repeatable processes. Hands-on
exercises will teach you the basics of the Nix expression language,
which you'll use to build, test, and locally run a Haskell Web
application, deploy it to the cloud, and maintain it in production.
In this talk, we look at an approach to abstracting IO out
of Haskell functions by representing side effects as generalized
algebraic data types, and implementing a side-effecting top-level
interpreter for them.
In this talk, we look at literate programming's roots, how Haskell
provides built-in support for it, and how Codedown enables literate
programming in any language.
In this talk, we explore examples of code written in familiar imperative
programming patterns, and refactor each one using a counterpart
functional programming pattern.
In this talk, we look at Validation: how to use it, why it
works, and where in category theory it comes from. We'll see how to use
the implementations provided by Scalaz and Cats, as well as how to roll
our own from scratch.
In this talk, we look at Haskell deveplopment with the Nix package
manager, and how to use it in addition to (and in place of) Cabal to
make tool installation a breeze, and dependency conflicts a thing of the
past.
In this talk, we look at how a Scala development team can work
collaboratively to build, test, and deploy their software using GitHub,
sbt, Travis CI, Coveralls, and Heroku.
Integrating multiple APIs of different sorts (e.g. Web facing RESTful,
internal library, data storage, low level event logging, etc.) into a
single application, the complexity of the manifold interactions can very
quickly become an obstacle to agility. In this session, engineers from
Versal will discuss how their move to a functional programming model
allowed them to migrate from an event-sourced architecture and in-memory
hierarchical data model to an on-disk relational data model that allowed
them to greatly simplify their application development process. Examples
of how to apply functional programming concepts to various API designs
will be provided.
Skip the similes, and muzzle the metaphors. In this talk we take a look
at functors and applicative functors. Using a text editor and the REPL,
we build from scratch a small library that we can use with our
production code.
In this presentation we'll talk about declarative UI programming using
delimited continuations and functional reactive programming. It's a neat
way to hide the noise of Java's ActionListener API and to keep UI
behavior cleanly defined in one place.
In this talk, we present an approach to building transparently scalable
applications using Swarm, a framework which enables code execution to
follow data within Scala's serializable delimited continuations.