• Mushtaq Ahmed
    Mushtaq Ahmed
    schedule 1 year ago
    Sold Out!
    90 mins
    Demonstration
    Intermediate

    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.

  • Liked Morten Kromberg
    keyboard_arrow_down

    Array Oriented Functional Programming with Dyalog

    Morten Kromberg
    Morten Kromberg
    Jay Foad
    Jay Foad
    schedule 2 years ago
    Sold Out!
    480 mins
    Workshop
    Beginner

    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.

  • Liked Morten Kromberg
    keyboard_arrow_down

    Parallel Programming in Dyalog using Futures and Isolates

    Morten Kromberg
    Morten Kromberg
    schedule 2 years ago
    Sold Out!
    45 mins
    Keynote
    Beginner

    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.

  • Naresh Jain
    Naresh Jain
    Dhaval Dalal
    Dhaval Dalal
    schedule 1 year ago
    Sold Out!
    90 mins
    Event
    Beginner

    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.

  • Liked Brian Lee Troutwine
    keyboard_arrow_down

    Fault-Tolerance on the Cheap: Making Systems That (Probably) Won't Fall Over

    Brian Lee Troutwine
    Brian Lee Troutwine
    schedule 2 years ago
    Sold Out!
    45 mins
    Talk
    Intermediate

    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. 

  • Naresh Jain
    Naresh Jain
    schedule 1 year ago
    Sold Out!
    120 mins
    Demonstration
    Intermediate

    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.

  • Dhaval Dalal
    Dhaval Dalal
    schedule 1 year ago
    Sold Out!
    45 mins
    Demonstration
    Beginner

    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.

  • Liked Rudraksh MK
    keyboard_arrow_down

    A(n) (un)comfortable introduction to Hy

    Rudraksh MK
    Rudraksh MK
    schedule 1 year ago
    Sold Out!
    45 mins
    Talk
    Intermediate

    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.

  • Liked Brian Lee Troutwine
    keyboard_arrow_down

    Instrumentation and Monitoring for Functional Architectures

    Brian Lee Troutwine
    Brian Lee Troutwine
    schedule 1 year ago
    Sold Out!
    480 mins
    Workshop
    Advanced

    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. 

  • Tanmai Gopal
    Tanmai Gopal
    schedule 2 years ago
    Sold Out!
    45 mins
    Experience Report
    Intermediate

    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.

  • Liked Shantanu Kumar
    keyboard_arrow_down

    Production Clojure: An Experience Report

    Shantanu Kumar
    Shantanu Kumar
    schedule 2 years ago
    Sold Out!
    45 mins
    Experience Report
    Intermediate

    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.

  • Liked Yeshwanth
    keyboard_arrow_down

    Building a REST API with Scalaz

    Yeshwanth
    Yeshwanth
    schedule 1 year ago
    Sold Out!
    45 mins
    Experience Report
    Beginner

    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.

  • Liked Abhinav Sarkar
    keyboard_arrow_down

    Introduction to Concurrency in Haskell

    Abhinav Sarkar
    Abhinav Sarkar
    schedule 1 year ago
    Sold Out!
    45 mins
    Demonstration
    Intermediate

    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.

     

  • Sudipta Mukherjee
    Sudipta Mukherjee
    schedule 2 years ago
    Sold Out!
    90 mins
    Demonstration
    Intermediate

    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.

  • Liked Naresha K
    keyboard_arrow_down

    Rethinking HTTP Apps on JVM with Ratpack

    Naresha K
    Naresha K
    schedule 1 year ago
    Sold Out!
    45 mins
    Demonstration
    Intermediate

    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.

  • Pratik Patel
    Pratik Patel
    schedule 1 year ago
    Sold Out!
    240 mins
    Workshop
    Intermediate

    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
  • Liked Nilanjan Raychaudhuri
    keyboard_arrow_down

    You say big data, I say Fast data

    Nilanjan Raychaudhuri
    Nilanjan Raychaudhuri
    schedule 1 year ago
    Sold Out!
    45 mins
    Talk
    Beginner
    Nowadays most of the "Big Data" problems are dealing with speed not size. Folks want "Fast Data". Speed is the problem to solve, not size. Most organizations today actually face smaller big data problems that they are trying to address through in-memory cached real-time processing of data. In this presentation we will explore architectures used for solving "Fast Data" problems. 
     
    We will be using Spark Streaming and Scala for code examples.

     

  • Liked Louis-Philippe Gauthier
    keyboard_arrow_down

    Building an Erlang microservice from A to Z

    Louis-Philippe Gauthier
    Louis-Philippe Gauthier
    schedule 1 year ago
    Sold Out!
    480 mins
    Workshop
    Beginner

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

  • Liked Louis-Philippe Gauthier
    keyboard_arrow_down

    Building high-performance Erlang clients using Shackle

    Louis-Philippe Gauthier
    Louis-Philippe Gauthier
    schedule 2 years ago
    Sold Out!
    45 mins
    Talk
    Intermediate

    Building performant network (TCP, UDP) clients can be tricky, especially at high concurrency. By giving you a framework for building asynchronous clients, Shackle solves most of this problem for you. Shackle is the result of multiple years of writing Erlang clients for our real-time bidding platform (RTB), AdGear Trader.

  • Liked Bernard Duggan
    keyboard_arrow_down

    Achieving High Uptime with Erlang's OTP

    Bernard Duggan
    Bernard Duggan
    schedule 2 years ago
    Sold Out!
    90 mins
    Tutorial
    Intermediate

    Few technical metrics are more closely watched in the world of online service delivery than a system's “uptime”. Response speed, number of concurrent users and data throughput are all forgotten about very quickly when users can't even get onto your system.

    The Erlang language was designed with fault tolerance as a core principle. Fault tolerance describes the ability of a system to keep running in the event of some kind of unexpected problem, without external assistance (in other words, without waking up your sysadmins) and with minimal impact to users. Consider a single monolithic C++ program, handling 10,000 concurrent users all with persistent TCP connections. If one user does something unusual and hits a poorly tested code path, causing a segfault, then 10,000 people see their connection drop. That's (obviously) not fault tolerant. If just that one user's connection dies and everyone else's carries on, that's fault tolerance (and also far preferable!).

    While Erlang's basic features give a degree of fault tolerance, they're not a silver bullet. The share-nothing memory model and ability to separate your system into thousands of isolated threads are extremely useful when building robust systems, but they're a foundation rather than the whole solution.

    The other killer for uptime is rolling out upgrades and fixes. Without some clever infrastructure, sooner or later your customers will see “We're down for scheduled maintenance – come back in 30 minutes”. One solution to this is “hot upgrades” whereby code can be upgraded on the fly with literally no downtime or interruption to ongoing services.

    This tutorial covers Erlang's Open Telephony Platform (which has almost nothing to do with telephony per se) and how it delivers on Erlang's promise of robust, fault tolerant, hot-upgradable software.