Become a web app developer in 2 days – ZERO HTML, JavaScript or CSS knowledge required

One of the nicer traits about Phosphorus Five, is that it allows you to create highly optimised, rich, interactive, and secure web apps – Without requiring you to know any HTML, JavaScript, or CSS – Or HTTP for that matter.

The above might sound absurd, but really it’s quite easily understood, once you understand how the development model of Phosphorus Five works. Hyperlambda and Phosphorus Five simply “reduces” HTML, JavaScript, and CSS down to “assembly code”. What I mean by that, is that to Hyperlambda HTML, JavaScript, and CSS has the same “function” as assembly code and machine code has to C++, Java or C#. Obviously when you write C++ code, it becomes machine code. However, you don’t need to worry about that!

One of the defining traits of (good) C/C++ compilers, is that they can almost always optimise your code, such that it for all practical concerns executes faster, than assembly code written by most developers. This is because a well written compiler can easily do things which are simply too complex for the human mind to understand, such as taking advantage of pipelining, L1 cache, etc. The same trait happens to exist within Hyperlambda.

In the video below, I demonstrate how to create a rich and complex web app, with a TreeView, dynamically databinded DataGrid, TabControl, and Modal Window – And not only do I do it in less than one minute, but the “app’s” bandwidth consumption is at a fraction of the bandwidth consumption that GMail and Twitter is using (1/50th to be accurate). This implies that it will be ~50 times faster and more responsive than GMail or Twitter is to the end user.

Too good to be true?

Well, watch the video, and afterwards feel free to reproduce my numbers, by downloading Phosphorus Five and verify my claims.

Notice – Before you dismiss this as marketing gibberish, let me inform you that I barely know any Assembly code. Still I am perfectly able to create apps, in roughly 25 different programming languages, including C and C++. So the ability to “reduce the web standards down to ‘assembly’ code”, has obviously been done many times before. First with C and C++, then later came Java and C#, which went further, by implementing garbage collectors, etc. To do the same to “the web”, is simply the natural conclusion, and natural progression, and arguably “evolution” in fact – And it is easily done, when you start creating generalised solutions, to common problems, to facilitate for higher levels of abstractions.

Therefor, I can say with confidence that, if you want to become a web app developer – You can teach yourself everything you need to know, in roughly 2 days, using Phosphorus Five. Of course, you won’t become a KungFu Ninja Shaolin Master web app developer, but you will be able to solve most of your needs, and your company’s needs too for that matter – Without ever having seen as much as a single curly brace, angle bracket, or CSS class declaration.

If you don’t believe me, then please feel free to explain how C# and Java works

Or even better, download Phosphorus Five, and prove that I am wrong if you can …

Advertisements

HOWTO become a web developer in 2 days

System development has historically been considered to be the equivalent of “black magic”. This is especially true for web development, since it requires a whole range of knowledge, ranging from CSS, HTML, and JavaScript in one end – To SQL, PHP and Apache in the other end. Plus tons of stuff “in between”. All of these technologies requires months, if not years or decades to master for that matter! So the header of this article obviously provokes those who already know how to create web applications, which is understandable.

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
  • JavaScript is created automatically, and hence the developer doesn’t even have to know about its existence
  • 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.

  1. I am the best web developer on the planet
  2. 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!

Creating a web based DBMS with 414 lines of code

Most frameworks can’t even wire up their Ajax requests with 414 lines of code, and before stuff such as autocomplete, syntax highlighting, paging, editing of items, etc is done, most DBMS systems are up there in the somewhere between 50KLOC and 500KLOC of code. With Phosphorus Five and Hyperlambda, I built a DBMS with 414 lines of code.

To put that into perspective, realise that even a simple widget such as the Bootstrap DateTimePicker is roughly 5,000 lines of JavaScript code. With Hyperlambda, I built a complete DBMS, with less than 10% of the code. And it’s **blistering fast**! Watch the video to see for yourself.

There is a point to it. It might sound like I’m bragging. If I am, I am not bragging about myself, but rather Phosphorus Five. The more I work with P5, the faster I am able to create new complex solutions, and less code is needed to create my solutions.

I will create a computer programming IDE using plain English as input

OK, so I have finally figured out a really kick-ass project to do, and it is an IDE for creating computer programs, which understands plain English, allowing me to have conversations such as the following illustrates.

  • [Computer] What do you want me to do?
  • [Me] Add a widget to my form
  • [Computer] What type of widget should I add?
  • [Me] A literal widget, of type div
  • [Computer] Do you want to apply some CSS classes to it?
  • [Me] Yes, make it 50 percent width and use the background red class

Etc …

Don’t believe me, watch this video, and realise I can easily reverse the process … 😉

I still haven’t created as much as a single line of code in these regards, but I figure it’ll probably be done in some few days 😀

Watch me discuss my code with my computer

In the video below, I am demonstrating how I can talk to my computer, have it talk back to me, and actually semantically analyse my code, using plain English sentences. It knows which constructs my code is using, such as if it is accessing my MySQL database, creating widgets, or if my code is a web service, etc – All of which is dynamically and semantically understood by the computer, by traversing my Hyperlambda graph object. Watch it and enjoy 🙂

For the record, after I had created the above video, I realised I could reverse the process, and actually create code from natural speech, such as e.g. plain English etc. Which of course will be my next project … 😉

Patient – People say I’m insane for speaking to my computer doctor. Doctor – Well, does your computer answer you …? 😉

Executing server side code from your browser – Hypereval

Hypereval is our newest family member. It allows you to evaluate Hyperlambda code, from your browser, and have your code execute on the server.

It features intellisense, autocomplete, intelligent indentation, etc, etc, etc. It’s built upon CodeMirror, and is extremely flexible for those wanting to configure it in different ways. A useful little module, which you can find in the Bazar for Phosphorus Five. Watch the video below for a short introduction …

An unbelievably flexible create, build, and deployment model for web apps

Sometimes when I try to explain Phosphorus Five, I feel as if I am trying to explain the concept of “air” to a caveman, who have never even known about its existence. For instance, I am currently discussing whether or not Hyperlambda is simply an inferior version of Lisp, or if it has intrinsically unique qualities, and hence is worthy of its own existence. The guy obviously knows tons about computer programming theory, compiler theory, Lisp, and is obviously incredibly smart -Still, it seems (almost) impossible for me to explain the advantages of the dynamic nature of Hyperlambda. Hence, I’ll try to instead of explaining, try to simply “click and show”, such that hopefully it becomes more clear …

When Niels Bohr and Albert Einstein was quarrelling about whether or not the moon exists in 1927, Heisenberg became tired after a while, and said the following

Stop arguing and do the math

I feel for paraphrasing him, and say something like the following

Stop arguing, and let’s code

When you’re confronted with something that doesn’t (quite) resemble anything you’ve seen before, it is often difficult to see the advantages. However, if you watch the video above, hopefully I don’t even have to explain them, since it’s arguably a self explanatory concept. And if it isn’t, it sure as hell becomes pretty clear after having created an app or two …

Is Hyperlambda a programming language?

Is Hyperlambda the first Turing complete anti-programming language in the world?

I’ve had lots of readers commenting on Phosphorus Five, and more explicitly Hyperlambda, stating how some of my claims are “impossible”. Particularly when I explain that there is neither any interpretation process, nor any compilation process occurring, at any level in Hyperlambda. Statements like this seems to upset some of my readers. This combined with my statements about how Hyperlambda is still Turing complete, obviously puzzles developers. Of course, the reasons are because they’ve never seen anything quite like this before, so it’s difficult to believe in such statements. Basically, every single programming language they’ve seen before, is either an interpreted language, a compiled language, or some sort of variation of both. I wanted to write this article to clarify this though, such that there (hopefully) won’t be any misunderstandings about this.

For the record, if somebody showed me something without “wheels”, and told me it was a “car”, I’d be suspicious too, which arguably sums up their concerns you might argue …

Short explanation; Hyperlambda is a relational file format, capable of describing “graph objects”. That’s its technical definition. Its structure is “name/value/children”, and you can add “children nodes” to any specific node you wish, by simply adding two CR+LF and 2xSP characters behind another node. This implies that it is arguably similar in “structure” to XML, JSON, HTML, and for that matter Edifact, which are other “file formats” capable of describing “graph objects”. Once the file format has been “parsed”, such graph objects can be “evaluated”. Below is an example.

.data
  name:John Doe
  name:Jane Doe
for-each:x:/@.data/*?value
  create-widget
    innerValue:x:/@_dp?value

The above Hyperlambda would for instance create two “widgets” (Ajaxified HTML elements), and render these back to the client. The above for instance, would create a graph object with one “root node”, having two children [.data] and [for-each]. The [.data] node would have two children itself, being its [name] nodes, etc. The values of any node can be found after its “:”. Now paradoxically, the above could just as easily have been declared with e.g. XML. Below is an example.

<root>
  <.data>
    <name value="John Doe" />
    <name value="Jane Doe" />
  </.data>
  <for-each value="/@.data/*?value" type="x">
    <create-widget>
      <innerValue value="/@_dp?value" type="x" />
    </create-widget>
  </for-each>
</root>

Notice, after the DOM structure of the above XML have been parsed, there is no further “compilation” or “interpretation” occurring as the “graph object” is evaluated. Such graph objects, are simply passed into an “eval” function, which you can find here. Yet again, let me emphasise once more, in case you didn’t “get it”.

No further compilation or interpretation is done after the Hyperlambda has been parsed! It is evaluated “as is”, period!

In fact, the only structural difference between Hyperlambda and XML, is that Hyperlambda have an “implicit root node”. Now each “function” in the above “anti-code” (it’s not technically “code”, since it’s not interpreted or compiled), is created as Active Events. Read more about Active Events here. This allows me to create any Active Event I wish, including events such as the following.

  • [if]
  • [else-if]
  • [while]
  • [!=] (comparison operators)
  • [eval] – The most important one of course, being the “CPU” of Hyperlambda

This implies, that I can do anything in Hyperlambda, that I can do in any other programming languages, including creating a “compiler”. For the record, creating a “compiler” in Hyperlambda is a terrible idea, but it is possible. The same way creating a “web app” in CISC x86 Assembly code, is also probably “possible”, but yet again, highly likely a terrible idea

I have created Active Events, that allows me to create a Turing complete “graph object”, which allows me to “declare” any programming instructions I want to “declare”. And since there is no “interpretation”, or “compilation”, ever occurring – Hyperlambda is no more a “programming language”, than that which XML (or HTML and Edifact) is. So the technical term for describing Hyperlambda, is arguably.

A “non-programming language”, based upon “anti-code”

This again creates some peculiar (and extremely interesting) side-effects. Among other things, if you are able to visualise this “graph object” (I refer to them as “lambda objects”) – You start realising you can modify them, as your “lambda” is executing – Which facilitates for “self modifying code” (among other things), to an extent previously impossible to fathom, using traditional “programming languages”.

So if you declare Hyperlambda to be a programming language, you’ll purely logically have to admit that this implies that XML is also a programming language. If you believe that Hyperlambda is interpreted, or compiled, you’ll purely logically have to admit that also XML is either interpreted, or compiled. Since defining XML as a “programming language”, is ridiculous, so is defining Hyperlambda a programming language also preposterous …

So why didn’t I use XML instead of creating my own file format (Hyperlambda) …?

Count the lines of code (LOC) above, and you’ll probably get it … 😉

What does Paul Graham have to do with this …?

Well, he explains this better (arguably) than I can. However, Hyperlambda is an ********EXTREMELY HIGH LEVEL TURING COMPLETE EXECUTION ENVIRONMENT*********, to an extent difficult to fathom. In fact, Hyperlambda (arguably) makes languages such as Lisp and JavaScript appear like “machine code” in comparison. For instance, I can create a MIME envelope with the following code.

p5.mime.create
  text:plain
    content:Foo bar

And it’s an integrated part of my “non programming language”, and becomes a “programming instruction”. 3 lines of code, allows for me to do what would require (literally) thousands of lines of code in any other programming language. Still, there is no semantic difference between how my [eval] function evaluates the above [p5.mime.create] Active Event, and how it evaluates an invocation to [if]. To create an Ajax widget, requires no more than 5 lines of code.

create-widget:foo
  innerValue:Click me!
  onclick
    set-widget-property:foo
      innerValue:I was clicked ...

To create something similar to the above, in e.g. C#, JavaScript or Java, would probably require hundreds of lines of code …

The above traits allows me (or you) to create “domain specific Active Events”, in C# or F# for instance, to “extend” Hyperlambda, with your own keywords. Then later “orchestrate” these events together, in an extremely loosely coupled fashion (through Hyperlambda), and facilitates for reuse previously unmatched in other traditional programming languages.

The end of the Rabbit Hole …

I don’t like saying this out loud, because it sounds so preposterous, but in fact, Hyperlambda facilitates for “exponential software productivity growth” – Which of course sounds so ridiculous, that most people tend to believe I am a fruitcake insane quasi conspiracy theorist for stating such a thing. Exponential software productivity growth, for those not understanding its meaning, is the equivalent of proclaiming having found “free energy”, “cold fusion” or having created a “never ending eternity machine, capable of sustaining its own movement, without adding energy to it”. However, the proof is in the pudding, as you can see in the video below …

Every single “app” in the above video, including the actual “operating system” and its “Bazar” was created by one man, in 6 months, and you can verify this by checking up my GitHub repository

Edit; Some commenter have argued that the lambda structure is in fact “interpreted”, since it creates a mapping between the string of “for-each”, and a method that “interprets” its arguments. This is of course true, and hence arguably turns lambda into an “interpreted structure”. However, since this lambda structure still can be built with XML, this still implies that we’ll have to accept the paradox of that XML is (potentially) a “programming language”, if we exchange the Hyperlambda (file format), with an equivalent XML file/string. Hence, if Hyperlambda is an “interpreted programming language”, then so is XML.

Notice though, that when you have a lambda structure, this can be directly modified by using Active Events such as [add], [insert-before] and [set]. These events acts upon the execution tree directly, and does not in any ways require you to type out “code” to have new “ideas” execute. In addition, any lambda object can also be serialised, during execution, into its associated Hyperlambda (file format), or an XML structure for that matter. Below is an example …

.exe
  event
switch:x:/../*/some-argument?value
  case:foo
    set:x:/@.exe/*/event?name
      src:do-foo
  case:bar
    set:x:/@.exe/*/event?name
      src:do-bar
eval:x:/@.exe

The above example illustrates directly modifying the lambda structure, as it is being executed, depending upon a [some-argument]‘s value, expected as input, and will either evaluate an Active Event named [do-foo], or another named [do-bar]. Since there are tons of other really weird examples, with highly interesting use-cases for this – The execution tree is in fact not even “fixed” as execution is initiated, and can be physically changed, according to arguments passed into it. And I don’t mean “passing in a lambda object”, I literally mean “physically changing the execution tree”. Even though lambda objects (obviously) can also be passed into it, of course …

In addition, you can for instance choose to copy and paste “half a lambda object”, and for instance rearrange the order of execution, having a function’s latter half, being executed before its first half, etc, etc, etc …

Regardless, I agree that a “lambda structure is interpreted”, after having given it a lot of thought, in addition to having been flooded with comments about this. Happy …? 😉

Can you communicate with your computer?

I don’t mean silly speech recognition or speech synthesis for the record – I literally mean communicate. For instance, can you communicate your ideas and intentions to your computer, and have it communicate its ideas back to you?

The reason why I ask, is because that’s arguably what makes us humans human. Even the Bible refers to this in John 1:1, arguably – Implying that, I can find any English speaking person on the planet, and we can have a dialogues with each other, bounce ideas to each other, have the other party semantically understand what we’re talking about, and then reverse the process, allowing the other party to inject ideas into our minds. This is at the foundation of of what we often refer to as “communication”.

Below you can find a piece of Hyperlambda. Traditionally, there have only existed two distinct different types of programming languages; Interpreted languages and compiled languages. Both of these have the same traits though, which is that the computer does not in fact understand these languages. They both need to be transformed into something else, before the computer can understand what we as humans are trying to communicate to it. Hyperlambda is in neither of these categories.

create-widget:foo
  element:button
  innerValue:Click me ...
  onclick
    set-widget-property:foo
      innerValue:I was clicked!

Hyperlambda at its core in fact, is not a programming language. It is simply a tree structure. Such tree structures, or “graph objects” to use the technical term – Just so happens to allow us to describe what I often refer to as “execution trees”. Execution trees are piece of logic, which a computer can understand directly, without having to “interpret” or “compile” it into something else. You can read more about this  in my MSDN Article about Hyperlambda.

This simple trait of Hyperlambda, literally means that your computer can understand it, without any interpretation process or compilation process occurring in between your code, and its understanding of it. This happens to create another highly interesting side-effect, which is that your computer can actually communicate its ideas back to you, in the form of Hyperlambda.

Hyperlambda hence becomes a common communication platform for computers and humans, and the first of its kind actually!

The Hello World app for Phosphorus Five

When you start out creating your own apps for Phosphorus Five, it helps to have a “template” to start out with, such that you know which files to initially create, to automatically handle installation, uninstallation, launching your app, etc. If you visit your Bazar in your Phosphorus Five installation, you can download such a “template” now. The app is called “Hello World”, and you can actually test it out for yourself here. You can see a screenshot of it below.

The app is (of course) open source, and you can find its code here. Or if you wish to see its code, you can actually launch the app, and click the “View code” button – Since the app is capable of displaying all Hyperlambda code it contains.