It was around 9 years ago (a few years after I started my first job) when I stumbled upon the Semantic Web. I remember reading through the RDF specification and thinking “This is it! That’s really the future!”. But I didn’t just see it as a better model for the Web! I was already in the custom application development business at that time struggling to model the business domain and what I saw in the Semantic Web was better domain modeling tools. Unfortunately none of the programming languages were designed to work with the RDF data model so it quickly became apparent that I would need a new programming language to get the benefits of the semantic approach. I wasn’t even thinking of building it myself back then.
So I continued my way through the maze of complex, rigid domain models and sub-optimal algorithms. I moved to a position where performance and reliability were the main concerns so there was more technology and less domain modeling. In the meantime I tried my best to avoid having to manually write all the boilerplate code that’s usually needed when dealing with data so I began to build code-generators. I tried many different approaches had a few successes but the whole thing wasn’t as efficient or revolutionary as I wanted it to be. Through all these years I used and loved Java but I began to bump into the limits of the language more-and-more frequently. Many new languages came out with useful features but all of them were either dynamically typed or on a completely different platform none of which was acceptable to me. This was the time when I first looked into Scala.
Scala was another revelation similar to the Semantic Web. Suddenly everything became possible without sacrificing anything else. Powerful static-typing, incredible type-inference, simple syntax and all this on the JVM. But the real revelation was FP. I did have FP classes at the university and I remember enjoying them but the overwhelming amount of OOP that poured from the industry simply nullified it. At least until Scala brought it back to life. There could be better functional programming languages, but none of those are capable of converting hardcore OOP programmers into FP enthusiasts. Scala also inspired me to look into other FP languages like Haskell which is the cleanest and most elegant programming language I have ever seen.
As I became more productive with Scala things began to move fast. Scala allowed me to build expression languages and experiment with language processing which helped me understand what a programming language can do for the developer. But the real inspiration came from a talk titled “We’re Doing It All Wrong” by Paul Phillips. Especially the part where he talked about how we change software development by throwing away a lot of the baggage of imperative, text-based languages and concentrate on expressing the problem precisely without any noise. It was great to see that I’m not alone in thinking that today’s software development is fundamentally flawed and that we should not give up seeking for a better solution. So I began to actively collect my ideas and combine them into a single cohesive system. And that’s how Lambda Core was born …