Why isn’t functional programming that popular even though it’s so beneficial? A Quora user once asked.

One of the the top comments was:

The user experiences of functional programming languages sucks.

I found this as the opening to the ‘Motivation’ section of the Keli programming language documentation.

What is Keli?

Keli is a programming language currently being developed with the goal of 1) making more developers adopt Functional Programming (FP) by 2) making the user experience of Functional Programming languages more enjoyable.

What is Functional Programming?

I won’t dwell on this subject too much. Wikipedia says this:

In computer science, functional programming is a programming paradigm — a style of building the structure and elements of computer programs — that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data.

For more a more detailed explanation, you can search ‘What is functional programming’ on DuckDuckGo, but the basics of FP are this:

Functions are will always produce the same output with the same input Data (stored in memory (eg. variables)) are immutable (eg. the values cannot be changed)

Now enters Keli

The designer and developer of Keli sees a few problems with the current ecosystem of FP programming languages:

Ambiguous function argument positions

Let’s look at this example:

Some FP languages have ambiguous argument positions, making the immediate understanding of parameters and values unapparent. The designer goes on to make a note that even Object Oriented (OO) languages don’t always fix this ambiguity:

The use of replace in this way is called infix notation, as the method connects the object to the parameters in between the two.

So, which is the the string to be replaced, and what should the new value be?

The designer of Keli fixes this by building on the design of Smalltalk:

IDE unfriendly

The designer of Keli makes a note that FP languages tend to be very hard to fully integrate into Integrated Development Environments (IDE), which are text editors with additional built-in features for deep integration of build tools, as well as helpful system utilities.

IDE’s can be very useful when developing large applications. As Functional Programming is seeing more in-production code, IDE’s can improve a team’s workflow. As such, the integration of FP languages into IDE’s makes sense. The IDE ecocsystem, however, lacks deep integration of FP languages.

The reason FP languages don’t integrate well into IDE’s, according to the designer of Keli, is because FP languages use infix notation. Although OO languages use infix notation, the design of OO languages allow for deeper integration with IDEs.

Conclusion

Keli looks to change this, by allowing for 1) a greater user experience when developing with FP languages, by 2) using a design choice (heavily inspired by Smalltalk) which allows for a seemless integration into IDE environments.

For more information on the design choices of Keli, please refer to the documentation.

I’m excited for Keli, and I hope to try it for a small Proof of Concept project soon. The project is currently in alpha, although it’s worth reviewing the compiler.

Shoutout to the designer/developer. I will leave on this note: if you visit the GitHub profile for the mind behind Keli, navigate to the bio section. You will see this quote:

Don’t wait for Utopia, build it.

Thanks for the inspiration, WJH. Full speed ahead!

Links: