Pre-Conf Workshop - Wed, Nov 13

Bootcamp Day - Thu, Nov 14

Apply FP - Fri, Nov 15

Mastering FP - Sat, Nov 16

Post-Conf Workshop - Sun, Nov 17

Designing Elixir Systems with OTP

Intermediate Workshop

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.

Target Audience

Developers and Architects interested in designing systems that deliver fast and resilient services

Outline
  • Introduction
    • Build Your Project in Layers
      • We Must Reimagine Design Choices
      • Choose Your Layers
      • Begin with the Right Data Types
      • Build Your Functional Core
      • Establish Your Boundaries
      • Test Your Code
      • Plan Your Lifecycle
      • Invoke your Workers
      • Do Fun Things with Big, Loud Wildebeests
  • Do Fun Things
    • Know Your Elixir Datatypes
    • Primitive Types
    • Lists
    • Maps and Structs
    • Strings
    • Tuples
    • Functions As Data
    • When To Leave Elixir
    • Know Your Elixir Datatypes
  • Start With The Right Data Layer
    • Access Patterns Shape Data Structures
    • Immutability Drives Everything
    • Try It Out
    • Start With the Right Data
  • Build a Functional Core
    • Organize Core Functions by Purpose
    • Compose a Quiz From Functions
    • Build At a Single Level of Abstraction
    • Keep the Left Margin Skinny
    • Try Out the Core
    • Build Your Functional Core
  • Test Your Core
    • Simplify Tests with Common Setup Functions
    • Improve the ExUnit Infrastructure
    • Provide Test Data With Fixtures
    • Prime Tests With Named Setups
    • Make Tests Repeatable
    • Compose Within Tests
    • Take Tests Beyond the Elixir Base
    • Test Your Functional Core
  • with Big, Loud Wildebeests
    • Isolate Process Machinery in a Boundary
      • Maintain Composition Through Uncertainty
      • Build Your Optional Server
      • Wrap the Server in an API
      • Prefer Call Over Cast to Provide Back Pressure
      • Extend Your APIs Safely
      • Wrap Your Core in a Boundary API
    • Lifecycle
      • Understand Lifecycles
      • Configure Applications to Start Supervisors
      • Start Per-User Processes with a Dynamic Supervisor
      • Touch Up the API layer
      • Manage Your Lifecycles With Supervisors
    • Workers
    • Test the Boundary
    • Put Them Together As Components
Bruce Tate
Founder
Groxio

Bruce Tate is a kayaker, climber, programmer and father of two from Chattanooga, Tennessee. A serial entrepreneur, he has helped start three companies, and most recently served as CTO for icanmakeitbetter. The author of more than a dozen books is active in the Elixir community as a speaker, author, editor and conference organizer. His love for teaching and computer languages led him to found Groxio in 2018.

As an author and speaker, he has written more than ten books including two JOLT award winners, most recently the book Seven Languages in Seven Weeks. He is the editor for the Seven in Seven line of books, including Seven Databases in Seven Weeks, with several other books under development.

When he is not coding, Bruce is an avid kayaker, climber, and mountain biker. When not coding, you can find him riding the bike trails by his home on Lake Travis or icing his most recent injury.

Question for Speaker?
Please rate Designing Elixir Systems with OTP

Applied Haskell Workshop

Intermediate Workshop

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.

Target Audience

Attendees who are comfortable with the basics of Haskell, and want to learn how to apply what they already know to real-life projects.

Outline
  • Tooling intro
  • Strictness/laziness/evaluation
  • Data structures
    • String types
    • Containers
    • Vector
  • Concurrency
    • Mutable variables
    • STM
    • async

If there is additional time, we can also cover, at the attendees' preference:

  • Exceptions
  • Streaming data
  • HTTP client/server
  • rio
Learning Outcome

The ability to write real world, professional Haskell code.

Michael Snoyman
VP, Engineering
FP Complete

Michael Snoyman serves as Vice President of Engineering at FP Complete, and is the founder and lead developer of multiple Haskell open source projects, including Yesod, Conduit, Stack, and Stackage. Focused on creating developer-friendly, high-performance libraries that improve software quality, Michael specializes in using Haskell, Rust, and modern DevOps to help projects make it to market faster, with fewer bugs. He regularly speaks about programming best practices and contributes to publications like Architecture of Open Source Applications and the IEEE Spectrum.

Question for Speaker?
Please rate Applied Haskell Workshop

Booting into FP

Beginner Tutorial

This session is an whirlwind tour of the FP land and is primarily meant for developers wanting to embark on their functional programming journey. We will use Java to understand most of the concepts, however, where it falls short to explain certain concepts, we will use Scala or Groovy or Clojure or even Haskell to demonstrate it. Starting with the basics - introducing the concepts with examples, we will evolve our understanding to take the mystery out of the monads (hopefully!)

Target Audience

Developers interested in beginning their FP journey.

Outline
  • Why Functional Programming matters?
  • Functions everywhere!
    • Pure and Side-effecting functions
  • Immutability
  • Referential Transparency
  • What is a Lambda?
  • Modularization
    • Lazy Evaluation
    • Higher-Order Functions
  • Tackling Complexity using Function Composition
  • Currying
  • Sequencing Operations using Monads
    • Streams (Lazy Lists)
    • Dealing with absence of values
  • Overview of Upcoming Sessions
  • Q & A (last 5-10 mins)
Learning Outcome

Grok the concept so that they are able to look for scenarios where this can be applied in their day-to-day work.

Dhaval Dalal
Software Artisan
Calixir Consultants Pvt. Ltd.

I currently work at Calixir Consultants Pvt. Ltd, Mumbai.  Enjoy software design, music, soft-skills development and food. I like to experiment and learn experientially.  I also enjoy exploring languages (both computer and spoken) and try to find expression for the same thought in different languages.  

Question for Speaker?
Please rate Booting into FP

Coding LiveView

Intermediate Demonstration

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.

Target Audience

Developers interested in building rich clients

Bruce Tate
Founder
Groxio

Bruce Tate is a kayaker, climber, programmer and father of two from Chattanooga, Tennessee. A serial entrepreneur, he has helped start three companies, and most recently served as CTO for icanmakeitbetter. The author of more than a dozen books is active in the Elixir community as a speaker, author, editor and conference organizer. His love for teaching and computer languages led him to found Groxio in 2018.

As an author and speaker, he has written more than ten books including two JOLT award winners, most recently the book Seven Languages in Seven Weeks. He is the editor for the Seven in Seven line of books, including Seven Databases in Seven Weeks, with several other books under development.

When he is not coding, Bruce is an avid kayaker, climber, and mountain biker. When not coding, you can find him riding the bike trails by his home on Lake Travis or icing his most recent injury.

Question for Speaker?
Please rate Coding LiveView

Introduction to Functional Programming using Haskell

Beginner Workshop

We will be spending the day learning the fundamentals of Functional Programming (FP) using the Haskell programming language. The exercise material will be a condensed selection of the NICTA/course which is regularly held in Australia over three days.

This one day session is targeted to experienced industry programmers who are looking to break into Functional Programming and develop the rudimentary skills and techniques that enable continued independent study. A refresher on Haskell syntax will be provided, however, it is highly recommended to practice with the syntax and development tools prior to obtain the best outcome for the day.

You will be required to bring a suitable development machine (portable) for working through the exercises. You will also need to install Glasgow Haskell Compiler (http://www.haskell.org/ghc/) version 7.8 or higher on that machine prior to the day.

Target Audience

Experienced industry programmers with interest in FP

Outline
  • Optional
    • mapOptional
    • bindOptional
    • (??)
    • (<+>)
  • List
    • headOr
    • product
    • length
    • map
    • filter
    • (++)
    • flatMap
    • reverse
  • Functor
    • instance Functor List
    • instance Functor Optional
    • instance Functor ((->) t)
    • instance Functor void
  • Applicative
    • instance Applicative List
    • instance Applicative Optional
    • instance Applicative ((->) t)
    • lift2
    • sequence
  • FileIO

Learning Outcome

Participants should expect to achieve a thorough introductory understanding of the meaning and practical applications of FP.

Tony Morris
Sr. Software Engineer
Queensland FP Lab, Data61

Tony Morris is a software product developer who has deployed functional programming techniques in industry for over 10 years. Tony teaches at the tertiary level and for professional programmers with a view toward producing a viable commercial result. Tony is currently a Senior Software Engineer at NICTA where he is tasked with promoting and educating on functional programming for the benefit of all Australian software developers.

Tony takes a fastidious, principled approach to functional programming both when deployed in practice and when in a learning environment to ensure maximum yield from the effort. Tony believes that exploring principles and the following consequences provides a rewarding experience for all involved.

Question for Speaker?
Please rate Introduction to Functional Programming using Haskell

Coffee/Tea Break

Question for Speaker?
Please rate Coffee/Tea Break

My journey with Erlang at Redbus

Beginner Talk

Going from Java to Erlang is not hard if given proper support. This talk is about the roller coaster journey with Erlang to build a scalable, soft real-time transaction platform. If you are a Java developer struggling to understand and adapt to Erlang this talk is for you.

Target Audience

Developers wanting to move to Erlang

Outline
  • Some basics of Java & Erlang as language
  • Resistance to accepting Change
    • War: Mutability vs Immutability
    • Precaution is better than cure(JAVA) vs Let it Crash attitude
  • virtual machine as powerful as an operating system
    • memory model, GC
    • what is soft real-time? how the language archives it
  • How Erlang's soft Real-time capability helped scale our systems in terms of the growth of transactions.
  • How some of the production nightmares solved by Erlang
Learning Outcome

Confidence to adapt Erlang with a clear understanding of the language for practical soft-real time systems.

Sujatha Hemmady
Tech Lead
Redbus

Engineer with 6 +years of experience in product development.

Question for Speaker?
Please rate My journey with Erlang at Redbus

Coffee/Tea Break

Question for Speaker?
Please rate Coffee/Tea Break

Eclipse Collections, Java Streams & Vavr - What's in them for Functional Programming

Beginner Talk

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.

Target Audience

Java developers . Basic familiarity with streams API assumed.

Outline
  • A taste of Eclipse Collections and Vavr - 5 minutes
  • Mutability vs immutability aspects - 10 minutes
  • Eager vs lazy evaluation - 10 minutes
  • Error handling - 5 minutes
  • Inter-op with Java collections API - 5 minutes
  • Richness of API - 5 minutes
  • Q&A - 5 minutes
Learning Outcome
  • Understand the strengths (and weaknesses) of Eclipse Collections, Java Streams, and Vavr through examples.
  • Understand the trade offs with respect to laziness/eager, immutability, and richness of API so that you make better decision while selecting one for your next projects.
Naresha K .
Consultant
Independent

Naresha works as an Agile Coach at AgileFAQs. He has been developing enterprise software and coaching developers for more than 10 years. He is passionate about learning new technologies, and techniques and applying them to solve business problems. 

Naresha is the founder organiser of Bangalore Groovy Grails Meetup. He has been a speaker at several conferences including Selenium Conf, Functional Conf and Grails Conf India, GR8 Conf India, GIDS. He also writes regularly for 'Healthy Code' magazine.

Question for Speaker?
Please rate Eclipse Collections, Java Streams & Vavr - What's in them for Functional Programming

Building a MySQL Database Driver in Elixir

Intermediate Demonstration

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.

Target Audience

Anyone who is curious about Database driver and Network Programming on BEAM

Outline

We will look at the following things in particular:

  • Intro to Elixir Binary pattern matching and Network Programming on BEAM
  • The MySQL Client-Server Protocol
  • Design and build a prototype MySQL driver for elixir called `mysqlex`
Learning Outcome

After this talk, you will learn the following:

1. Parsing binary data using elixir binary pattern matching and build a simple parser.

2. How to build a socket application using `:gen_tcp` module of erlang.

3. Understanding the MySQL protocol packets such handshake packet, and the many text protocol packets such as `COM_QUERY` and `COM_PING`.

Mohd Maqbool Alam
Student
Guru Gobind Singh Indraprastha University

I'm Maqbool, a developer from Delhi. I enjoy learning about programming language theory, distributed systems, Cloud Native technologies, and opensource. I am working towards building an elixir community in Delhi.

Question for Speaker?
Please rate Building a MySQL Database Driver in Elixir

Deep Dive Into Pattern Matching And Destructuring

Beginner Demonstration

Pattern Matching and Destructuring are two simple, yet powerful features in functional programming languages. There are several ways we can leverage them to make cleaner code. It also encourages you to think data as a first-class citizen and provide the essential tooling.

In this session, we are going to learn what these techniques bring to the table by looking at some real-world use-cases in Kotlin & Clojure.

Target Audience

Developers

Outline
  • Overview of how to model data in functional programming
  • Discussion on the relationship between sub-type polymorphism and pattern matching
  • Overview of Expression Problem
  • Demonstration of different ways of using destructing
Learning Outcome

The participants will get an idea of how to use Pattern Matching and Destructuring and apply them in their day-to-day work.

Tamizhvendan S
Lead Consultant
Ajira

Tamizh is a Pragmatic, Passionate and Polyglot Programmer. He started his programming journey at the age of 12, and the passion has not left him since then.

He is a Full-Stack solution provider and has a wealth of experience in solving complex problems using different programming languages and technologies. F#, Clojure & Haskell are some of his favourites.

Tamizh is also a functional programming evangelist and authored two books "F# Applied & F# Applied II", both are a practical guide for web development in F# using Suave.

He works as a Lead Consultant in www.ajira.tech and blogs at https://www.demystifyfp.com and http://blog.tamizhvendan.in

Question for Speaker?
Please rate Deep Dive Into Pattern Matching And Destructuring

Lunch Break

Question for Speaker?
Please rate Lunch Break

Lunch

Question for Speaker?
Please rate Lunch

BEAM Architecture Handbook

Intermediate Talk

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.
Target Audience

Elixir and Erlang developers interested in knowing more about design patterns on the BEAM

Outline

I'll talk about architecting BEAM applications, starting from the perspective of a single instance of the VM (processes, supervision) and moving on to multiple VMs (nodes) interacting with each other.

Learning Outcome

I hope to give people tips and design patterns that they can apply to their Elixir/Erlang libraries and applications.

Andrea Leopardi
Core Team Member
Elixir Lang

Elixir core team member, developer advocate, software architect (Community.com)

Andrea is a human born in the ancient lands of central Italy. He loves functional programming, beautiful code, and learning stuff. He's a software architect, speaker, and member of the core team of the Elixir programming language. His weak spot is having red hair.

Question for Speaker?
Please rate BEAM Architecture Handbook

Make your program spicy - Currying and Partial Function Application (PFA)

Beginner Demonstration

In this session, we will look Currying and Partial Function Application (PFA) in Functional Programming. Languages like Clojure don't have currying, but PFA, where has Haskell currying and not PFA, whereas Scala has both, Groovy wants you to call methods like curry() and rcurry(). In OO paradigm, we use DI (dependency Injection) and we will see how this is automatically subsumed using Currying and PFA.

Target Audience

Developers interested in learning and applying this concept

Outline
  • Overview of the concept
  • A practical DI example
  • All live coding in different languages
  • Q & A (last 5-10 mins)
Learning Outcome

Understand the concept so that they are able to look for scenarios where this can be applied in their day-to-day work.

Dhaval Dalal
Software Artisan
Calixir Consultants Pvt. Ltd.

I currently work at Calixir Consultants Pvt. Ltd, Mumbai.  Enjoy software design, music, soft-skills development and food. I like to experiment and learn experientially.  I also enjoy exploring languages (both computer and spoken) and try to find expression for the same thought in different languages.  

Question for Speaker?
Please rate Make your program spicy - Currying and Partial Function Application (PFA)

Coffee/Tea Break

Question for Speaker?
Please rate Coffee/Tea Break

Do you OOP in Elixir?

Beginner Experience Report

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.

Target Audience

Programmers moving from OOP to FP languages

Outline
  • Outline of Elixir Lifecycle (5 mins)
  • Popularity of Elixir(1 min)
  • Adoption of Elixir(2 mins)
  • Common mistakes in adopting Elixir(6 mins)
  • Writing clean code in Elixir(3 mins)
  • Conclusion and Questions(3 mins)
Learning Outcome

Avoiding common mistakes while programming in Elixir.

Nikhil More
Sr. Engineer
Volansys

I am a backend developer and presently working on Elixir. 

Question for Speaker?
Please rate Do you OOP in Elixir?

Coffee/Tea Break

Question for Speaker?
Please rate Coffee/Tea Break

JVM Language Interoperability

Beginner Demonstration

Language interoperability is the capability of two different programming languages to natively interact as part of the same system. Interoperability is advantageous because different programming languages are optimized for specific tasks, and allowing them to communicate can create better systems.

Apart from the Java language, the most common or well-known JVM languages are:

  • Scala, a statically-typed object-oriented and functional programming language
  • Clojure, a modern, dynamic, and functional dialect of the Lisp programming language
  • Kotlin, a statically-typed language

In this session, we'll demonstrate how your program can interop with different JVM languages.

Target Audience

Java Programmers interested in leveraging Functional Features of other JVM languages

Outline

Slides at https://www.slideshare.net/RavindraJaju/jvm-interop-functional-conf-2019.

Code with README detailing how to get started can be found at https://github.com/jaju/fnconf-2019-jvm-interop

Learning Outcome
  • Setting up a JVM application with tooling that supports multiple JVM languages
  • Demonstrating with working examples interoperation between multiple languages
  • Languages used in the talk/demo
    • Clojure
    • Java
    • Kotlin
    • Scala
  • Using, in a subjective-opinion manner, different languages for their strengths in the examples
    • Clojure - concise ways to deal with data-processing (JSON-handling, CSV parsing, bulk-creation of datastructures), and demonstrating NREPL awesomeness
    • Kotlin - Safe, compiled HTML generation via DSL
    • Scala - Parser-combinator for dealing with user-input simple arithmetic expression to evaluate them to numbers

Tamizhvendan S
Lead Consultant
Ajira

Tamizh is a Pragmatic, Passionate and Polyglot Programmer. He started his programming journey at the age of 12, and the passion has not left him since then.

He is a Full-Stack solution provider and has a wealth of experience in solving complex problems using different programming languages and technologies. F#, Clojure & Haskell are some of his favourites.

Tamizh is also a functional programming evangelist and authored two books "F# Applied & F# Applied II", both are a practical guide for web development in F# using Suave.

He works as a Lead Consultant in www.ajira.tech and blogs at https://www.demystifyfp.com and http://blog.tamizhvendan.in


Ravindra Jaju
Chief Idea Seeker
Gyaanweb

I'm a technology fan looking for ways to increase developer efficiency. I've moved across various programming languages, frameworks and tools in this pursuit, over the last 20+ years.

Along the way, I've founded two start-ups as the CTO, and worked with various kinds of organizations and people.

My interests include working with text data, large-scale data-processing, using PLs on the JVM that encourage the functional-programming style, and mentoring younger people. And indeed, looking to learn more from everyone.

Question for Speaker?
Please rate JVM Language Interoperability

After the Crash

Intermediate Talk

'Let it crash' gets thrown around a lot in the Erlang community. An experienced
programmer (with understandably different experiences) on first encountering
this idea in Erlang is often found asking what we let crash? And what happens
after?

I will attempt to answer this question.

Erlang puts distributed systems programming ideas front and center. We'll also
talk about this in the context of letting processes crash and how that affects the
design of our software.


Target Audience

Programmers familiar with either erlang/elixir and OTP

Outline

- What should happen after the crash?
- What can crash and what shouldn't?
- How does this affect software design in Erlang


At each step, we will make comparisons to other programming languages &
examine these ideas in action in popular Erlang codebases

Learning Outcome

Erlang/Elixir developers will come out with more reasoned process design (for their beam process) and this in turn makes their system more robust and maintainable.

Ravi Chandra Padmala
Partner
nilenso
Question for Speaker?
Please rate After the Crash

KPI driven development : Gradual journey from imperative to functional development in JAVA

Beginner Talk

Even though there was a delay; but JAVA has been catching up quite nicely when it comes to FP. With frequent releases and feature inclusions at a faster pace, the FP landscape in JAVA is becoming better and better every day. A lot of cutting edge projects(inspired by other languages like clojure, scala, oCaml, haskell, F# etc..) with their high-end/superior APIs complementing the language. The best part is these are just not syntactic sugars; the underlying impact of functional programming(from the language as well as the libraries) when analyzed deeply is extremely enriching and profound. The KPIs which can directly get a face-lift is a lot

1. Reduced dev/unit-testing effort

2. Less boilerplate code

3. Less mutation and higher thread safety

4. High perf persistent data-structures

5. Proven performance improvement, reduced allocation and higher throughput

Developers who have been practicing java/jvm languages for several years will find this really appealing and intriguing.

Target Audience

Java developers, FP practitoners

Outline

The presentation contains the following modules

  • FP knowhow in java with quick/crispy examples
    • syntax of lambda and closures
    • Methods to convert top-down/oo code into functional java code
    • Pure functions and reduced mutation
    • OO design patterns to functional design patterns
  • Popular Functional libraries in the ecosystem (examples, usage pattern, comparative study)
    • Vavr, cyclops
    • functionaljava, fugue-guava
    • Steamex, poetix-radioactive
    • resilience4j, failsafe
    • others
  • Functional java and its impact on performance
    • Byte code analysis
    • Impact on GC
    • latency, and throughput
  • Testing methodologies and comparison
    • Effective testing
    • Java vs other jvm languages Clojure, scala, kotlin etc.
Learning Outcome
  • OO to FP mindset
  • Learn and practice the FP advancements in java
  • Improve KPI on the enterprise java dev cycle
  • Get a fair idea where Java stands against other functional languages
  • Applying functional design patterns
Anirban Bhattacharjee
architect
Walmart Labs

Generalist developer/designer dabbling into a little bit of everything... ui/ux, app dev, db/app tuning, sre, infra, ci/cd, scripting, distributed systems. Got acquainted with functional programming around mid-2010 (after several early years of exposure to structured/imperative programming). Ever since then learning gradually the tricks of FP and practicing in bits and pieces.

Question for Speaker?
Please rate KPI driven development : Gradual journey from imperative to functional development in JAVA

Q & A Panel Discussion with Code Beam Lite India Speakers

Beginner Talk

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

Target Audience

All

Outline

Q & A sessions in a fish-bowl style panel.

Naresh Jain
Founder
Xnsio

Developer...Consultant...Conference Producer...Startup Founder…struggling to stay up-to-date with technology innovation. Null Process Evangelist.

Naresh Jain is an internationally recognized Technology & Product Development Expert. Over the last decade, he has helped streamline the product development practices at many Fortune 500 companies like Google, Amazon, JP Morgan, HP, Siemens Medical, GE Energy, Schlumberger, Ford, EMC, CA Technologies, to name a few clients. These days, he is more focused on engineering excellence and product innovation. In a nutshell, hire him as a consultant/mentor, if your entire organization wants to move beyond the Agile and Lean mindset. Learn more about his expert services.

Naresh Jain's Startup Icons

Naresh is leading a consulting business called XNSIO, which helps organizations build the essential product, technology & people capabilities required to transform their business for the digital world. He is also responsible for building ConfEngine.com - one-stop conference/event management platform.

Check out our awesome products!

Agile Software Community of India

In 2004, Naresh started the Agile movement in India by creating the Agile Software community of India, a registered non-profit society to evangelize Agile, Lean and other Leading-Edge Software Development methods in India. He is responsible for creating and organizing 100+ international conferences including the Functional Conf, Open Data Science Conference, Simple Design And Testing Conference (SDTConf), Agile Coach Camp, Selenium Conf India, Appium Conf, jQuery and Open Web Conference and Eclipse Summit India. He started many Agile User Groups including TechJam, Agile Philly User Group, and groups in India.

In recognition of his accomplishments, in 2007 the Agile Alliance awarded Naresh with the Gordon Pask Award for contributions to the Agile Community.

Learn more about Naresh at https://nareshjain.com


Andrea Leopardi
Core Team Member
Elixir Lang

Elixir core team member, developer advocate, software architect (Community.com)

Andrea is a human born in the ancient lands of central Italy. He loves functional programming, beautiful code, and learning stuff. He's a software architect, speaker, and member of the core team of the Elixir programming language. His weak spot is having red hair.


Bruce Tate
Founder
Groxio

Bruce Tate is a kayaker, climber, programmer and father of two from Chattanooga, Tennessee. A serial entrepreneur, he has helped start three companies, and most recently served as CTO for icanmakeitbetter. The author of more than a dozen books is active in the Elixir community as a speaker, author, editor and conference organizer. His love for teaching and computer languages led him to found Groxio in 2018.

As an author and speaker, he has written more than ten books including two JOLT award winners, most recently the book Seven Languages in Seven Weeks. He is the editor for the Seven in Seven line of books, including Seven Databases in Seven Weeks, with several other books under development.

When he is not coding, Bruce is an avid kayaker, climber, and mountain biker. When not coding, you can find him riding the bike trails by his home on Lake Travis or icing his most recent injury.


Mohd Maqbool Alam
Student
Guru Gobind Singh Indraprastha University

I'm Maqbool, a developer from Delhi. I enjoy learning about programming language theory, distributed systems, Cloud Native technologies, and opensource. I am working towards building an elixir community in Delhi.


Nikhil More
Sr. Engineer
Volansys

I am a backend developer and presently working on Elixir. 


Ravi Chandra Padmala
Partner
nilenso

Sujatha Hemmady
Tech Lead
Redbus

Engineer with 6 +years of experience in product development.

Question for Speaker?
Please rate Q & A Panel Discussion with Code Beam Lite India Speakers

Asynchronous Functional Programming on the JVM

Beginner Demonstration

We'll take a close look at core.async - the CSP library for Clojure(script).

  • The motivation
  • Problems suitable for CSPs to handle
  • Syntax
  • Patterns

Given the minimalist nature of Lisps, the syntax is underwhelming, but applications can be exciting in the manner they make complex problems within reach.

Target Audience

Developers familiar with multi-threading, concurrent programming, and are looking for a different and extremely effective ways to improve their art in this area.

Outline
  • Overview
  • Syntax
  • Self-contained problems with solutions - live coded.
  • Q & A (last 5-10 mins)
Learning Outcome

Understand where and how to use CSP. And specifically know how to use core.async in your everyday work.

Ravindra Jaju
Chief Idea Seeker
Gyaanweb

I'm a technology fan looking for ways to increase developer efficiency. I've moved across various programming languages, frameworks and tools in this pursuit, over the last 20+ years.

Along the way, I've founded two start-ups as the CTO, and worked with various kinds of organizations and people.

My interests include working with text data, large-scale data-processing, using PLs on the JVM that encourage the functional-programming style, and mentoring younger people. And indeed, looking to learn more from everyone.

Question for Speaker?
Please rate Asynchronous Functional Programming on the JVM

Logic Programming à la Carte

Intermediate Keynote

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.

Target Audience

Data Engineers, Data Scientists, Architects, Product Owners

Edward Kmett
Chair of the Haskell Core Libraries Committee, Research Engineer
Machine Intelligence Research Institute

Edward spent most of his adult life trying to build reusable code in imperative languages before realizing he was building castles in sand. He converted to Haskell in 2006 while searching for better building materials. He now chairs the Haskell core libraries committee, collaborates with hundreds of other developers on over 250 projects on github, works on ways to try to better scale functional programming, logic programming and formal methods at the Machine Intelligence Research Institute, and is obsessed with finding better tools so that seven years from now he won’t be stuck solving the same problems with the same tools he was stuck using seven years ago.

Question for Speaker?
Please rate Logic Programming à la Carte

Your first Haskell web app with WAI and Warp

Beginner Tutorial

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.

Target Audience

People interested in learning how to do applied web development in a functional language like Haskell.

Outline

[Slides available online](https://www.snoyman.com/reveal/first-app-wai-warp)

  • Describe WAI's goals
  • Explain the core data types
  • Discuss the three core concepts: application, handler, and middleware
  • Our first web app
  • Using Request information
  • Different Response types
  • Applying some middlewares
  • How to deploy
Learning Outcome

Familiarity with the core of the WAI ecosystem, with the ability to either continue using WAI for building web apps or, as recommended, jump into a web framework.

Michael Snoyman
VP, Engineering
FP Complete

Michael Snoyman serves as Vice President of Engineering at FP Complete, and is the founder and lead developer of multiple Haskell open source projects, including Yesod, Conduit, Stack, and Stackage. Focused on creating developer-friendly, high-performance libraries that improve software quality, Michael specializes in using Haskell, Rust, and modern DevOps to help projects make it to market faster, with fewer bugs. He regularly speaks about programming best practices and contributes to publications like Architecture of Open Source Applications and the IEEE Spectrum.

Question for Speaker?
Please rate Your first Haskell web app with WAI and Warp

Full-stack, functional web development on WebAssembly with F# and Bolero

Beginner Talk

Bolero (http://fsbolero.io) is a functional, reactive web development library for F# developers targeting WebAssembly via Blazor. Next to building on a familiar Model-View-Update (MVU) architecture, Bolero also integrates a number of power features from WebSharper (http://websharper.com) to enable ultra-efficient, full-stack F# web applications. By plugging into the ever-growing Blazor ecosystem, you will enjoy developing most of your code base without JavaScript, and discover a new and promising alternative to building performant web applications. Come to this talk and learn everything you need to know about developing Bolero applications, and jumpstart your productivity with skills that will leave any Blazor developer impressed.

Target Audience

.NET (C#, F#) developers, FP developers, Level 100+

Outline
  • Quick look at the landscape - Blazor and Bolero
  • Getting started with Bolero - your first Bolero project
  • The Model-View-Update (MVU) pattern
  • Working with server and client side code
  • Next steps (HTML templating, integrating Blazor components)
  • Advanced topics (JavaScript interop, and more)

Learning Outcome

Attendees will be able to develop basic F# full-stack web applications that run on WebAssembly via Blazor, understand how to structure their applications, how to use templating to display UI controls and full pages, how to retrieve and work with data from the user, and how to work with existing components.

Adam Granicz
CEO
IntelliFactory

Adam Granicz (@granicz) is a 9x F#/.NET MVP and the coauthor of five F# books, key F# community member and evangelist, a regular speaker at developer conferences and workshops, and the CEO of IntelliFactory, the F# company specializing in trainings, consulting, and developing functional, reactive web and cloud applications.

Question for Speaker?
Please rate Full-stack, functional web development on WebAssembly with F# and Bolero

Building an E-Commerce Marketplace Middleware in Clojure

Beginner Case Study

Have you ever wondered how we can build a real-world, production-ready, end-to-end application using the functional programming principles? Immutability, Pure Functions and all other functional programming things sound good on paper but How can we build something useful by applying it?

At Ajira, We recently built an e-commerce marketplace middleware in Clojure for a leading retail chain to sell their products on multiple e-commerce sites seamlessly. In this case study, we are going to build a minimal version of this project using which I will be sharing how we implemented it.

Target Audience

Developers and Architects

Outline
  • Problem Statement Overview
  • Reading Application Configuration From Environment Variables
  • Managing Application Component's life cycle.
  • Database Connection Pooling & Migration
  • Logging Infrastructure
  • Handling events from the Message Queue
  • Integrating with external APIs
  • Information Processing
  • Specifying Data Schema
  • Lessons Learnt
Learning Outcome

The attendees will get an idea of how to develop an end-to-end application in Clojure using functional programming techniques.

Tamizhvendan S
Lead Consultant
Ajira

Tamizh is a Pragmatic, Passionate and Polyglot Programmer. He started his programming journey at the age of 12, and the passion has not left him since then.

He is a Full-Stack solution provider and has a wealth of experience in solving complex problems using different programming languages and technologies. F#, Clojure & Haskell are some of his favourites.

Tamizh is also a functional programming evangelist and authored two books "F# Applied & F# Applied II", both are a practical guide for web development in F# using Suave.

He works as a Lead Consultant in www.ajira.tech and blogs at https://www.demystifyfp.com and http://blog.tamizhvendan.in

Question for Speaker?
Please rate Building an E-Commerce Marketplace Middleware in Clojure

An Intuition for List Folds

Beginner Talk

In this talk, we go back to first principles, defining and examining the definition for a cons list, then take a look at the ubiquitous right and left fold functions on a list.

The primary focus of this talk is to develop an intuition for how these functions work so that we can best decide when to apply them. Multiple programming languages will be used to help emphasise the independence of the gained intuition. This talk will generally be interactive with the audience as we solve problems and build confidence in our new knowledge.

Knowing how to apply the various list fold functions is a common question by the student of FP. This talk aims to provide a solid, reliable answer to this question. No prior understanding of list folds is necessary.

Target Audience

Programmers who know about left and right list folds, but don't have a good intuition for them

Outline

We will explicitly discuss both left and right folds and form an accurate, intuitive basis for applying them.

Learning Outcome

Gaining confidence in using left and right list folds for solving programming problems.

Tony Morris
Sr. Software Engineer
Queensland FP Lab, Data61

Tony Morris is a software product developer who has deployed functional programming techniques in industry for over 10 years. Tony teaches at the tertiary level and for professional programmers with a view toward producing a viable commercial result. Tony is currently a Senior Software Engineer at NICTA where he is tasked with promoting and educating on functional programming for the benefit of all Australian software developers.

Tony takes a fastidious, principled approach to functional programming both when deployed in practice and when in a learning environment to ensure maximum yield from the effort. Tony believes that exploring principles and the following consequences provides a rewarding experience for all involved.

Question for Speaker?
Please rate An Intuition for List Folds

From C# monolith to functional actors with Orleans and F#

Intermediate Talk

This is an experience talk from my work with NRK, the

Norwegian Broadcasting Company, Norway's public broadcaster.

Over the last 3-4 years we've taken the TV and radio streaming sites from a monolith to multiple

domain based services. We'll look at how we've transitioned the from a pure object oriented development team to a function friendly organzation, how gorwing the organization forced us to work with Conways law, as well as a deep dive into the bounded context of personalization.

Keeping track of user progress and favorite shows is the responsibility of Personalization domain, with high performance requirements and surprisingly

complex business rules. With new business rules and changing architecture, Personalization was in dire need of work. Combining FSharp and its typesystem and immutability with Orleans, an open source Virtual Actor platform for distributed high-scale computing applications, provided us with functional programming with OO principles in a fast and scalable platform. I'll show why we chose this path, the benefits we gained going from C# to F# and some of the lessons learned building on an actor model.

Target Audience

If you're interested in a journey from C#/OO to F#/Functional with DDD

Outline

An introduction to NRK, where we were and the problems we had.

How a growing organization required us to change the way we worked. Conways law, DDD and working togehter.

A deeper look at personalization and why it is difficult.

How we ended up with FSharp and Orleans.

Functional takeaways and actor model lessons learned.

Learning Outcome

Takeaways from a growing organization on how and why we went from a C# monolith to domain specific services. And why and how we ended up with functional programming and actor modelling for one of the domains.

Harald Schult Ulriksen
Principal software engineer
Aurum AS

I'm a principal software engineer and partner at Aurum AS. A nice development consultancy based in Oslo with senior staff only. We take roles such as tech lead and architect in customer projects and thrive when we can bridge the business and product owner with software development. We work with DevOps and development processes, software architecture, front and server side development on both hosted and cloud platforms. 

Question for Speaker?
Please rate From C# monolith to functional actors with Orleans and F#

Functional Data Structures for Time Series Summary

Intermediate Case Study

Overview

IOT is ubiquitous now a days. With time series data pouring in from all possible sources, there is an increasing need to process the data at near real time. However, the transmission, storage and compute cost associated with this data is ever increasing.

Functional Data Structure for Time Series

In this talk, we will look at functional implementation of discrete wavelet transforms implemented using Haskell. We will use Haar wavelets for the the demo. The high and low pass filter definition of a wavelet allows a very simple functional implementation of Haar wavelet transform.

Wavelet Transform

We will look at simple recursive definition for forward and reverse wavelet transforms. The wavelet transform is very simple to implement in O(N) time complexity using recursive definition, and higher order functions.

Wavelet as a Container

Though, these transform functions are good for bulk transform i.e. to convert incoming data to/from wavelet space at once, they are not good for point queries. We will look at how we can partition a wavelet vector in dyadic ranges, and dynamically construct orthonormal basis of the wavelet by directly querying only log N coefficients.

Wavelet Approximation

The wavelet container that we constructed can be sparse. i.e. it is possible to prune the coefficients that are not contributing to approximation, and still use the wavelet container.

Wavelet Sketching

Sketches are random algorithms to estimate the result with a given accuracy with high probability.

We can use sum-of-square energy function property to prune the coefficients. Finally we use sublinear AMS sketching algorithm to predict the energy, and prune the coefficients efficiently in log N time rather than O(N) time. This allows us to quickly prune the wavelet container by getting rid of large number of coefficients. This allows very compact representation of the time series data that allows point queries.

We show Haskell implementation

  • Sketch as a class, and linear properties of Sketch
  • Implementation of AMS using hash functions, and probability distributions
  • Using AMS with hash bucketing to prune wavelet coefficents

Use Case

We will look at a historical stock data, and use wavelet transform and sketching to reduce the data size.

Current Status

Currently being studied at my organization, such functional application is found to be useful in representing data for quick analytics.

Target Audience

People interested in applying FP in day-to-day life to solve interesting problems.

Outline
  • Necessity of approximating time series
  • Representing discrete wavelet transformation for multivariate signals in functional language (Haskell)
  • Applying wavelet transforms for Haskell Lists
  • Creating functional sketches
  • Using sketches and wavelet coefficients.
  • Running query on container.

-

Learning Outcome
  • Stream algorithms
  • Working with random algorithms
  • Signal processing in functional language
  • Reducing signal size
Yogesh Sajanikar
Software Engineer
Traderwave Pte Ltd, Geometric Ltd

Work Experience

Devops + Backend, Traderwave Pte, Singapore/India

  • Haskell based microservices
  • IBM Bluemix cloud infrastructure

 

Practice Head, Geometric Ltd, Pune India

  • Cloud/Distributed Computing
  • Big Data/Analysis
  • Functional Programming

 

Previous

Devops, Modelling Infrastructure Group, Standard Chartered, Singapore

  • Devops for Quantitiative Finance Group

Education

2016, Stanford University (Stanford Centre for Professional Development)

  • Functional Systems in Haskell
  • hspark : Spark RDD in Haskell

2012, Utretcht University (Summer School - Functional Programming)

  • Applied functional programming in Haskell

1996, IIT Bombay (M.Tech. - Production Engg.)

  • Process Planning + NC Code generation for prismatic parts

 

Question for Speaker?
Please rate Functional Data Structures for Time Series Summary

Dr. StrangePipes or: How I learned to stop worrying && "function" in Shell

Intermediate Workshop

What scares the Shell out of people?

Artefacts of the long and idiosyncratic history of Unix.

We have so many powerful, stable, widely-available Unix tools and standards, but also plenty of inconsistencies, variants, and arcane caveats; enough to help us... surprise... ourselves in creative new ways. See that cliff you're currently falling off? Yeah, someone went down that road when you were still eating chalk in kindergarten. (Or perhaps you fell off it once before, when I was eating chalk in kindergarten, but it was so long ago that you forgot you've been there done that :-))

Worse, there's no adult supervision, only user manuals. Within Shell's neon-lit environs, one must learn to tread with care, creativity, and cool calculation.

One must learn to accept the silent echo as reward for success.

Why go to Shell at all?

Several of us already get by just fine with a few memorised spells from Shell. That's not a bad way to live, but we miss out on tremendous everyday value that we can unlock with the Unix way.

For there exists a vast no-man's land between memorised tricks and large scale "designed" solutions; wherein no single software tool can really solve all the problems we encounter.

Yet, any modern *nix PC has all one needs to adequately and speedily tailor-make solutions for almost any problem we may encounter in the underserved no man's land.

Solutions that we can use effectively until we truly hit the kind of scale problems or domain complexity that merit use of specialised tools.

Unix nature is deeply Functional

The Unix tools philosophy naturally leads to functional architectures that can scale almost effortlessly. And functional programmers could do worse than learn to exploit such power.

I'll just leave you with Douglas McIlroy's answer to "Read a file of text, determine the n most frequently used words, and print out a sorted list of those words along with their frequencies.", as seen in More Shell, Less Egg:

tr -cs A-Za-z '\n' |
tr A-Z a-z |
sort |
uniq -c |
sort -rn |
sed ${1}q

A purely functional, automatically buffered data processing pipeline, built with standard reusable parts, written in 1986, directly usable on today's computers.

Imaginative Functional Programmers (aren't we all?!) will find striking parallels between the facilities, concepts, and design principles available in their $Langs, and their *nix environments.

No surprise, because in the dreamy mists of time, the wise hackers of Unix lore, and SmallTalk lore, and APL lore, and Lisp lore, and Forth lore etc... were all different, but they were all together, too.

Target Audience

Programmers seeking to grok Unix nature

Outline

We will not aim to write highly "portable"/multi-platform shell programs. That's really hard to get right, and requires time investment that will simply not pay off in the generally homogenous environments that we inhabit.

We will focus on the sweet spot occupied by everyday problems we encounter in the bounded contexts our everyday work life. It is here that we can powerfully leverage the Unix way.

We will see how to apply FP techniques to build our own "swiss army toolkits" of custom functions and utilities...

  • that work seamlessly with the standard Unix model, and so
  • are useful not just within scripts, but also interactively at the command line
  • can interoperate with any other tool that understands the Unix way
  • allowing us to get surprisingly little code to do surprisingly powerful things

We will find ways to exploit built-in host semantics and guarantees, to avoid manual state management, locking, and/or mutable book-keeping (e.g. streaming-data-oriented semantics/APIs, pipes, subshells, process substitution, good use of standard I/O/Error etc.).

We will use a standard Shell, with standard built-in *nix tools, and perhaps a few widely ported installable packages. Specifically, the system I will use to demo/teach includes:

  • Ubuntu 18+ (and all the pre-packaged standard tools)
  • Bash 4.4+
  • Gnu AWK (i.e. gawk, which may not be standard on your linux)
  • jq (for JSON processing)
  • emacs, vim, tmux, and git

Things I show should port over fairly easily, if not directly, to other *nix/shell combinations.

Learning Outcome

Sooner or later, you will find yourself left with with no choice but to go to Shell (or a Shell user), searching for truth in The Machine.

So why not already learn "fn" ways to...

  • enhance one's own personal workflow (type less, think and design more)
  • help one's small team/group translate repetitive, manual, error-prone tasks into shared workflows, standards, and conventions
  • tame oncall log analysis problems (and post-incident analysis problems too),
  • solve little-data and middle-data problems (crunch a few Mega/Gigabytes to a few Terabytes of data),
  • stitch together build/deploy/analytics/whatever pipelines and keep 'em running

And who knows? Perhaps you will far surpass this workshop, and manage to quietly replace yourself with tiny shell scripts that keep you earning your pay while you colonise everything in Kerbal Space.

Aditya Athalye
Programmer?
((λx.(x x) (λx.(x x))

tl;dr

(((fn [x] (x x)) (fn [x] x)) 'x)

Longer version:

(((fn [x] (x x)) (fn [x] x))
"Clojure-brained APL and Math n00b trying to remain \"functional\"
while c
omposing software-defined, virtually networked systems
further composed of zipped files
running within application VMs
running within OS containers
running within \"proper\" virtual machines
running within actual hardware
running within unknown data centers
running within other continents
running because of absolute strangers,
all the time marveling how anything even works at all.")

Question for Speaker?
Please rate Dr. StrangePipes or: How I learned to stop worrying && "function" in Shell

GADTs in OCaml

Intermediate Tutorial

OCaml is a multi-paradigm programming language with a pragmatic mix of functional and imperative programming features. OCaml, which has been around since 1996, has grown to be a battle tested language, widely deployed and used in production systems. In this talk, we will look at the support for Generalized Algebraic Data Types (GADTs), a powerful generalization of the more mundane Algebraic Data Types (ADTs). We will start with an example of building an interpreter for a small language and add type safety through GADTs. We will then look at a few powerful type-safe design patterns that GADTs enable.

Target Audience

functional programmers prepared to imagine extending the functional paradigm

Outline
  1. OCaml syntax primer
  2. Let bindings, function definitions, recursion and strict evaluation
  3. Abstract Data Types (ADT's)
  4. Intuitive explanation of Generalized Abstract Data Types (GADT's)
  5. Examples of using GADT's to encode type safe abstractions
Learning Outcome

This tutorial aims to cover the support for using a certain feature of the OCaml programming language (GADTs), for encoding type-safe abstractions. By the end of this tutorial, the participants would have

  1. A basic understanding of GADT's, as extensions of the Abstract Data Types (ADT's)
  2. Knowledge of design patterns that can be expressed using GADT's
  3. Exposure to applying GADTs to real world problems.
Anmol Sahoo
Research Associate
IIT Madras

Anmol Sahoo graduated with a Bachelor of Engineering degree in Mechanical Engineering from India but his love for computer architecture brought him to the Shakti project. He is currently working on the software tooling around Shakti and he loves long-distance running.

Question for Speaker?
Please rate GADTs in OCaml

Supercharged Web Application development with Purescript

Beginner Workshop

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.

Target Audience

People new to strongly typed functional programming

Outline
  1. Prerequisite - Participants can read up on Purescript and initialise a simple project via the template at https://github.com/ajnsit/purescript-react-starter.
  2. 5-10 minutes - Talk about the advantages of Purescript. Briefly outline the ecosystem. Discuss the structure of the Purescript application, best practices, and tools used in the template.
  3. 15 minutes - Live-code and run a hello-world style web application with Purescript and React bindings. Demonstrate making changes, IDE support etc.
  4. 20 minutes - Continue live-code. Add a third party UI component (https://github.com/frontend-collective/react-sortable-tree) and import it via FFI. Write a simple application that demonstrates wrapping and controlling the state of that component from Purescript.
  5. Take follow up questions if there is time.
Learning Outcome

Attendees will learn how to build a simple purely functional web application with Purescript. They will also gain an understanding of Purescript and its ecosystem, and be able to learn more on their own.

Anupam Jain
Associate Director, Analytics
S&P Global

I am a Haskell developer with over a decade of FP experience.

I currently work as Associate Director of Analytics at Standard and Poor's where we build cutting edge financial solutions using Functional Programming.

Previously I founded GeoHangout.com which was built on a Functional Stack.

I love Free and Open Source Software. You can see some of my code at - https://github.com/ajnsit.

In my spare time, I organise regular FP meetups in Delhi NCR and surrounding areas, as the founder of The Delhi NCR Haskell And Functional Programming Languages Group. We have a Telegram group - https://t.me/fpncr.

I often talk about web development and functional programming. Some of the slides are available - https://speakerdeck.com/ajnsit. Some videos are available at https://www.youtube.com/channel/UC7TUykDPHPs0rSiPodAQFsg/playlists.

Question for Speaker?
Please rate Supercharged Web Application development with Purescript

Learnings from using haskell in production

Intermediate Experience Report

Over a period of 7 years, we have applied Haskell across Web apps, compilers, parsers for our customers across various industries. This is our report on how some of the unique features of Haskell have not only helped us create stable production environments but also break barriers. On the other hand, there is a high cost of on-boarding new developers and few other pain points. So, is Haskell worth the investment?

Target Audience

Haskell practitioners who are planning to use or using haskell in production.

Outline

1. Introduction - timeline of our experiences with Haskell. (3 mins)


1.1 Who we are and what we do with Haskell?
1.2 Quick introduction on the three most biggest challenges we undertook.
2. Breaking barriers with haskell (13 mins)

TypeQL - A query language for the internet.
3. Takeaways (4 Mins)

3.1 Lets you solve bigger problems.
3.2 Types lets you automate.
3.3 Abstractions are unicorns.
3.4 And of course Haskell can be used in production.

Learning Outcome

Gain insights into the pros and cons of using haskell in production in a wide variety of settings.

Sreenidhi Nair
Senior Haskell Developer
ByteAlly

I'm a developer with 6 years of experience in Haskell. Co creator of typeql - a query language on top of haskell and FMap - a compiler targetting iOS, Android and Web. I love to tinker with fp languages and learn new things!

Question for Speaker?
Please rate Learnings from using haskell in production

Streamly: Declarative Concurrency and Dataflow Programming in Haskell

Intermediate Talk

Overview: Streamly is a Haskell library for writing programs in a high level, declarative data flow programming paradigm. It provides a simple API, very close to standard Haskell lists. A program is expressed as a composition of data processing pipes, generally known as streams. Streams can be generated, merged, chained, mapped, zipped, and consumed concurrently – enabling a high level, declarative yet concurrent composition of programs. Programs can be concurrent or non-concurrent without any significant change. Concurrency is auto scaled based on consumption rate. Programmers do not have to be aware of threads, locking or synchronization to write scalable concurrent programs. Streamly provides C like performance, orders of magnitude better compared to existing streaming libraries.

Motivation: Haskell has a beautiful abstraction capability. Haskell lists, several streaming and concurrency libraries are some examples of good programming abstractions. The problem is that concurrency is not handled elegantly and declaratively by these libraries. Moreover, the lack of good performance gives rise to special purpose performance centric libraries like text and bytestring creating more confusion. Streamly unifies, lists, streaming, concurrency, logic programming and reactive programming with unparalleled performance. We can finally have a unified string handling.

Audience: Streamly is designed to express the full spectrum of programs. Do not think that if you are writing a small and simple program it may not be for you. It expresses a small program with the same efficiency, simplicity and elegance as a large scale concurrent application. It unifies many different aspects of special purpose libraries into a single yet simple framework. It is especially suitable for high performance and scalable backend data processing systems. If you use or plan to use any real time streaming or data flow programming frameworks including Apache Flink, Apache Spark or asynchronous/reactive programming frameworks like ReactiveX/RxJs then you may be interested in Streamly.

Target Audience

Engineers and architects interested in designing scalable, concurrent, high performance and correct by construction systems with excellent composability and little maintenance overhead.

Outline

Functionality Overview: Streamly covers the functionality provided by Haskell lists as well as the functionality provided by streaming libraries like streaming, pipes, and conduit with a simpler API and better performance. Streamly provides advanced stream composition including various ways of appending, merging, zipping, splitting, grouping, distributing, partitioning and unzipping of streams with true streaming and with concurrency. Streamly subsumes the functionality of list transformer libraries like pipes or list-t and also the logic programming library logict. The grouping, splitting and windowing combinators in streamly can be compared to the window operators in Apache Flink. However, compared to Flink streamly has a pure functional, succinct and expressive API.

The concurrency capabilities of streamly are more advanced and powerful compared to the basic concurrency functionality provided by the async package. Streamly is a first class reactive programming library. If you are familiar with Reactive Extensions you will find that it is very similar. For most RxJs combinators you can find or write corresponding ones in streamly. Streamly can be used as an alternative to Yampa or Reflex as well.

Streamly focuses on practical engineering with high performance. From well written streamly programs one can expect performance competitive to C. High performance streaming eliminates the need for string and text libraries like bytestring, text and their lazy and strict flavors.

Structure of the Talk: In this talk we will introduce Streamly, its streaming API and how concurrency fits in the streaming framework. We will go through some examples and see how Streamly can express complex real world programs in a simple and concise manner. Broadly, the following topics will be touched:

  • Motivation for Streamly
  • Streams
  • Folds
  • Arrays
  • Concurrency
  • Managing State
  • Errors and Exceptions
  • Strings
  • File and Netwotk IO
  • Performance
Learning Outcome

You will learn about data flow/streaming programming paradigm and how you can express programs in a declarative manner. You will learn how concurrency can be expressed in a declarative manner and how it fits with data flow programming paradigm. You will understand where and how you can use Streamly to solve general programming problems. After this talk, and a bit of follow up reading, you should be able to write concurrent file/IO, networking (e.g. a web server) or reactive applications using Streamly (e.g. games).

Harendra Kumar
Founder
Composewell Technologies

Harendra has been architecting scalable software systems for past two decades, in several domains, ranging from mobile networks, embedded systems, web servers and file systems. He has also worked on refactoring large scale software systems. He is passionate about creating better software development tools, so that a developer focuses on the design and architecture of the product rather than routine and painful labor oriented tasks. He wants to make the job of a software developer more joyful.

After working on C for decades he decided to look for better language options and chose the Haskell programming language after a lot of research. He has been working on Haskell for several years now and contributed several packages. His current interest is Streamly, a concurrent data flow programming framework in Haskell which unifies several fundamental abstractions and aims to make programming a joy. Streamly makes concurrent programs composable, concurrent programs are written as if you are writing non-concurrent ones. He founded Composewell Technologies to develop better tools for more modern software engineering. You can follow him on twitter or github or find more about him on linked-in.

Question for Speaker?
Please rate Streamly: Declarative Concurrency and Dataflow Programming in Haskell

Getting property-based testing to work after struggling for 3 years

Intermediate Talk

I got excited about property-based testing after hearing John Hughes talk at Functional Conf 2016. I tried it that year with QuickCheck, but failed miserably (it almost derailed the entire project delivery). I cribbed about it in my talk at Functional Conf 2017. In 2018, Srihari's talk got me excited again. This time, I tried with Hedgehog, and got it to work!

This talk is about this journey and its learnings. We'll talk about how Hedgehog was used to test [1]:

  • A Postgres backed task/job queue
  • A small Wai/Servant based webapp

And no, we will not talk about the most common (and completely useless) example of reversing a list!

[1] Both of these are part of an open-sourced task/job queue library.

Target Audience

Intermediate practitioners

Outline
  • Understanding property-based testing of pure code through real-world examples
  • Problems faced while testing stateful code (most commonly where state is stored in a DB)
  • Approaches used by various libraries for testing stateful code
  • Walk-through of how property tests were used to ensure correctness of a Postgres-backed job/task queue
  • Walk-through of how property tests were used to test a small DB-backed webapp
Learning Outcome

How to use property-testing effectively in typical web applications

Saurabh Nanda
Founder
Vacation Labs

Founder & CEO, Vacation Labs

Our travel-commerce platform is built using ~150,000 lines of Rails and ~120,000 lines of Javascript. Recently, we've spent a year evaluating   typed-FP languages, and have successfully added ~46,000 lines of Haskell into our tech stack.

I'm always on the lookout for techniques to write correct programs without compromising on speed of development. After all, what good is a correct program, if it's late to the market and no one runs it in the first place!

I've been coding since my school days (BASIC, Pascal, Foxpro, dBase, C, Visual Basic, C++), all throughout engineering (Linux admin, PHP, MySQL), and then at Cleartrip where we wrote the first version of the platform in Common-Lisp & Rails. At Vacation Labs, we're using Rails, Javascript, Typescript, Angular, Postgres, Redis, and Haskell.

 

Question for Speaker?
Please rate Getting property-based testing to work after struggling for 3 years

Lambdas: The Functional Programming Companion of Modern C++

Intermediate Talk

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

Target Audience

Programmers acquainted with basics of Object Oriented Programming in C++ or Functional Programmers of any other language

Outline

Here is the proposed outline of my session and expected amount of time it will take

  • Introduction of functional programming and C++11 (Changes, History & Future) - ~ 7 - 10 Mins
  • Lambdas and Closures in C++ ~ 5 Mins
  • Immutability and Partial function Specialization - ~8 - 10 Mins
  • Functional MultiThreading with Lambdas. - ~8 - 10 Mins
  • Lambdas in STL - ~ 7 - 10 Mins
  • Interesting Addons like Pattern Matching with Lambdas - ~ 5 Mins
  • Q & A ~ Rest of the available time

Learning Outcome

The participants of this talk shall be able to understand the changes that makes C++ a functional programming language. They will also be able to understand how to write functional code in new C++

Deepak K [Daksh] Gupta
Founder & Software Crafter
CodesBay

Deepak K Gupta [ a.k.a Daksh] is Founder & Software Crafter at CodesBay (www.CodesBay.com).

He is a long time software developer and has worked (and working) on multiple domains, including but not limited to VoIP, Protocol Stack, IP Networking & Security,  Telecom Intelligence, App Development(Mobile & Web), Cloud Computing, Machine Learning & Artificial Intelligence. 

Deepak is also a Public Speaker and has spoken in many global Technical and Agile Conferences. He is also an avid Blogger and a YouTuber and creates online contents on Software Development. More details about his work can be found @

https://www.youtube.com/CodesBay

https://www.github.com/CodesBay

https://www.medium.com/@DakshHub

https://www.CodesBay.Com

https://www.linkedin.com/in/dakshhub 

 

Question for Speaker?
Please rate Lambdas: The Functional Programming Companion of Modern C++

Programming Obesity: A Code Health Epidemic

Beginner Keynote

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.

Target Audience

Anyone who has ever struggled to find a bug, performance problem, or found that they can't believe a simple piece of software could require so much memory and cpu.

Outline

The nature of programming obesity

Some examples

The Diagnosis

Case Study

A Path Forward

Learning Outcome

The audience will come away with a set of clear proposals on how they can improve their own code and how they might be able to improve their practice of programming not only on a day to day level, but also on more fundamental levels that change the way that they approach programming design in the first place.

Aaron W Hsu
Computer Scientist
Indiana University

I'm a passionate computing artist with over a decade of experience in Scheme before I began to explore the wider application of array languages to HCI/d, parallel programming, human/computer performance, and human to human communication.

I work on a lot of software, and I have worked on all sorts of little trinkets throughout my life as a programmer and Computer Scientist. You can find little pieces of my work at GitHub.

However, my main project these days is the Co-dfns compiler, which is a high-performance, parallel APL compiler that is itself implemented in Co-dfns using a purely data-parallel compiler construction technique that avoids branching, recursion, or explicit control structures such as looping. Instead, the entire compiler is a data-flow program constructed through array programming and function composition in the simplest manner imaginable.

Question for Speaker?
Please rate Programming Obesity: A Code Health Epidemic

Joy - Maintaining Passion for Programming

Intermediate Keynote

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.

Target Audience

Developers and managers who work with them

Learning Outcome

Learn to program with joy, improving both your personal and professional lives

Bruce Tate
Founder
Groxio

Bruce Tate is a kayaker, climber, programmer and father of two from Chattanooga, Tennessee. A serial entrepreneur, he has helped start three companies, and most recently served as CTO for icanmakeitbetter. The author of more than a dozen books is active in the Elixir community as a speaker, author, editor and conference organizer. His love for teaching and computer languages led him to found Groxio in 2018.

As an author and speaker, he has written more than ten books including two JOLT award winners, most recently the book Seven Languages in Seven Weeks. He is the editor for the Seven in Seven line of books, including Seven Databases in Seven Weeks, with several other books under development.

When he is not coding, Bruce is an avid kayaker, climber, and mountain biker. When not coding, you can find him riding the bike trails by his home on Lake Travis or icing his most recent injury.

Question for Speaker?
Please rate Joy - Maintaining Passion for Programming

Propagators

Intermediate Demonstration

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.

Target Audience

developers, Technical leads and Architects,programmers, testers, business analysts and product owners,programmers, testers, business analysts and product owners and product owners

Edward Kmett
Chair of the Haskell Core Libraries Committee, Research Engineer
Machine Intelligence Research Institute

Edward spent most of his adult life trying to build reusable code in imperative languages before realizing he was building castles in sand. He converted to Haskell in 2006 while searching for better building materials. He now chairs the Haskell core libraries committee, collaborates with hundreds of other developers on over 250 projects on github, works on ways to try to better scale functional programming, logic programming and formal methods at the Machine Intelligence Research Institute, and is obsessed with finding better tools so that seven years from now he won’t be stuck solving the same problems with the same tools he was stuck using seven years ago.

Question for Speaker?
Please rate Propagators

APL Training Wheels

Beginner Tutorial

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.

Target Audience

Anyone who finds APL confusing and wants to learn the basic skills and avoid the early pitfalls.

Outline

Introduction

APL Trinity of Basics

The Basics to Learning APL and Core Concepts

How to Progress

Learning Outcome

By the end of this tutorial, the audience should have a clear understanding of the core foundational concepts of APL, how to approach reading and writing beginning level APL expressions, and the explicit thought process that goes into APL expressions before all of this knowledge is internalized. The audience should have confidence in working through basic APL expressions and working up to larger ones.

Aaron W Hsu
Computer Scientist
Indiana University

I'm a passionate computing artist with over a decade of experience in Scheme before I began to explore the wider application of array languages to HCI/d, parallel programming, human/computer performance, and human to human communication.

I work on a lot of software, and I have worked on all sorts of little trinkets throughout my life as a programmer and Computer Scientist. You can find little pieces of my work at GitHub.

However, my main project these days is the Co-dfns compiler, which is a high-performance, parallel APL compiler that is itself implemented in Co-dfns using a purely data-parallel compiler construction technique that avoids branching, recursion, or explicit control structures such as looping. Instead, the entire compiler is a data-flow program constructed through array programming and function composition in the simplest manner imaginable.

Question for Speaker?
Please rate APL Training Wheels

Lightweight dependent types for scientific computing

Intermediate Demonstration

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..

Target Audience

Functional programmers and anyone interested in using alternative languages and type systems for scientific computing

Outline
  • Intro
  • Why functional programming for scientific programming
  • Dependent types and 'lightweight' or restricted dependent types
  • Sylvester - an F# DSL for scientific computing
  • Using Visual Studio Code as an IDE for scientific computing
  • Type-level natural number arithmetic and constraints in Sylvester
  • Type-safe linear algebra
  • Type-safe linear equation solving
  • Type-safe neural network construction
Learning Outcome

Participants will appreciate how powerful functional programming and higher-level type systems can be for scientific programming. While one of the allures of using dynamic languages like Python for scientific computing is its ease-of-use, there's another dimension to ease-of-use where the language can help the user avoid errors in the libraries or tools he or she is working with.

Allister Beharry
Software Developer
Freelancer

I've been programming computers both as a hobby and professionally for almost 20 years. I like both Windows and Linux. My current focus is computer security, machine learning and .NET HPC.

Question for Speaker?
Please rate Lightweight dependent types for scientific computing

Demystifying Function Sub-typing

Intermediate Talk

What is a Type for a function? When can you say that a function is a sub-type of another function? Why should you even bother?

Function sub-typing is one of the most confusing areas of FP. In this talk, I'll take a deep dive and explain the core concepts of function types which applies to many different languages. More than just explaining the mere rules, I will be deriving those rules in a step-by-step fashion till the eureka moment so that you will never be confused again.

The topics covered:

  1. Sub-typing basics
  2. Covariance & Contravariance
  3. Function sub-typing
  4. Implementation gotchas in different languages (Java, Scala, Haskell, JavaScript)
Target Audience

Anyone using FP, preferably strongly typed languages like Scala, Haskell etc.

Outline
  • 5 mins
    1. Essential basics and an invented programming language for our discussion
    2. What is sub-typing
  • 8 mins
    1. Covariance & Contravariance
    2. Deriving the function sub-type
  • 7 mins
    1. Usage examples for function sub-types
    2. Implementation caveats in popular systems
Learning Outcome

Strong understanding of function sub-typing, useful in library design and contract modelling.

Anish George
UI Developer
ThoughtWorks

Frontend Engineer and Programming enthusiast currently working at ThoughtWorks (Pune). Outside software, I spend time playing my guitar, reading or travelling

Question for Speaker?
Please rate Demystifying Function Sub-typing

Zippers

Intermediate Talk

The term zipper is a colloquial used to describe n-hole (most often, 1-hole) contexts. That is, a data structure that has a _hole_ or _pointer_ focused on a specific element with the ability to efficiently traverse to its neighbouring elements, providing an elegant solution for the need to efficiently traverse and _modify_ immutable data structures.

In this talk, we will look at examples of zippers for canonical data structures such as lists and other products and sums. We will then define comonads and see the relationship between zippers and comonads.

Most of this talk will be spent on the practical application of zippers in everyday programming. We will solve some simple problems using zippers. We will then contrast why we might use a zipper, compared to a lens.

Finally, for a fun and interesting observation, we will look at the algebraic structure of products and sums, then compute the derivative of these structures. Turns out, a derivative of a data structure is its zipper ("McBride, Conor, et al (2005). ∂ for Data: Differentiating Data Structures").

Target Audience

Programmers working out navigating immutable data structures

Outline

A 45 minute talk and questions on the use-cases for which zippers are appropriate, for any data structure. We will look at some trivial and not-so-trivial data structures, their associated zipper, and how we might use it.

Learning Outcome

Gaining confidence with using immutable data structures in your work.

Tony Morris
Sr. Software Engineer
Queensland FP Lab, Data61

Tony Morris is a software product developer who has deployed functional programming techniques in industry for over 10 years. Tony teaches at the tertiary level and for professional programmers with a view toward producing a viable commercial result. Tony is currently a Senior Software Engineer at NICTA where he is tasked with promoting and educating on functional programming for the benefit of all Australian software developers.

Tony takes a fastidious, principled approach to functional programming both when deployed in practice and when in a learning environment to ensure maximum yield from the effort. Tony believes that exploring principles and the following consequences provides a rewarding experience for all involved.

Question for Speaker?
Please rate Zippers

Delivering your APLs

Beginner Tutorial

Most talks on APL at FunctionalConf have focused on the way array oriented programming allows you to quickly deliver concise and efficient solutions to problems with an analytical core. This talk will focus on the development environment, and follow the life of an APL code snippet from it's interactive discovery, via testing and debugging, through to delivery as a web service and a shared object, embedded into a solution implemented in Python.

Target Audience

Anyone interested in array languages.

Outline

The presentation will essentially be an interactive demo, in which an APL function is prototyped, packaged, and finally called from a Python application.

Learning Outcome

The audience will learn about the tool chains typically used for writing, testing and debugging code, source code management and finally packaging of solutions written in APL.

Morten Kromberg
CXO
Dyalog

Morten Kromberg has been developing applications and tools for developers in APL since 1979 – almost ¾ of the time that has passed since the first APL interpreter saw the light of day in 1966 (coincidentally, this is roughly the same fraction of his own life). Amongst other things, he was the CTO of Adaytum Software from 1995 to 2000 (http://www.thefreelibrary.com/Adaytum... where he was responsible for the development of a highly successful business planning solution based upon APL, which was subsequently acquired by Cognos and is currently known as IBM Cognos 8 Planning.

Since 2005, Morten has been the CTO of Dyalog Ltd (www.dyalog.com) , which has become the fastest-growing vendor of APL interpreters, based in Bramley (Hampshire), UK. Morten is a frequent speaker at APL conferences, and presented a paper titled “Arrays of Objects” at 2007 the symposium on Dynamic Languages, on the integration of object and array paradigms in Dyalog APL (http://portal.acm.org/citation...).

More at http://www.dyalog.com/blog/about-the-cto/.

Question for Speaker?
Please rate Delivering your APLs

How debuggers work in Lispy languages

Intermediate Talk

Debuggers are one of the most essential tools for any kind of development.

Debuggers in Lispy languages make use of Lisp's homoiconicity. They are a bit different from debuggers for languages like C or Java.

This kind of information is usually not needed in day to day development and hence it remains hidden.

In this talk, I will take Clojure's cider-debug as an example and explain how it uses homoiconicity. Along with cider-debug, I will also talk about REPLs and how REPL client-server communication happens (with nREPL as an example).

Target Audience

1. Developers who work with Lispy languages. 2. Developers interested in knowing how debuggers work. 3. Clojure developers.

Outline

1. What is Homoiconicity.
2. REPLs.
3. REPL client-server communication.
4. Lispy debuggers with cider-debug as an example.
5. How debuggers for lispy languages are different.
6. Internals of lispy debuggers.

Learning Outcome

Good understanding of:
1. Debuggers for Lispy languages.
2. REPL client-server communication.
3. Overview of cider-debug features.
4. Internal details of cider-debug.

Suvrat Apte
Backend Engineer
Helpshift
Question for Speaker?
Please rate How debuggers work in Lispy languages

Why is Haskell so hard to learn? (and how to deal with it)

Beginner Talk

Haskell is notoriously hard to learn. I have struggled with the learning curve. I have seen others struggle with it. And I have seen developers struggling to wield the language effectively even after months of learning.

We'll talk about five things that give Haskell this (understandably) bad rep, and how to effectively deal with them during your learning phase.

Target Audience

Beginners

Outline
  • Few concepts where Haskell is fundamentally very different from other popular languages
  • Shortcomings of the core language
  • Curse of the Monads (and no, this will not be another monad tutorial)
  • Libraries and documentation
  • Not knowing how to use the type-system effectively
Learning Outcome

You will learn a bunch of tips & trips on how to effectively navigate the Haskell landscape, i.e. what parts of to focus on, what not to bother with (at least till intermediate level).

And, for a brief period of time, you will not feel so bad about struggling with Haskell :-)

Saurabh Nanda
Founder
Vacation Labs

Founder & CEO, Vacation Labs

Our travel-commerce platform is built using ~150,000 lines of Rails and ~120,000 lines of Javascript. Recently, we've spent a year evaluating   typed-FP languages, and have successfully added ~46,000 lines of Haskell into our tech stack.

I'm always on the lookout for techniques to write correct programs without compromising on speed of development. After all, what good is a correct program, if it's late to the market and no one runs it in the first place!

I've been coding since my school days (BASIC, Pascal, Foxpro, dBase, C, Visual Basic, C++), all throughout engineering (Linux admin, PHP, MySQL), and then at Cleartrip where we wrote the first version of the platform in Common-Lisp & Rails. At Vacation Labs, we're using Rails, Javascript, Typescript, Angular, Postgres, Redis, and Haskell.

 

Question for Speaker?
Please rate Why is Haskell so hard to learn? (and how to deal with it)

Handling and Composing complex side effects in Clojure with Sanity

Intermediate Talk

At Helpshift, we face managing complexity of these side effects which touch 10s of different systems. Each side effect poses a failure scenario which can lead to it's own business decision. Compounded failures pose even more complexity. To add to the problems we extending the codebase to add new business logic regularly.

I will present a solution which is a combination of Clojure and FP following techniques. We will also discuss how ideas when combined together can create an elegant solution,

1. Data - Side effects definition as data

2. Almost no syntax - Minimal definition

3. Many functions for one DS - Multiple execution and failure recovery modes for side effects

Target Audience

Clojure or FP practitioners

Outline
  • Introduction to Clojure and how we do side effects
  • Some patterns that emerged at Helpshift when doing side effects
  • All patterns lead to a singular problem of Mudball collecting state
  • A solution using simple constructs
  • It's usage patterns and how it's better than previous patterns
  • How it survives the test of production woes
  • Alternatives which provide similar solutions and comparisions
Learning Outcome
  • It is totally possible to tame the Mudball of state that get's in the way mostly while doing IO. In the process we learn of the different patterns of doing IO and computations.
Kapil Reddy
Platform Engineer
Helpshift

Kapil Reddy is a Platform  engineer at Helpshift, and is a core developer on many of the scalability projects at Helpshift.  He believes that skynet is already sentient.

Question for Speaker?
Please rate Handling and Composing complex side effects in Clojure with Sanity

Building a blog engine in F# with WebSharper

Intermediate Tutorial

When it comes to developers blogging, expectations are high and many find that it’s a worthwhile effort to develop simple scripts, tools and even full engines to enhance and support blogging about their favorite language. In this hands-on session, you will implement your own blog engine from scratch in just a few hundred lines of F# code using WebSharper, and use its static file generation capabilities to generate blog pages that you can deploy directly into GitHub Pages or host in any web server. The resulting blog can easily be styled using WebSharper’s powerful templating capabilities, and even automated to rebuild when you commit new content or blog articles in your blog repository. You will also learn about adding dynamic functionality to your generated blog pages, or even turning your blog engine to a hosted solution that provides further capabilities as well. No more searching for blog engines with the right features, code what you need and enjoy!

Target Audience

.NET/FP developers

Outline
  • Getting started with WebSharper
  • Introduction to sitelets, a type-safe abstraction for server-side functionality in full-stack WebSharper applications
  • Static content/site generation from sitelets
  • Basics of dealing with markdown
  • HTML templating with WebSharper
  • Putting everything together
  • Advanced topics - switching to a hosted solution, adding CMS capabilities
  • Q&A
Learning Outcome

Attendees will be able to develop HTML applications in F#, implement a simple blog engine with generated pages for each article, seamlessly incorporate dynamic content, and understand where to add their customizations if needed.

Adam Granicz
CEO
IntelliFactory

Adam Granicz (@granicz) is a 9x F#/.NET MVP and the coauthor of five F# books, key F# community member and evangelist, a regular speaker at developer conferences and workshops, and the CEO of IntelliFactory, the F# company specializing in trainings, consulting, and developing functional, reactive web and cloud applications.

Question for Speaker?
Please rate Building a blog engine in F# with WebSharper

Papers We Love - Elixir Edition

Beginner Talk

Elixir is a modern programming language built for concurrency, robustness, and maintainability. Although the Elixir team comes from “industry” backgrounds, the history of Elixir is full of cases where the team has reached for existing research in order to solve problems arising with the language. For example, we based our implementation of a code formatter on a series of papers on pretty printing and formatting code. In this talk, I’d like to go share our learnings and experiences as a bunch of industry folks getting help from academia to approach and tackle real-world problems and come up with real-world solutions.

Target Audience

Any software developer

Outline

I'll talk about different papers that heavily influenced the design and implementation of parts of the Elixir programming language.

Learning Outcome

Show attendees how we practically used existing research to avoid having to reinvent the wheel when working on some areas of Elixir.

Andrea Leopardi
Core Team Member
Elixir Lang

Elixir core team member, developer advocate, software architect (Community.com)

Andrea is a human born in the ancient lands of central Italy. He loves functional programming, beautiful code, and learning stuff. He's a software architect, speaker, and member of the core team of the Elixir programming language. His weak spot is having red hair.

Question for Speaker?
Please rate Papers We Love - Elixir Edition

Monad-bayes: Probabilistic programming in haskell, tutorial & implementation

Intermediate Case Study

We take a dive into probabilistic programming, beginning with a high-level explanation of what probabilistic programming is. We then continue to see how to use the monad-bayes library for performing tasks such as regression in a bayesian formalism. We also look into the implementation of the library, which involves performing an interesting sampling method (markov-chain-monte-carlo) on a very unique space (the space of computational traces of the program). We finally end with next-steps for the haskell community to improve in the probablistic programming space, ala pyro for python

Here is our tiny re-implementation of monad-bayes, boiled down to the essentials: https://github.com/bollu/shakuni

Paper on which the talk is based on: http://mlg.eng.cam.ac.uk/pub/pdf/SciGhaGor15.pdf

Target Audience

Those with an interest in performing data science and bayesian methods with haskell

Outline

Begin by motivating bayesian reasoning and probabilistic programming. Show monad-bayes as an API for solving bayesian inference problems. Describe the implementation of the library, markov-chain-monte-carlo methods, and the space of computations that we will be sampling on. Close with further thoughts on where this library can be taken.

Learning Outcome

Learn about probabilistic programming, markov chain monte carlo, implementing probabilistic programming with conditioning, and the monad-bayes API

Siddharth Bhat
Student
IIIT Hyderabad

I work on compilers, formal verification, and functional programming. 

Question for Speaker?
Please rate Monad-bayes: Probabilistic programming in haskell, tutorial & implementation

Hierarchical Free Monads and Software Design in Functional Programming

Advanced Talk

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.

Target Audience

Haskell, PureScript developers who wants to know more about software design in large in pure functional languages.

Outline
  1. Software Design in Functional Programming
    1. The main tasks of Software Design
    2. Inversion of Control: how, why, when
    3. Final Tagless vs Free Monads vs Effect systems vs Freer vs…
  2. Introduction into Software Design with Free Monads
    1. The key idea of Free Monads
    2. Layering the application
      1. Domain Model
      2. Business Logic Languages
      3. Scenarios
      4. Application State
      5. Database Model
      6. Implementation layer
      7. Runtime
  3. Sample program
  4. Testing of Free Monad
    1. Functional testing
    2. Integration testing
  5. Conclusion
Learning Outcome

The audience will learn about eDSLs design and semantics, about the ways of structuring of applications, about the importance of layering, about testing and other aspects of software design, - and all this based on the Hierarchical Free Monads approach.

Alexander Granin
Sr. Haskell Developer
Juspay

My name is Alexander Granin. Let me introduce myself.

I’m a Functional Developer. My primary languages are: Haskell and PureScript. I’m also a proficient C++ developer with more than 10 years of experience.

I’m a researcher. I’m creating projects showing the usage of advanced FP in C++ (Free Monads, Lenses, Comonads, Design and Architecture with a pure FP style)

I’m a famous speaker. I gave more than 15 talks at Russian conferences and meetups including FPure, FPConf, C++ Russia and others.

I’m a writer. I’m the author of the book “Functional Design and Architecture” and many articles investigating how to build and structure applications in pure FP languages.

My GitHub

My talks

Question for Speaker?
Please rate Hierarchical Free Monads and Software Design in Functional Programming

Typesafe Functional SQL

Intermediate Talk

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.

Target Audience

People with some functional programming experience

Outline
  1. Introduction to FP and Relational Algebra, and why they are a good fit.
  2. Problems with Typing SQL in FP.
  3. How Row Types solve the problem.
  4. Real world examples with Ermine, and Purescript-Consequence
Learning Outcome

After the talk, attendees have a good idea why Functional Programming is a good fit for interfacing with Relational Databases.

Anupam Jain
Associate Director, Analytics
S&P Global

I am a Haskell developer with over a decade of FP experience.

I currently work as Associate Director of Analytics at Standard and Poor's where we build cutting edge financial solutions using Functional Programming.

Previously I founded GeoHangout.com which was built on a Functional Stack.

I love Free and Open Source Software. You can see some of my code at - https://github.com/ajnsit.

In my spare time, I organise regular FP meetups in Delhi NCR and surrounding areas, as the founder of The Delhi NCR Haskell And Functional Programming Languages Group. We have a Telegram group - https://t.me/fpncr.

I often talk about web development and functional programming. Some of the slides are available - https://speakerdeck.com/ajnsit. Some videos are available at https://www.youtube.com/channel/UC7TUykDPHPs0rSiPodAQFsg/playlists.

Question for Speaker?
Please rate Typesafe Functional SQL

Have you GADT ?

Intermediate Talk

The type-system of Haskell is well-known as well as notorious for its rigour & strong mathematical foundations.
In this talk, we would like to explain about the recent idea of GADT's and how they help eliminate runtime checks & issues.

Our hope is that newbies to Functional Programming, and esp., Haskell are no longer intimidated by the term GADT's but instead see them as their ally in conquering some types of problems.


Target Audience

Haskell aficionados and well as people curious about Haskell/FP

Outline
  • Introduction Algebraic Data Types (ADTs)
  • A Sample problem where ADT's are not enough (and why)
  • Possible solutions
  • Enter GADT's & how they address the problem
  • Caveats, Issues & learning pointers...
Learning Outcome
  • An insight into the beauty & power of GADT's (from a Mathematical & common-sense of point of view)!
  • The audience, even if from the world of other typed languages like Java should be able to come away with an appreciation of the rich type system of Haskell, which is the research-crucible for all things pure & functional!
Raghu Ugare
Architect, Designer, Developer
LambdaMatters

Passionate about getting people to love math, science and programming. Very fond of books, movies, music, fonts, exploring different programming paradigms and languages, and can be frequently found experimenting on numbers, algorithms and patterns using Mathematica.

Currently in love with FP in general & Haskell in particular, & Machine Learning...


Vijay Anant
Architect, Designer, Developer
LambdaMatters

I am passionate about technology and teaching. I volunteer to teach when I get free time, and have a penchant for history, anime, and poetry. Generally interested in technology as a whole, fiddle with many programming languages and tech. Currently I'm all about Functional Programming and Haskell. I love to talk in conferences and MeetUps. 

Question for Speaker?
Please rate Have you GADT ?

Q & A Session With Functional Conf Speakers

Beginner Keynote

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

Target Audience

All

Outline

Q & A sessions in a fish-bowl style panel.

Naresh Jain
Founder
Xnsio

Developer...Consultant...Conference Producer...Startup Founder…struggling to stay up-to-date with technology innovation. Null Process Evangelist.

Naresh Jain is an internationally recognized Technology & Product Development Expert. Over the last decade, he has helped streamline the product development practices at many Fortune 500 companies like Google, Amazon, JP Morgan, HP, Siemens Medical, GE Energy, Schlumberger, Ford, EMC, CA Technologies, to name a few clients. These days, he is more focused on engineering excellence and product innovation. In a nutshell, hire him as a consultant/mentor, if your entire organization wants to move beyond the Agile and Lean mindset. Learn more about his expert services.

Naresh Jain's Startup Icons

Naresh is leading a consulting business called XNSIO, which helps organizations build the essential product, technology & people capabilities required to transform their business for the digital world. He is also responsible for building ConfEngine.com - one-stop conference/event management platform.

Check out our awesome products!

Agile Software Community of India

In 2004, Naresh started the Agile movement in India by creating the Agile Software community of India, a registered non-profit society to evangelize Agile, Lean and other Leading-Edge Software Development methods in India. He is responsible for creating and organizing 100+ international conferences including the Functional Conf, Open Data Science Conference, Simple Design And Testing Conference (SDTConf), Agile Coach Camp, Selenium Conf India, Appium Conf, jQuery and Open Web Conference and Eclipse Summit India. He started many Agile User Groups including TechJam, Agile Philly User Group, and groups in India.

In recognition of his accomplishments, in 2007 the Agile Alliance awarded Naresh with the Gordon Pask Award for contributions to the Agile Community.

Learn more about Naresh at https://nareshjain.com


Aaron W Hsu
Computer Scientist
Indiana University

I'm a passionate computing artist with over a decade of experience in Scheme before I began to explore the wider application of array languages to HCI/d, parallel programming, human/computer performance, and human to human communication.

I work on a lot of software, and I have worked on all sorts of little trinkets throughout my life as a programmer and Computer Scientist. You can find little pieces of my work at GitHub.

However, my main project these days is the Co-dfns compiler, which is a high-performance, parallel APL compiler that is itself implemented in Co-dfns using a purely data-parallel compiler construction technique that avoids branching, recursion, or explicit control structures such as looping. Instead, the entire compiler is a data-flow program constructed through array programming and function composition in the simplest manner imaginable.


Andrea Leopardi
Core Team Member
Elixir Lang

Elixir core team member, developer advocate, software architect (Community.com)

Andrea is a human born in the ancient lands of central Italy. He loves functional programming, beautiful code, and learning stuff. He's a software architect, speaker, and member of the core team of the Elixir programming language. His weak spot is having red hair.


Bruce Tate
Founder
Groxio

Bruce Tate is a kayaker, climber, programmer and father of two from Chattanooga, Tennessee. A serial entrepreneur, he has helped start three companies, and most recently served as CTO for icanmakeitbetter. The author of more than a dozen books is active in the Elixir community as a speaker, author, editor and conference organizer. His love for teaching and computer languages led him to found Groxio in 2018.

As an author and speaker, he has written more than ten books including two JOLT award winners, most recently the book Seven Languages in Seven Weeks. He is the editor for the Seven in Seven line of books, including Seven Databases in Seven Weeks, with several other books under development.

When he is not coding, Bruce is an avid kayaker, climber, and mountain biker. When not coding, you can find him riding the bike trails by his home on Lake Travis or icing his most recent injury.


Edward Kmett
Chair of the Haskell Core Libraries Committee, Research Engineer
Machine Intelligence Research Institute

Edward spent most of his adult life trying to build reusable code in imperative languages before realizing he was building castles in sand. He converted to Haskell in 2006 while searching for better building materials. He now chairs the Haskell core libraries committee, collaborates with hundreds of other developers on over 250 projects on github, works on ways to try to better scale functional programming, logic programming and formal methods at the Machine Intelligence Research Institute, and is obsessed with finding better tools so that seven years from now he won’t be stuck solving the same problems with the same tools he was stuck using seven years ago.


Saurabh Nanda
Founder
Vacation Labs

Founder & CEO, Vacation Labs

Our travel-commerce platform is built using ~150,000 lines of Rails and ~120,000 lines of Javascript. Recently, we've spent a year evaluating   typed-FP languages, and have successfully added ~46,000 lines of Haskell into our tech stack.

I'm always on the lookout for techniques to write correct programs without compromising on speed of development. After all, what good is a correct program, if it's late to the market and no one runs it in the first place!

I've been coding since my school days (BASIC, Pascal, Foxpro, dBase, C, Visual Basic, C++), all throughout engineering (Linux admin, PHP, MySQL), and then at Cleartrip where we wrote the first version of the platform in Common-Lisp & Rails. At Vacation Labs, we're using Rails, Javascript, Typescript, Angular, Postgres, Redis, and Haskell.

 

Question for Speaker?
Please rate Q & A Session With Functional Conf Speakers

Let's Lens

Intermediate Workshop

Let's Lens presents a series of exercises, in a similar format to the Data61 functional programming course material. The subject of the exercises is around the concept of lenses, initially proposed by Foster et al., to solve the view-update problem of relational databases.

The theories around lenses have been advanced significantly in recent years, resulting in a library, implemented in Haskell, called lens.

This workshop will take you through the basic definition of the lens data structure and its related structures such as traversals and prisms. Following this we implement some of the low-level lens library, then go on to discuss and solve a practical problem that uses all of these structures.

Target Audience

All

Learning Outcome

An attendee who completes this workshop should expect to confidently use the lens library, or other similar libraries, in their every day programming.

Edward Kmett
Chair of the Haskell Core Libraries Committee, Research Engineer
Machine Intelligence Research Institute

Edward spent most of his adult life trying to build reusable code in imperative languages before realizing he was building castles in sand. He converted to Haskell in 2006 while searching for better building materials. He now chairs the Haskell core libraries committee, collaborates with hundreds of other developers on over 250 projects on github, works on ways to try to better scale functional programming, logic programming and formal methods at the Machine Intelligence Research Institute, and is obsessed with finding better tools so that seven years from now he won’t be stuck solving the same problems with the same tools he was stuck using seven years ago.


Tony Morris
Sr. Software Engineer
Queensland FP Lab, Data61

Tony Morris is a software product developer who has deployed functional programming techniques in industry for over 10 years. Tony teaches at the tertiary level and for professional programmers with a view toward producing a viable commercial result. Tony is currently a Senior Software Engineer at NICTA where he is tasked with promoting and educating on functional programming for the benefit of all Australian software developers.

Tony takes a fastidious, principled approach to functional programming both when deployed in practice and when in a learning environment to ensure maximum yield from the effort. Tony believes that exploring principles and the following consequences provides a rewarding experience for all involved.

Question for Speaker?
Please rate Let's Lens

Building a real-time, reliable, resilient web application in one day with Elixir and Phoenix

Beginner Workshop

We'll explore how to built connected, real-time web applications using Elixir and the Phoenix framework.

  • Look at the basics of Elixir, or rather the things we need to dive into the workshop
  • Get started with the basics of Phoenix and how to build simple HTML web applications with it
  • Introduce channels and learn how to use them in order to communicate with clients in real time
  • Talk about distribution and how to work with Phoenix on multiple servers
  • Talk about LiveView and learn how to update data on a page from the server without any JavaScript

Target Audience

Anyone with an interest in Elixir and web development

Outline
  • Look at the basics of Elixir, or rather the things we need to dive into the workshop
  • Get started with the basics of Phoenix and how to build simple HTML web applications with it
  • Introduce channels and learn how to use them in order to communicate with clients in real time
  • Talk about distribution and how to work with Phoenix on multiple servers
  • Talk about LiveView and learn how to update data on a page from the server without any JavaScript
Learning Outcome

Attendees will be exposed to Elixir, Phoenix, and their core selling features, such as concurrency, isolation, resiliency, real-time server-client communication, and so on. They will have worked with a real Phoenix application and have made changes to it themselves.

Andrea Leopardi
Core Team Member
Elixir Lang

Elixir core team member, developer advocate, software architect (Community.com)

Andrea is a human born in the ancient lands of central Italy. He loves functional programming, beautiful code, and learning stuff. He's a software architect, speaker, and member of the core team of the Elixir programming language. His weak spot is having red hair.

Question for Speaker?
Please rate Building a real-time, reliable, resilient web application in one day with Elixir and Phoenix

APL Workshop Intensive

Beginner Workshop

This is an intensive workshop for those who are interested in learning how to think, read, and write APL. It will help give you the tools, mental framework, and structure for doing things "the APL way." In this workshop, you will have the chance to spend intensive time thinking like an APL programmer. What makes it different? How does the code look at the end? What thought process do you go through to get there? Get a chance to play around with a wide array of problems and solving them "the APL way."

Taijiquan Classics say, "Four ounces deflects a thousand pounds."

APLers might say instead, "Fifty characters solve a thousand problems."

Target Audience

Anyone interested in a deep, intensive dive into the world of APL.

Outline
  • Introduction
  • The APL Way
  • Thinking like an APLer
  • Problem Solving, Exploratory Programming
Learning Outcome

Participants should come away with a clear picture of APL programming techniques, including a bit of confidence in applying them on their own, and should comfortable exploring and reading other programmer's APL.

Aaron W Hsu
Computer Scientist
Indiana University

I'm a passionate computing artist with over a decade of experience in Scheme before I began to explore the wider application of array languages to HCI/d, parallel programming, human/computer performance, and human to human communication.

I work on a lot of software, and I have worked on all sorts of little trinkets throughout my life as a programmer and Computer Scientist. You can find little pieces of my work at GitHub.

However, my main project these days is the Co-dfns compiler, which is a high-performance, parallel APL compiler that is itself implemented in Co-dfns using a purely data-parallel compiler construction technique that avoids branching, recursion, or explicit control structures such as looping. Instead, the entire compiler is a data-flow program constructed through array programming and function composition in the simplest manner imaginable.


Morten Kromberg
CXO
Dyalog

Morten Kromberg has been developing applications and tools for developers in APL since 1979 – almost ¾ of the time that has passed since the first APL interpreter saw the light of day in 1966 (coincidentally, this is roughly the same fraction of his own life). Amongst other things, he was the CTO of Adaytum Software from 1995 to 2000 (http://www.thefreelibrary.com/Adaytum... where he was responsible for the development of a highly successful business planning solution based upon APL, which was subsequently acquired by Cognos and is currently known as IBM Cognos 8 Planning.

Since 2005, Morten has been the CTO of Dyalog Ltd (www.dyalog.com) , which has become the fastest-growing vendor of APL interpreters, based in Bramley (Hampshire), UK. Morten is a frequent speaker at APL conferences, and presented a paper titled “Arrays of Objects” at 2007 the symposium on Dynamic Languages, on the integration of object and array paradigms in Dyalog APL (http://portal.acm.org/citation...).

More at http://www.dyalog.com/blog/about-the-cto/.

Question for Speaker?
Please rate APL Workshop Intensive