For the record; If you happen to read this article, and you object to my claims, I have no problems with that, as long as you can prove your argument. If you simply dismiss it as “click bait” or exaggeration, then I am sorry to say that it is highly likely that the train will literally leave you behind.
I have created a Web Operating System. This operating system has a lot of interesting traits. Among other things it has its own unique programming language called Hyperlambda. This programming language is built upon a unique axiom called Active Events. And the bridge between the server and the front end is created around a unique idea called Managed Ajax.
These 3 traits combined, allows its developers to shift their focus, away from the nitty gritty stuff they would have to focus their attention on in most other web development axioms – And on to something which is arguably much easier to understand, and arguably gives you the same power as all the above technologies gives you combined. Hyperlambda is not really about its features, it’s about its *lack of features*. To illustrate this weird and unintuitive fact, let me create a short list of what Hyperlambda does not contain.
- Hyperlambda has no OOP mechanisms
- Types are more or less irrelevant
- The mapping between the client and the server happens “automagically”, so there are no rich client side “APIs”
- Etc, etc, etc …
It doesn’t take a rocket scientist to realise that once you remove all of the above hurdles from the art of learning how to create web apps, then the task will become significantly easier. Assuming I am not lying in the following article, which can easily be verified by checking out my GitHub repository for Hyper IDE. Then simple deductive logic dictates that at least one of these two statements purely logically must be true.
- I am the best web developer on the planet
- There is something about Hyperlambda which significantly increases your productivity, one way or another
Hint; I am not the best web developer on the planet …!
What I did with Phosphorus Five and Hyperlambda though, is not historically unique. We’ve seen similar shifts in our axioms many times before. The most famous example would obviously be when we stopped creating software in assembly, and started compiling “high level languages” down to machine code, through languages such as Cobol and C. Every single software developer on the planet, agrees upon that if you create code in C or C++, you’re much more productive than if you were to create these same apps in assembly. The same is true for the shift from C/C++ with manual memory management, to higher level languages such as C#, Java and PHP – Which among other things, automatically handles your memory.
As you study these shifts, you will notice a commonality between all of them, which is that we move “upwards in the ladder of abstraction”, every time we see these types of shifts. This is facilitated for by among other things faster hardware, due to Moore’s law, allowing us to run our software in a higher level environment – In addition to partially facilitated for by new axioms, no longer requiring us to know about some particular subject, such that we can apply reusable functions and methods, which we previously were unable to use.
A great example of the latter from above, is how most C# developers today have no idea of how to implement a simple sorting algorithm. If I asked you to implement for instance quick sort or selection sort, would you be able to do it without having to Google the algorithm? The reason why most C# developers can’t implement a simple sorting algorithm, is because we already have “System.Generics.List<T>.Sort”. This method is implemented such that it will in 90% of the cases simply choose the fastest possible sorting algorithm you could possibly implement. Hence we become “lazy” (which is a good thing when developing software, because it cures the “not invented here syndrome”). And the 10% of use cases were it performs sub-optimal, has no relevance for our ability to create working software.
Paul Graham once wrote an essay about this, where he claims that given two different axioms, the one using the highest possible level of abstraction to solve a problem at hand will always win.
Hyperlambda is an extremely high level axiom
Which implies that for the projects where you can use it, it will always win, regardless of what other types of (lower level) abstraction you are using trying to solve the same problem. Notice, it’s not everywhere you can use Hyperlambda, because sometimes this extreme high level abstraction, creates penalties for us, which we cannot for some reasons live with. So it’s no “magic bullet”.
However, if I can create a web based integrated development environment with Hyperlambda, and I can do it in 7 days – Then I can say with statistical confidence that you can also highly likely solve your problems with it. Ditch the attitude punk, and embrace the future! Because it’s coming one way or another, regardless of what you happen to “think about it”.
Every time you accuse me of “click baiting”, you are in fact informing the world about your own fears
And yes, my ideas are dangerous, because they imply that what you spent decades mastering – Your kids will spend two days mastering. Get over it, it’s called “evolution” dude, and it’s a GOOD THING!