Micro a tiny CSS framework

I have seen some pretty tiny CSS framework before. Milligram comes to mind for instance. However, even though CJ Patoilo did some pretty kick ass cool things with only 2Kb of CSS, it simply isn’t enough, at least not for me – So I created my own CSS framework, and I called it Micro.

Even though Micro is created for my own needs in regards to Phosphorus Five, it easily stands on its own legs today. In the latest release, I completely refactored Micro, and I seriously cleaned it up, and I was able to tick it in on 6.4Kb. In addition, there’s a couple of font files (IcoMoon) and an (optional) skin file. All in all, we’re talking about ~50Kb, give or take. If you exclude the fonts, it’s less than 10Kb, and it’s not even minified. Not too bad if you ask me. Minified and zipped, without fonts, it probably wouldn’t be more than ~5Kb. Still it gives you arguably “everything” you need. Below is a screenshot of Micro and how it is used in Hyper IDE.

However, “what’s in it for me” you may ask? After all, a CSS framework is pretty useless unless it solves your needs, right? Well, Hyper IDE and the entirety of Phosphorus Five is using Micro. You can try out Hyper IDE here. So obviously you get a treeview, modal windows, tab controls, buttons, grid layout, and tons of other goodies. In fact, everything in Phosphorus Five, one way or another, is built around Micro.

In addition, it is extremely easy to skin. It is built around the axiom of CSS variables, which allows you to “inject” your own features into its core, without having to fiddle with what selectors to use for some particular type of element. Check out the code for the Graphite skin here. Which is what Hyper IDE is using. Then realise that by simply exchanging some few CSS variables, I can make the above “graphite” skin look like the following. The skin below is called “Bubble Gum” btw, and doesn’t necessary represent my taste in colours for the record … 😉

You can check out the skin file for “Bubble Gum” here. Yet again, besides the font inclusions for “Roboto”, only a few lines of CSS, and you get the above.

Below you can see the same app using the “serious” skin, which probably is a better fit for most people. You can see the code for “serious” here. Besides from the font import, there are no more than 5 changes required to create a CSS skin resembling the following screenshot.

Notice, these two last screenshots are of the exact same application, only with different skins. Not too bad if you ask me …

I still have some work to do in regards to documentation. The docs over at the main GitHut page is hopelessly outdated for the record. But if you use it in combination with Hyper IDE, the docs are “starting to get there”. Below is a screenshot of one of the doc pages which you can find by opening Hyper IDE and clicking the “?” button in the top right corner.

Below I have a small video, where I demonstrate some of its features.

All in all, not too bad for ~5Kb of CSS 🙂

If you want to reproduce what I did in the video, you can download Phosphorus Five here.

The dying web

Maybe you haven’t noticed, but the web is dying. Regardless of which network or client I am using, every time I reload Twitter, GMail, or Reddit for that matter – It takes longer and longer time. Of course, at some point, these websites will simply require so much CPU and bandwidth resources locally for my client(s), that I will simply “give up”, and I suspect so will millions of others, at roughly the same time.

Ever since 1942 (something), we’ve been blessed with Moore’s law. A week ago, we got to taste a little bit of Murphy’s law, and every single client and server on the planet, lost half its CPU performance OVER NIGHT! This implies that your router is now running at 50% of its previous capacity, the web servers are running at 50% of its capacity, and the JavaScript runtimes in our browsers are running at 50% of their capacities. However, even before “Meltdown”, we had been on a downwards spiral for a looooong time.

Twitter is using roughly 4MB of bandwidth, on a page reload, with an empty cache. GMail is consuming 5.4MB of bandwidth. When I started doing these performance measurements about a year ago, GMail was only consuming 4.2MB. Obviously something is very, very wrong with “the web”

For decades we have been living on “borrowed performance” (Quote; Miguel DeIcaza), and we have been spoiled, to the point where we started thinking that it was OK to spend 5MB, simply downloading a handful of 160 characters long messages from our friends and colleagues. This is obviously no longer “OK”. The other day, I went through my friends list on Twitter, and I realised that most of the people I used to work with – Haven’t written a single Tweet for several years! And I suspect you’ll notice the same, if you go through your list of friends. I don’t know where these people are hanging out these days, maybe at coffee shops? Or maybe the local mall? For that matter, maybe this is a *good* thing …?

At the same time, the “bots” have arguably taken over Twitter, to the point where the computers have started engaging in “discussions” between themselves, sending gibberish back and forth, I suspect they don’t even remotely understand themselves. I have “bots” following me, every day, with hundreds of thousands of “followers”. Who are these followers …? Skynet drones …?

Are you OK with such a development Twitter …?

Everybody knows the fix for this, but nobody has the courage to speak out about it, because it implies radical change, to the way we perceive “the web” ...

The “new and improved” Twitter

Think globally, shop locally!

When I was living just outside of San Francisco, the above signs were literally plastered all over the place, on every single available wall, in and around Sonoma County and Napa Valley. Which is kind of ironic, since apparently 98% of every single bit moved through the internet, either directly, or indirectly, goes through San Francisco these days. It doesn’t take a rocket scientist to see the problem here …

The argument is that if we created a distributed web, the bits and bytes would (obviously) move WAAAAAAAAAAY faster from the servers to our clients. In addition, this would require creating new websites and apps, based upon new axioms, not requiring the servers to push 5MB of *crap*, simply to illustrate an animated GIF or two in our browsers. I have no idea why Twitter or GMail are using 5MB of bandwidth to put an animated GIF, and/or a couple of email subjects into my browser – But I do know that at some point, I will simply “walk away”

And so will millions, if not billions of others too …

In case you believe I am not telling the truth, feel free to check out my reference and data here. And data simply doesn’t lie …!!

Edit; I was permanently banned from Reddit’s /r/webdev for posting this article as a comment to my own thread. As to which I asked the moderators the following; “Errh, why?”. However, to be honest I don’t even care why …

Performing 1,000,000x better than Google

I love neutral metrics, simply because they don’t lie, and arguing against them, is like arguing that the Earth is flat. Hence, neutral metrics allows us to get our points through, in a scientific and verifiable manner. In such a way, they become the punchline that is impossible to argue against. Below is a chart of the difference in bandwidth consumption between GMail, Twitter and Hyper IDE. It was measured on an empty cache, using Google’s own tool – Google Chrome Inspect!

Below is the data I collected to create the above chart. First GMail.

Then Twitter …

Then Hyper IDE …

My results are of course reproducible. I assume you can find GMail and Twitter yourselves. Here is Hyper IDE, in case you want to verify my math. For the record, Hyper IDE is a fully fledged web based integrated development environment, supporting more than 100 programming languages out of the box. It also allows you to create rich and complex web apps, with a server side back end, in 0.649 seconds. Below you can see the last number verified.

Hyper IDE’s initial release was built in 7 days, which you can verify yourself on its GitHub page, and read an article about here. Hence, when I said 1,000,000x, I was in fact not exaggerating. Accumulated, these numbers becomes somewhere between 50 and 300 orders of magnitudes. So a more accurate number would be …

1,000,000,000,000,000,000,000,……….. – AKA; One Googol

PS, I wrote it without the spelling error … 😉

If Google can’t create web apps, what makes you think YOU can?

The header of this blog might sound absurd, especially considering that Google is one of the largest companies on the planet, employing some of the best web developers on the planet. Hence, the first thing I must obviously do, is to prove that they can’t create web apps. However, I don’t have to do this, because Google have already proven it themselves.

Do me a favour, visit this link, and make sure you turn on “Inspect” in for instance Google Chrome. Then open the “Network” tab, and turn OFF your browser cache. Then “refresh” your page. Below is a screenshot of how your page should look like.

For any web developer out there, explaining the above screenshot, should not be necessary! If you don’t “get it”, go pick up a book about web development. ANY book about web development!

My second prove comes from the fact of that if you visit Apple’s App Store, you can actually download a thick client app, that allows you to check your GMail email. Do I seriously even need to explain why this proves my point …?

My third proof, is that there exists an “alternative view” for GMail, which you’re being asked if you want to use instead as you start GMail. It says roughly, quote; “Click here if you have a slow internet connection”. Facts are, there’s almost no company in existence in the world today that knows how to create web apps. At least not well. Below is a screenshot of Twitter BTW, to make sure I bash them too, equally much …

So let me finish with my punchline, which you’ve arguably already read …

If Google can’t create web apps, what makes you think YOU can do it?

Hint; There exists a solution, which BTW, for the record, looks like this. You can try it out for yourself here

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!

Brute force password attack prevention

For quite some time, I have been playing around with the ideas of being able to secure Phosphorus Five from brute force password attack, and actually once you spend time on it (pun!), it is actually quite simple. My idea came from being a regular user at Reddit.com, where you have a “cool down period” between each comment you’re allowed to submit. This is something I assume Reddit implemented to prevent a single user to flood a thread with dozens of comments, which is actually kind of cool, though slightly annoying every now an then I must admit. Basically, if you try to post more than x comments during some fixed time period, it will deny you to post your next comment, and inform you that you’ll have to wait some x minutes before you’re allowed to post another comment.

A brute password dictionary attack, will mostly be implemented through a “dictionary attack”, based upon some “x number of common passwords”. Now assuming you have an averagely complex password, or combination of common words and character combinations, and some adversary can try 5 password per second – A brute force attack your server by guessing your password, seldom takes more than 1 day or two – If that much!

Time is your friend

By implementing a similar “cool down period” as Reddit did for their commenting system, on the same username, we can significantly increase the required time needed to brute force attack a server. If we set the cool down to say for instance 60 seconds between each successive attempt – Then all of a sudden you have increased the time necessary to open your server from 1-2 days to 300-600 days. If you create good password routines, which implies changing your password twice a year (at least), this implies that long before any brute force attack has been successfully implemented, you’ll have invalidated the entire process, by having changed your password.

Now the implementation has a couple of “buts”, which among other things is that it must be implemented on a “per username basis”. If you implemented it on a “per IP basis” for instance, you would not guard against a *distributed* brute force attack, which could simply utilise a bot net with 300 different servers, and 300 different IP addresses – Which would completely invalidate these security measures, eliminating this “cool down period”. Hence, it must be implemented on a “per username basis” to be effective.

This has a couple of side effects, which among other things implies that if your server is under attack from a brute force attack, then you won’t be able to login to your own system yourself. This negative side effect, can be significantly reduced though, to the point of almost oblivion – By simply still allowing users to login through their persistent authentication cookies. Since these cookies (should be!!) implemented as some sort of hashed string, there would be little if any point in implementing the same brute force protection for people accessing the system through their existing credential cookies. Trying to brute force a hashed string, is basically useless, since the number of permutations are simply too large. And as long as you salt your passwords, then creating a pre salted rainbow database over a password dictionary, trying different hashed values from your password dictionary, becomes literally impossible – Assuming you keep your salt a secret.

All in all, I must confess that I am pretty confident in that this is a pretty nifty idea, which significantly reduces an adversary’s ability to crack a server. And obviously, this will be an integral part of the next Phosphorus Five release 😉

A comparison between Hyper IDE, Cloud9, CHE and CodeAnywhere


First a disclaimer, I have never used any of the above products, so my comparison will have to be based upon what Hyper IDE does – Or more accurately what it can do. Hyper IDE’s main USPs are in fact not about what it does, which might sound weird – But rather in what it can do, as I will hopefully be able to explain to you during this article, such that it makes sense. This might sound weird for the uninitiated, but hopefully we will have a common understanding of what this implies, as I wrap up this article, and reach my conclusion at the end down here.

First of all, Hyper IDE is new. The above products have been around for years, so inevitably they will have some features that Hyper IDE does not. This also implies, that I have barely started scratching the surface of the possibilities of Hyper IDE, and Phosphorus Five too for that matter. However, the difference is in the platform that Hyper IDE is built upon.

Hyper IDE, a living system

Hyper IDE is built on Phosphorus Five and Hyperlambda. This allows me to do a lot of “out of the box things”, such as for instance create what I refer to as “living documentation”. These are code snippets and “living elements”, embedded directly into the documentation, allowing me to have the documentation interact with the system – And have buttons and UX elements, in the documentation, that evaluates some piece of Hyperlambda snippet when interacted with. This allows me (and you) to create for instance articles about “How to get started with AngularJS”, in the documentation, and embed buttons like “Click here to do the above”, which would create a new “AngularJS template application” for the developer. Since the code for creating this new app, would be directly embedded into the documentation itself, which would “reach into” the API of Hyper IDE, to create a new app – This facilitates for a more fluid experience, and results in a more tangible learning experience, by including the tactile learning parts of the brain. I refer to this as literate documentation.

The documentation is also extendible, allowing for developers to document their own modules, components, and programs the same way. I (or you) could for instance, directly from the documentation, install new modules, components, and applications – As the developer is interacting with some UI element. Or I could directly from the documentation, send a PGP encrypted email, with the code from the currently active editor, to some other developer, using Sephia Five, etc. Or a link to it, etc.

This modularised architecture also implies that Hyper IDE does not live in “isolation” from the rest of Phosphorus Five. And since P5 is a complete web operating system, with lots of other apps and components, I can do things such as integrate it with Camphora Five modules, which would facilitate for teams of developers to collaborate on projects, and declaratively create their own project management tools, such as “TODO lists”, “Assigned to”, “Chat clients”, etc – Embedded directly into the IDE itself, according to their own specifications. Below is an example of me using Speech Recognition in Google Chrome, to literally talk to my computer, and have the computer generate computer code, from natural spoken English.

The above example uses the “Magic Menu”, which is an extendible speech recognition enabled, modularised, and extendible “navbar”. You can read about the Magic Menu here. For the record, the above example is a relatively “esoteric example”, but illustrate how Hyper IDE, and all components and modules from Phosphorus Five, can become extensions of each other, resulting in that the end result, literally becomes more than the sum of its parts – Arguably proving that 2+2==5. The Magic Menu could also be used to create “Macros” for Hyper IDE, which evaluates some “action” when interacted with, such as analysing the code, and providing automated code reviews, executing pre configured shell scripts, Hyperlambda snippets, etc. Another example would be to integrate Hyper IDE with Camphora Five CRUD modules, creating project management plugins. Below I am creating a new CRUD app with Camphora Five (2 minutes out in the video), for then to edit the automatically generated CRUD app using Hyper IDE.

Since Camphora Five has support for custom views, and also at its core is an API, this allows developers to embed things such as lists, project management tools, and chat clients, by creating custom views, that can easily be “injected” into the IDE itself. Below is a curiosity; “A Babel fish telephone”, that will translate from any language, and display the results in the receivers mother tongue, reading it out loud.

Using the above ideas, I could (in theory) have multiple developers, not even able to understand each others’ language, yet still collaborate on code, and communicate with each other perfectly fine. Yet again, the above is probably a really “weird” example, but things like the above, could be embedded directly into the IDE, and become natural living extensions of the IDE itself – Implying that not two installations of the system, would ever look the same, but rather be customised according to the customer’s needs.

Hyper IDE is a “living thing”, where other IDEs are more “static in nature”

Which I can say with confidence and certainty, since many of these ideas are impossible to implement without Hyperlambda, and I created Hyperlambda, and none of the other IDEs are implemented in Hyperlambda. So even though I have barely even scratched the surface of what’s possible with Hyper IDE by combining it with Hyperlambda and other Phosphorus Five modules – I can say with 100% certainty, that it will dwarf the possibilities of other similar types of IDEs in the long run, due to this “dynamic nature”.

Hyper IDE is a complete platform

For the record, one can build any types of apps in Hyper IDE, such as I am illustrating below, where I am creating a C# console application from my iPhone.

But, the true power arises from the realisation of that Hyper IDE is a complete platform, due to being built upon Phosphorus Five. For instance, Phosphorus Five comes pre-bundled with Hyper Core, which is an HTTP REST based ORM library, allowing me to interact with MySQL, and all other database systems, and/or business logic objects, on the server side, securely from (for instance) JavaScript clients. This implies that as you install Hyper IDE, you already have a secure backend for your front end code, and you don’t need any additional installations before you can start coding. Below I am illustrating how this interacts with Hyper IDE, allowing me to create an AngularJS app in seconds, that already as I click the “Create” button, is wired up towards the server side using HTTP REST services – And having already automatically created my database schema.

This allows a developer to literally “start out running”, without having to install additional dependencies, necessary for the developer to become productive. Another example of this, is how Phosphorus Five already contains features such as URL resolvers (allowing for URL rewriting in a dynamic environment), etc, etc, etc. The above “wizard” is also extendible in nature, and would allow anyone to create his or hers own specialised type of “wizard”, to automatically create new modules, according to input supplied from the GUI of Hyper IDE.


Hyper IDE comes with all the security features of Phosphorus Five. This facilitates for a lot of interesting scenarios. For instance, one could partition the developer team up into multiple different roles, and have each role only having write access (and/or read access) to only specific parts of the code. This facilitates for a lot of highly interesting “out of the box scenarios”, such as allowing you to for instance outsource the creation of some specific component, or module, to a 3rd party – Yet still deny this 3rd party to even read other parts of the code in the system – While still physically have all the code in one server, and being able to create builds, even for the company you outsourced to – Even though the builds themselves, are dependent upon access to the entire code tree.

For instance, I have setup my own server, such that everybody can edit the contents of the “/test/” folder. You can try this in the following link if you wish, by editing this file, and saving it. While if you try to change the following file, and save it, you will be denied access to saving it. If you even try to read the following file, you will be denied access. This makes it much more easy to assign read and write access, to specific parts of the system, using the integrated Peeples module. If you want to see how this access system works in practice, you can see the following video.


The main USP in Hyper IDE, is actually not in its features, or what it actually does today. It is rather more about what id can do, either by me creating modules and/or plugins to it – Or by its users creating their own extensions, that somehow modifies the system one way or another. Hence, Hyper IDE is arguably not an IDE per se. It is more a “platform for configuring your own personalised IDE, according to your own needs, and what features the end user and developer needs in his personalised installation”. Making the system highly “Agile in nature”. Of course explaining things like this to other developers, is often difficult, since everything mentioned in this article has arguably never been seen in these parts of the universe before (even though some developers will claim they have seen it before) – However, hopefully I was able to accurately answer the following question;

What’s in it for me?

… from your point of view. If not, feel free to ask questions.

Psst, you can modify Hyper IDE’s code, from inside of Hyper IDE, and I created Hyper IDE, using Hyper IDE in fact 😉

Still not convinced? Download it an try for yourself 🙂


Living software documentation

Software documentation has always haunted me some way, and I have for a long time been fascinated with Donald Knuth’s ideas about “literate code”. Well, I figured, why not “literate documentation” instead? Implying that the documentation for your system, is allowed to execute computing instructions, within its “reader”? This would allow me to create tutorials, that literally “creates themselves”, since the documentation can “reach into the systems its documenting”, and modify the state of it.

In the video below, I am demonstrating how such a documentation system can be created, and more specifically how it will be done, in the upcoming release of Hyper IDE. The advantages are obvious, I think. If you can’t wait, and want to try out Hyper IDE today, even without the “literate documentation parts”, you can download Hyper IDE here. Or you can try out my documentation system here.

A JavaScript/CSS/HTML wristwatch

I just found this amazing little wristwatch snippet thingie on CodePen. Since the thing was licensed as MIT, I figured I’d put it in my own private little collection for later use. See the thing here, or browse its code here.

It’s made by “Sindre”, and you can check out the original CodePen here. However, I think it looks better in Hyper IDE, on its own, without the “chrome” from CodePen. It’s entirely made in JavaScript, CSS and HTML, and uses some pretty nifty features of CSS to pull it off. Check it out for yourself 🙂

If you’d like to create your own private “CodePen” server, such as I have here, you can download Phosphorus Five, which contains Hyper IDE here.

Sharing tutorial code with the world

I was searching around for tutorials about AngularJS, and watched a couple of YouTube videos, and read a couple of blogs, as it dawned upon me that Hyper IDE is actually a really great way to share code for tutorials. The reasons is that it allows you to setup a server, and allow people to directly access the code, in the exact same manner as you created it. For an example, check out my AngularJS controller JavaScript code here.

The above link to my AngularJS controller is write protected. Yet still, it allows people to edit its code – It just doesn’t allow them to save their changes. However, if you want to, you can create a folder where your readers and viewers can even edit the code. If you open up any files in the previous link, you can even save your edits. Of course, granting or denying access, is easily done by creating access objects, and creating new users in the system.

These traits allows you to easily setup a “tutoring environment”, for showcasing your code, regardless of whether or not you’re using AngularJS, ReactJS, or “whateverJS”. In fact, you can also easily showcase other types of code too. Of course the last link, might be a little bit “extreme” for most people, but it gets the point through I would think. By using Hyper IDE in your tutorials, and sharing the code as direct links into your own private Hyper IDE installation, you basically create a very smooth paths for your users, to immediately start playing around with your code, in the same environment that you created the code from within. Resulting in what a psychologist/teacher would probably refer to as “cognitive resonance”.

Hyper IDE is Open Source, and bundled as an integrated part of Phosphorus Five. It even contains a REST based ORM backend, making it easy to integrate your code also with some server side endpoints. If you’d like to give it a try, I would appreciate your feedback.

Download Phosphorus Five here.