#talk

29 posts

Single-Serving Values in Scala with Linear Types May 21, 2021

Have you ever had a program try to read a file after the handle had been closed, or query a database after the transaction had been committed? How about shadow a variable and accidentally use the wrong reference?

Linear types require that all values are used once and only once. In this talk, we learn about how linear types can be used in Scala programs to prevent runtime errors like these by detecting them at compile time.

Attendees will leave this talk with a new tool in their functional programming toolbox that they can use to solve real-world problems.

Introduction to Functional Programming April 25, 2021

In this workshop, we learn about the basics of functional programming in Scala by building simple algebraic data types, implementing common patterns from category theory, and writing handy functional effect systems.

Microservices in Real Life April 10, 2019

Microservices architectures foster rapid development and deployment of incremental improvements. This makes it easy (and fun) to build an expanding suite of software in a patchwork of available time.

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.

Functional Electromagnetism March 30, 2019

Strengthen your understanding of functional programming by looking at it from a fresh and unconventional perspective.

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.

Functional Infrastructure May 26, 2017

Nix, the "purely functional package manager", is part of an ecosystem of tools used across the spectrum of software development, from local prototyping and development to production deployment and maintenance.

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, scale it in and out, and maintain it in production.

Whether your role is in development, testing, QA, DevOps, or automation, Nix has something for you.

Purifying Code with Algebra September 16, 2016

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.

Literate Programming with Codedown May 29, 2016

Codedown is a little utility to extract code blocks from Markdown files. It can be used to help check the correctness of code in articles and slideshows, or even to allow Markdown to be the distribution format for a project's source code.

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.

Applicative Validation in Scala March 30, 2016

One of the first functional data structures I reach for when writing code that interacts with a person or another system is Validation. It allows me to accumulate, parse, transform, and verify input in a type-safe and parallelizable operation.

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.

Scala via JavaScript August 14, 2015

As a longtime Scala developer who recently switched to (nearly) full-time JavaScript development, I have learned some interesting and unexpected lessons about the capabilities and ecosystem of both JavaScript and Scala.

In this talk, we'll go through some of the more compelling examples, and see what one language might learn from the other.

Nix, Plus or Minus Cabal July 14, 2015

In this talk, we look at Haskell development 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.

Types and JavaScript June 23, 2015

How to use types to reason about code.

Discovering Knowledge in Linked Data April 24, 2015

By building on the foundations of the Semantic Web, we can create tools that help people explore relationships between data, connect information, and discover knowledge.

In this talk, we'll look at how to search Wikidata from a graph database via a domain-specific language. We'll be able to ask simple questions such as "What happened on this day in history?", and tricky questions such as "What were some of the fields of work of physicists who worked at institutions where Richard Feynman also worked?".

SOA Proliferation Through Specification January 27, 2015

A look at how Swagger specifications can help in the development, adoption, and deployment of services in a service-oriented architecture.

Functional Refactoring January 24, 2015

Refactoring provides an accessible opportunity to learn about imperative and functional design patterns, and Scala's hybrid OO/FP design caters to both.

We explore examples of Scala code written using familiar imperative design patterns, and refactor each one using a counterpart functional pattern. We learn how to replace mutable variables with the state monad, loops with folds, thrown exceptions with sum types, dependency injection with the reader monad, and much more. As we go, we build a mapping of corresponding imperative and functional patterns.

DevOps for Scala August 8, 2014

It's easy to establish reliable development processes with free Web-based tools.

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.

Putting Functional Programming to Work June 26, 2014

Frequently among the benefits claimed of functional programming are promises of safety, composability, and reusability, but it is often difficult to connect these ideas with production code solving real-world problems.

In this session, we dig into one particular tool: the state monad, to see how it lives up to these promises and helps power the Versal platform.

Real-World Functional Programming May 28, 2014

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.

Functors and Monads in Java May 3, 2014
Visualizing and implementing categorical functors and monads in Java.
Effect Systems January 24, 2014

Effect systems allow the separation of the semantics of a program from the specification of a program. An effect system is made up of effect types, effectful programs, and effect handlers. An effect is an operation, behavior, pattern, or signature of which the meaning is up for interpretation by an effect handler.

We explore different ways to implement effect systems in Scala. We begin by describing an effectful program that we would like to write as a pure value. We then write different toy effect systems that can run it.

Rapid Scala Development with sbt September 14, 2013

Developing software in Scala requires only three tools:

In this talk, we look at a simple way to develop sophisticated software in Scala using these tools together.

Scala in 2018: A Panel with Rod Johnson September 12, 2013

In this panel, we debate Rod Johnson's ScalaDays 2013 keynote about obstacles to Scala's widespread adoption.

Hands-On Category Theory August 2, 2013

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.

TDD with FireOtter June 11, 2013

In this talk we describe FireOtter, a library for human readable CSV-based specification testing.

The State Monad December 13, 2012

In this talk, we explore the State monad as a way to represent state changes in a purely functional way.

Beyond the Reader Monad: Dependency injection with Jellyfish November 16, 2012

Jellyfish is a Scala library for direct-style functional dependency injection via delimited continuations.

Functional JDBC in Java with the Reader Monad April 26, 2012

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.

Functional Reactive UI Thing November 14, 2011

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.

Imperative Web Workflows via Delimited Continuations September 10, 2011

A neat way to use continuations is to represent blocking, asynchronous code as imperative-style functions. I put together a little library to help write Web-based workflows, which involve multiple round-trip steps between the client and server, with the user providing input along the way.

Transparent Scalability Through Portable Continuations August 8, 2011

Transparent scalability is an elusive characteristic sought for successful software projects which inevitably outgrow themselves. A common way to approach the design of such applications is with the MapReduce pattern, which requires considerable foresight into how the application can be broken down into the functional map and reduce operations. A problem with this and similar approaches is the investment required at the beginning of development; the problem domain must be carefully analyzed and a solution crafted to support the predicted scalability needs. It would be preferable if applications could be developed simply and cheaply, then later, when necessary, made scalable without reworking the existing source code.

We present an approach to building transparently scalable applications using Swarm, a framework that enables code execution to "follow the data" within Scala's serializable delimited continuations. Swarm abstracts the location of data across a distributed system from the developer, eliminating costly architectural and modeling requirements of popular distributed computing patterns and frameworks.

We explain the design of an example implementation of a Twitter-like Web application that uses Swarm's continuation-passing style collections, and show how the developer is unburdened by the complexity of scalability.

We demonstrate how this Swarm-based application can be transparently scaled without requiring changes to the code or accommodation by the architecture.