schedule Nov 18th 03:00 PM - 03:45 PM place Studio 4 people 11 Attending

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.This time the focus of code jugalbandi will be on solutioning in different paradigms - object-oriented or functional programming and array-oriented paradigms.

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

 
4 favorite thumb_down thumb_up 0 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.

Learning Outcome

Our hope is that via a Code Jugalbandi session:

  • People programming in different paradigms - object-oriented, functional or array oriented, can see how to approach the same problem in each paradigm. This also shapes the thoughts differently. The key take away would be to understand how a particular problem is a natural fit for solutioning in a particular paradigm.
  • 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.

Target Audience

Developers interested in FP paradigm and Array oriented paradigm.

Prerequisite

Open mind and know at least one functional programming language.

schedule Submitted 6 months ago

Comments Subscribe to Comments

comment Comment on this Proposal

  • Liked Aaron W Hsu
    keyboard_arrow_down

    Aaron W Hsu - Design Patterns vs. Anti-pattern in APL

    Aaron W Hsu
    Aaron W Hsu
    Computer Scientist
    Indiana University
    schedule 4 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    APL is a notorious language with a reputation for being "write only" and difficult to learn. Yet, many people consider APL to be their single most productive, advantageous tool that they hope never to give up. In particular, it is generally observed that many computer scientists have a poor opinion of the usability of APL, while many data scientists and domain experts find the language to be exceptionally usable.

    This session focuses on the experienced programmer's struggle to gain real facility with APL beyond the basic, trivial understanding of its semantics and syntax (which can be taught in a few hours). We will observe this struggle through a "human-centered" experience analysis identifying a set of Pattern/Anti-pattern tensions that are at the heart of the intermediate APL learning "wall." By examining the experience of thinking and working with APL code versus regular code, we can identify principles of APL coding practice that directly oppose the widely taught and embraced best practices of the broader programming community. We'll see not only what these principles are, but also why they survive in APL and how they contribute to the positive development cycle of an experienced APL programmer, instead of the negative impact such practices usually have when writing in other languages.

    Understanding these practices will provide a focus point for the discussion of programming experience design and the use of concise array language, as well as provide a structure for becoming better able to write, read, and think in APL expert.

  • Liked Eric Torreborre
    keyboard_arrow_down

    Eric Torreborre - Practical eff monad for micro-services

    Eric Torreborre
    Eric Torreborre
    Senior Software Engineer
    Zalando
    schedule 10 months ago
    Sold Out!
    45 Mins
    Talk
    Advanced

    This talk presents how we use the Eff monad at Zalando to structure a REST microservice. Even when programming with functions, modules and components still matter, and I will present a new approach for dependency injection using the Reader monad (classic) and tree rewriting (what?). Then we will see how to specify more precisely several components (authentication, request to other services and database access) with the Eff monad and support additional concerns like logging or asynchronous execution.

    Once you get the basic idea, the possibilities are endless! Rate limiting is just another component and another set of effects involving time and state, testing becomes really clean and easy.

  • Liked Tony Morris
    keyboard_arrow_down

    Tony Morris - Functional Programming in Aviation

    45 Mins
    Case Study
    Beginner

    In this talk & demo, we have a look at some of the low-hanging problems in general aviation and how functional programming can be applied to provide significant improvements in efficiency and air safety. The current solutions to problems such as navigation, traffic/terrain collision avoidance and weight/balance calculations will be demonstrated to the audience, mostly for amusement. More seriously, we will have a look at the legacy that has led to the way things are, and how to improve by applying our programming skills.

    We will look at:

    • how aviation safety is regulated.
    • how aeronautical services are provided to flight operators.
    • how aeronautical navigation is conducted and regulated.
    • how the weight and balance for a flight is conducted.
    • the methods by which aircraft and ground coordinate between each other.

    We will see:

    • some real (and basic) data management problems in aviation, that very obviously threaten safety, then solve them, using programming.
    • we will see a live demonstration of aeronautical navigation methods, investigate incident reports where lives were lost as a result, and consider how our programming skills can yield improvements, possibly even save lives.
    • we will conduct a real weight&balance calculation for a flight, then once hilarity inevitably ensues, we will look at the problems that arise by this method, then solve them using data structures and functional programming. Some
      of these practical problems are obvious, even to a non-aviator, and the predictable incident reports are the end result.
    • finally, we will have a look at a live demonstration of a software defined radio (SDR), receiving ADS-B transmissions from aircraft (live), an AHRS implementation and GNSS receiver using off-the-shelf, low-cost parts. We will look at why these instruments are helpful to aircraft pilots and interact with that device using the Haskell programming language.
  • Liked Aaron W Hsu
    keyboard_arrow_down

    Aaron W Hsu - Functional Array Funhouse Intensive

    Aaron W Hsu
    Aaron W Hsu
    Computer Scientist
    Indiana University
    schedule 6 months ago
    Sold Out!
    480 Mins
    Workshop
    Intermediate

    How would your make your programs easier to write, inherently parallel, and have high performance across GPUs and CPUs? How about a development methodology that makes agile programming look sluggish and unreliable? How about shrinking the size and complexity of your code base by an order of magnitude, while increasing performance by an order of magnitude? This intensive workshop is designed to demystify the strange and special world of array programming like you may never have seen it before. Iverson-style array programming terrifies some and amazes others, but no one can argue with the results in areas such as finance, energy, education, or medical research. New research has made array programming scalable across a wide array of parallel hardware architectures. Often renowned for remarkably short, concise code that does a tremendous amount, the area of production level, array programming is an often misunderstood area. This workshop will bring you through a whirlwind of array programming concepts by example and case study, opening up the curtains on the original interactive functional programming language in its modern incarnation. You will learn how you can make use of this sometimes mystical world, with an emphasis on the concepts and how to integrate these concepts into a practical, targeted development methodology and ecosystem for maximizing productivity and leveraging the benefits of notational thinking to their full effect. The goal is to let you keep the magic and fun of programming alive while you use that magic for your benefit in the real world.

  • Liked Chaitanya Chalasani
    keyboard_arrow_down

    Chaitanya Chalasani - High Performance Data Mart using Event Plots

    20 Mins
    Demonstration
    Intermediate

    Reporting data for finite state machine transactions like calls require exhaustive data mining into 10s and 100s of parameters for 1000s of calls per hour. These postmortems require heavy processing and can demand millions of maps per reduction. The presentation is a case study and demonstration of near-realtime asynchronous event processing based plotting of events and states of FSMs. Thus creating semi-cooked event plots delivering lightening fast reports with extensive customizability.

  • Liked Emil Soman
    keyboard_arrow_down

    Emil Soman - Turn Hours into Seconds - Concurrent Event Processing

    Emil Soman
    Emil Soman
    Software Consultant
    Codemancers
    schedule 5 months ago
    Sold Out!
    45 Mins
    Case Study
    Intermediate

    For programmers who have been using locks for synchronizing threads to solve all concurrency problems, embracing message passing and creating concurrent data flows is an enlightening experience. This talk is a case study of a real world concurrency problem where the developer started with a slow non-thread-safe solution and refactored it step by step into a fast yet simple concurrent solution making use of Elixir's concurrent computation library called Flow.

  • Liked Aloïs Cochard
    keyboard_arrow_down

    Aloïs Cochard / Tony Morris - Introduction to Functional Programming using Haskell

    Aloïs Cochard
    Aloïs Cochard
    Computer Science Research
    Orexio / Swisscom
    Tony Morris
    Tony Morris
    Senior Functional Programming Engineer
    Data61 / CSIRO
    schedule 5 months ago
    Sold Out!
    480 Mins
    Workshop
    Beginner

    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.

  • Liked Roger Hui
    keyboard_arrow_down

    Roger Hui - Tests, Derivations, Proofs

    Roger Hui
    Roger Hui
    programmer
    Dyalog Ltd.
    schedule 6 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    John Hughes and Mary Sheeran in Why Functional Programming Matters [0] list “algebra as a litmus test” as one of the four salient features of functional programming, and Ken Iverson in Notation as a Tool of Thought [1] lists “amenability to formal proof” as one of the five important characteristics of notation. Using the language APL, we prove the correctness of some programs, derive simplifications, and illustrate design validation and program test techniques for functional programs.

    [0] Hughes, John, and Mary Sheeran, Why Functional Programming Matters, Code Mesh, London, 2015-11-02 to -04.

    [1] Iverson, Kenneth E., Notation as a Tool of Thought, Communications of the ACM, volume 23, number 8, 1980-08.

  • Liked Anil Wadghule
    keyboard_arrow_down

    Anil Wadghule - Building Distributed System with Erlang Ecosystem

    45 Mins
    Demonstration
    Intermediate

    In this talk, we will explore how can we write a distributed system with Elixir/Erlang. We will cover distributed systems basics, how a distributed system is capable of enhanced performance and how it gives us higher availability.

    Then we would start with a demonstration of a distributed system written with Elixir programming language. We will spend most of the talk discussing the demo code.

    We will also cover main advantages of Elixir/Erlang ecosystem to build distributed systems.

    We will explore aspects such a latency, throughput, computing power. We will understand how Elixir is capable for fault tolerance, resilience. We will explore tool set provided by OTP library. What tools from library helps us to write a distributed system.

    But distributed Erlang/Elixir *has known limitations*. For example, issues with when a network is fully meshed, how many numbers of nodes which can scale we get in a cluster, how sending large data over distribution is an issue etc. What are solutions for it?

  • Liked Shri Vignesh Balasubramaniam
    keyboard_arrow_down

    Shri Vignesh Balasubramaniam - Understanding some basic FP constructs by writing a simple Programming Language

    45 Mins
    Demonstration
    Beginner

    What I cannot create, I do not understand - Richard Feynman

    Most of the time, we end up being consumers of a language. Language creation is not something which many of us do as part of our daily job. And as such, we become consumers of using various concepts like types of a language, functions-as-first-class citizens, closures, let expressions, etc. But what are these? What is semantics behind them? And how do language creators enable a language to have these? Once we understand what these mean, we go beyond the language specific implementations and can be true polyglots who can think in terms of these composable abstractions.

    This beginner focussed talk+demonstration hopes to clarify few fundamental concepts by building a language from the ground up. This talk has its foundations in a couple of academic courses which I got to be part of during 2012/2013.

    Using Racket(a variant of Scheme) as a vehicle, a hypothesized programming language (MathL) is introduced with its specifications, syntax, and rules. And slowly this language is built up with more features.The language is realized via an interpreter/executor. [We would not be discussing compilers here].
    Some tests also would be done which would help to verify the language implementation.

     

     

     

  • 20 Mins
    Talk
    Beginner


    A lot of companies still decide to go with Node.js / Java / Ruby / Python for building web apps.

    In this talk, we will focus on, how Elixir ecosystem is ready to replace Node.js / Java / Ruby / Python for most of the web apps

    The aim of this talk is to present why Elixir lang is a good choice for building your next web app.

    We will explore some of the features and tool that Phoenix web framework provides that replaces the need of using Java / Node.js / Ruby / Python for web apps. e.g. Better concurrency model, Ecto for database interaction,  Phoenix channels, Simple APIs, Umbrella apps etc, Speed of development.

    The talk will have a deep comparison of the runtime of Node.js, JVM, Ruby/Python with Elixir runtime. (e.g. http://joearms.github.io/2013/04/02/Red-and-Green-Callbacks.html for comparing Erlang callbacks with JavaScript callbacks, Comparison of JVM with BEAM  http://ds.cs.ut.ee/courses/course-files/To303nis%20Pool%20.pdf etc)

    We will also compare syntaxes of these languages by seeing the code of the same app but with multiple languages.

    This talk will also show how using Elixir also helps us a become better programmer because of features like immutability, functions, pattern matching, first class processes etc, great syntax.

    At the end of the talk, every Java / Node.js / Ruby / Python developer should feel confident about Elixir and talk will motivate them to choose Elixir over Java / Node.js / Ruby / Python for building the next web app.

  • Liked Cameron Price
    keyboard_arrow_down

    Cameron Price - Making it Fast: The Power of Benchmarking

    Cameron Price
    Cameron Price
    CTO
    TRX.tv
    schedule 5 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    There's an old expression, usually attributed to Kent Beck, that we should "Make it work, make it right, make it fast", in that order. This talk is going to focus on making it fast.

    Not long ago, I was working on a little problem in Elixir that involved a two dimensional array. Now, Elixir doesn't really have arrays, it has lists, maps, tuples, and binaries, so the one thing we can be sure about when implementing a 2-d array is that we're going to be simulating it using something else. What I discovered was surprising, and served as an important lesson about actually benchmarking things.

    In this talk, we'll discuss the importance of benchmarking, demonstrate some tools that make benchmarking in Elixir very simple, and show you some surprising results about which approaches are faster in this language.

  • Liked Abhiroop Sarkar
    keyboard_arrow_down

    Abhiroop Sarkar - Wormholes and teleporting with Transient.

    Abhiroop Sarkar
    Abhiroop Sarkar
    Student
    University of Nottingham
    schedule 7 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    The transient library in Haskell/Eta composes arbitrary pieces of software in concurrent, parallel and sequential settings using standard Haskell/Eta combinators like applicative, alternative, bind etc. It provides algebraic and monadically composable primitives for concurrency, parallelism, event handling, transactions and multithreading

    It liberates the programmers from dealing with state machines, objects frameworks, routes, configurations and callbacks. Transient expresses business functionalities as compact category theoretical expressions which compose. These compositions are verified during compilation, although the code might be executing in different machines.

    It presents a fresh new approach to programming concurrent and distributed systems.

     

  • Liked Sandesh Soni
    keyboard_arrow_down

    Sandesh Soni - Putting REST to Rest using GraphQL

    20 Mins
    Talk
    Beginner

    Alternative to APIs - GraphQL by Facebook

    Using GraphQL with Elixir using AbsInThe-GraphQL library

  • Liked Ryan Lemmer
    keyboard_arrow_down

    Ryan Lemmer - Haskell Design Patterns

    Ryan Lemmer
    Ryan Lemmer
    Programmer, code-coach
    Independent consultant, Cape Town
    schedule 7 months ago
    Sold Out!
    480 Mins
    Workshop
    Intermediate

    This is an experiential workshop, we will code together, and explore ideas from first principles. You will need GHC 8.*

    The workshop is pitched at Haskell enthusiasts (you don't have to be hardcore at Haskell, I am not!). We'll be writing code together and apart, reflecting on code and ideas, and getting into and out of trouble.

    Patterns for IO

    Experience the 3 styles of IO programming in Haskell, in the order in which they evolved:

    * imperative style (the status quo)
    * Lazy IO and its limitations
    * Iteratee IO, the solution to Lazy IO

    As we compare the different styles, we will pay attention to

    * what controls evaluation
    * space and resource management
    * the relationship between producer and consumer

    From Foldable, Traversable to Lenses

    We follow the evolution of fold and map on lists, to their generalisation over arbitrary types with the Foldable and Traversable type-classes.

    The Lens library raises Foldable and Traversable to an even higher level of abstraction. We will see how the Lens library gives a unified vocabulary for traversal of arbitrary data structures.

    Functor, Applicative, Arrow, Monad

    These data types fall on a spectrum of power and generality (Functor being the most general, and Monad the most powerful). By experiencing how these types differ in the way they compose, we can gain a clearer understanding of where and how each type may be used.

    Dependent Haskell / Type-level programming 101 (bonus material)

    In modern Haskell, the line between types and functions have blurred, types have become as powerful and expressive as functions. Since we can write functions on type-level, we can do whatever we like with types! Almost.

    Let's write some type-level code, and see why Dependently Typed Programming matters.

    Datatype Generic Programming (bonus material)

    This style of Haskell programming is based on a simple technique: instead of defining functions for ad-hoc types, we deconstruct our types into a more fundamental type representation, and then write generic functions against the lower-level type. These generic functions are impervious to changes in the original, higher-level data types.

    We will experience datatype generic programming from first principles, and along the way uncover the key ingredient in the magic sauce called GHC.Generics.

  • Liked Sandesh Soni
    keyboard_arrow_down

    Sandesh Soni - Elixir on Ruby

    20 Mins
    Talk
    Beginner

    For ruby and rails users who want to understand and learn elixir

    give a basic understanding
    Topic is not why Elixir? Its how Elixir.


    mix tooling, Ecto, tests
    Popular Elixir Library Alternates for Ruby libraries(Authentication, etc)

    This does not cover OTP framework.