35 years with computers

Jakob Nielsen’s Thirty years with computers reminded me that I am about two months shy of my 35th anniversary of computer usage.

My first computer was the CDC 6400, which served the computing needs of the Hebrew University in Jerusalem, Israel. The computer had a lot of magnetic core memory – 32K 60-bit words. That is 240K bytes (or 320K characters, as CDC 6400 represented each character in 6 bits). I communicated with it by means of punched cards, which spoke FORTRAN IV. It communicated with me by means of printouts, for which I had to wait an hour after submitting my punched cards.

The thing which I remember most from that time was the extremely limited power of the programming tools then available. It happened sometimes that I wanted to do something, but the language or the libraries just did not have the requisite feature to support what I wanted to do. Today, almost all languages and libraries are complete in this way.

My vision for year 2039 (that’s 35 years from now) is that the languages, to be used for communication between humans and computers, will be much more powerful. They will make huge strides toward the Software Engineering ideal of having a small change in specs always translate into a small change in the source code of the actual software. Any case, in which a small change in specs yields a big change in the final software’s source code, will be a major news item, a reason to invent a yet more powerful computer language, and lots of rejoicing by bored software developers and language lawyers.

Why is XML much more popular than LISP and Scheme?

As I read Extensible Programming for the 21st Century, I pondered the secret of success of XML. In a way, I am already using XML software (glade, the GUI editing tool, saves the edited GUI description in a XML file, which can later be read by a Python library and used to construct the GUI for a script).

After all, it can be considered to be just another syntactic representation of LISP or Scheme. For example, the transformation between
(+ 1 2)
and

<paren>
   <token name="+"/>
   <token name="1"/>
   <token name="2"/>
</paren>

is trivial.

My guess is that XML succeeds because it allows the developer to add types to S expressions and to constrain them and their contents. This is like imposing hard-typedness on variables and/or their values in a conventional programming language. XML works because the developer can give different names to his expressions besides the equivalent of naming every tag <paren>.

As a proof of concept, it may be a good idea to develop a XML representation of a script in a popular scripting language (such as Python), along with code for transforming the script between its language and the language’s XML representation.

Advice to platform developers

If you are developing a platform or framework or hardware or OS and want other people to develop applications on top of your creation, then the following will make it easier for them and save you from being cursed by your developers:

  1. Ability to script all steps involved in building software.
  2. Ability to run script-based regression testing.
  3. Make your source code available to the developers, so that they can fix bugs which kill their applications, work around annoying limitations which you did not realize, and in general avoid the Stallman’s Printer Driver syndrome.
  4. Make it possible for people with limited budgets to participate in the party, because cool ideas and money do not necessarily go together.
  5. Build in logging and debug support.
  6. Training for developers – courses.
  7. Mailing lists and Web forums for your developers.
  8. Excellent documentation, with several examples, is mandatory!
  9. Mechanism for reporting runtime failures. Due to psychological reasons, it must be as easy and pleasant as possible for software developers to activate it in their software.

The above checklist was put together at November 2001 after having using few platforms for developing cellular applications, which drove me crazy by their utter failure to follow the above principles. I won’t mention names here but my resume is available in my Web site…

Should test cases of GPLed software be under GPL as well?

Pros:

  1. By definition, source code is the form of software, which is easiest to modify. The actual executable is created from it by an automatic build process, which may include compilation and linking. If you modify a complicated piece of software, you want to make sure that your modifications broke nothing. To do this efficiently, you need test cases.
  2. If your modifications are not generally useful, owners of secret test cases won’t test your modifications. The same applies if you were forced to fork the software package in question.

Cons:

  1. RMS didn’t require this so far. RMS’ printer driver problem can be solved without test cases. This has not been a requirement so far.
  2. Some test cases may embody proprietary software usage scenarios, and releasing them to the world, as required by GPL, would reveal too much of the company’s trade secrets.
  3. When you add your modifications to a GPLed software package, users with secret test scenarios will test your modifications, if they are useful for them. If your modifications break the software, they will fix them and you’ll get back their fixes thanks to the GPL.

At any case, there is a case for strong recommendation that test cases be constructed for GPLed software, and that they be released together with it and under the same license (GPL or LGPL).

Selling your software – a brief review of two articles by Eric Sink

Closing the Gap, part 1 talks about the function of proactive sales in a small ISV.
Closing the Gap, Part 2 describes an alternative to hiring a sales guy.

Both parts elaborate on closing the gap between your product and a prospective customer.
Part 2 also has links to further reading about the subject.
Those parts and several other articles by Eric Sink are worth the time spent reading them.

What happens if we cross physics with Scheme?

The data structures in Scheme (and for that matter, also in Lisp) can be used to model different realities. Functional programming corresponds to closed systems, which evolute in time without interaction with their surroundings beyond initial conditions and harvesting of computation results. Imperative programming corresponds to open systems, which interact with their surroundings and their state contains a record of such interactions which occurred in the past.

So I am wondering whether additional models of reality can be investigated by means of Scheme. Such as open systems, which hold memory of both past and future events.

In my Google search, I found only the following:
SCMUTILS Reference Manual, which is referred to by Christopher Browne’s Web Pages. However SCMUTILS is not what I am looking for.

Source of inspiration: chapter 3 of the SICP 2nd edition.

PyGTK Hell

I am prototyping a keyword search based application.

For easy programming, I use Python.
For easy GUI design, I chose glade.
So I have to use PyGTK.
The application is not demanding in terms of innovative technology or software versions, so I use a PC with RedHat 8.0.

However, I ran into a snag:
I wanted to use the gtk.TreeRowReference binding to refer to rows of a listbox, which I want to delete.
However, it turns out that the Python bindings of GTK didn’t cover 100% of the GTK’s API. One of the missing APIs is… gtk.TreeRowReference, which was added only to PyGTK 2.4.
The PyGTK version which came with RedHat 8.0 is 1.99.12.

I worked around the problem by using paths. Since paths (unlike references) become invalid if rows are inserted/deleted into the listbox before the row referred to, I had to delete the rows in reverse order – from the end to the beginning.

I promise to myself that next time I install Linux from fresh, I’ll use Debian. Then I’ll be able to solve the problem by upgrading packages until I get PyGTK 2.4 and the appropriate versions of packages upon which it depends.

Another book on software development methodology

Joel on Software recommends Mike Gunderloy’s book Coder to Developer.
There are additional rave reviews.

I am still in middle of Richard Dawkins’ A Devil’s Chaplain (about evolution theory, religion, etc.).

How do other people cope with 20 excellent books waiting to be read, especially if they have family obligations?

Websites for lifetime students

If you have free time to learn something new for the sake of learning rather than for grades, diploma, degree or qualification:

Red Rock Eater News Service – http://polaris.gseis.ucla.edu/pagre/rre.html
This is mostly about social and political aspects of computing and networking.

Troubleshooters.com(R) – http://www.troubleshooters.com/troubleshooters.htm
If you, like everyone, need to troubleshoot something such as a malfunctioning car or a mysterious software bug, read what this Web site has to say about being more productive troubleshooter.

Perfecting the art of building embedded systems – http://www.ganssle.com/
For those fortunate to have a career developing software for embedded systems.
Several articles have relevance also for people, who do not do embedded development.