:::: MENU ::::
Browsing posts in: Functional Programming

Functional programming in Javascript and F#

During June 2011 I presented a session at the SPA2011 conference in London, UK.

My session was a hands on introduction to functional programming techniques with code samples in Javascript and F#. The focus on the session was to get peopling thinking about first class functions; and the techniques they enable to simplify and increase readability of code when solving certain classes of problems.

The code samples can be found at:

An online/executable version of the Javascript code is at http://functional-javascript.davidlaing.com.

Judging by the feedback I received, the session went very well. People seemed to like the hands-on format of the session; and just being left alone for a while to learn something at their own pace.


Implementing the strategy pattern without an explosion of classes – part 3 of ??

I feel uncomfortable when I see large switch statements. I appreciate how they break the Open Closed Principle. I have enough experience to know that they seem to attract extra conditions & additional logic during maintenance, and quickly become bug hotspots.

A refactoring I use frequently to deal with this is Replace Conditional with Polymorphism; but for simple switches, its always seemed like a rather large hammer.

Take the following simple example that performs slightly different processing logic based on the credit card type:

Its highly likely that the number of credit card types will increase; and that the complexity of processing logic for each will also increase over time. The traditional application of the Replace Conditional with Polymorphism refactoring gives the following:

This explosion of classes containing almost zero logic has always bothered me as quite a lot of boilerplate overhead for a relatively small reduction in complexity.

Consider however, the functional approach to the same refactoring:

Here we have obtained the same simplification of the switch statement; but avoided the explosion of simple classes. Whilst strictly speaking we are still violating the Open Closed Principle; we do have a collection of simple methods that are easy to comprehend and test. It’s worth noting that when our logic becomes very complex; converting to the OO Strategy pattern becomes a more compelling option. Consider the case when we include a collection of validation logic for each credit card:

In this case the whole file starts to feel too complex to me; and having the logic partitioned into separate strategy classes / files seems more maintainable to me.

To conclude then, the fact that languages treat functions as first class constructs, gives us the flexibility to use them in a “polymorphic” way; where our “interface” is the function signature.

And for some problems, like a refactoring a simple switch statement; I feel this gives us a more elegant solution.


Higher order functions – simplifying loops – part 2 of ??

This is the 2nd part of my series on everyday functional programming.

Filtering

Suppose you have a collection of items and need to grab just a subset that match a certain criteria. Programming C# in an imperative style, you could use a for or foreach loop as follows:

Functional programming recognises this common scenario as a higher order function known as a Filter [3]; where you want to create a new list for every element that evaluates to true when a predicate function is applied to it.

In C#, filter is implemented as the LINQ Where(Func)) extension method, allowing one to write the following:

Apart from the obvious reduction in number of lines; notice how much clearer the intent of the filter is, and the many opportunities for error we have eliminated.

In Javascript we use the filter function:

Mapping

In many instances you find yourself wanting to perform the same operation on every item in an existing collection. In Javascript in an imperative style we might want to do the following

In functional programming this is know as the higher order function: Map [4] and in Javascript can be applied using a single statement map()

In C#, map is implemented by the LINQ Select(Func) extension method:

[1] – http://railspikes.com/2008/7/29/functional-loops-in-ruby-each-map-inject-select-and-for
[2] – http://msdn.microsoft.com/en-us/library/system.linq.enumerable.aspx
[3] – http://en.wikipedia.org/wiki/Filter_(higher-order_function)
[4] – http://en.wikipedia.org/wiki/Map_(higher-order_function)


Everyday functional programming – part 1 of ??

This is the first of a series of blog posts where I will be exploring how functional programming techniques are useful in the daily life of a working “enterprise software” developer.

If you, like me, began programming in the 1990’s, then you will probably have started in a procedural programming style with simple task orientated scripts, and then progressed to an object oriented style for its better fit with event orientated GUI applications. As the software craftsmanship movement has grown over the past few years, you will have honed your S.O.L.I.D. OO skills; and focussed on making your code maintainable & testable/ed.

Whilst functional programming has an academic & computational background; functional elements have begun finding their way into mainstream languages. In this series of articles I’ll be concentrating on the two languages I am most familiar with – C# and Javascript – and how exploiting the functional programming features in these can help to make the code you and I write every day more expressive & maintainable, and in some instances dramatically more scalable.

I won’t be trying to explain the concepts behind functional programming – others have done an exellent job of that already; so I’ll just link to them [1] [2]. Rather, I’ll be curating practical examples where a functional style can be applied to everyday programming problems.

  1. Higher order functions – simplifying loops
  2. Implementing the strategy pattern without an explosion of classes
  3. Side effect free functions – code that is easy to test & reuse

[1] – http://en.wikipedia.org/wiki/Functional_programming
[2] – http://www.defmacro.org/ramblings/fp.html