Arnold Kling  

The Rip Van Winkle Effect

The Interaction Between Status... Austro-Keynesianism...

I have been working on some educational software--nothing revolutionary,, and nothing ready to show just yet. It is interesting to see how different the software world is from when I left it in 1999. I'll put the rest of this post, which is mostly off-topic, below the fold.

Back then, it was Web 1.0. A typical web application consisted of a sequence of screens. The web server gave the user one screen, then the user typed in some input, clicked a submit button, got another screen, etc. You still see this process if you make an airline reservation, and you get one screen to select your destination, then another screen to choose the outbound flight, then another screen to select the return flight, and so on. The standard approach was CGI, and those of us who were really cutting-edge used Java Servlets.

It seems that I slept through Web 2.0. Here, a typical web application is on one screen, with a lot of back-and-forth between the user and server going on behind the scenes. Think of something like an autocomplete feature when you do a search. The standard approach is often called AJAX.

What I think of as Web 3.0 is app-like web applications. Here, as a user you are not necessarily going to be connected to the Internet while you run the application. Instead, you might download it and run the thing off line. That is what you do with many apps. (Obviously, there are apps that by their nature require constant communication. Those would be exceptions to what I term as Web 3.0. To some people, they might *be* Web 3.0.)

Compared to when I went to sleep, HTML (the language that codes web pages) is much more flexible and has more elements that can be programmed. In the old days, document.write() was about the only tool you had for changing the content of a page. Now, every element of what is now called the DOM (document object model) can be manipulated. It is that flexibility that makes it possible to design an application where all the action takes place on a single screen, rather than a sequence of screens.

Another new development that intrigues me about HTML these days is SVG, or scalable vector graphics. It strikes me as a tool for allowing users to manipulate graphical elements. My guess is that if it had been around 15 years ago, people would use it a lot more. But so many people have learned to use proprietary tools that do not rely on the SVG standard (the tools may support SVG, but that is not the same thing) that SVG may never come to dominate in terms of mindshare. One frustration I have about SVG is that all of the Android versions up through g, which includes the Kindle Fire and most of the Droid phones in the market, do not have a browser that supports SVG.

Compared to when I went to sleep, there are a zillion open-source "tools" that are designed to solve some problem in application development. I find these a mixed bag. Sometimes they solve the easy parts of the problem, and you are still stuck with the hard parts. Sometimes they create more problems than they solve. I have a bias against these tools, a bias which borders on the irrational (besides me, who else in the 21st century does not like jQuery?). The other thing that these tools create is bitter arguments among developers over what the "technology stack" ought to or ought not to include.

Compared to when I went to sleep, you don't need to have a book sitting next to you while you try and figure out code. You just ask Professor Google how to, say, enable the user to delete a row in a table that you have created, and you can almost always find the answer.

Perhaps the biggest surprise is that JavaScript is alive and well as a language. One reason for that is that JavaScript has always had useful functions for manipulating HTML. But there may be deeper reasons. See Douglas Crockford. (Much of this talk goes over my head, but I get something out of it.)

For me, the biggest adjustment has been to thinking in JavaScript terms, or more properly, in JSON terms. Before I went to sleep, we thought that it was a bug to have an array without a predefined dimension or an object without a predefined scheme. Now, those look like features. Similarly, before I went to sleep, one thought in terms of relational databases. Now, I just think in terms of chains of these undimensioned arrays and unpredefined objects.

There are those who argue that XML is better in theory than JSON. And then there are those of us who do not follow the theory and see JSON as a grab-and-go solution.

Another adjustment that I have to make is that connection speeds are a lot higher than before I went to sleep, so that web sites think nothing of putting a megabyte worth of stuff on a page. So when I think of jQuery as bloated, I am being somewhat stupid, because it is only about 100K. The amount of CPU effort and bandwidth that you can afford to waste nowadays is just phenomenal. The more you make a fetish out of writing code that works efficiently the sooner Moore's Law is going to turn you into a dinosaur.

Comments and Sharing

CATEGORIES: Growth: Consequences

COMMENTS (16 to date)
Butler T. Reynolds writes:

I've been awake the whole time as a software developer and the changes over the years still leave me in a state of shock (not to mention woefully behind).

Matt H writes:

The big important thing to know about jQuery is that since everyone uses it, the user never has to download it, the file is always cached. So instead of including the jQuery file you include a reference to a public copy of it, everyone does this and no user has to download it. Google provides this as a service for free.

Also SVG is nice because its xml/dom based so manipulating it is really similar to manipulating a webpage. Its a shame it didn't make it as a technology. I like it way more than canvas.

Todd Fletcher writes:

I've been in the biz since 1998, and I'd say cloud is the biggest change. Mostly web developers glue cloud services together the days. And the debugging tools are incredible. Firebug, how did we live without you?

Jquery's 100k saves you a zillion lines of custom JavaScript so it's not a bad deal, to say nothing of time.

david writes:

Canvas is probably what will displace SVG. It's too bad, really. But the idea of DHTML, with Javascript in the driver's seat, beat the idea of semantic-web XHTML too handily.

david writes:

I should note that a lot of web applications, even highly asynchronous ones, still use the CGI page-by-page model for certain things.

For one thing, users seem to associate it with solidity and reliability - it is hard to get the 'feel' right in AJAX, you need prompt feedback to the user's interface all the time and if you can't code it to work right always, just use the browser's UI and do it old-school. Flaky AJAX is much worse than a page load. For another, there are frequently situations where a wizard is more appropriate than a long menu, so you're doing the page-by-page thing anyway.

Ken writes:

I was pretty knowledgeable in the mid 90s then fell asleep. I love the metaphor. The open source CMS out there make things pretty easy for the types of things I tend to do. I love building on the cloud. The ability to test and scalability... Awesome!

I think interactive video is extremely useful for educational tools.

dL writes:

Technically, web x.0 refers to the (machine) semantic interconnectedness of web platforms. It doesn't really refer to UI. So, for example, web 2.0 would refer to RSS, XML, XHTML and so forth.

web 3.0 would refer more to the interconnectedness of not of just platforms, but also devices across platforms. The glue here would be more along the lines of JSON,AJAX,REST and, yes, CSS.

A major UI development from the late 1990s would be the emergence of the MVC design pattern tied around UI presentation on web platforms. Here I'm talking about, for example, Rails. Quite a bit of server-side development is moving toward the MVC paradigm. For example, MVC and Struts for J2EE.

Another major component of web UI is the so-called RIA, meaning "Rich Internet Applications." Or: web-sites acting like desktop applications(no repainting of the UI as a consequence of user interaction with the app). This has gone through several iterations. The first was java(applets). This was a complete bomb. The second was "Flash." Flash works as an active-X control plugin(windows) or a java plugin(mac, linux) that was supposed to be a "write once, run everywhere" platform for desktop and mobile. But Steve Jobs literally killed flash(disallowing it on iOS). But was flash was doomed in any event. It was too damn buggy. It's a major resource hog(on mobile, a battery power eater), and it operated in a sandbox environment within the browser. Flash remains purely as a platform for desktop video and a gaming platform. But both of those will be superseded as well. Adobe has already given up and has moved on to "Air."

The third iteration is good ole "javascript." This is not because of some major improvement to the language. It is because of the emergence of what I would call "javascript virtual machines" which allow you to code against a framework instead of the browser itself. Here I'm referring to frameworks like jQuery, Prototype, moo tools, etc(but mainly jQuery). This was a big missing piece of the puzzle. But it is also in combination with the fact that browsers are now much more reliable in implementing the standards. This is a major change from the 1990s. Anyone who was doing web programming back in the 90s knows the headaches involved in the UI rendering issues across MS IE and Netscape.

Now HTML5. CSS3, Javascript,AJAX and a javascript virtual machine framework(jQuery) allow the browser itself to be an actual, competitive application platform. Now you also MVC javascript frameworks being added on top of this(reference the reset Game of Thrones Javascript conference). The competitiveness of this model(particularly JSON) is driving the first major change in database technology in a couple of generations: the replacement of sql relational databases with NoSQL DBs storing JSON documents or "blobs."

On the cutting edge is the emergence of server-side javascript, Node.js, which is based off of Chromes javascript v8 engine, that seeks to compete with the traditional server-side Stacks(LAMP and Windows/.Net stack).

And, of course, more and more stuff is moving to the cloud. Not only data, but the application service layer itself.

Scott writes:

Another area there has been incredible improvement is in the debugging process. firebug and dev tools in browser have become very very nice. I wish server side debug had kept pace.

There is still so much on the horizon.

Daublin writes:

There is something like an economy in the free software being shared among developers nowadays. Facilities like github make it easy to share code across multiple projects. I'd be interested in your take on how this economy functions.

No money changes hands for a lot of this economy. The main motivator for participating strikes me as network effects and as personal advertising. If I can get you to also use much of the software that I am using for my own app, then (a) there is some likelihood you will fix a problem in that software that helps me, and (b) you and I can swap between our two apps more easily, because we are more familiar with more of the code. There's also the small matter that we get to know that each other exist.

Regarding mediocrity, note that as transaction costs go down for sharing code, the marginal software project that is barely worth downloading decreases in quality.

Thomas DeMeo writes:

A couple of points-

SVG is more likely a technology that will explode a couple of years from now, particularly on phones and tablets. Android may be a problem today, but 3.0+ has support. It requires some horsepower to smoothly render the more exciting capabilities, like drag and drop and automated transitions, so only the very newest phones would have the processing power anyway. For apps just starting development, it is worth thinking about.

Another interesting story here is how Apple's market dominance and the iPhone was able to compel the widespread adoption of standards in browsers that made all this cool new stuff workable. Before then, all the browsers were drifting off in their own direction.

Ricardo writes:

Likewise, I fell asleep for a while, first doing embedded software and then inexplicably pursuing a Ph.D. in economics (which will be conferred later this week!). So I had to look up JSON. When I found out what it was, I thought: I've been doing that for years, in Python, without even realizing it. (Surely it is no coincidence that the syntax is identical... I wonder which came first.)

Dave writes:

I have similarly started development of a site after over a decade off and concur with your sentiment. I now spend most of my time using technologies that didn't exist then. I alternate between being perplexed by how to do some modern web feature and then being completely amazed at how easy it is to learn the solution using free open source tools (although I still run into occasionally challenges that require quite a bit of research).

One way I've actually gone back in time though is to use vim for all coding instead of any recent IDEs.

My basic feeling is that server side has become much easier and front ends have become harder (but much more flexible). I like using divs for layouts, but they took way more time than tables to figure out. Otherwise though, between Django and jQuery, development has been relatively quick.

Dan writes:


I've gone the other way - from pure VIM to the PyCharm + the IdeaVIM plugin (which works for all(?) IntelliJ IDEs).

KendallB writes:

I'd also be interested in your take on the economics of GitHub. It is become ubiquitous among web developers, and it's value is undeniable.

JPA writes:

don't use SVG, use canvas or svg-tiny. No one but Adobe has a 1.1 fully compatible implementation. Every browser has issues with some part of the bloated, kitchen sink standard of vector graphics.

If SVG 2.0 is controlled by a community and not Adobe, it may have a chance to take off. But 1.1 has almost every conceivable vector rendering feature, so you will never see a good open source reference implementation or an efficient mobile implementation.

Kendall writes:

When I graduated from college they had just equipped a computer lab with TRS-80s which had no hard drive, a 256K floppy and 64k of ram. When I got out of the Army 7 years later (long story) I thought I had lost my mind when I walked into a store and saw a spinning 3-d ball on an Apple and they were talking about Mega-bytes of memory. I am old enough to remember the sound and smell of a lab using hole punch cards.

Comments for this entry have been closed
Return to top