Closing Braces

A couple of weeks ago, for some now-forgotten reason, I found myself thinking about the first programming language I ever learnt.

In particular, I was thinking about the pros and cons of it being a minimal, assembler-like language that was designed specifically to teach the fundamentals of computers and programming.

The language was CESIL (“Computer Education in Schools Instructional Language”), the year was 1974, I was 15, and the class was CSE “Computer Studies”. The hardware was hand-punched cards that were sent off by post to some other place, with results returned a week later, just in time for the next lesson.

For the second year we moved on to BASIC using a Teletype crammed into a corner of a little room up in the school’s attic (theoretically that should have been a lot better, but in practice it was so inconvenient and unreliable as to be almost useless).

That sounds unbearably tedious and uninspiring now, but way back then it was amazing that we were able to use an actual real-life computer and were learning about computers as part of our schooling.

Anyway, as clunky as the arrangements were, and as much as others will no doubt disagree, I still think CESIL itself was a great introduction to programming.

Conceptually, it was an assembler-like language that operated on integer values in a single register. It supported:

• Named variables
• A handful of simple operations on the register and one variable or constant
• Conditional branching based on testing of the register value and labels on statements
• Some minimal input facilities (reading one value at a time from a list supplied at the end of the source file)
• Some minimal output facilities (a simple “print” statement) facilities
• Pretty much nothing else… at least as far as I remember.

The syntax was just about the simplest one could imagine for that particular set of features. You can probably already picture the entire language.

The beauty of this was that, with no prior knowledge of computers of any kind (which in those days usually meant not even having a realistic concept of what a “computer” is), you could be taken straight into tackling simple algorithmic problems (like finding the largest of a given set of numbers, sorting numbers etc), without any undue distraction or complications. At the same time the class lessons could use this as a context for explaining computer hardware, what was actually happening when your program ran, and more general computer-science topics.

You were immediately seeing a reasonable model of the fundamental concepts of computers and algorithms, getting a feel for what programming is like, how to test and debug code etc, but without getting bogged-down in syntax rules or complex abstractions. The once-per-week cycle taught you to be careful and precise, and to desk-check and dry-run your code. More generally it forced you to figure out what you were doing, rather than just flapping around and guessing with a trial-and-error approach (like so many people seem to do today).

In practice the limited resources also meant that some things had to be done in pairs or small teams. So whether by design or accident, you also got a taste of what it’s like to develop code with other people.

Against it, there was clearly a limit to how far you could go with CESIL, the practical difficulties made for very slow progress, and the language itself was never going to be of any direct use to you afterwards (as opposed to, say, being taught a real assembler language). So even in a two-year course you really did need to move on to something else fairly quickly and then forget about CESIL.

But on the whole I still think it was a great way to lay the foundations for a lifetime of programming. I’m grateful to whoever instigated getting this set up and introduced into schools – I suspect my career may have been very different without it!

Anyway, once this had crept back into my head for no particular reason, it seemed worth a quick look to see if CESIL has entirely vanished or whether there’s any information on it still knocking around. Whilst I’ve not found any official documentation or history, somebody has blogged about stumbling across the CESIL course book.

More astonishingly, someone has resurrected it – by writing an open-source interpreter for it. I’m rather tickled to see that someone has done this, just for the sake of it!

I think GWT, Android and its Dalvik VM and Google App Engine for Java are all very interesting. But as a developer I’ve been a bit put off by this nagging worry that they’re not “real” Java, and that going off in that direction would progressively take me outside the (so far) relatively-benign stewardship of Sun and the JCP.

The worry is that things like this would take me away from the community standards with a choice of competing and compatible implementations, and into a world of arbitrary single-vendor products with quirks and foibles, lock-in, arbitrary changes and suprise announcements that can suddenly turn your world upside-down.

With the Oracle acquisition of Sun, that perception could change very rapidly.

Hopefully Oracle will play nice and keep the good bits of Sun’s approach to Java whilst sorting out the problems. Hopefully they’ll manage to retain at least the key people, put in sufficient resources to finish and “polish” the things that Sun never managed to, and make better decisions on strategy and marketing. Make the JCP better, or at least not make it worse. And find a way to make good money from Java without having to do anything untoward. If we’re really lucky they’ll do all of that without making a mess of the technology itself.

But back in the real world, does anyone really think that’s how it’s going to go? I’ve only a little experience of Oracle products and their way of doing things, but what I’ve seen from them in the past doesn’t fill me with any great confidence for the future of Java.

So in my head I’m expecting this to degenerate into a rather old-school fight between Oracle, IBM and to some extent Google, with them all pushing increasingly proprietary and “integrated” stacks that live in their own idiosyncratic universes and gradually diverge from each other. With lots of theatre about joint specifications and standards, but increasingly nasty disagreements and battles over licencing. There will always be some independent open-source alternatives and smaller players for particular parts of the stack, but in this scenario I can’t see these managing to keep up with the big guys (nor having any real impact outside of their own small niches).

On paper, out of Oracle, IBM and Google, the advantage might now appear to lie with Oracle. But in practice they are all big enough to mess things up very badly. There’s certainly plenty of scope for them to do so.

On that basis, the Google stuff suddenly looks no more proprietary or risky than anyone else’s solutions, and could easily be the least-bad (and least-evil?) of an imperfect bunch. Arguably they already have a head-start down the road that the others are now about to follow. They’re also way more “zeitgeist” and future-oriented than IBM or Oracle.

Theoretically Microsoft and .NET might gain from all this. If people stop seeing the Java world as a neutral, no-lock-in platform based on community-agreed specifications, then .NET starts to look like just as valid an option as Oracle’s Java stack or IBM’s Java stack or Google’s Java offerings. But I’d expect that anyone with reason to choose Java rather than .NET would still do so even if Java were to fragment into separate vendor universes.

In the end this all depends on what Oracle actually do with Java, and with products such as Glassfish. At the moment we’re all just speculating based on our own experiences of Oracle and their products; their history with previous acquisitions; and an awful lot of guesswork. So for now I guess I have to give them the benefit of the doubt and wait until we see their strategy and plans and their actual behaviour.

But if I ever get any spare time, I’m now far more likely than before to spend it looking into Google’s java-related platforms and tools, and I can’t imagine I’m the only one…

So if I was Google I’d be feeling pretty happy about it on the whole.

Whilst searching for something else, I stumbled across the use of the prefix “kibi-“ for the quantity 1,024 (i.e. 2¹⁰), with this standing for “kilobinary” and having a corresponding symbol Ki.

For example, this leads to the term kibibyte for 1,024 bytes, kibibit for 1,024 bits, 4 KiB to indicate 4,096 bytes etc.

Apparently, as much as ten years ago the IEC started adopting a whole set of such “binary prefixes” to parallel the normal decimal SI prefixes of “kilo-“, “mega-“, “giga-” etc.

So as well as “kibi-“, we also have the prefixes “mebi-” (2²⁰), “gibi-” (2³⁰) and so forth, all the way up to “yobi-” (2⁸⁰).

For further details, see (for example):

• Wikipedia: Binary Prefix
• SearchStorage.com: Kibi, mebi, gibi, tebi, pebi, and all that
• NIST: Prefixes for binary multiples
• IEC: When is a kilobyte a kibibyte? And an MB an MiB?

I’m very surprised to have not come across any of this before, but I guess you learn something every day!

It all seems like a great idea for clearing up the ambiguity in the use of the normal SI prefixes when dealing with binary stuff (e.g. whether someone saying “megabyte” means 1,000,000 bytes or 1,024 x 1,024 bytes).

Some of the names don’t exactly trip off the tongue, and gave me the giggles at first, but that’s probably just from being unfamiliar.

I imagine it’s very hit-and-miss to get something like this into common usage, but I’d have thought that plenty of geeks would have latched onto these terms by now. At any rate, I’d like to think that Maurice Moss regularly puts these prefixes to good use.

Does anyone actually use these prefixes in real life or are they just an idea that has never gained any traction? Am I alone in having not heard of them or did this pass everybody by?

Maybe it’s time to start spreading the word and using these terms more widely…

(The following is inspired by a recent experience – but naming no names!)

Here are some ideas for making sure that I don’t buy software from you. If you do this really well, I’ll add you to my list of companies to be avoided. You might need to take other steps to put other people off, but these will definitely go a long way towards doing the trick for me.

First, make sure your website doesn’t give much detail about your product beyond a general outline of its features. There are obviously many things you can omit that will usually send me away immediately (for example, pricing, licence terms, system requirements). But to really annoy me you should be a bit more subtle at this early stage.

The real trick is to give the “bare bones” without actually providing enough information for me to come to any conclusions. That way I have to actually try the software in order to learn anything, and must guess whether it’s worth bothering with. You can get quite creative with this. A lot will depend on your particular product, but basically you need to make sure that nothing that feels like actual documentation ever manages to leak out onto the website.

The next step is to require me to “register” for a trial, and then login with userid/password, even if all I want at this stage is to see the full documentation. Making me register for a trial of the software might or might not discourage me, depending on the software and how well you handle this, but having to register just to see the documentation is always a real winner.

Follow this up by sending me a hard-sell marketing email with lots of guff in it about how wonderful you are. In this first email, you need to really push your top-of-the-range corporate/enterprise capabilities and consultancy. Throw in as much management-speak as possible. This gets extra marks if I’ve already told you via your registration form that I’m trying your software as a “home” user, and looking for just one licence for personal use on a single system.

However, don’t imagine that a simple automated “do not reply” email will be adequate. That’s half-expected, and far too easy to ignore. Instead, you need to wait a bit and then send a personally-written email that offers to help with the trial. Make sure this is poorly written and includes some obvious stock phrases. The ideal is probably to write each such email individually, but with plenty of “cut-and-paste” of standard sections. Maybe with some badly thought-out scripting or mail-merge for some of it. Repeat my name a few times. Start informally then use lots of “sir” and “mr.” in the body of the email. You’ll probably want to outsource all of this work to the lowest bidder to make sure it’s done as badly as possible.

If I’m in the mood to reply, I’ll perhaps explain that I’ve already looked at some particular competing product and likely to adopt it, but just taking a quick look at some alternatives. I might give some feedback on what I’ve already seen of your own product.

In response to this you need to send me a second email to change my mind. This second email should explicitly presume that I am going to make a purchase from you. Remember, always say “when” rather than “if”.

Your priority in this second email is to bombard me with criticisms of the competitor that I’ve said I’m likely to choose. These should at the very least be highly debatable, but ideally you should try to make them ruthlessly overstated and blatantly alarmist. If possible, base them on an old version of the product rather than its current release. A few outright lies will get you top marks here.

For the best effect, it needs to be obvious that these criticisms are previously-prepared, canned arguments that you keep ready for use against each competing product. You’re looking to make them a completely transparent attempt to scare me away from the competitor, in a way that will only work if I’m ignorant of the facts and unfamiliar with the product concerned. To pull this off you’ll need to ignore the fact that I’ve clearly just done my own evaluation of the competing product and found it to be at least adequate.

For example:

• Try to scare me away from a highly-respected open-source competitor by explaining that open-source means “everyone” can change the code and this could “damage” my system.
• For open-source products relating to security, tell me that using an open-source product would, by its very nature, put my security at risk (extra points for each repetition of the word “risk”).
• Describe the competitor’s product as “unreliable” and your own as “much more reliable”. Be careful not to give any figures or evidence, as that would ruin the effect.
• Tell me that the competing product has an unfriendly and difficult user-interface. This works especially well when I’ve just finished evaluating it and found its user-interface to be perfectly okay. To get the maximum benefit, make sure that your own product’s user-interface and documentation are a mess.

As final flourish, try concluding this second email with a personalised “call to action” that accidentally uses somebody else’s name (e.g. “call me to arrange your purchase, mr. Earnshaw”).

Finally, make sure that all emails are written by someone that isn’t very good at the language being used (in my case, English). If you have offices in my own country, or another country that speaks the same language, you’ll need to carefully outsource this work to somewhere else. To be really sure, write the emails in some other language and then automate their translation. This might take some effort to set up, but as an added bonus you’ll make me pessimistic about what dealing with your support team might be like.

Please note: I’m dreadful at languages, and don’t expect everyone else to speak mine perfectly. If you’re a very small company or individual, any attempt to talk to me in my own language is wonderful as far as I’m concerned. I’m also happy enough if you write in your own language and leave it to me to try and translate it. But if you have a website and product documentation in English, and you’re claiming to have offices all over the world with multiple offices in the USA and the UK, and you’re also boasting about big-scale corporate/enterprise support and consultancy stuff, I’ll find it very hard to take you seriously if you send me marketing-style emails that seem like they were written by a rather strange four-year-old.

If you want to be really ironic, you can use your poor English to criticise the competing product for having “user made and not official” language packs.

Clearly you can build on that, and I might find it amusing to continue corresponding with you, but the chances are I’ll be long gone by this point.

I’m in the process of setting up phone numbers and contact details for a new IT company, and I’d started to look at fax-to-email services as we don’t want to be mucking around with phone lines or needing any particular equipment.

But then I got to thinking, why are we even bothering?

It feels almost obligatory to include a fax number in the company’s contact details, but there doesn’t seem to be any real need for this – we’re just doing it for the sake of it, and because everybody else does. The fact that we’d happily use a “pretend” fax number that actually converts everything to e-mail just seems to prove this.

Maybe I’m lacking in imagination, but if we aren’t asking anyone to send things to us by fax, it’s kind of hard to envisage situations where somebody would need or want to send faxes to us. Other than spam, of course.

Even if there might be rare occasions where for some reason we need to be sent the image of a piece of paper, how likely is it that fax would be someone’s preferred or only option (rather than, for example, scanning and e-mailing the document, or sending a copy by post)?

Maybe there are some countries with specific issues over what forms of communication are legally binding, or where bandwidth or technology constraints somehow conspire to make fax useful. Maybe there are some individuals who have access to fax facilities and like fax, but don’t have or don’t like email.

As it happens, at one point I did know someone who had a cheap fax machine as their home’s only working piece of telephony equipment, so you couldn’t phone them, you could only fax them, and if you were lucky they’d eventually notice and fax you back – but that was a decade ago, and these days even they have a proper phone that you can phone, and an email address too.

None of the above scenarios seem likely to impact this particular company. In any case, at worst we can always deal with exceptional cases individually as they arise. I can’t see anything that comes close to us needing to publish a fax number for general use.

So I’m wondering if this is just our own particular situation, or if I’ve missed something, or if fax really is now a relic of history that nobody need worry about any more.

Is there anybody out there that still likes fax? Any industries where it’s still how things are done? Any IT or otherwise “modern” companies that insist on faxes for signed contracts and the like? And most of all, is it acceptable for a high-tech IT company to not publish a fax number – or does anyone see a reason why it’s still necessary?

I’d like to think that the internet, email, image processing, legislation and business attitudes have all advanced to the point of rendering fax completely obsolete, but I dare say somebody out there will know otherwise… in the meantime our company isn’t going to be getting a fax number unless and until we find a specific need for one.

The internet has just given me a surprise Christmas present – after losing track of her for many years, I’ve suddenly stumbled across a recent Verity Stob article.

It seems she is still going strong, and currently has her own column (or whatever you’d call it these days) on The Register at http://www.regdeveloper.co.uk/r_and_r/verity_stob/.

Back in the days of .EXE magazine, it was a real treat to turn to the back page each month and find her unique brand of techie humour. It varied a lot, but was often pretty scathing on subjects that entirely deserved it, and was all the more funny for being devastatingly accurate. In the days before the internet made every possible opinion on everything instantly available, it sometimes seemed like the only sane voice amidst all the madness.

I especially remember articles like You May Start (on certification exams), Thirteen Ways to Loathe VB, the diaries of one Mrs Gates as she attempts to cope with an MS-powered home, and the biblical “History of the Borlandites” saga.

When .EXE folded, that seemed to be it. A Best of Verity Stob book suddenly appeared a couple of years ago, and makes it clear that since .EXE she has had items published in Dr Dobbs Journal and at The Register, but it didn’t sound like anything current or ongoing.

Then yesterday I innocently follow a link to something that sounded interesting, and found a strange little article at the end of it. Authored by one Verity Stob. And it isn’t alone.

Now this is entirely my own fault, but it had just never occurred to me to look for her – it was just something in the past that was gone and gone. It’s wonderful to find that she’s still writing. My only problem now is how to find the time to catch up on it all…

I guess I also need to try and remember everything I’ve ever liked, and do a search for it. Sometimes it seems like nothing stays in the past any more, but the problem is remembering to look!

I was rather tickled to read “You know you are an old geek when…”. It rang quite a few bells for me, and dredged up a lot of what seem like ancient memories of former lives.

I’ll stick my hand up for items 1 (though more often it was a queue to use a terminal rather than pairing), 2 (probably “used to speak hex”, don’t need to do that as much anymore), 4, 5 (different set of languages, but there in spirit and timescale), 6 (one particular project), 7 (on an early 1980’s minicomputer where there was no other option), 8, 9, 10, 11 (done or participated in), 13 (at school).

It also made me think of lots more that could be added to the list. I was going to reply with a comment on web-a-week, but it doesn’t seem to accept comments. So here are…

…some more ways to know if you are an old geek:

1. You remember when each individual bit of memory was stored in something you could physically see and hold in your hand.

2. Other geeks look surprised and confused when they discover that you know something new and trendy.

3. You’ve worked on large-scale commercial databases that weren’t relational (actually, this has just about come back round again… let’s say “pre-relational”).

4. You remember having discussions with colleagues about whether the “goto” statement really is harmful.

5. You’ve used assembler routines to compress/decompress data in some arcane, application-specific way so that it can be squeezed onto fewer magnetic tapes whilst still being accessible to higher-level languages.

6. The public adverts for “The Last One” had you worried – until you convinced yourself logically that whatever it really was, it couldn’t possibly be what the adverts were claiming, and the world would need programmers for a while yet.

7. You remember the excitement of the first time you got sent somewhere with a “luggable” PC (and how much your arms ached afterwards).

8. You’ve written programs that used teletext as the user-interface.

9. There was a time when you thought Ada might be a good thing to get into, once there are compilers for it (APSE anyone?).

10. You can name more than one programming language where you’ve used 5 or more consecutive major versions.

11. You remember writing programs on paper pads and sending them to “data entry” to be “keyed in” (or using equally prehistoric stuff, like manual card-punches).

12. You’ve worked on projects where the system design consisted entirely of a set of flowcharts.

13. You have programming books that are older than the people you’re working with.

14. You can’t decide whether it’s really cool or deeply depressing that all the source code you’ve ever written can now fit on a device smaller than your thumb.

Here are another couple of possibilities, but I suspect these might be personal foibles rather than anything more universal:

15. You suspect that mankind’s ability to successfully complete large and complex technological projects in a reasonable timescale reached a peak somewhere around 1970, and has been in decline ever since – and you believe that this is largely for non-technical reasons (i.e. it’s not the geeks who are the problem).

16. You’ve witnessed several generations of programmers each start from scratch and blissfully ignore what’s gone before, and seen them gradually re-discover much the same issues and re-invent much the same solutions (but with totally different terminology, and with a lot of false starts and outright mistakes along the way).

Anyone else got any?