Workshops & Unconference are included in the ticket price
Open the doors and registration
See you later
Open the doors and registration
The best time to talk with speakers and attendees
See you later
Rock concert with gallons of beer and tons of music
The best time to talk with speakers and attendees
Open the doors and registration
See you later
Rock concert with gallons of beer and tons of music
On Thursday, October 26th, Lambda World will host an Unconference during the morning and a few workshops in the afternoon before the start of LW talks. If you want to add your talk to the unconference, here is the spreadsheed we created for that
Organised by the Scala Center, the SC Spree is a four-hour event devoted to the development of popular Scala tools and libraries in the ecosystem.
The perfect time for international Scala developers to meet up and improve their skills by solving issues in community projects and advancing the state of the art of everyone’s daily toolkit.
The Spree will be lead by Scala Center’s engineer Jorge Vicente Cantero.
While he’ll introduce actionable issues and offer continuous help to anyone that needs it, his goal is to make sure everyone enjoys hacking collaboratively on Scala ecosystem projects.
Rumor has it that he’ll provide token gifts to anyone that makes a PR!
Do you know Scala and want to have some fun? Join us!
We are excited to be hosting Lambda World in two different countries for the first year! Lambda World Seattle will be hosted September 10th-11th in Seattle, Washington (USA) at the Living Computers Museum, followed by Lambda World Cadiz October 25th - 26th in Cadiz, Spain at the Palacio de Congresos. CFP’s for both conferences are now open
We study all sorts of aspects of programming languages, their ease of use, type system, their level of abstractness, but we feel one aspect is overlooked, how a programming language sounds like when read aloud. Is reading aloud hard? Well, yes.
We found that developers cannot pronounce code in a consistent fashion. We had 25 experienced developers read code aloud, and it was a mess, even for simple statements. For example, how to pronounce an assignment statement like x = 5? Is it “x is 5”? Or “set x to 5”? Or “x gets 5”? And what about an equality check? Is it “if x is is 5”? Or “if x is 5”? Or “is x is equal to 5”? What can we learn from reading code aloud? We think programming language designers could learn a lot from hearing their language spoken. For example, if programmers consistently read if x == 5 as “if x is 5”, = or even is might be better keyword. What is the ultimate end game of this idea? We envision programming language designers of the future to prescribe a way that their language sounds, much like languages have style guides. When the sound or ‘phonology’ is defined, it can be practiced, taught and analyzed.
This will be useful while learning to program, but could be a valuable tool people that interact with code in an oral way, such as visually and physically disabled programmers, and developers that are doing (remote) pair programming. What will the talk cover?
In the talk, we will describe our experiment and what we learned from it, so other interested in exploring how languages sound can start well-prepared and informed.
Felienne Hermans Assistant Professor, Delft University of Technology
Felienne is assistant professor at Delft University of Technology, where she researches programming for everyone, from spreadsheet users to young kids. Felienne’s biggest passions in life is to share her enthusiasm for programming with others. She teaches programming in a community center in Rotterdam every week, she organizes the Joy of Coding conference, a one day developer conference in Rotterdam celebrating the joy and art of programming, and she is a host at SE radio, one of the most popular software engineering podcasts on the web. If she is not coding, blogging or teaching, she is probably dancing Lindy Hop, running or playing a (board)game.
"What is my program actually doing?" Sometimes you feel a need to execute a functional program yourself. Ok, here's a function call. I'll first look at arguments. Now I've got values of arguments, so I'll go onto the function. Remember, this parameter is now this value, that parameter is now that value... You jump around the program, back and forth between variables and pieces of code, and keep collecting results of these visited pieces.
This talk introduces diagrammatic models of functional-program execution. The underlying idea is to express the above process using diagrams; the "token", your agent, moves around a diagrammatic representation of a whole program, and visited pieces of the diagram dynamically change to represent their results (so we do not need to remember!).
We will explore these diagrammatic models, which help us not only with visualising program execution but also with designing a language. These models can cover from conventional programming, with various evaluation strategies including call-by-value (used in OCaml) and call-by-need (lazy, used in Haskell), to unconventional (but increasingly significant) programming with "computational graphs".
Last but not least, the models are for mathematical reasoning; from cost analysis of execution to equational reasoning justifying compiler optimisation.
Koko Muroya (室屋 晃子) Assistant Professor, RIMS, Kyoto University
I am an assistant professor at Research Institute for Mathematical Sciences (RIMS), Kyoto University (Japan), and also a doctoral student at University of Birmingham (UK). What attracts me is visual aspects of functional programming -from information flow in a program, to a diagrammatic representation of execution of a program- that give a handy way to understand functional programming, especially mathematical reasoning behind it. Preferred pronoun: she/her.
Steven W.T. Cheung Doctoral Student, School of Computer Science, University of Birmingham,
I am a PhD student at the University of Birmingham (UK) who is interested in programming language semantics, compilers and language design. More specifically, I am interested in studying the semantics of functional languages with dataflow model using diagrammatic representation. Dan Ghica is my supervisor and together with Koko Muroya we are designing a functional language for machine learning.
This talk focuses on how Impostor Syndrome and the Dunning-Kruger effect work to undermine our estimation of our individual skills. Who do these cognitive biases affect? And how do they collectively shape the face of the software development industry? The impact of these biases on personal and professional relationships among individuals and groups will be examined, along with what can be done to diagnose and cope with them.
Jessica Rose Technical Manager, FutureLearn
Jessica Rose is a technology professional and public speaker specializing in community building, outreach and developing better processes for talent in technology. She is passionate about fostering more equal access to technical education and digital spaces. She's founded the Open Code meetup series and co-founded Trans*Code. She's also rubbish at writing about herself in the third person. Preferred pronouns: she/her.
Recently, many people in the functional programming community, and specifically in the Scala community, seem to follow the trend of solving their programming problems with more and more fancy abstractions and techniques. If in doubt, we throw a monad at the problem, and if that's not good enough, we'll make it free. Naturally, to top it off, we have to sprinkle the whole thing with some type-level programming, because this is common courtesy these days. In this talk I want to challenge some of the fundamental assumptions of how we think and work. With all our sophisticated engineering, are we actually solving the right problems? Are we rushing towards technologically exciting solutions too quickly? How much of the complexity in our software is inherent in the problem domain, and how much of it is of our own making? We may have honorable intentions, but do our solutions come at an acceptable price? Maybe it's time to slow down, think about what the problems we have to solve actually are, and how to do so in the simplest way possible.
Daniel Westheide Software Engineer, INNOQ
Daniel Westheide is a software developer from Berlin, Germany. He has a background in human-computer interaction, semantic web technologies, and adaptive web applications, and has been working as a backend engineer since 2007. He has been using Scala and Clojure professionally since 2011 and likes to spread the love for functional programming and domain-driven design. Author of The Neophyte's Guide to Scala
Haskell, the pure and lazy functional programming language, has now been around for more than 25 years. It had a profound influence on many other programming languages on the JVM: Java, Clojure and Scala and elsewhere: Purescript, Swift, Go (just kidding, not Go :-)). In this talk you will discover which Haskell constructs have made it to mainstream programming languages and change the way you program today. You will also get a glimpse of the features which are yet to be transferred for our greatest benefit. Warning: after this talk you might be tempted to try the real thing!
Eric Torreborre Senior software engineer, Symbiont
I am a Scala / Haskell developer, promoting the use of Functional Programming to sell fashion at Zalando in Berlin. As a member of the Scala community, I created libraries like specs2, eff and I love to share my experience about testing or functional programming at conferences or on my blog. Preferred pronouns: he/him.
Like the computer keyboard, the musical keyboard is a precise and high-bandwidth input device. Its power is a consequence of its elegant embodiment of the structure of Western European music, where simple mathematical ratios are experienced as consonance. In this talk, Chris will use a combination of the two kinds of keyboard to explain scales, chords, tuning systems and some differences between traditional and algorithmic musical performance. Expect demonstrations, and to discover the tragedy of the Pythagorean comma.
Chris Ford Principal Consultant, ThoughtWorks
I first got into music coding from the necessity of not having access to a physical piano, but I was soon hooked on the parallels between musical and programmatic structures. I have been giving talks about music theory and programming for many years now, converting different aspects of musical theory into Clojure. I am a Principal Consultant working for ThoughtWorks Spain here in Barcelona. My day job involves working with whatever technology stack best solves our clients’ problems, as well as helping them with software testing, agile approaches and product development. Preferred pronouns: he/him.
Testing is one of the most fundamental aspects of being a software developer. There are several movements and communities based on different methodologies with regards to testing such as TDD, BDD or design by contract. However, in the FP community testing is often not a large topic and is often glossed over. While it’s true that testing in functional programming tends to be less important, there should still be more resources on how to create tests that add actual value.
This talks aims to provide exactly that, with good examples on how to leverage property based testing, refinement types and the most difficult part: figuring out how to test code that interacts with the outside world.
Luka Jacobowitz Software Engineer, codecentric AG
Luka Jacobowitz is a functional programmer from Germany passionate about finding great abstractions to engineering problems. I’m also a maintainer of several typelevel projects, including various Cats libraries as well as OutWatch. I care deeply about equality and seek to make learning of pure functional programming as easy as possible. Preferred pronouns: he/him.
Despite its increasing popularity, functional programming is still stuck in the back seat when it comes to the enterprise. This talk aims to address common pitfalls in enterprise software engineering which can be avoided through the application of functional programming principles, as well as to introduce the clarity and maintainability inherent to functional code. In this talk, we will cover computational effects including failure handling, IO and partiality using various functors and monads. We will also explore the 'softer' side of teaching and advocating for FP at work, including strategies for coaching teammates off of imperative and side-effect ridden coding practices.
The material in the talk will focus on Scala specifically, but the principles should apply to any programming language supporting types. While enterprise software is implied in the title, the learnings and examples in the talk can be implemented in any commercial software development environment. The content presented is intended to have multiple levels of approachability. Beginners will be exposed to FP concepts from a relatable and novel angle, while advanced programmers will learn new ways to approach and teach these concepts. Engineering managers can gain an understanding of how functional code scales and remains maintainable.
Functional programming, in Scala and in general, is very jargon-y. Words and co-Words such as coyoneda, adjunction, comonad transformers and divisible functors are impressive, but without making effort to place them in our day-to-day context, they remain an academic interest. That's a shame, though - these data types and type classes can really make our life easier!
In this talk, I will take 3-4 plain and business-y use cases and show how they can benefit from some lesser known constructs from functional programming. Boilerplate will be slain, elegance will ensue and hopefully - you will find them useful enough to incorporate in your day-to-day work!
Itamar Ravid Software Engineer, Independent,
Itamar is a freelance software engineer. He’s been working with all facets of software development for over a decade - from data infrastructure, through CI/CD processes to backend development. His current interests include in microservice architectures and stream processing systems on the JVM. Itamar is a functional programming addict and contributes to several open-source projects in the Scala ecosystem, such as the Cats library and ENSIME. Preferred pronouns: he/him.
In dire need of better tools when producing screencasts for Haskell at Work, I started building Komposition, the video editor for screencasters. This desktop application automatically detects scenes in screen capture video, detects sentences in audio parts, and features and a high-productivity editing workflow keyboard-driven navigation.
I’ll talk about why I started this project, and share my experiences building Komposition using Haskell. I’ll describe its architecture, what packages and techniques I’ve used, and outline the plans for its future.
Oskar Wickström Software Engineer, Haskell at work
After some years of musical education, Oskar Wickström began his journey into the world of software. He’s currently doing remote work in Haskell, and in his spare time he creates screencasts at http://haskell-at-work.com . Among the technical topics that interest Oskar are functional programming, systems design, web technology, and programming languages. His more aesthetic side, which mostly involves music, draws him towards graphics and UI design every now and then.
In this talk we will have fun with object algebras and type parameters! Those simple but powerful beasts can quite easily get us:
Let's prove that, with the appropriate tooling, pure FP in Java is quite achievable and desirable!
Jean-Baptiste Giraudeau Software Engineer - Functional Programmer, Lombard Odier Investment Managers
Functional programming enthusiast, DDD practitioner, proficient team player. Researcher of elegant solutions to complex problems. Free 'libre' software evangelist. A correct and maintainable program derives from clear specifications, exposes sound semantics and allow simple and local reasoning on its code. Strongly typed functional programming is the most effective technique I found that allow me to write correct and maintainable software. This is why domain driven design, applied mathematics and modern programming languages like Haskell, Scala, F# are essential tools for me. For the when I must use Java, I created and open-sourced 'Derive4J': a tool to ease functional Programming in Java.
Rust is a systems programming language with a nice type system and quite a few (maybe surprisingly) functional features. Where do they come from? Let's see if Haskell knows.
Lisa Passing , Open Knowledge Foundation DE
Lisa is a Berlin-based developer hacking on video games and coding creatively whenever she can. She is co-organizing the Berlin ClojureBridge chapter and helping spread peace, love and parenthesis whenever she can. Preferred pronouns: she/her.
To overcome the burden involved in interactively mechanizing mathematical proofs on a computer, most theorem-proving systems such as Coq and Isabelle, support user-customizable proof automation by means of tactics.
Tactics, introduced by Milner in Edinburgh LCF, are programs that can inspect and algorithmically manipulate assertions in the prover's base logic, with the goal of simplifying or discharging them.
While tactics are clearly useful in practice, they are beset by a number of fundamental limitations. They are written in a domain-specific scripting language, which by necessity resides outside of the prover's base logic, and lacks the base logic's precise typing. This in turn makes tactics famously difficult to maintain, and impossible to precisely specify and verify.
In this talk I will present an alternative architecture for user-customizable proof automation, specifically in Coq, which overcomes the above limitation.
The starting point is the observation, well known as Curry-Howard isomorphism, that proofs and programs in Coq are equivalent entities. Thus, concepts and ideas developed in the world of programming, can be applied to mathematics as well.
In particular, I will show how the idea of overloading a method name in programming (a.k.a. ad hoc polymorphism, static dispatch), can be applied to mathematical theorems.
Such an 'overloaded theorem' realizes a method for an automated discharge of a class of proof obligations, which, unlike a tactic, can itself be verified in the base logic of Coq, and flexibly composed with other Coq programs, theorems and proofs.
This is joint work with Georges Gonthier, Beta Ziliani and Derek Dreyer.
Aleksandar Nanevski Associate Research Professor, IMDEA Software Institute
My research is in the design and implementation of programming languages and logics for software verification. More specifically, I am interested in applying programming methodology to facilitate the construction of formal proofs in mathematics in general, and of program correctness in particular. My recent focus has been on designing methods for integrating programming with pointers, concurrency, and other important imperative features, into dependent type systems such as that of the proof assistant Coq. The goal of the integration is to leverage the proving power of Coq to obtain effective and scalable ways for reasoning about security and correctness of imperative programs. I am also interested in all other aspects of formal mathematics and programming language theory and applications related to compilation, optimization, semantics, interactive theorem proving, program extraction, automated deduction, decision procedures, program analysis and model checking.
This talk is about a journey: from imperative code to purely functional one. It starts with a program written in imperative style. Its weak spots can be quickly recognized: lack of robustness, testability and maintainability. We seek our salvation in the functional paradigm, but the road to enlightenment, has many dangerous and deceivable dead-ends. The quest has a happy ending, as we reach code that is performant, testable, readable and maintainable. Keep in mind however that knowledge comes from experience. As once someone wise said 'Its the not the Destination, it's the Journey.'
Though it is not a live coding session, it will sure feel like it. Code is written in Scala, parental guidance is advised.
Paweł Szulc Scala Developer, Pyrofex Corporation
Pawel Szulc is primarily a programmer. Always was and always will be. Experienced professionally in JVM ecosystem, currently having tons of fun with Scala and Haskell. Humble apprentice of Functional Programming. Runs a blog rabbitonweb.com.
Romain Calascibetta Software Engineer, Tarides
I am one of the main contributors of the the MirageOS operating system library and the main developer of the Irmin Git-like distributed store. I previously designed and lead the implementation OPAM, the package manager for OCaml and I've worked on XenServer.
While functional programming may be a simpler and more expressive way to build applications, even functional software endeavors over time are dominated by problems surprisingly similar to those found in traditional approaches. Besides leading ClojureScript compiler development, I’ve had the fortunate opportunity to work closely with a diverse set of clients on ambitious projects and experience their ClojureScript pain points first hand. In this talk, we’ll cover the benefits provided by functional programming without ignoring the many past glaring holes in our technology that have been slowly filled over time by observing users trying to ship real products.
David Nolen Software Developer, The New York Times
Functional programming is becoming pervasive in every branch of development, and if you're starting a new frontend project you can choose from many languages that allow you to embrace FP from the start.
In this presentation, we'll see how we can progressively migrate a codebase to TypeScript and start reaping the benefits of functional programming. You'll learn how to sneak FP into your code base, and get away with it!
Gabriele Petronella Functional Programmer, Buildo
I flip bits in a functional fashion. Building awesome things in scala, react and swift at @buildo. Organizer of Scala Italy (http://scala-italy.it)
Using monads gets you higher in the ladder of functional programming. Now, imagine where you can get when you create your own custom monads!
This workshop focuses on the different concepts and techniques. Conceptually, a custom monad is defined by some set of operations (its syntax or algebra), and one or more ways to execute it (its semantics, handler, or interpreter). We shall focus on the three different approaches to custom monads: initial, final, and operational, and how abstracting the common patterns lead us to the concepts of free and freer monads.
Familiarity with the concept of monad, and common instances such as Reader, State, or Maybe, is assumed.
Alejandro Serrano Mena Junior lecturer, Universiteit Utrecht
Almost every step in my professional life has been related to functional programming in one way or another. Currently, I work at Utrecht University, both doing research about functional languages, and teaching our students about basic and advanced Haskell. Before that, I was involved in Nublic, a small start-up where we tried to develop the concept of a 'personal cloud'. The project didn't really take off, but we all learnt a lot of Scala. I really enjoy speaking to other about the niceties of functional programming. Some years ago I wrote the book 'Beginning Haskell', and soon I'll be publishing 'The Book of Monads'. I am quite active in technical conferences such as LambdaWorld or LambdaConf, meet-ups in Spain and the Netherlands, apart from more academic conferences about this topic. Preferred pronouns: he/him.
After 20 years of evolution Java Virtual Machine became a real masterpiece of engineering and can easily outperform static compilers in many cases. There are however lot of issues arising when someone tries to use JVM for functiona laungagues. It is particulalry hard to create efficient Haskell implementation for JVM Developers of Eta tried it once again in a little bit different way. We will analyze how it works on a sample system, where the business logic is written in Haskell and middleware components and libraries in Java. We will try to analyze when it makes sense and how does it compare to the pure Java/Haskell implementation in terms of performance and code quality. We will play with it ans solve create some working projects combining power of Java/Jvm and Haskell.
Before workshop please have installed:
Jarek Ratajski Anarchitect, Engenius GmbH
Jarek Ratajski - Java Developer with a functiona heart I love programming since my first line of code I did on the C64 in Basic. Somewhere in 90ties I've switched from C++ to java and spent then 18 Years developing JavaEE software working for various companies and projects. Now I work for Engenius in Switzerland being Java developer at banks during the days and Scala/ScalaJS open sources hacker at nights. Preferred pronouns: he/him.
In this workshop we’ll learn how to use Arrow and Functional Programming to build up our own web app.
The starting point will be basic RESTful API built using Ktor, a Kotlin framework for encoding web apps. The API will provide a bunch of endpoints, some authenticated and some public ones.
Our main goal is to learn how to encode the main concerns that an app of this nature could have but using the Arrow data types and abstractions in a functional style.
We’ll address some key points like error handling, code branching, deferring execution, wrapping I/O effects, and polymorphism through typeclasses. We’ll end up raising the level of abstraction to use the Tagless Final style, and maybe Free, if there’s time!
Jorge Castillo Senior Mobile Engineer, 47 Degrees
Software Engineer @47deg. Speaker. @caster_io instructor. @arrow_kt maintainer. Blog http://bit.ly/2sMwbH5 Hiroaki creator https://goo.gl/6PZcCp. Preferred pronouns: he/him.
Raúl Raja CTO, 47 Degrees
Co-Author and maintainer of Λrrow, Freestyle and other FP libs in the Scala and Kotlin communities. CTO @47deg, Optimistic. Preferred pronouns: he/him.
F# is a relatively new primarily Functional programming language for the .Net platform. It is a statically typed managed functional language that is fully inter-operable with other .NET languages like C#, Visual Basic.NET etc. It builds on the power of Functional Paradigm and combines it with .NET Object-Oriented model enabling the developer to use the best approach for a given problem.
Functional programming (FP) offers several benefits. The code tends to be terse which leads to enhanced developer productivity. FP encourages pure functions which are much easier to reason about and debug, as well as eliminates large class of bugs due to side effect free programming. Moreover, immutability leads to easy parallelization of the code. Algebraic Data Types can be used to express domain object conveniently and control state space explosion.
F# is great practical choice for developing reliable and highly scalable real-world system that are quick and easy to develop due to the design of the language itself combined with the ability of the language to use a large no. of 3rd party libraries designed for the .NET platform.
Unfortunately, support for multiple paradigms often leads to confusion. Newcomers tend to find the transition from object-oriented world to functional world difficult. Moreover, it often leads to abuse where developer tries to use the same old imperative style of coding in a functional language and is unable to take advantage of the features, the language has to offer.The objectives of this talk are:
Nikhil Barthwal Senior Software Engineer,
Nikhil Barthwal is a Senior Software Engineer currently working in a Social Media company in California. He has several years of work experience with both big companies & smaller startups and also acts as a mentor to several startups. He is particularly fond of using Functional programming languages like F# for better productivity. Outside work, he speaks at local meetups as well as international conferences on several topics related to Distributed systems & Programming Languages. He has a Master's in Distributed Systems and a Bachelor's in Electrical Engineering.
Luckily I asked for it shaken. But what if we didn't??? How can we make sure that we get our refined drink? How can we prove that property? In a beginner-friendly way, we introduce you to LiquidHaskell (LH), a Haskell extension that allows us to distill our types to assure stronger guarantees of our code at compile-time. We start with a quick, hands-on approach to Haskell, introducing the basics so no one gets lost. Then, we deep dive into LiquidHaskell to get our hands dirty. Through plenty of tiny exercises, we see what refinement types are, how they can help us write safer code and prove that we get the drink we ordered.
Please take five minutes to follow the installation instructions *before* the workshop:https://github.com/janschultecom/20181025-strongly-typed-martini And don't forget to bring your laptop!
Jan Schulte Freelancer,
I am a freelance software consultant with over 10 years of industry experience living in Düsseldorf, Germany. Ever since entering industry as Java developer I wondered why things couldn’t be as easy as they were with Prolog back in university. I got my mojo back when hit by the functional programming train about 5 years ago. Since then I work full-time with Scala. I like to stick my nose into topics I have little clue about and give workshops & meetups about them. Apart from that I am also (co-)organising the [Lambda|Scala|Idris] user groups in Düsseldorf. Besides software talk to me about hiking, sports, homebrewing, food. Favourite Bond: Badass Daniel Craig Favourite Drink: Campari Negroni
Adrián González Scala Developer, rindus
I was born in the sunny city of Malaga, southern Spain. I quickly started to appreciate strongly typed programming languages after some sleepless nights during my early working years with dynamic languages. I am overwhelmingly fascinated by functional programming since I discovered it during my latest student years of Informatics Degree in the university. I have been professionally working with Scala for roughly a year, but my objective is to place Haskell as my main programming language. If you can't find me doing some Scala, or fancying Haskell, you will find me trying to grasp some mathematical concept or enjoying salsa dancing in the nearest club.
Looking for a partner to share Scala code with? A partner you can joke with about how “for” loops just look bad? Interested in learning cool new Scala features? Looking for a fabulous life partner? Awesome, but you probably won’t find the latter here :) Here you’ll explore the Scala way-of-life by engaging in pair programming with developers you just met.
The workshop is based on vanilla Scala, where we’ll answer short Scala functional exercise, trying to find interesting answers that may inspire us for years to come (as opposed to just finding a quick answer!). Every time the bell rings, we’ll solve a new question with a new partner. Don’t worry about missing out on interesting methods for solving the questions; between each round we’ll showcase and explore interesting solutions, so you’ll get to wander through new styles for writing Scala, how to make your code more readable, and acquire new tools for your Scala tool box.
Amit Anafy Server Developer, Wix
Amit loves bullet proof code (and puppies :]). She has been developing in various languages since 2008 and for the past three years is trying to tame the functional beast as a Scala developer at Wix.
Interest on Blockchain is increasing due to the set of awesome features that they offer, which perfectly fits on complex requirements from many enterprise use cases, for instance, from the way you transact business or manage assets, to the way you use your machines, vote, rent a car, and even prove who you are,... and it is being used not only by banks and other financial institutions, but by hospitals, retailers, and governments among others..
Some of those features, like decentralization among others, are even more awesome when functional programming is used. The objective of this workshop is for people interested in functional programming who want to know how to use it in the context of Blockchain applications.
In order to get a deeper knowledge about how functional programming may help to develop a blockchain application, focus will be put on how to develop some multi-tier system, coded with Scala, that will include some of the most required features in modern systems.
During the workshop, participants will work put hands on code in order to learn how to develop, deploy and use the aforementioned application, as well as giving them some guidelines to customize it for some specific uses.
In order to use this project, we need to build scorex by hand to this specific commit.
We will be focusing on the practical side of Coq, but the theoretical underpinnings will also be covered.
We will see how a dependently typed functional programming language lets you write your code, specify its behavior and reason about it within the same framework
Curry-Howard correspondence, verified typeclasses, a bit of logic and maths — you’ll see that even induction can be fun!
A word of caution is order: it is very addictive, just like videogaming for some
The easiest way to have Coq and all the dependencies installed is to download an Ubuntu-based VM image (approx. 2 GB) from here: https://software.imdea.org/fcsl/artifacts/ubuntu-18.04-coq.ova (login/password: fcsl/fcsl). It has Coq 8.8.1 and two development environments preinstalled (Emacs+ProofGeneral and CoqIDE).
If you’d like to have a native installation (Coq runs on Windows, Linux, and macOS), you will need: • An installation of Coq — any version from 8.7.0 up to (and including) 8.8.2, see https://github.com/coq/coq#installation • An installation of the Mathematical Components library (version 1.6.2 up to 1.7.0), https://github.com/math-comp/math-comp. The library consists of several packages, we are interested in the ssreflect package only. • An IDE-like editor for interacting with Coq. There are several choices, including: - Proof General (PG), an Emacs-based IDE. You might want to try out company-coq, which an extension of PG. In addition, there is the built-in coq layer for Spacemacs users. - CoqIDE is a simpler stand-alone IDE. It is distributed with Coq, so it should be available once you have Coq installed. It can also be compiled from scratch, but on some platforms this may involve installing additional packages for GUI libraries and such. - vscoq: Coq Support for Visual Studio Code.
Note that the Coq development team provides a bundled installer for Windows which should have all the dependencies we need.
Another alternative is to use your OS's package manager (e.g. APT, Homebrew, etc.) to install Coq and CoqIDE packages, but those are likely not to have mathcomp/ssreflect library. Your best choice here is either the opam package manager (https://opam.ocaml.org) or the Nix package manager (https://nixos.org/nix/). I hope that the Nix users are advanced enough to setup the dependencies on their own. If you decide to go with opam then once you have opam installed and set up, the dependencies can be installed with the following commands (for more detail see e.g. https://software.imdea.org/fcsl/setup.html): opam repo add coq-released https://coq.inria.fr/opam/released opam install coq-mathcomp-ssreflect
Anton Trunov Research Programmer, IMDEA Software Institute
Anton was an industrial software engineer and wrote embedded software for safety-critical applications, where he learned the importance of formal methods for verification. Several years ago he discovered Coq, fell in love with interactive theorem proving, and last year moved to Madrid to prove things about concurrency using his favorite tool. Anton does not play video games. Preferred pronouns: he/him.
Some functional languages require a lot of ceremony to do imperative things. Some have complex abstractions around concurrency or distribution. Some make handling failures painful.
Elixir is a flexible language that has many of the nice things functional programming provides, but also strives for being practical.
In this talk, we'll see how Elixir and the Erlang virtual machine provide a set of tools that make it easier to work with concurrent, distributed applications.
We'll see how failure handling and most of all recovery are built in the foundations of the language. We'll see how this plays well with modern system architectures.
Andrea Leopardi Member of, Elixir core team
I'm a software developer and a programming language enthusiast with an obsession for clean and beautiful code. I love learning. I strongly believe in accessible culture and education and in open-source software. I am a member of the core team of the Elixir programming language.
An experience report on a year of learning and working professionally with Haskell. Functional programming newcomers can expect an empathetic tale of learning Haskell the hard way, pitfalls to avoid and tips to get started with Haskell effectively. Seasoned practitioners will gain an overview of the current state of Haskell learning for beginners and where we could learn from other programming language communities.
Abby Sassel ,
I’m a software engineer who’s worked with functional languages such as Haskell, PureScript, and Clojure for love and money since 2015. Over the last year or so, I’ve been discovering how static type systems can be used to help create elegant and robust software. I’m always interested in how we can create more accessible and inclusive spaces in programming communities. Preferred pronouns: she/her.