Accepted (22)
Active (6)
Mushtaq Ahmed
Mushtaq Ahmed
Demystify the Reactive Jargons
Mushtaq Ahmed
Mushtaq Ahmed

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.

Duration: 60 mins
Level: Intermediate
»
deep-dive  
×
»
60_mins  
×
demonstration  
×
intermediate  
×

concurrency  
×
scala  
×
non-blocking  
×
async  
×
streams  
×
rxjava  
×
3 weeks ago by Mushtaq Ahmed

Mohit Thatte
Mohit Thatte
Purely functional data structures demystified
Mohit Thatte
Mohit Thatte

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 

Duration: 45 mins
Type:  Talk
Level: Beginner
»
deep-dive  
×
»
45_mins  
×
talk  
×
beginner  
×

1 month ago by Mohit Thatte

Shashi Gowda
Shashi Gowda
Functional Reactive UIs with Elm
Shashi Gowda
Shashi Gowda

Elm is a strongly typed functional reactive programming (FRP) language that compiles to HTML, CSS, and Javascript. In Elm, the Signal type represents a time-varying value--things like mouse position, keys pressed, current time are signals. With Signals, one can write terse code that is isomorphic to a dataflow diagram of the app. The code hence feels natural and is 100% callback free. All this, with powerful type inference.

This talk is an introduction to FRP. It explores functionally composing graphics and UIs, and creating interactions and animations with the Signal type. There will also be an overview of Elm’s execution mechanism and the time traveling debugger: a consequence of Elm's purely functional approach.

While instructive, it will be good fun too, in the spirit of Elm.

Duration: 90 mins
Type:  Tutorial
Level: Beginner
» »
90_mins  
×
tutorial  
×
beginner  
×

javascript  
×
web  
×
interaction  
×
ui  
×
html  
×
elm  
×
animation  
×
type-system  
×
1 month ago by Shashi Gowda

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

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

Duration: 60 mins
Type:  Talk
Level: Advanced
»
deep-dive  
×
»
60_mins  
×
talk  
×
advanced  
×

scala  
×
haskell  
×
unification  
×
oop  
×
2 weeks ago by Rahul Goma Phulore

Bhasker Kode
Bhasker Kode
Writing and improving tail recursive functions
Bhasker Kode
Bhasker Kode

What is tail recursion?

Snippets from a few languages

Design choices around recursion

What kind of functions can be made tail-recursive? 

How do you profile such improvements?

 

 

Duration: 45 mins
Type:  Talk
Level: Beginner
» »
45_mins  
×
talk  
×
beginner  
×

recursion  
×
profiling  
×
1 month ago by Bhasker Kode

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

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.

 

Duration: 45 mins
Level: Beginner
» »
45_mins  
×
beginner  
×

haskell  
×
gofer  
×
teach  
×
1 month ago by Aditya Godbole

Ramakrishnan Muthukrishnan
Ramakrishnan Muthukrishnan
An introduction to Continuation Passing Style (CPS)
Ramakrishnan Muthukrishnan
Ramakrishnan Muthukrishnan

Traditionally functions return some value. Someone is waiting for that value and does some computation with it. This "someone" is called the continuation of this value. In a normal functional call, the continuation is "implicit". In the "continuation passing style" (hence forth called with the short form, CPS), we make the continuations explicit. In this style, function definitions take an extra argument called "continuation" and it never return. The "return value" of the function 'continues' by passing this value as an argument to the continuation. Continuations are sometimes called "gotos with arguments".

CPS is used as an intermediate stage while compiling a program since it makes the control structure of the program explicit and hence can be converted easily to machine code. Another feature of a CPS-transformed function is that it is tail-recursive even if the original function was not written in a tail-recursive style.

Continuations enable a programmer to build new control operators (if the language's built-in operators does not already provide the control operators the programmer need).

Duration: 60 mins
Type:  Tutorial
Level: Intermediate
»
deep-dive  
×
»
60_mins  
×
tutorial  
×
intermediate  
×

continuations  
×
scheme  
×
racket  
×
cps  
×

Vagmi Mudumbai
Vagmi Mudumbai
Clojurescript and Om - Pragmatic functional programming in the Javascript Land
Vagmi Mudumbai
Vagmi Mudumbai

Javascript programmers have had a lot of choices when it comes to programming. There were days of mootools, scriptaculous and jQuery and then there are now days of Angular, Ember, Knockout and the like. As a javascript programmer myself, I find that Clojurescript/React as Om offers a fresh perspective into building performant Javascript UIs that are easy to write.

The talk will introduced concepts of React, immutable datastructures in Clojure and live code an application that demonstrates the concepts.

 

Duration: 60 mins
Level: Beginner
1 month ago by Vagmi Mudumbai

Venkat Subramaniam
Venkat Subramaniam
Haskell for Everyday Programmers
Venkat Subramaniam
Venkat Subramaniam

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.

Duration: 90 mins
Type:  Talk
Level: Intermediate
» »
90_mins  
×
talk  
×
intermediate  
×

functional  
×
lazy  
×
static-typing  
×
haskell  
×
3 weeks ago by Venkat Subramaniam

Debasish Ghosh
Debasish Ghosh
Property based testing for functional domain models
Debasish Ghosh
Debasish Ghosh

Manual testing is something that's error prone, incomplete and impossible to replicate on a large scale. We have instead been using xUnit style of testing for quite some time now. This approach has a number of drawbacks like (a) We need to write test cases by hand which again doesn't scale for large systems (b) We may miss out some of the edge cases (c) Safeguarding missing cases with coverage metrics doesn't help, since metrics are mostly based on heuristics (d) maintaining test cases and test data is a real pain.

In property based testing we write properties and not low level test cases. And let the system generate test cases which validate such properties. There are 2 main advantages with this approach:

  1. You think in terms of properties (or specifications) of the domain model which is the right granularity to think about
  2. You don't need to manage test cases, which is completely done by the system that generates a large collection of test data

This approach is ideal for the functional programming paradigm, which focuses on pure functions. Using functional programming it's easier to reason about your model - hence it's easier to test functional programs using properties. In this talk I will take some real world examples of property validation and verification using scalacheck (the property based testing library for Scala) and a real world domain model.

Duration: 45 mins
Type:  Talk
Level: Intermediate
» »
45_mins  
×
talk  
×
intermediate  
×

3 weeks ago by Debasish Ghosh

Abhijit Pratap Singh
Abhijit Pratap Singh
Designing concurrent applications in Haskell and Erlang
Abhijit Pratap Singh
Abhijit Pratap Singh

Functional languages are in the news for many good reasons. One of them is the method in which they solve the traditional problems relating to concurrency and parallelism while keeping the troubles of shared state at bay.

This talk is to explore the paradigms of concurrency in these languages and realize the advantages of such paradigms over the traditional ones. Its pretty much evident in the recent past how simple apps have scaled massively without any hiccups using Erlang, Haskell and other functional languages and this talk will also show a demo of a scalable cache written in both Erlang and Haskell and simulating them for their performance and integrity.

 

Duration: 45 mins
Type:  Case Study
Level: Beginner
» »
45_mins  
×
case-study  
×
beginner  
×

erlang  
×
haskell  
×
concurrency  
×
1 day ago by Abhijit Pratap Singh

Akash Manohar
Akash Manohar
Elixir Today: a round-up on state of Elixir and it's ecosystem
Akash Manohar
Akash Manohar

Elixir is a functional and dynamic language built on top of the Erlang VM. The development of the language is happening at a fast pace. People in the community have participated actively to write tools and libraries, required to write real-world apps in Eilxir.

In this talk, I will attempt to skim through all the new features in Elixir, a few important libraries with short examples and some learning resources.

Each tool showcased in this talk, will have a 3-step tryout, with the simplest example.

Duration: 60 mins
Type:  Talk
Level: Beginner
» »
60_mins  
×
talk  
×
beginner  
×

elixir  
×
4 days ago by Akash Manohar

Tejas Dinkar
Tejas Dinkar
Monads you already use (without knowing it)
Tejas Dinkar
Tejas Dinkar

Monads are a little bit like Quantum Physics: If you think you understand quantum mechanics, you don't understand quantum mechanics.

Monads are very useful for chaining computation together, in a simple way. The best explanation I've heard for them so far is that they are `programmable semicolons'.

In this session, I'll describe a few patterns that are solved by monads in some FP languages, and how you are already using them.

Some monads I plan to cover:

* Maybe Monad (being the easiest to explain)

* List monad, and how it is used to model non-determinism

* The state monad

* The IO monad

And maybe a few others

Duration: 20 mins
Type:  Talk
Level: Beginner
» »
20_mins  
×
talk  
×
beginner  
×

monads  
×
1 week ago by Tejas Dinkar

Andy Marks
Andy Marks
Adopting Functional Programming for the win!
Andy Marks
Andy Marks

For some years, there has been a quiet renaissance in a form of software development once relegated to niche fields of academia and computer science: functional programming. Functional languages like Scala and Clojure are attracting significant attention from developers, and aspects of functional programming are creeping into established development languages/platforms like Java and .Net.

But what is the catalyst for this renaissance? The increasing scale and sophistication required of custom software development has led people to reprioritise the benefits of functional languages (e.g., immutability, expressiveness) as a way of increasing code quality, boosting development productivity and reducing complexity.

This presentation is aimed at those unfamiliar with functional programming and will describe the reasons for it’s recent resurgence and why many IT organisations should be considering trialling functional programming alongside their existing development languages.

Duration: 45 mins
Type:  Talk
Level: Beginner
» »
45_mins  
×
talk  
×
beginner  
×

13 hours ago by Andy Marks

Amit Dev
Amit Dev
A practical introduction to Monads
Amit Dev
Amit Dev

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.

Duration: 30 mins
Level: Beginner
» »
30_mins  
×
demonstration  
×
beginner  
×

monads  
×
3 weeks ago by Amit Dev

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

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.

 

Duration: 45 mins
Level: Beginner
» »
45_mins  
×
beginner  
×

haskell  
×
gofer  
×
teach  
×
1 month ago by Aditya Godbole