Language Oriented Programming: The Next Programming Paradigm
It is time to begin the next technology revolution in software development, and the shape of this revolution is becoming more and more clear. The next programming paradigm is nearly upon us. It is not yet fully formed different parts have different names: Intentional programming, MDA, generative programming, etc. I suggest uniting all of these new approaches under one name, 'language-oriented programming', and this article explains the main principles of this new programming paradigm.
Today's mainstream approach to programming has some crucial built-in assumptions which hold us back like chains around our necks, though most programmers don't realize this. With all the progress made so far in programming, we are still in the Stone Age. We've got our trusty stone axe (object-oriented programming), which serves us well, but tends to chip and crack when used against the hardest problems. To advance beyond stone, we must tame fire. Only then can we forge new tools and spark a new age of invention and an explosion of new technologies.
I'm talking about the limitations of programming which force the programmer to think like the computer rather than having the computer think more like the programmer. These are serious, deeply-ingrained limitations which will take a lot of effort to overcome. I'm not being pretentious when I say that this will be the next big paradigm shift in programming. We will need to completely redefine the way we write programs.
In this article, I present my view and my current work toward Language Oriented Programming (LOP). First I will show what is wrong with mainstream programming today, then I'll explain the concept of LOP by using the example of my existing implementation, the Meta Programming System (MPS). This article is intended to give you a bird's-eye-view of LOP, to spark interest in the idea, and hopefully to generate feedback and discussion.
Part I. Language Oriented Programming Overview
Language Oriented Programming and the Meta Programming System
Ideally, being a programmer means I can do anything on a computer. I have complete freedom, complete control. But in reality, programmers today have very restricted freedom. Sure, I can do anything on a computer, but some things take me years of effort when it should take much less time. Something is wrong here.
Programmers are restricted because they are heavily dependent on programming infrastructure which they cannot easily change, namely the languages and environments that they use. If I want some extension to a language, I must wait for the language designer to update it. If I want some extra power from my IDE, I must wait for the IDE vendor to add the new features. It is this dependence which limits my complete freedom. Sure, I can write my own compiler or IDE. In fact, this is why I started work on IntelliJ IDEA, because I was tired of being dependent on the existing weak Java IDEs. But this takes a lot of time and effort and is simply not practical for most programmers. There is a big difference between theoretical freedom and practical freedom. When I talk about freedom here, I mean practical freedom.
The way to gain freedom is to reduce our level of dependency. For example, one of the main goals of Java is to reduce dependency on the operating system, giving developers the freedom to deploy on different operating systems. So, to gain freedom over languages and environments, we should reduce our dependency on them.
Why is this a problem? Any general-purpose language, like Java or C++, gives us the ability to do anything we want with a computer. This is true, at least in theory anyway, but general-purpose languages tend to be unproductive as I will explore later. Alternatively, we could use domain-specific languages (DSLs, aka 'little languages'), which are tailored to be highly productive in a specific problem domain, such as SQL for writing database queries. The strength of DSLs, domain specificity, is also their weakness, since any real-world program will involve many different domains.
It's not a question of general-purpose versus domain-specific. I want all freedoms. I want to be able to do anything, and also be highly productive at the same time. There aren't any good ways to do this yet. Ideally, I would be able to use different languages for each specialized part of the program, all working together coherently. And the environment would fully support these languages with refactoring, code completion, navigation, and all the other productivity tools that are available for mainstream languages.
To achieve this independence, I need the freedom to create, reuse, and modify languages and environments. For this freedom to be practical, it needs to be easy to achieve. If we solve this problem of easily developing languages and environments, it will be a giant leap forward for programmers. This is where Language Oriented Programming comes in.