Study

In between contractor work I've done a couple of days worth of study. Programming that is. I usually do between jobs, and since I've had a few in my career (about 10, depending on how you count) it's been a few dives here and there. Usually on something with buzz, sometimes cutting edge stuff, occasionally some bleeding edge tinkering.

I'm one of the late early adopters when it comes to software in general and programming tools in particular. I did C a couple of years after it became a standard and C++ not very long before it became an ISO standard; Linux from pretty early on; Python as it was becoming fast, simple and useful; git as it overtook the other free, distributed SVCs; iOS as companies started to take an interest.

The advantage of being late is that you see where things are heading. But over the last years three software fields have been expanding massively, but I haven't hardly paid attention. They are HTML, Android and Java. All of these are technically flawed one way or another.

• HTML is separated into structure, style and logic. The structure is that of hierarchical boxes-in-boxes, pretty much like any layout manager since the 80's. Sometimes you use CSS to move a box out of it's parent and place it relative to screen or page, but generally it's boxes-in-boxes. If you want to make changes to a layout you usually have to spend horrid amounts of time to move a box into a different parent. Both for layout/style reasons, but also for logic reasons, and especially so for single page applications as load order comes into play with Ajax, etc. And browser/IE compatibility.
  
  Performance-wise it's really bad. The traditional static web page is not very responsive: when you click a button, the next page can take seconds to appear. Seconds! In the year 2014. Usually there is also some flickering involved when loading a page. But single page applications is usually not much better. Response times when clicking is usually also in the seconds, and on almost all sites you see some icons moving a couple of times during load, and text is pushed down while other components load, etc.
  
  Technically, HTML+CSS+JavaScript is too "open", you can solve a problem in any number of (bad) ways, which leads to a plethora of frameworks to assist you. And as companies struggle to use something which will survive a decade, they grasp for JSP, Java Servlets, ASP .NET, Rails, Python Django, Node.js, Django, GWT, Backbone.js, CoffeScript, Angular, jQuery and a ton of others. This alone should get everyone thinking "what's wrong with this picture", but strangely enough status quo is all I hear. (My theory is that most of the good people managed to stay out of the HTML slough.) Frameworks in general are evil things, but on a quagmire tech platform perhaps it's the least bad option.
  
  But worst of all, worse than all of the technical awfulness, is that HTML design allows you to make all pages unique. So after 37 signals published their series of articles on A/B testing, small software entrepreneurs en masse set out to make long pages with round photos where content is split up into easy-to-read chunks, starting with a link to an easy-to-read pricing plan and ending in a footer where you can reach the other products. Good for them - uniformity is a good thing. Both for your eyes and your wallet. Apple understood this and perfected a one-size-fits-all layout-and-logic engine in iOS. This is what the customer wants, and this is what the suppliers should deliver. Unfortunately, most site's still look like something the cat dragged in, but in a unique way. The overall lack consistency between sites is why pretty much all HTML pages look like shit, no matter how well-designed they are. That's why it's important to have a type of iOS-ey template to stick to.
   
• Android. Well what can I say. It's still miles behind iOS in almost all ways possible, but it's open and gratis. In the long run I suppose Android could win, but right now it's too much compatibility hassle, too much design uniqueness (same flaw as HTML), and way too much code+work to make an app that looks great on all/most/any target device.
   
• Java. Verbose, slow and more often than not comes with huge do-it-all frameworks. Which are great for hellowdy world, but not so good when scaling up. Sure, Java takes the mundane and error-prone out of C++, but it also adds a virtual machine, byte code and usually a build system or two including dependency management. And the everything-is-an-object just gets on your nerves as much as the verbosity after some time. Steve Yegge nailed it with "you can't trust anyone who loves it too much." Oh so fair, candid and right the guru is.

Now it's gotten so far though that it's even hard to find contractor work unless you're prepared to get your hands dirty with the above technologies. So I started looking into React JS for the client-side part of single page webapps. It sort of takes away some of the ugly disconnects between HTML and JavaScript, and it does it fairly well I think. You can read about my conclusions here. It still sucks ass though as most of the above still applies.

Interestingly, with React JS I would be a fairly early adopter if I started using it now. Especially as the community around Angular JS is dwarfing the React community, no matter how bad Angular is in the long run. But I'm not going to. It's always sad to see the better (or least bad) party go down, but it wouldn't be the first time.

Changing the status quo

What I would like to see in the future to replace the current state of affairs is some new type of full-screen OS desktops replacing the windowed dittos in Windows/OSX/X but loaded from a server backend. Design should be fairly strict by default, it would take some effort for custom designs (like iOS), not the other way around (like HTML). Communication should be REST/JSON, so you don't have to know more than the four HTTP methods as RPC is a bitch as 100+ operators always gets messy, requiring murder. Documentation is murder. The language doesn't matter as long as it's run native without a virtual machine bogging things down, and it must have good tooling. Which excludes a lot of junk. Portability would have to be built-in; and client and server code would be similar or same.

If this type of system was easy to install and also contained a great standard library (like for instance Python) it could potentially kill HTML, Android and iOS development along with .NET/Java VMs in a single blow! And what a great stack to start out with: the feeling of native without the hassle; the intrinsic performance of native; a standardized and beautiful fullscreen design; and the distribution and connectivity of the web.

It needs to contain a compatibility layer for windowed apps, but with that in place it would easily replace Explorer.exe, Dock.app, KDE, Gnome or whathaveyou. If it contains the basic web surfing (i.e. Chrome in fullscreen) and it trajects above the viral threshold, this type of tech could eliminate the ugliness of HTTP once and for all. We'd all have design restrictions, high performance and good tooling. Thus creating good-looking, distributed, fast applications would be fun again (and the end-users would love it)!

This type of system will be to software what IP is to communication. (To bad we're all still running RS-485. Sure, sure it's better than what came before! Yes, yes!)

Please Linus Thorwalds or Mr. Equally Magnificent Programming Guru, build this über-system now!