I wrote a few articles about why functional programming sucks (1, 2) and why some functional libraries suck (3, 4). Obviously the titles were a little click bait and I think anyone reading the articles understood that I argue that it is the mindless hype that sucks, not the (FP) paradigm itself. Anyways, writing those articles, getting some feedback on them, and programming on my projects gave me more thoughts.
Lets say we have these programming paradigms:
- Functional Programming: Pure, testable functions, avoiding state and variables.
- Object Oriented Programming: Encapsulating data inside objects exposing a simplified, safe interfaces
- Imperative Programming: Explicitly instructing the computer step by step what to do and how to do it, changing state (or Procedural Programming if you like)
- Declarative Programming: Expressing your problem as data, and something else takes that data and produce what you want
- State Machines: Global data and distinct states: your program reacts to input, transitions between states and modifies its data
As you perhaps understand, I do not aspire to be a computer scientist. This is all very practical.
I find – and I dont know if you will find this obvious or outrageous – that all these paradigms have strengths and weaknesses, and that a reasonably sized program or system will need to use a combination of them.
Here follows some strenghts and weaknesses:
Functional Programming Strengths
- High reusability
- Highly testable code
- Compact code
- Transformation, or streaming, or raw data matches the reality of networked services
Functional Programming Weaknesses
- Obscurity – some code can be very cryptic and hard to read
- Over engineering – attempting to make super reusable code can complicate simple things
- Avoiding state – sometimes you have a state and you need to deal with it (and with FP there is a risk you try to avoid reality rather than face it head on)
- Performance – FP comes with some overhead
- Algorithmic complexity – it can be hard to understand the algorithmic complexity, or to write an efficient implementation, and this can lead to performance problems
Object Oriented Programming Strengths
- Encourages clear APIs
- Encourages reusability
- Encourages information modelling
- Allows refactoring of implementation
Object Oriented Programming Weaknesses
- It adds little (no) value and significant overhead to serialize/deserialize data as it is sent/received and stored/loaded
- Inheritance is a questionable concept
- Ideally, objects have only one-way-dependencies, but in the real world this creates difficult, artificial design problems and complexity
- It adds code and concepts that may cost more than you practically get from it: public/private declaration, getters/setters
Imperative Programming Strengths
- Simple and straight forward
- Little overhead: high performance
- Algorithms explicitly implemented: high performance
- Works the same in many different languages
Imperative Programming Weaknesses
- Bad testability: if you have too big procedures with too many side effects
- Bad maintainability: if you end up writing too big, complex modules
- You can end up writing much code, copying and pasting
- It takes discipline
Declarative Programming Strengths
- Can be very compact
- Can be very easy to read (if you understand/accept the “language”)
- Can allow for quickly adding or changing features
Declarative Programming Weaknesses
- Performance may be bad and/or unpredictable
- Although compact, it can be very cryptic
- Debugging can be very hard
State Machine Strengths
- Can deal with complex states
- Suitable for error handling, recovery
- Can deliver efficiency at system level
State Machine Weaknesses
- Requires proper analysis and design upfront
- May be hard to refactor or change
- Complex (represents and deals with complexity rather than hides it or lets someone else take care of it)
I now imagine a simple mobile/web application (like an little online betting site). There is data storage, server side application logic, authentication, http APIs, client loading data, client side application logic, UX, and the user saving/updating data to the system.
Server Side
The server itself should be thought of as a state machine. It can be up and good, but it can also be starting or shutting down. It can have bad or missing connectivity to other services (authentication, payment, data feeds). It can be in maintenance mode or perhaps in test or debug mode. It needs to hold and renew cached data. All these things can dramatially affect how a simple API call is handled! Failing to do this in a structured way can lead to very complicated API implementions or severe performance or stability problems.
If there are adapters connecting to other systems or the storage these may very well be implemented in an Object Oriented way. They expose a simple and safe API and they hide a lot of implementation.
When it comes to server side business logic it is fed with input from the storage or cache and its output is sent over the network to clients (or the other way around). Such business logic should be designed in a Functional way: it should be clear what it does and what data it uses, and it can and should be testable.
The implementation of the business logic or the adapters may be performance critical and non trivial. Imperative programming can be used here – inside what is exposed as Functional or Object oriented code. It must not leak. But every bolt and nut in an FP function does not have to be implemented using FP principles, and every internal part of an Object need not be built on the principles of Object Orientation.
Finally, the definition of the APIs, the access rules can be Declared. Other code can execute these rules and declarations behind the scenes.
Client Side
The client also needs to be thought of as a state machine first. Is the user authenticated and logged in? Have we received all data, or are we still waiting for something? Have we received the latest updates or have there been connection problems? Does the user have edited, dirty, state that is not saved to the server? Are we having errors saving data that we are retrying? Where in the application is the user and what settings, configurations or policies applies to the user? You need to deal with all these things. If you try break it into many small modules with no mutual dependencies you will find that is very hard. Put the damn global state somewhere, and accept that it is a global state. Make it all publicly readable for anything that cares. Changing of the state is a completely different business that must only be done via specific interfaces (the entire state machine can appear like an Object).
Now Declare your user interface: the pages, buttons, colors and everything else. Write code that consumes these declarations and produce the UX. To the state machine this code may appear Object Oriented, and your UX components are probably some kind of OO objects, reusable across the pages.
Whenever you can, break stuff out into Functional, pure, testable functions.
And when it comes to getting stuff done, as long as your code is contained within Objects or Functions and they do not leak: write simple and efficient Imperative code if that is the best.
The GUI can be described in data rather than code in a declarative way.
Conclusion
It is quite pointless to talk about (for example) Functional programming as better or worse than anything else. It simply depends on. And for programs/systems of non-trivial size and complexity, mixing programming paradigms is fine.
More reading
I came across this article on programming languages design. It is concluded with: “Languages are becoming more multi-paradigm. I think it is wrong to talk about oh I only like object-oriented programming, or imperative programming, or functional programming language.”
0 Comments.