There’s an amazing lineup of functional programming awesomeness at NDC Oslo this year. The track will be in Room 2 all week. Pick a nice seat and get cozy! I will update this page with links to session recordings as they are posted.
##Day 1 (Wednesday, June 17, 2015)
Keynote by Bruce Schneier - “Data and Goliath: The Hidden Battles to Collect Your Data and Control Your World”
- Bryan Hunter “Lean and Functional Programming” - (Room 2)
“Companies adopt Lean because it is a proven path to improving delivery times, reducing cost, and improving quality. A company that writes software cannot truly embrace Lean without also embracing functional programming. Why? Lean is about building quality into the process. Lean is a systemic method for reducing waste, overburden, and inconsistency. With OO, many forms of waste, overburden, and inconsistency are unavoidable. A defect early in the process always results in a defect in the product later in the process, and OO itself is a defective process. In this session we will go from the origins of both Lean and FP and see how specific FP concepts (examples in F#, Elixir) map onto Lean principles. We will also discuss why some companies fail at Lean and FP.”
- Yan Cui “A tour of the language landscape” - (Room 2)
“There seems to be a new programming language every week, and for us busy developers we just don’t have the time to keep up with them. But have you wondered what we might haved missed out on whilst we’re busy working in our language of choice?Having spent time with numerous programming languages the past few years I have learnt something new from each. In this talk, we will go on a whirlwind tour of the interesting concepts and ideas I have encountered, from F#’s type providers and Rust’s borrowed pointers, to Elm’s signals and Idris’s dependent types to name a few.”
- Scott Wlaschin “Enterprise Tic-Tac-Toe - a Functional Approach” - (Room 2)
“Follow along as I ridiculously over-engineer a simple game to demonstrate how functional programming can be used to create a real-world “enterprise-ready” application.
Topics covered include: encoding business rules into types, data hiding with parametric polymorphism, using functions for capability-based security, exposing a REST API with HATEAOS, the functional approach to logging, actors, scalability and more.”
- Venkat Subramaniam “Learning From Haskell” - (Room 2)
Whether you’re a fan of static typing or functional style of programming, a language that stands far apart and serves as a guiding force to a lot of different languages in these areas is Haskell. Learning about Haskell gives a very different perspective on typing and about functional programming. Knowing how Haskell does these influences the way we think and design our applications in different languages. Whether you program in C#, F#, or any of the other languages, come to this talk to get influenced by Haskell’s way of thinking and coding.
- Andrea Magnorsky “Computation expression in context : a history of the otter king” - (Room 2)
I heard that computation expressions are kind of like monads. I heard that monads are like burritos or space suits, and that they are pretty much magical. I also heard that they are monoids in the category of endofunctors…
As a writer of code that all sounds awesome, and I want to know and understand (and I’m sure you do too) what those terms actually mean, and most importantly why we should care about them. What are their practical uses? So, in this talk we are going to attempt to do just that. Failure is possible, but the attempt is valuable. It’s a lot to chew so make sure you had your tea/coffee.
- Mark Seemann “Type Driven Development” - (Room 2)
The F# type system is both stronger and more flexible than the type system in e.g. C#. You can use this to your advantage to rapidly evolve a prototype.
In this talk you’ll see an example of how to evolve a Finite State Machine that solves a real problem, using the F# type system as a driver.
##Day 2 (Thursday, June 18, 2015)
- José Valim “Idioms for building distributed fault-tolerant applications w/ Elixir” - (Room 2)
This talk will introduce developers to Elixir and the underlying Erlang VM and show how they introduce a completely new vocabulary which shapes how developers design and build concurrent, distributed and fault-tolerant applications. The end of the talk will focus on Elixir and include some live coding.
[Expectations: Introduce Elixir, its ecosystem and design goals within the Erlang Virtual Machine]
- Jérémie Chassaing “Event Sourcing and DDD with F#” - (Room 2)
Storing history rather than current state, Event Sourcing is a radical technique to implement efficiently Domain Driven Design. But many stop before even trying, convinced of the difficulty to implement it. A short F# sample shows how to implement Event Sourcing. The functional approach leads to a simple, clear and production ready solution, and uncluttered domain code ! No prior knowledge of F# required…
- Chris McCord “Phoenix - a framework for the modern web” - (Room 2)
Phoenix is an Elixir web framework for building productive, reliable applications with the performance to take on the modern computing world. Together, we’ll review what makes Phoenix great and how it uses Elixir to optimize code for performance – without sacrificing programmer productivity. Along the way, we’ll see neat features like live-reload and generators and how Phoenix’s realtime layer takes on the modern web.
- Karl Krukow “The Need for Closure” - (Room 2)
In psychology, the need for Clojure “… is usually provoked after experiencing an emotional conclusion to a difficult life event, such as the breakdown of a close interpersonal relationship [with an unreliable concurrent program, personal note]…” . “A person with a high need for closure prefers order and predictability and is decisive […]” .
My path to Clojure started with trauma, then Java Concurrency in Practice, (then almost Scala), then hope and then, finally, Clojure in production at Xamarin Test Cloud. When I first heard of Clojure back in 2008, it was love at first sight .
This talk will be a friendly, practical introduction to Clojure for those who are new and curious. We’ll look at the cornerstones of Clojure, as well as look at practical examples drawn from our use of Clojure in building Xamarin Test Cloud , a cloud services that provides access to more than a thousand mobile devices for the purpose of mobile quality assurance. Leave inspired to try out Clojure.
- Greg Young “Functional Data” - (Room 2)
I have always said that Event Sourcing is “Functional Data Storage”. In this talk we will try migrating to a idiomatic functional way of looking at Event Sourcing. Come and watch all the code disappear! By the time you leave you will never want an “Event Sourcing Framework (TM)” ever again!
- Mathias Brandewinder “Crunching through big data with MBrace, Azure and F#” - (Room 2)
For data exploration and rapid prototyping, the productivity of an interactive scripting environment is hard to beat: simply grab data, run code, and iterate based on immediate feedback. However, that story starts to break down when the data you have to process is big, or the computations expensive. Your local machine becomes the bottleneck, and you are left with a slow and unresponsive environment.
In this talk, we will introduce MBrace.net, an open-source and free engine for scalable cloud programming. Using the MBrace programming model, you can keep working in your beloved familiar scripting environment, and easily execute C# or F# code on a cluster of machines on Azure. We will focus primarily on live demos, from provisioning an Azure cluster with Brisk, to analyzing large datasets in a distributed fashion; in particular, we will discuss how this setup is relevant to data science and machine learning.
- Torben Hoffman “Using Elixir to get the fun back in Lego Mindstorms” - (Room 2)
Robots are fun. Programming is fun. Programming Lego robots with the visual environment… well, not so fun. This is the starting point for putting Elixir on the Lego Mindstorms EV3. It ought to be fun to do, but my son and I got lost in the visual environment when trying to do advanced things. After having created a simple EV3 library in Elixir the fun started coming back. This talk is about how the EV3 Elixir library works and how to use it to make robot control software that is easy to write and understand. One of the key building blocks in Elixir - as in Erlang - is processes, and we will have a look at how to design things using lots of processes and how that makes things easier to work with. We start from conceptual architecture and end with elegant Elixir programs. As we go along a visual notation that fits the domain will be introduced showing the benefits of having a small semantic gap between domain, architecture and language.
##Day 3 (Friday, June 19, 2015)
- Phil Trelford “F# for C# Developers” - (Room 2)
This talk is for C# programmers who are curious about F#, a multi-paradigm and cross-platform programming language.
In: test driven development, classes and functions
Out: maths, monads and moth-eaten jumpers
Expect plenty of practical examples with live code samples, including interop between C# and F#.
- Tomas Petricek “End-to-end Functional Web Development” - (Room 2)
One of the myths about F# is that it is only good for complex mathematics. In this talk, I’ll show you that this could not be further from truth. A web server is essentially a function from a request to a response and so functional programming is a perfect fit for it.
In this talk, I’m going to walk through a complete web development story with F#. We’ll start with a script file to test a couple of ideas, wrap the code into a web server and we’ll finish by deploying our system to Azure and Heroku. If you’re curious what this is going to be about, you can check out one of the samples that we’ll build at www.fun3d.net.
You will learn:
- How to write web applications using the Suave.io web server
- How to call REST services using F# Data type providers
- How functional web server design makes it easier to test your system
- How to deploy F# web apps to Azure and Heroku with FAKE
- Irina Guberman “Maximizing throughput on Multicore Systems” - (Room 2)
Erlang is the best language there is for getting the most out of your concurrent system – it was created with multi-core processing in mind! However, to get the best of it we need to understand what our concurrent processes are actually doing and how they’ll play out with our system’s physical limitations, a concept also known as mechanical sympathy. I would like to explore this subject based on my project at Ubiquiti Networks and take a look at an existing tool that could make the task of maximizing throughput on you multicore system easy and fun: the “Jobs” Framework by Ulf Wiger.
- Explore a business case scenario of a highly concurrent HTTP server requiring high CPU utilization.
- Explore “Jobs” framework in great detail with code snippets and fun pics. By the end of it anyone can start using it even developers with no Erlang background!
- And last but not least: Demonstrate that Erlang is a fantastic choice for writing highly concurrent applications! Target audience: Any developer interested in writing concurrent applications.
- Chris McCord “Metaprogramming Elixir” - (Room 2)
Elixir macros give programmers the power to write code that writes code. This power eliminates boilerplate, allows Domain Specific Language abstractions, and provides the freedom to extend the language. Leveraging the fact that it can be represented by its own data structures, Elixir can interrogate its own code to peer in for analysis or to add additional functionality. Used appropriately, macros offer effective module composition and code generation techniques, while more liberal use can serve as an outlet for novel insights through experimentation.
Starting from the basics of macros, we’ll explore these ideas from an introductory level through advanced topics and real-world use-cases. Along the way, we’ll see how Elixir uses meta-programming to generate parts of its own standard library. We’ll also examine how macros can be used to save time and share functionality in a fun and productive way.
- Tomas Jansson “F# as our day job by 2016” - (Room 2)
F# is a language I am passionate about and a language I would like to use on my day job, and for that to be a reality I need you to join me! I want you to join me in the welcoming F# community where you can see a new world open up for you and enabling you to solve problems more efficiently than you do today with C#. F# is not a language that is used only in academia, it is a general purpose language that is growing every day with an awesome community of brilliant people. F# also defines the future of C# in many ways, so if you want to be ahead of the game you should jump on the F# bandwagon today. There are many reasons to learn F# like; a new paradigm will make you a better overall developer, F# will make you write less bugs and you will have more fun at work!
I this presentation I will show you:
- What the strengths of F# are
- Why you should start using F#
- How you get started with F#
- Don’t hesitate, join the F# movement. The only way to improve is to change!
- Torben Hoffman “Implementing the logic for a board game in Elixir” - (Room 2)
Board games are fun and good challenges when exploring a new language. The requirements are clear - if only software requirements were as clear - and poses some interesting problems when it comes to implementation of the often quite cunning rules.
Imperative, object-oriented and functional languages all provide their own answers on how to implement board game logic.
Elixir is a concurrency oriented, functional language. This means new ways of solving the problems.
In this talk we will look at how Elixir can be used to implement the logic for the board game classic Acquire. And some of the ideas can even be used for “real-life” problems as well!
Talk objectives: * Show how to break down board game logic in to manageable pieces. * Show how processes and functional programming work together in asoftware design. Target audience: programmers wanting to understand a different way of thinking. the little board gamer inside all of us.
It is business time for functional programming, and the goal of th track is to help you “make it real” in 2015 by bringing FP into your day job. For many attendees the benefits of F# are within reach, and we have assembled a stunning line-up of F# badasses (including hometown hero Tomas Jansson) who will each demonstrate how moving to F# is a good business decision. Outside of F#, one of the most business relevant (and exciting) stacks is the pairing of Elixir (a modern Erlang VM language) and the web framework Phoenix. We’re delighted to have José Valim (creator of Elixir) and Chris McCord (creator of Phoenix) join in this year’s FP track. Game on!