Functional Programming with Javascript

The workshop introduces concepts of functional programming using the ever popular Javascript programming language. It’s an ideal start for programmers who are in the process of transitioning into the Functional Programming world.

The ideas presented in this course will provide programmers with the necessary background knowledge to learn any pure functional language such as Scala, Haskell or Erlang – which otherwise require a steep learning curve.

Prerequisites –

1. Proficiency in any one programming language(.js )
   2. Worked in live projects for 3 years or more.

Why Functional Programming with .js

Functional programming has become a really hot topic in the JavaScript world. Just a few years ago, few JavaScript programmers even knew what functional programming is, but every large application codebase I’ve seen in the past 3 years makes heavy use of functional programming ideas.

• Pure functions instead of shared state & side effects
• Immutability over mutable data
• Function composition over imperative flow control
• Lots of generic, reusable utilities that use higher order functions to act on many data types instead of methods that only operate on their colocated data
• Declarative rather than imperative code (what to do, rather than how to do it)
• Expressions over statements
• Containers & higher order functions over ad-hoc polymorphism

ABOUT THE FACILITATOR

Anand has held senior level (including executive and board level) positions in various technology companies. He is currently a General Partner in a boutique software services company, Codewalla. He is also an Executive Partner in Revel Advisory Services LLP, which provides strategic services to start-up tech companies.

Anand is the author of the series of books on functional programming- “The Magical World of Functional Programming”, which has sold over 3,000 copies on Amazon.

• Forget whatever you think you know about JavaScript, and approach this material with a beginner’s mind. To help you do that, we’re going to review the JavaScript basics from the ground up, as if you’ve never seen JavaScript before. If you’re a beginner, you’re in luck. Finally something exploring ES6 and functional programming from scratch! Hopefully all the new concepts are explained along the way — but don’t count on too much pampering.
• If you’re a seasoned developer already familiar with JavaScript, or a pure functional language, maybe you’re thinking that JavaScript is a funny choice for an exploration of functional programming. Set those thoughts aside, and try to approach the material with an open mind. You may find that there is another level to JavaScript programming. One you never knew existed.

JavaScript has the most important features needed for functional programming:

1. First class functions:The ability to use functions as data values: pass functions as arguments, return functions, and assign functions to variables and object properties. This property allows for higher order functions, which enable partial application, currying, and composition.
2. Anonymous functions and concise lambda syntax:x => x * 2 is a valid function expression in JavaScript. Concise lambdas make it easier to work with higher-order functions.
3. Closures:A closure is the bundling of a function with its lexical environment. Closures are created at function creation time. When a function is defined inside another function, it has access to the variable bindings in the outer function, even after the outer function exits. Closures are how partial applications get their fixed arguments. A fixed argument is an argument bound in the closure scope of a returned function. In add2(1)(2), 1 is a fixed argument in the function returned by add2(1).

“Why JavaScript?” Because JavaScript is the language that most real companies are using to build real software. Love it or hate it, JavaScript has stolen the title of “most popular functional programming language” from Lisp, which was the standard bearer for decades. True, Haskell is a much more suitable standard bearer for functional programming concepts today, but people just aren’t building as many real applications in Haskell.

As programs get bigger, they also become more complex and harder to understand. We all think ourselves pretty clever, of course, but we are mere human beings, and even a moderate amount of chaos tends to baffle us. And then it all goes downhill. Working on something you do not really understand is a bit like cutting random wires on those time-activated bombs they always have in movies. If you are lucky, you might get the right one ― especially if you are the hero of the movie and strike a suitably dramatic pose ― but there is always the possibility of blowing everything up.

Admittedly, in most cases, breaking a program does not cause any large explosions. But when a program, by someone's ignorant tinkering, has degenerated into a ramshackle mass of errors, reshaping it into something sensible is a terrible labour ― sometimes you might just as well start over.

Thus, the programmer is always looking for ways to keep the complexity of his programs as low as possible. An important way to do this is to try and make code more abstract. When writing a program, it is easy to get sidetracked into small details at every point. You come across some little issue, and you deal with it, and then proceed to the next little problem, and so on. This makes the code read like a grandmother's tale.