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, Dhaval and Ryan will take turns at coding the same problem using different languages and paradigms. There would be multiple such rounds during the Jugalbandi.

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

Outline/structure of the Session

During the session, 2 presenters will take turns at coding the same problem using different languages and paradigms.  There would be multiple such rounds during the Jugalbandi.

We would will keep the option open to have more than 2 presenters.

Learning Outcome

Our hope is that via a Code Jugalbandi session:

  • People programming in different paradigms - imperative or functional, can see how each language solves the same thing differently.
  • Promote learning by comparison and contrast - a natural way for human mind to grasp new things.
  • It can also become a source of inspiration to try out a new languages and paradigms.
  • Would give people confidence that being polyglot can be within their reach.

Target Audience

Developers interested in FP paradigm.

schedule Submitted 2 years ago

Comments Subscribe to Comments

comment Comment on this Proposal
  • Pramod Sadalage
    By Pramod Sadalage  ~  2 years ago
    reply Reply

    This would a great way for folks to learn, are you doing to be following certain structure such as.. process a list in language X and Y ..

    • Dhaval Dalal
      By Dhaval Dalal  ~  3 months ago
      reply Reply

      Hi Pramod,

          We plan to take a few problems and solve them in different languages (can cut across paradigms as well).  Each round of problem solving - as Ryan calls them "Melodies" would last for about 10-15 mins, so we should be able to do around 4-5 melodies during the session.

      thanks,

      Dhaval.

  • Naresh Jain
    By Naresh Jain  ~  2 years ago
    reply Reply

    This is a great proposal. I would really love to see more people participate in this. That way we can have more examples from different languages and different paradigms.


  • Liked Ryan Lemmer
    keyboard_arrow_down

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

    Ryan Lemmer
    Ryan Lemmer
    schedule 2 years ago
    Sold Out!
    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.

  • Mushtaq Ahmed
    Mushtaq Ahmed
    schedule 2 years ago
    Sold Out!
    60 mins
    Demonstration
    Intermediate

    Sync, Async, Blocking, Non-Blocking, Streaming are the buzzwords in the reactive programming world. This talk will attempt to attach some meaning to them. It will also demo the performance and resource consumption patterns for blocking-io, Scala Futures and RxJava Observables for comparable programs. Finally, a command line application that consumes twitter streams API will demo what is possible using the new reactive abstractions.

  • Liked Mohit Thatte
    keyboard_arrow_down

    Purely functional data structures demystified

    Mohit Thatte
    Mohit Thatte
    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

    Functional Programming in Java

    Premanand Chandrasekaran
    Premanand Chandrasekaran
    schedule 3 years ago
    Sold Out!
    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 Rahul Goma Phulore
    keyboard_arrow_down

    Object-functional programming: Beautiful unification or a kitchen sink?

    Rahul Goma Phulore
    Rahul Goma Phulore
    schedule 2 years ago
    Sold Out!
    60 mins
    Talk
    Advanced

    Scala began its life as an experiment to “unify” object-oriented programming and functional programming. Martin Odersky believed that the differences between FP and OO are more cultural than technical, and that there was a room for beautifully unify various ideas from the two into one simple core.

    How successful has Scala been in its goals? Is it the like “the grand unified theory of universe” or like the infamous “vegetarian ham”? [1]

    In this talk, we will see just how Scala unifies various ideas – such as type-classes, algebraic data types, first-class modules, functions under one simple core comprising of traits, objects, implicits, and open recursion. We will how this unification unintendedly subsumes many concepts that require seprate features in other languages, such as functional dependencies, type families, GADTs in Haskell. We will see how this has given a rise to a new “implicit calculus”, which could lay a foundation for next generation of generic programming techniques.

    We will see that this unification comes at a certain cost, wherein it leads to some compromises on both sides. However many of these trade-offs are particular to Scala (largely due to the JVM imposed restrictions). The goal of unification is still noble, and we need not throw the baby out with the bathwater.

    [1]: https://twitter.com/bos31337/status/425524860345778176

  • Liked Venkat Subramaniam
    keyboard_arrow_down

    Haskell for Everyday Programmers

    Venkat Subramaniam
    Venkat Subramaniam
    schedule 2 years ago
    Sold Out!
    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

    Applying functional programming principles to large scale data processing

    Kishore Nallan
    Kishore Nallan
    schedule 2 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 Rahul Goma Phulore
    keyboard_arrow_down

    Promise of a better future

    Rahul Goma Phulore
    Rahul Goma Phulore
    schedule 2 years ago
    Sold Out!
    45 mins
    Talk
    Intermediate

    Futures and promises are no strangers to most programmers. They have made their way into major mainstream languages, including but not limited to, Java, C#, JavaScript, and C++.

    This abstraction however is typically dreaded due to the way they’re typically done. Most manifestations lead to the insidious callback hell, and some, like Java’s, are incredulously limited.

    Why can’t we keep our simple, straightforward code, and still have the concurrency benefits of futures and promises?! Turns out we can. Functional programming is here to the rescue! We will see how the seemingly obscure abstractions like monads, delimited continuations allow us to do just that.

    We will also go over some syntactic-transformation based approaches (basically, macros), such as C#’s async-await, and see how it compares with the functional approaches discussed earlier.

  • Anil Wadghule
    Anil Wadghule
    schedule 2 years ago
    Sold Out!
    45 mins
    Talk
    Beginner

    As Object Oriented programmers, we follow SOLID Design Principles for improving OO design of our applications.

    If you take the SOLID principles to their extremes, you arrive at something that makes Functional Programming look quite attractive.

    Objects are merely a poor man's closures. And ultimately Closures are a poor man's objects.

    This talk explains about how applying SOLID Design principles like Single Responsibility Principle (SRP) leads to many small classes. Furthermore, if you rigorously apply the Interface Segregation Principle (ISP), you'll eventually arrive at the ultimate Role Interface: an interface with a single method.

    If you apply the SRP and ISP like that, you're likely to evolve a code base with many fine-grained classes that each have a single method.

    Objects are data with behaviour. Closures are too are data with behaviour.

    This talk will enlighten how applying Object Oriented Design Principles to their extreme will lead you to Functional Programming.

    It's necessary for Object Oriented programmer to understand why Functional programming makes sense.

    At the end, this talk will also cover essential basics of Functional programming needed to be known for every Object Oriented Programmer.

  • Liked Shakthi Kannan
    keyboard_arrow_down

    Lambdaaaaaaaaaa Calculus

    Shakthi Kannan
    Shakthi Kannan
    schedule 3 years ago
    Sold Out!
    60 mins
    Talk
    Beginner

    This talk is an introduction on lambda calculus and will address the foundations of functional programming languages.

    We will learn the building blocks of lambda calculus - syntax, rules, and application.

  • Liked Mushtaq Ahmed
    keyboard_arrow_down

    Typeclasses as objects and implicits

    Mushtaq Ahmed
    Mushtaq Ahmed
    schedule 2 years ago
    Sold Out!
    60 mins
    Tutorial
    Intermediate

    Haskell has populairzed typelcasses a principled way to add ad-hoc extensions on existing data types. They allow you to 1) add new operations on existing data types and 2) support new data types on existing operations, and thus solve the famous "expression problem".

    There is a lot of similarily between typeclasses and Java good practices of programming to interfaces and preferring composition over inheritance. The missing link is the implicit dictionary passing which allows haskell to be much more concise and expressive.

    In this tutorial, we will look at how Scala adopts typeclasses by adding the missing link of implicits.

  • Liked Bodil Stokke
    keyboard_arrow_down

    The Mess We've Made

    Bodil Stokke
    Bodil Stokke
    schedule 2 years ago
    Sold Out!
    60 mins
    Keynote
    Beginner

    In this talk, we'll explore why some technologies end up inexplicably dominating our field while others fade away despite their obvious merits. What will it take for the languages we care about to succeed, and what are the consequences of success? Let's apply a broad perspective to the mess we've made of modern computer science, and explore our options for getting the situation back on track through a careful examination of history, science and ponies.

  • Liked Amit Dev
    keyboard_arrow_down

    A practical introduction to Monads

    Amit Dev
    Amit Dev
    schedule 2 years ago
    Sold Out!
    30 mins
    Demonstration
    Beginner

    Some people find it hard to understand Monads (like pointers in C). But it is actually a simple concept (like pointers in C). In this session we try to understand Monads and why they are useful through examples. It is purely from a practical point of view and no theory is covered.

  • Liked Mushtaq Ahmed
    keyboard_arrow_down

    Functions as objects

    Mushtaq Ahmed
    Mushtaq Ahmed
    schedule 2 years ago
    Sold Out!
    60 mins
    Tutorial
    Beginner

    Objected oriented languages like Scala support the paradigm of programming with functions. How does it work? The language has to conceptually map functions to objects. This tutorial will explain this idea by starting with a simple Java-like code and progressively refactor it to make use of higher order functions. As a result, you will learn about a few syntax sugars and also the cost implication of using objects to represent functions.