-
keyboard_arrow_down
Edward Kmett - Logic Programming à la Carte
45 Mins
Keynote
Intermediate
I've been working on a logic programming framework in Haskell, called guanxi (關係) with an eye towards scalability. To build it I leaned heavily on my previous work on propagators and a bunch of other little bits and pieces of algebra and category theory in the design process. A number of patterns have arisen repeatedly throughout the process of building this library. I'll give a tour through the current state of guanxi and try to extract some of the more reusable bits of its design for your inspection.
-
keyboard_arrow_down
Naresh Jain / Aaron Hsu / Andrea Leopardi / Bruce Tate / Edward Kmett / Saurabh Nanda - Q & A Session With Functional Conf Speakers
Naresh JainFounderXnsioAaron HsuComputer ResearcherDyalog Ltd.Andrea LeopardiCore Team MemberElixir LangBruce TateFounderGroxioEdward KmettResearch EngineerMachine Intelligence Research InstituteSaurabh NandaFounderVacation Labsschedule 3 years ago
45 Mins
Keynote
Beginner
During the conference you might have had questions that did not get answered, this is your opportunity to get them answered by our expert panel group
-
keyboard_arrow_down
Bruce Tate - Joy - Maintaining Passion for Programming
45 Mins
Keynote
Intermediate
Many people in our industry are programmers because we're curious and passionate about coding. Each of us can remember latching onto a trivial programming problem and staying with it deep into the night. For far too many of us, that passion for programming fades under the slow, wilting heat of the day to day grind.
In this talk, Bruce Tate, author of Seven Languages in Seven Weeks, takes a frank look at the grind and offers some practical advice on putting the "fun" back into "functions". We'll introduce some pragmatic ideas to get you excited about the journey again. We can't always dramatically change our circumstances, but we can often make small tweaks to how we approach problems.
Come along. Enjoy the journey.
-
keyboard_arrow_down
Aaron Hsu - Programming Obesity: A Code Health Epidemic
45 Mins
Keynote
Beginner
Programs are getting fat. They're becoming slow. They're taking up more computing resources. They're getting harder to maintain and more complex from the ground up. Layer upon layer of sophistication is causing us to lose our ability to predict what software will do. Where's that bug? Why is everything going so slowly? Am I even using the right data structures? Where's that important point in the documentation again?
What's happened to us? In this meta-dive into the nature of our approach to programming, we will explore some of the dangers of our current approaches to programming and the how/why of our current programming obesity problem. We will look at real case studies and see just how bad the situation can be.
But we will also explore how we can battle these sources of obesity. In this passionate plea for code that we can gain control over again, we will look at examples of how we can return to a state of high-performance on all levels, from code size to code scalability. We will look at the principles that can help us to reach leaner, more efficient, more usable, less buggy code. We will hopefully find some light at the end of the tunnel, and how we can change our outlook on programming to push ourselves towards code that benefits not only ourselves, but also those that will come after us.
-
keyboard_arrow_down
Andrea Leopardi - BEAM Architecture Handbook
45 Mins
Talk
Intermediate
If you are writing a stateless web application backed up by a database, there is a good chance Elixir is a great fit. However, this is not where it shines. In this talk, we will discuss how to architect Elixir applications in order to leverage the features of the language and of its runtime.
We will look at this both from a lower level, talking about the architecture of processes inside an Elixir application, as well as from a higher perspective of writing Elixir services and architecting systems to play to Elixir's strengths. We will see practical use cases and discuss design patterns. -
keyboard_arrow_down
Edward Kmett - Propagators
45 Mins
Demonstration
Intermediate
There are a lot of algorithms that revolve around iterating a form of information propagation until it attains a deterministic fixed point. CRDTs, Datalog, SAT solving, functional reactive programming, and constraint programming all fit into this mold.
One framework for these sorts of algorithms is the notion of a “propagator” due to Sussman and Radul, but until now little rigor has applied to know how such algorithms terminate with consistent results. Another framework is Lindsey Kuper’s work on the notion of “lattice variables” (LVars), which addresses termination, parallelism and eventual consistency well, but not iteration.
By blending these frameworks, I’ll build up a series of sufficient conditions for propagators to terminate with consistent results and proceed to show how we can use this common framework to steal insights and quirks from each individual domain to try to optimize the rest.
-
keyboard_arrow_down
Bruce Tate - Coding LiveView
45 Mins
Demonstration
Intermediate
Startups and web developers take note. Phoenix LiveView is the revolutionary framework that allows rapid development of real-time web interactive applications without custom JavaScript. You read that right the first time, and the Elixir community is buzzing. So far, the performance numbers have been nothing short of earth-shattering.
In this session, you’ll see how it all works. We will do some live coding to show you LiveView under the hood.
-
keyboard_arrow_down
Naresh Jain / Andrea Leopardi / Bruce Tate / Mohammad Maqbool Alam / Nikhil More / Ravi Chandra Padmala / Sujatha Hemmady - Q & A Panel Discussion with Code Beam Lite India Speakers
Naresh JainFounderXnsioAndrea LeopardiCore Team MemberElixir LangBruce TateFounderGroxioMohammad Maqbool AlamSoftware DeveloperUnderjord ABNikhil MoreSr. EngineerVolansysRavi Chandra PadmalaPartnernilensoSujatha HemmadyTech LeadRedbusschedule 3 years ago
45 Mins
Talk
Beginner
During the Code Beam Lite conference you might have had questions that did not get answered, this is your opportunity to get them answered by our expert panel group
-
keyboard_arrow_down
Bruce Tate - Designing Elixir Systems with OTP
480 Mins
Workshop
Intermediate
You know how to code in Elixir; now learn to think in it. Learn to design libraries with intelligent layers that shape the right data structures, flow from one function into the next, and present the right APIs. Embrace the same OTP that’s kept our telephone systems reliable and fast for over 30 years. Move beyond understanding the OTP functions to knowing what’s happening under the hood, and why that matters. Using that knowledge, instinctively know how to design systems that deliver fast and resilient services to your users, all with an Elixir focus.
Elixir is gaining mindshare as the programming language you can use to keep your software running forever, even in the face of unexpected errors and an ever-growing need to use more processors. This power comes from an effective programming language, an excellent foundation for concurrency and its inheritance of a battle-tested framework called the OTP.
If you’re using frameworks like Phoenix or Nerves, you’re already experiencing the features that make Elixir an excellent language for today’s demands. This book shows you how to go beyond simple programming to designing, and that means building the right layers. Embrace those data structures that work best in functional programs and use them to build functions that perform and compose well, layer by layer, across processes. Test your code at the right place using the right techniques. Layer your code into pieces that are easy to understand and heal themselves when errors strike.
Of all Elixir’s boons, the most important one is that it guides us to design our programs in a way to most benefit from the architecture that they run on. The experts do it and now you can learn to design programs that do the same.
-
keyboard_arrow_down
Mohammad Maqbool Alam - Building a MySQL Database Driver in Elixir
45 Mins
Demonstration
Intermediate
Have you ever wondered what happens beneath the covers when you talk to your Database? Well, you are in for a treat! In this talk, we are going to uncover the dark magic behind Database Drivers. We will look at everything that is needed to talk to a database, query its data and transform it into the native data types in Elixir.
-
keyboard_arrow_down
Michael Snoyman - Your first Haskell web app with WAI and Warp
45 Mins
Tutorial
Beginner
Haskell's Web Application Interface (WAI- pronounced "why") provides an abstraction between web applications and web servers. This allows many different web frameworks (e.g., Yesod, Spock, and Servant) to share servers like Warp and middlewares.
Haskell's web frameworks offer a wide variety of feature sets, type-level and metaprogramming, and intended use cases. And for most use cases, I would recommend using an existing web framework, which will help you avoid common pitfalls and more quickly address common use cases.
But not today! In this tutorial, we're going to step through building a functioning web server using just the bare-bones WAI interface and Warp as a server. Familiarity with the basics of Haskell will be a plus, but this will be a talk open to all FP and Haskell skill levels.
-
keyboard_arrow_down
Alexander Granin - Hierarchical Free Monads and Software Design in Functional Programming
45 Mins
Talk
Advanced
Functional Programming is going through the same process of rethinking as Object Oriented Programming has passed already. FP today is not only something mystical, something barely applicable for day-to-day tasks, but rather a whole philosophy of building big, complex applications, with own tools, approaches and methodologies. We can see a lot of ideas about software design and architecture emerging from the FP community: talks, books, articles. We’re actively discussing Final Tagless, Free Monads, effect systems and other approaches, but it seems the theme not yet covered and we don’t know about possibilities we have.
In this talk, I’ll tell you about the power of Free Monads in building complex applications in Haskell and PureScript. These applications will be satisfying the requirements like maintainability, testability, simplicity. You’ll know how to create a safe concurrent application state, how to divide the application into layers and how to keep the code sane. In fact, you can do the same with Final Tagless or extensible effects, but the approach with hierarchical Free Monads has some specific properties making it the best tool to separate concerns and create a very interesting eDSLs with different semantics.
The talk is based on the ideas I’m describing in my book “Functional Design and Architecture”. I also gave several talks about this theme earlier (you can find all my talks here).
I’ve used these ideas to build software for different companies, including Juspay (Bengaluru), Restaumatic (Poland), Enecuum (Hong Kong). We’ve created several interesting technologies that were not possible to make without Free Monads. Some of them are open sourced.
-
keyboard_arrow_down
Anupam Jain - Typesafe Functional SQL
45 Mins
Talk
Intermediate
We'll discuss how to use strongly typed functional programming to build a typesafe and highly declarative DSL to generate SQL, that allows better abstractions and minimises runtime errors. We'll focus on type systems, and build an intuition for row types and how it guarantees correctness for SQL. I'll cover some parts of actual SQL generation.
A similar talk was given at IIIT Delhi earlier, however that was more geared towards beginners to Functional Programming (link below). I plan to give a more intermediate level talk this time.
-
keyboard_arrow_down
Nikhil More - Do you OOP in Elixir?
20 Mins
Experience Report
Beginner
One of the strategies being adopted by RoR or Java software developers in adopting Elixir is they have not yet adapted themselves to unlearn the OOP in developing the web systems. This has caused OOP concepts to creep into full fledged Elixir systems. This presentation seeks to highlight these subtle points that need to be avoided to make the code more FP and less OOP.
-
keyboard_arrow_down
Allister Beharry - Lightweight dependent types for scientific computing
20 Mins
Demonstration
Intermediate
Sylvester is an F# DSL for scientific computing which implements an advanced type system where vector, matrix, tensor, neural-network and other types have numeric properties like dimension sizes, rank, layer node size, etc., encoded as part of the type. Type-level constraints for operations like matrix multiplication or network layer construction utilize the F# type checker as a type-checker for linear algebra and other mathematical domains which allows for type-level verification of mathematical operations and for Intellisense-enabled IDEs to provide immediate feedback that helps the user avoid errors in mathematical expressions..
-
keyboard_arrow_down
Naresha K . - Eclipse Collections, Java Streams & Vavr - What's in them for Functional Programming
45 Mins
Talk
Beginner
Intuitive collections types can certainly help developers positively in terms of increased developer productivity and higher readability. As a developer on JVM you have plenty of options from the community. In this presentation, I compare three popular collections libraries - Eclipse Collections, Java Streams API, and Vavr. I present the code examples using all the three APIs. I firmly believe, there is no one library that is perfect for all situations. Hence we compare these libraries along the dimensions of mutability/ immutability, eager/lazy evaluation, richness of expression, error handling aspects. By the end of the presentation, we identify the strong areas for each of these APIs.
-
keyboard_arrow_down
Deepak K [Daksh] Gupta - Lambdas: The Functional Programming Companion of Modern C++
45 Mins
Talk
Intermediate
C++ as a Programming Languages had ruled the programming world for quite some time. It was so much synonymous to Object Oriented Programming that when functional programming came into the picture, nobody initially thought of C++ as a candidate for the same.
Fortunately, the C++ Standardization (isocpp.org) committee had a different idea and they later came up with C++11 which was a paradigm shift in the language. C++ now not only allows programmers to write functional code, but it has also evolved the language into a meta programming language.
The core of these changes which enables functional programming in C++ revolves around the introduction of Lambdas. Suddenly, with lambdas, we’re not only writing functional code in C++ but can also have functional threads, functional locks, and functional memory management.
The beauty of lambdas can also be judged from the fact that it has also made many of the STL (Standard Template Library) algorithms functional which, along with the concepts and ideas of Closures makes C++ an ideal candidate to be considered for writing functional codes which includes immutability, Partial function specialization, and pattern matching.
In this talk, I’ll take you on the journey of functional Programming in modern C++ and how to write awesome and simple C++ code which conforms to all tenets of Functional Programming.
The talk shall contain full fledged examples which shall be made available to participants post conference
We’ll also see how the language has evolved and why it’s still a favorite for doing performance intensive jobs which we can, of course, do in a functional way
-
keyboard_arrow_down
Michael Snoyman - Applied Haskell Workshop
480 Mins
Workshop
Intermediate
This full day workshop will focus on applying Haskell to normal, everyday programming. We'll be focusing on getting comfortable with common tasks, libraries, and paradigms, including:
- Understanding strictness, laziness, and evaluation
- Data structures
- Structuring applications
- Concurrency and mutability
- Library recommendations
By the end of the workshop, you should feel confident in working on production Haskell codebases. While we obviously cannot cover all topics in Haskell in one day, the goal is to empower attendees with sufficient knowledge to continue developing their Haskell skillset through writing real applications.
-
keyboard_arrow_down
Aaron Hsu - APL Training Wheels
45 Mins
Tutorial
Beginner
APL is getting a lot of attention lately due to its potential for very high performance portability and suitability for both rapid prototyping of complex solutions as well as deployment of complex algorithms to high-speed, modern parallel hardware. It has the potential to vastly improve the speed, scalability, and size of your code bases. But APL has a reputation as an intimidating language to learn.
In this back to the basics tutorial, we will explore the core of APL, and focus on those areas that usually trip up the beginner in learning APL. We will also walk you through how to approach an APL expression, how to reason about them, and how to read them efficiently. We will teach you the skills that the expert APLer has internalized, and how you can work through these skills externally and explicitly in a way that will help you to eventually internalize these critical skills in a way that makes you efficient at using APL on real world problems.
-
keyboard_arrow_down
Anupam Jain - Supercharged Web Application development with Purescript
45 Mins
Workshop
Beginner
UPDATE: Please setup https://github.com/ajnsit/purescript-react-starter (follow the instructions in the README) on your laptops as a **prerequisite**.
Purescript is a purely functional, strongly typed language, that compiles to Javascript.
It provides several high quality libraries for frontend development, and comes with excellent tooling and editor support that makes writing code a snap!
In this talk I will provide a quick introduction to some basics of Purescript, and then dive into an interactive demonstration of building a non-trivial web application from scratch. I will show how to interface with React bindings, and how to interface with some existing Javascript libraries (a React UI component lib).
The presentation will be interactive and similar to an inpromptu talk I gave which is linked below. However, I will also demonstrate live coding of an actual purescript application which people can follow along.
Bring your laptop to follow along.