Dyalog is an array first multi-paradigm language based on an APL language kernel. In APL, it is common for the application of primitive functions to arrays of conforming shape to imply a map; the function is applied item-wise to corresponding elements of the arguments, producing a result of the same shape. APL also provides a variety of explicit operators that provide different mappings of user-defined functions, or more generally functional compositions, to multi-dimensional and nested arrays.

One might expect that such language features would provide a complete framework for parallel programming. In practice, writing programs that can be efficiently executed in parallel on current hardware is extremely difficult, if implicit or explicit maps are the only parallel language feature available and an interpreter or compiler needs to deduce where to introduce the asynchronicity that is required in order to take advantage of the hardware.

This talk will present Futures and Isolates, and related parallel operators constructed upon them, which were added to Dyalog version 14.0 in 2014. The goal has been to provide explicit forms of deterministic asynchronous execution, designed to be very familiar to APL users, and continue to allow them to view the language as an executable mathematical notation, while taking advantage of parallel hardware that is now readily available.

In this talk, I will talk about our motivation for creating Julia. Julia is a high-level, high-performance dynamic programming language. It provides a sophisticated compiler, distributed parallel execution, numerical accuracy, and an extensive mathematical function library. Julia’s Base library, largely written in Julia itself, also integrates mature, best-of-breed open source C and Fortran libraries for linear algebra, random number generation, signal processing, and string processing. In addition, the Julia developer community is contributing a number of external packages through Julia’s built-in package manager at a rapid pace. This is why Julia is seeing rapid adoption in universities for teaching and research, as well as in businesses.

I will discuss what makes Julia fast. Julia's ability to combine these levels of performance and productivity in a single language stems from the choice of a number of features that work well with each other:

1. An expressive parametric type system, allowing optional type annotations;
2. Multiple dispatch using those types to select implementations;
3. A dynamic dataflow type inference algorithm allowing types of most expressions to be inferred;
4. Aggressive code specialization against run-time types;
5. Metaprogramming;
6. Just-In-Time compilation using the LLVM compiler framework; and
7. Careful design of the language and standard library to be amenable to type analysis;

I will also touch upon how the language design has made it possible to explore many parallel programming models in Julia, completely within the language.

See: http://www.julialang.org/

Startups are hot. They're fun. They're exciting, challenging, and romantic. They're also brutal. Only 1 in 20 startups succeed. 

This talk is about how functional programming gives startups an advantage. Because every advantage is critical, in the fight to survive. And then to scale up, and thrive.

Organising code as chained combination of data processing steps is a common pattern. Functional programming has made it ubiquitous due to concise lambda notations. But there are wide variations in how these pipelines are implemented. In this talk we will explore important properties of lazy data streams such as: push vs pull, hot vs cold, linear-flows vs graphs, perishable vs reusable, unicast vs multicast, synchronous vs asynchronous back-pressured etc.

We will then explain "reactive-streams" protocol which guarantees asynchronous back-pressure for push based data streams. We will conclude with a demo using Akka-Streams which is an implementation of this protocol. The demo will involve a) streaming images from server to the browser over websockets, b) transferring large files from one source server to multiple destination servers.

Dyalog is a modern, array-first, multi-paradigm programming language, which supports functional, object-oriented and imperative programming based on an APL language kernel. During the morning and early afternoon, Dyalog's functional language guru John Scholes will introduce the fundamentals of functional programming in APL. At the end of the day, Dyalog CTO Morten Kromberg will round off with an application development session, showing how a simple web application with a HTML5/JS front-end and a RESTful web service can be used to deliver the power of APL to end users, or as embeddable components for other application tools. The "hands on" sections of the workshop can be followed under Mac OS X, Linux, or Microsoft Windows.

In Indian classical music, we have Jugalbandi, where two lead musicians or vocalist engage in a playful competition. There is jugalbandi between Flutist and a Percussionist (say using Tabla as the instrument). Compositions rendered by flutist will be heard by the percussionist and will replay the same notes, but now on Tabla and vice-versa is also possible.

In a similar way, we will perform Code Jugalbandi to see how the solution looks using different programming languages and paradigms.

During the session, conference attendees will take turns at coding the same problem using different languages and paradigms. There would be multiple such attempts by different participants during the Jugalbandi.

Building computer systems that are reliable is hard. The functional programming community has invested a lot of time and energy into up-front-correctness guarantees: types and the like. Unfortunately, absolutely correct software is time-consuming to write and expensive. Fault-tolerant systems achieve system-total reliability by accepting that sub-components will fail and planning for that failure as a first-class concern of the system. As companies embrace the wave of "as-a-service" architectures, failure of sub-systems become a more pressing concern. Using examples from heavy industry, aeronautics and telecom systems, this talk will explore how you can design for fault-tolerance using functional programming techniques, type theory, monitoring, instrumentation and effective team dynamics. 

When we think of OO, most people think of modeling THE real world in software by mapping every real world object (nouns) to entities in software. These entities are then modeled using Is-A-Has-A relationship to build complex, polymorphic hierarchies with deep object graphs. State is stored and mutated in-place inside the object to achieve the desired functionality. This paradigm leads to a fairly convoluted design and encourage imperative style of programming.

Not everyone who has designed large complex systems, think of OO the same way. For instance, people who Test Drive, do not have the luxury of a big-up-front design, instead they focus on small and incremental design. IME, TDD facilities a design that is side-effect free and encourages a declarative style of programming. While decoupling and composing objects in a functional style with the right granularity of abstraction.

Let's assume we've to build a web commenting and discussion feature (like Disqus). And we've a requirement to implement this as a jQuery Plugin. Can we apply pure functional principles to design this? Or will the design be better if we try a classical OO JS approach? In this live demo, we'll build this plugin from scratch and see how TDD will help us drive an object-functional design to strike a pragmatic balance between the 2 paradigms.

If you thought Monads are a mystery, then this demonstration would show you how to evolve your code towards a Monad without knowing about it. This demo will neither go into any Category Theory nor begin with monadic laws.  Instead, we will start with typical code that you see in your daily life as a developer, attempt to DRY (Don't Repeat Yourself) it up and eventually use Monad to remove duplication and verbosity. You'll also see how Monads make your code more declarative and succinct by sequencing the steps in your domain logic.

Also, we know in Java8 Checked Exceptions + λ == Pain!  To be more precise, we will evolve a Try (exception handling monad) which is missing in Java8, similar to one found in Scala.  Finally, map back Try to the 3 monad laws.

This talk is an introduction of sorts to Hy, a Lisp dialect embedded in Python. We'll explore the semantic designs of Hy from a Lisp programmer's perspective, and we'll look at how Hy gives you the best of Lisp-style functional programming, with the ability to hook into Python's ecosystem.

Using a hands-on format, this workshop will address the design and construction of a well-understood back-of-house system found in larger organizations: a resource-consumption based billing system. We will focus on multi-group collaboration to build a service-oriented architecture with individual groups being responsible for a service vertical. Basic infrastructure tools and specific goals for each service vertical will introduce and teach functional concepts that will be immediately useful in existing production environment. Each service vertical and the total integrated system will be exercised by a tool that I will provide. Intra-component protocols will be well-specified and groups will be free to meet their goals as they see fit. No specific language will be used. Participants are encouraged to use languages they are comfortable with. The principles being taught in this workshop will require functional architectures and this will be covered explicitly. Special emphasis will be placed on designing for instrumentation and monitoring using functional principles and the goals of the workshop will support this emphasis. 

When we were building our cloud orchestration platform, we were looking into writing our API Gateway server in scala and strictly functional because we knew the API is going to be doing lot of heavy lifting and it will be constantly extended. We stumbled upon scalaz, a brilliant library for scala to write functional programs. It was indeed a pleasure for the whole team to write the API since then.

I will be talking more about how we designed and built the REST API that powers megam cloud platform(megam.io). Developers with scala experience will be able to take away on getting started with scalaz library.

Haskell is widely known as a functional programming language which is great to write pure (non I/O) code and immutable data structures. But it is not well known that it has a great support for a wide variety of concurrency models too.

In this talk we shall explore the various concurrency models and primitives supported by Haskell including green threads, mutable variables, channels and software transactional memory. We shall see how the purity, laziness, and the strong type system of Haskell come together, and help write clean and modular concurrent code. We shall explore these by writing a mutli-user chat server with support for private and channel chatting.

From the perspective of one of the few companies in the country using Haskell in production (hasura.io), we will talk about the journey of using Haskell as a programming language to build and maintain real world software.
From the burden of choosing a language that probably has a single digit number of active developers in the country, to
the joys of a small team churning out code that just keeps on working.

We'll go over how we created a team, organized work ("software development practices"), architecting code, tooling up, testing, performance tweaking and finally deploying a Haskell codebase. We hope that Haskell developers with some prior experience will be able to take away
something new about the Haskell ecosystem, and those interested in just functional programming will see tangible value in how certain features unique to Haskell have an impact.

Expect a case study, a review of some cutting-edge tools and how to use them, and some Haskell code samples that will make you grunt in geeky approval.

This talk is about our experience of using Clojure in production at Concur for building a SaaS platform.

To set the perspective, Concur is a 22 years old, USD 8.3 billion enterprise, now a part of SAP. More than 70% of Fortune 500 companies use Concur for travel and expense solutions. Concur's SaaS platform serves 25,000 customers with 25 million users. The Concur SaaS platform was reaching its limits and needed "re-architecting". This talk is about why we chose Clojure at Concur and how we are building one of the world's largest B2B SaaS platforms in Clojure.

We will discuss the practices we established, experiments we did and the lessons learnt. We have now built a platform that follows open standards, is rigorously tested, tolerates failure and performs well. We will go over how we reached there, how we deployed the code to production and how we monitor those today.

If you are considering using Clojure in production or even simply interested in Clojure, you may get useful insights to take away from this talk.

Machine learning is more popular than ever because there are several dataset available and we can use several tools at our disposal to learn an insight from this data.

In this session I shall show how F# can be used for several machine learning tasks and I will be using industry standard APIs

During this session participants will be solving several machine learning challenges from Kaggle like handwritten digit recognizer (https://www.kaggle.com/c/digit-recognizer)

During this session participants will write code in F# to solve real challenges like this one

https://gist.github.com/sudipto80/72e6e56d07110baf4d4d

and they will get to understand the process of machine learning system design pipeline.

HTTP application programming model on JVM traditionally has been based on the thread per request model. However increasing scale and complexity of applications are forcing the developers to think in new directions. Ratpack is one of such efforts. Ratpack is a collection of libraries glued with Java 8 and makes use of Netty, Guava and Reactive Streams. Ratpack also provides a Groovy DSL, helping developers to use declarative style.

In this demo, I will explore the asynchronous programming model leveraged by Ratpack. Composition, immutability, laziness are the core techniques used in building an application, which in fact are the ideas from functional programming. Though Ratpack has a variety of features, my focus for this presentation is asynchronous, reactive and functional aspects of Ratpack.

This is an introductory level workshop on ClojureScript. Attendees should have working knowledge of Clojure and should bring a laptop with the ability to install and run development software.

ClojureScript is a functional programming for JavaScript. ClojureScript is a compiler for Clojure that emits Javascript. ClojureScript is practical, elegant, and most importantly, fun! In this workshop, we'll go from setting up the ClojureScript platform to building a database-backed website in 3 hours. We'll introduce concepts in Functional Programming and avail of the awesome ClojureScript browser REPL to build a web app. We'll also discover the power of Om, a ClojureScript library that marries the popular React.js framework into ClojureScript.

ClojureScript is a version of the popular functional programming language Clojure that compiles to JavaScript. We will avail of the awesome ClojureScript browser REPL to build a web app. In this workshop we'll cover the following topics to get you up-and-running and on the way to becoming a ClojureScript expert:

1. Installing the ClojureScript platform
2. Setting up the interactive browser REPL
3. Building web apps with ClojureScript
4. Persisting to a database in ClojureScript
5. Fast single page applications using Om

Microservices are the new black, but what are they and why should you use them? This workshop's goal is to demonstrate the advantages of microservice architecture and teach you how to build your first production-ready Erlang microservice! Together we will build a simple distributed key-value store with a RESTful API and go over all aspects of an Erlang project (from build tools to scaling out our microservice).