In the earliest days of computing, programmers interacted with computers via “hard wiring” and subsequently via punched cards. The really big advance came when CRTs could be attached to computers and users (vice programmers) had their first chance at interaction.

These first CRTs were known as “block mode” devices, or "green screens" after the screen color of one very popular model, and the computers of the day were mainframes. Note that as of this writing, block mode is apparently so archaic that not even Wikipedia has an entry. Block mode devices allowed the programmer to establish fields on the screen into which the user could key values. The user would tab between the fields keying their values and subsequent to completing their input they would press the equivalent of the “send” button. Communication with the computer took place at this time.

The send button caused all the data entered on the screen to be “collected” by the CRT, typically into a single “string” of characters with the fields separated by a very special character (ideally one that could not be typed on the keyboard). Once the computer received this string it trundled through it, parsing and checking the content. If an error was found, a message was sent back to the CRT notifying the user. The user (ideally) corrected the error and resent the string and the process was performed until the string was accepted.

It should be apparent that while block mode was quite a bit better than punched cards it was annoying in a couple of ways. Firstly, the CRT didn’t have the capability of doing any edit checks on the fields so the user could merrily key anything into any field, thinking they were doing a great job until they hit send. The bigger issue was of course that most systems were programmed to only display a single error at a time. So, if you keyed a form with 10 errors, you got to hit send 11 times before the system would accept your input. Not friendly.

The response by the “block mode” BUNCH (extra points if you know the acronym) was to have studies done showing that sub-second response time was the key. If you just had enough hardware and could spit those individual error messages back in under a second, your users would be happy as clams (although I don’t know how we know that clams are happy). A great amount of hardware was sold trying to make response time fast enough so productivity wouldn't suffer.

Enter the minicomputer, with a different solution. Minicomputers allowed the CRT to communicate on a key-by-key basis. Software could be built to accept input on a field-by-field basis (really a line-by-line basis) or a key-by-key basis. Data could be verified immediately after it was keyed, and in some cases, even while it was being keyed. Much friendlier.

Fast-forward now about 40 years and the advent of web browsers and web forms. Consider all the effort of hundreds if not thousands of companies to put every application ever created onto the web. Consider that the vast majority of those applications work like block mode terminals. No data validation as data was being keyed only a single error message displayed when “enter” was hit.

Recognizing the deficiency of this model, what was the response? Yup, you guessed it, studies showed that if we sped up the response time then it would be OK! Sorry, didn’t pass muster the first time, won’t pass muster the second (maybe the 3rd if you consider client-server in the middle).

So, now what do we have? Well, we have newer technologies to plug the holes created by the other new technologies. JavaScript tried, but it apparently just wasn’t enough so now we have the coolest of the cool - AJAX (can anybody say “client-server”?). Admittedly our forms can look a lot spiffier now, but it has taken about 10 years of maturation before the new tools developed the capacity to solve problems approximately as well as the tools of 30 years ago. Progress is our middle name.

Lesson to be considered: Every industry replaces the old with the new, but it seems to me that many people doing software development (and managing software development) spend a lot of money on new technology so they don’t “get behind.” But, maybe we spend so much money, time, and effort trying not to be behind, that we can never get ahead?