schedule Oct 9th 09:00 AM - Jan 1st 12:00 AM place Grand Ball Room

It's been around for a long time, but everyone's talking about it all of a sudden. But why and why now? We've been

programming in languages like Java for a while, quite well. Now we're asked to change and the languages themselves

are changing towards this style of programming. In this keynote, a passionate polyglot programmer and author of

"Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions" will share the reasons

we need to make the paradigm shift and the pure joy—the benefits—we will reap from it.

 
3 favorite thumb_down thumb_up 0 comments visibility_off  Remove from Watchlist visibility  Add to Watchlist
 

Outline/structure of the Session

The keynote takes about 70 to 75 minutes in duration. Involves a good balance of convincing to depart from the mainstream and showing how to.

Learning Outcome

Learn the benefits of functional programming

Motivated to make the paradigm shift

Reap the benefits of immutability, function purity, and lazy evaluations.

Target Audience

Developers, architects, managers

schedule Submitted 3 years ago

Comments Subscribe to Comments

comment Comment on this Proposal

  • Liked Thomas Gazagnaire
    keyboard_arrow_down

    Thomas Gazagnaire - Compile your own cloud with Mirage OS v2.0

    60 mins
    Talk
    Intermediate

    Most applications running in the cloud are not optimized to do so. They make assumptions about the underlying operating system, resulting in larger footprints with increased costs and risks.  The open source Mirage OS represents a new approach where the application code is combined with the specific components of the operating system it needs into a single-purpose unikernel appliance. With Mirage OS, developers can create lean and efficient unikernels for secure, cost-effective and high-performance network applications. Mirage OS unikernels run directly on the Xen Project hypervisor, which allows them to be quickly deployed to many leading cloud platforms.

    Mirage OS is fully written in OCaml, from the device drivers and network stack to higher-level synchronisation protocols and databases. In this presentation I will explain how we developed Mirage OS and why we choose to do so in a strongly typed functional language with a powerful module langage. I will then present some of the new features of Mirage OS v2.0 such as: support for ARM devices, Irmin: a Git-like distributed database and OCaml-TLS: a comprehensive implementation of the TLS protocol in pure OCaml. 

  • Liked Morten Kromberg
    keyboard_arrow_down

    Morten Kromberg - Pragmatic Functional Programming using Dyalog

    Morten Kromberg
    Morten Kromberg
    CXO
    Dyalog
    schedule 3 years ago
    Sold Out!
    60 mins
    Demonstration
    Beginner

    APL is a member of the family of languages that are approaching middle age (Ken Iverson’s book titled “A Programming Language” was published in 1962). APL was very influential in the 60’s and 70’s, and widely used to deliver “end user computing” - but although the REPL, dynamic scope and lack of a type system endeared APL to domain experts, it also drew fire from computer scientists, most famously when Edsger Dijkstra declared that “APL is a mistake, carried through to perfection. It is the language of the future for the programming techniques of the past it creates a new generation of coding bums.”

    Dyalog is a modern, array-first, multi-paradigm programming language, which supports functional, object-oriented and imperative programming based on an APL language kernel. Dyalog allows people with good ideas – from bright high school students to PhDs – to contribute directly to the software development process using a notation which fits comfortably with those used in their own domains. Subject matter experts can write prototypes or, with suitable training and/or support, highly efficient, parallel and robust code that can be embedded in high-performance production applications.

  • Liked Ryan Lemmer
    keyboard_arrow_down

    Ryan Lemmer - Realtime Distributed computing: dealing with Time and Failure in the wild

    45 mins
    Experience Report
    Intermediate

    There is a growing need for scalable, realtime business systems that are continuously running and highly-available. Two very different frameworks/approaches you could use to build such systems are Storm and Akka.

    Systems created with Storm or Akka are distributed, at runtime, on as many machines as you choose. The inherent concurrency implied by this brings the issues of State, Time and Failure into sharp focus. Functional programming has much to say about dealing with state and time; not surprisingly, both Storm and Akka have strong roots in functional languages (for Storm it is Clojure, and for Akka, Scala).

    In this talk we'll explore the core concepts and challenges of distributed computation; the role of functional programming in concurrent distributed computing; we'll take a look at Storm and Akka, by example, and see that as different as these 2 approaches are, the underlying difficulties of distributed computation remains evident in both: dealing with time, and dealing with failure.

  • Liked Mohit Thatte
    keyboard_arrow_down

    Mohit Thatte - Purely functional data structures demystified

    Mohit Thatte
    Mohit Thatte
    Programmer
    Helpshift Inc.
    schedule 3 years ago
    Sold Out!
    45 mins
    Talk
    Beginner

    Immutable, persistent data structures form a big part of the value proposition of most functional programming languages.

    It is important to understand why these data structures are useful and how they make it easier to reason about your program. 

    It is also instructive to see how these data structures are implemented to get a greater appreciation for the inherent tradeoffs between performance and immutability.

    In this talk I will do a walkthrough of some of these data structures drawing from the work of Chris Okasaki[1], and attempt to explain the essential ideas in a simple way. 


    [1] Purely Functional Data Structures, Chris Okasaki, School of Computer Science, Carnegie Mellon University 

  • Liked Premanand Chandrasekaran
    keyboard_arrow_down

    Premanand Chandrasekaran - Functional Programming in Java

    60 mins
    Workshop
    Beginner

    Functional programming has started (re)gaining prominence in recent years, and with good reason too. Functional programs lend an elegant solution to the concurrency problem, result in more modular systems, are more concise and are easier to test. While modern languages like Scala and Clojure have embraced the functional style whole-heartedly, Java has lagged a bit behind in its treatment of functions as first-class citizens. With the advent of Java 8 and its support for lambdas, however, Java programmers can finally start reaping the power of functional programs as well. Even without Java 8, it is possible to adopt a functional style with the aid of excellent libraries such as Guava.

    This talk will explore how to apply functional concepts using the Java programming language and demonstrate how it can result in simpler, more elegant designs. We will conduct this in a hands-on workshop style with attendants being encouraged to code-along. So bring your favorite Java 8 aware IDE, an open mind and prepare to have a lot of fun.

  • Liked Venkat Subramaniam
    keyboard_arrow_down

    Venkat Subramaniam - Haskell for Everyday Programmers

    90 mins
    Talk
    Intermediate

    I learn different languages not to make use of them, but to program in my current languages in a better way. As we adapt functional style of programming in mainstream languages, like Java, C#, and C++, we can learn a great deal from a language that is touted as a purely functional language.

    Haskell is statically typed, but not in a way like Java, C#, or C++. Its static typing does not get in the way of productivity. Haskell quietly does lazy evaluation and enforces functional purity for greater good. Everyday programmers, like your humble speaker, who predominantly code in mainstream languages, can greatly benefit from learning the idioms and style of this elegant language. The next time we sit down to crank out some code in just about any language, we can make use of some of those styles, within the confines of the languages, and move towards a better, functional style.

  • Liked Kishore Nallan
    keyboard_arrow_down

    Kishore Nallan - Applying functional programming principles to large scale data processing

    Kishore Nallan
    Kishore Nallan
    Software Engineer
    Indix
    schedule 3 years ago
    Sold Out!
    45 mins
    Talk
    Intermediate
    At Indix, we deal with a stream of unstructured and constantly changing data. This data is processed through a series of systems before being fed as structured input to our analytics system. In this talk, I will walk through our experience of building a large scale data processing system using Hadoop that's focused on immutability, composition and other functional programming principles.
  • Liked Aditya Godbole
    keyboard_arrow_down

    Aditya Godbole - Learning (from) Haskell - An experience report

    Aditya Godbole
    Aditya Godbole
    CTO
    Vertis Microsystems
    schedule 3 years ago
    Sold Out!
    45 mins
    Experience Report
    Beginner

    Functional programming as a programming style and discipline is useful even in languages which are not pure functional languages. By practising programming in a pure functional language like Haskell, programmers can drastically improve the quality of code when coding in other languages as well.

    The talk is based on first hand experience of using Haskell in internal courses in our organisation to improve code quality.

    This talk will cover Gofer (one of the earliest variants of Haskell) as a teaching tool, including the choice of the language, the features from Haskell that should (and shouldn't) be covered and the obstacles and benefits of the exercise.

     

  • Liked Venkat Subramaniam
    keyboard_arrow_down

    Venkat Subramaniam - Transforming your C# code to Functional Style

    45 mins
    Talk
    Intermediate

    Since the introduction of lambda expressions in C#, we have had two different style of programming. Yet, programmers used to the habitual style often find it easy to fall back on those old practices. In this presentation we will take a number of common tasks we code in C#, discuss the downsides of the habitual style, transform it into functional style, and discuss the benefits. We will also discuss some techniques that can help make this transformation easier on everyday projects.

  • Liked Venkat Subramaniam
    keyboard_arrow_down

    Venkat Subramaniam - Designing with Lambda Expressions in Java

    90 mins
    Talk
    Intermediate

    As Java programmers we have used a number of design patterns and design techniques. With the introduction of lambda expressions, we now have some more sharper tools in our design toolbox. Come to this presentation to learn how we can implement some elegant design ideas with lambda expressions. We will learn about these design techniques, not using diagrams, but by realizing the ideas in code.

  • Liked Venkat Subramaniam
    keyboard_arrow_down

    Venkat Subramaniam - Programming with Lambda Expressions in Java

    90 mins
    Talk
    Intermediate

    Now that Java is supporting lambda expressions, it's time to hone our skills to make use of them. Lambda expressions can help create concise code, however, it takes more than learning the syntax to put them to good use. In this presentation we will learn the idiomatic use of lambda expressions, explore the ways in which we can use them to solve common tasks, and look into libraries and APIs that make use of them in Java.