My new CPU instruction is going to load into EAX the value of EAX from 10 seconds in the future.

Crazy talk, I know. But I’m going to ignore the “you can’t do that!” aspect, because that’s just silly rejectionism. Instead, I’m going to think about how to actually implement the instruction.

Supposing we had a second computer, nay, a supercomputer available. That supercomputer has a virtual machine in it, that exactly matches our machine. It’s going to pack 10 seconds of runtime of our computer into the time to execute one instruction, and provide the value back to our machine.

And we’ve implemented it. Well, with a few exceptions.. Our virtual machine simulator doesn’t have the connection to a supercomputer to provide the same 10 seconds in the future instruction. We’d need an even more super computer. Also, I’ve assumed that 10 seconds of runtime is 10 seconds of realtime, which may or may not hold.

That isn’t anything new really, that’s an old turing machine problem. The question of whether a turing machine can determine if a program for that machine will ever halt is considered unsolvable by that same machine.

But that’s because we need that external connection to the supercomputer to give us that 10 seconds’ future result.

Supposing we didn’t. We already know about virtual machines. We already know we can run, on one machine, a virtual machine that just emulates everything. If we don’t worry about time and memory, we could concieveably do all this on one machine, by just firing up a virtual machine that’s a copy of our currently running machine, running it for 10 seconds, then returning to our original machine with the result.

That one can even provide the same 10-seconds’ future EAX, by just creating a second virtual machine within the virtual machine.

So my instruction is going to be a FORK. It means “clone yourself and continue, then in 10 seconds, die and return EAX”

It’s an interesting instruction. We already use branch prediction and pipelining very similarly. And it highlights something we should have noticed earlier. Of COURSE a turing machine can solve the problem of it ever halting. It just takes the machine waiting for itself to run to completion.

One of the interesting problems with FORK in software is telling the two apart. If we really execute a FORK instruction, and really accomplish it, then the new machine is expecting the results of a fork instruction in EAX. Supposing the next instruction is the equivalent of “oh, well, don’t do that then”.

What should the fork instruction assume? should it assume a value at all? should it nest again? we’ll just run out of resources cloning machines. Maybe throw a temporal processor exception?

I see a paradox. There is one here, there’s no way to just nest machines forever. Paradoxes by their nature is interesting, because they either can’t happen, or can’t not happen. So if it’s not happening, it never will. And if it is happening, it’s a tautology and always will.

So press onward. We don’t need to nest forever. EAX is only 32 bits. We only need to create 2^32 virtual machines, each with a different value for EAX, let them all run, and figure out which one resolves the paradox. Which machines, when given a value for EAX, actually produce that same value in 10 seconds time.

And the instruction, the same for all of them, is now “Guess and Explode if Wrong” (GEW?), and of course we throw away the one that guesses it explodes, though I suppose that can’t happen because “exploded” isn’t a valid value of EAX, but now we have the problem of them all exploding.

We’ve gotten around the requirement of requiring intramachine communication, though we still have the cellular automata problem of a machine copying itself, but it stands to reason that if we can copy it, we can also copy it with a new value of Guessed EAX.

If we keep the VM on the same machine, running inside the same machine, then we can answer the larger class of turing problems, provided that we have a specific limitation on the instruction set. There can’t be a halt instruction, because that can’t be emulated without halting the machine, we’re working with non-self-modifying code here, and there must be a return-to-host-or-halt instruction. With those two limits, one program can analyze another and determine if it ever halts within an arbitrary limit, by running it for that long. And the only reason we can’t say if a program will EVER halt is because we can’t run it one step past forever and see.

But that’s for really complicated predictions. Most predictions in a computer system can be made more simply. If all we want to know is the result of a function call, we can do that in the same machine, by setting up a little function-calling sandbox closure and calling it.

I wrote a patent similar to this, many years ago, in which an application could trade runtime for user input, by cloning itself and predicting that input, and then destroying those that guessed wrong. It’s even trainable using standard net techniques.

Pretty easy to see how this technique could be used in a distributed processing system, the function-closure model is very similar to google’s map/reduce, and I doubt it will be long before the OS vendors figure out that they can export memory and runtime to other systems.

Writing about how my less savvy family members are terrified of anyone touching their computer, for fear of damaging the stuff they use, I got thinking about the problem that their issues are showing exists. Because applications do have that problem.

One solution I often see are VMs, but the solution is less interesting than the reason. Why are VMs better than applications? Separate OSes can’t interfere with each other the way separate applications can. But really they have the same requirements. Independent hardware interfaces, protected memory, protected processor time, so why aren’t applications exactly as rock-solid as a VM is? So far the only answer I can come up with is the OS sucks. Sucks because it allows applications to indirectly destabilize each other through it’s interactions with the app.

From a windows perspective, some of that is solvable, some is not. Windows has grown to the point where separate users are handled reasonably well, though not yet perfectly, such that it’s almost impossible for one non-admin user to break something in a different non-admin user’s session.

It does that by keeping a separate registry for each user. (mostly). It doesn’t do that for applications though, so if I change network settings in Yahoo, and it decides to be [un]helpful and propagate those to the IE/Windows (integrated) registry key, it could potentially break IE or any other app that uses those settings. Though not without UAC confirmation now.

Fair time to the Linux side (fair isn’t fair, interesting. But offtopic).. Linux handles multiple users very well, even allows CPU runtime quotas, and it’s virtually impossible for one app to take out another, even indirectly through syscalls. Might be able to do something with IOCTLs, or otherwise cause IO bottlenecking that slows the whole system, but I’m not sure exactly how. Linux is also pretty good about service accounts, where the vanilla kernel does almost nothing on its own, used to be that you needed a service running just to ping it, though that’s a kernel module now.

The various fans generally tell me that windows is just as capable in that regard, and I have no doubt the windows kernel is.

I’m pretty sure granddad is admin of his box. He doesn’t log in. I think if I changed the autologin username to a non-administrative user, he’d just call me up and complain that he couldn’t install some software he bought, and the local pc repair place would simply reformat his machine with blank admin windows, business-pirated. They all seem to do that now.

What’s at question here is the application framework, even if granddad weren’t admin, and could install an app that is totally contained within his specific windows environment, one evyl (www.stopbadware.org) install later and he’s still got 15 IE plugins he can’t get rid of.

Android, that little Linux/Java OS Google wrote on the G1 phone, runs each application as a separate user. as it’s own user. Apps are incapable of interacting with each other, unless they specifically decide to keep things in common locations.. Like the SDCard where all your “good data” is stored is visible to all apps, and there have been a few already that brokenly delete all SDCard contents….. music/photos/all non-phonebook user data. Oops.

It makes IPC tough, but not impossible. Google’s got a few special mechanisms in place, particularly for starting/stopping other apps or invoking them dialog-box style.

But I digress. My point was the OS doesn’t seem to be doing its job, applications should be as isolated from each other as users are, even so far as having their own copy of system-wide configurations, like the registry, with administrative-oversight propagation to other apps or the whole system.

Some of that dependency is inevitable. If you update a video driver, it’s necessarily going to affect everything that uses video. That’s even true for a VM, to some extent. Video in a VM is still pretty crappy though, I don’t think you can use OpenGL/D3D in a VM, though I see no reason why it couldn’t.

Honestly, you could write the above two lines any time over the past 12 years, and it wouldn’t look out of place.

Security is an ongoing concern, which is weird, because it doesn’t seem to be solved. A lot of times it’s an afterthought, and security is challenging enough to begin with. I’m regularly amazed by the utter lack of security that exists for convenience’s sake. The two do tend to contradict, but so often are pitted opposite through accident, afterthought, or intent.

So why must there be patches? I understand generally that if there’s a bug, it needs to be fixed, so patch it. But to take another tack, if word wrecks my formatting, then all I do is reformat it. If an app crashes or doesn’t work the way I want, deletes my files, I don’t run it, don’t use it. If I install it and it turns out badly, I uninstall it.

I wonder if similar approaches can be used with OS or DLL or standard library calls?

Basically, the OS should allow you to hook those calls, check the parameters, and do something else. Windows and others already have syscall hooks for auditing purposes, that’s where we get strace output and the like, so security can be maintained, and the mechanisms are there. It hasn’t been extended to the dynamic loader, however, and there isn’t any way for you, as an administrator, to change something so that word, specifically, doesn’t have the ability to open a socket to ha.cx, write to the boot.ini file, call GetObjectEx with a bad CLSID, or some other evil act.

Seems like it would be pretty easy to isolate the bad behavior in that way, at the OS level, and give you back a little control over what these applications do with your system.

The problem with “It Just Works” is “It Just Doesn’t”.

I can’t count the number of times some unnamed thing has gone wrong and prevented something from “just working”. I had a windows box that lost its drivers. The built-in drivers that ship with windows. Lost. Plug in a USB key, and it asks you to install the USB Storage driver. Or the Floppy Disk driver. Could make it work, browse to the windows driver directory, find the file that’s already in the OS driver collection, and tell it to use that one, and it goes. Still, a normal user confronted with such things is immediately lost, all because windows can’t find it’s own driver database, which should “just work”, for a USB generic device, which should also “just work”.

This morning I had a RedHat 5 system that couldn’t see it’s PS/2 mouse. i8202 driver loaded, gets interrupts from the keyboard, no problem, no mouse. You’re not supposed to have to reboot Linux, but what can one do when the bus just won’t talk to the device? Yeah, yeah, go hardcore CTRL-ALT-F1 and drop that sissy graphical desktop. I did. But that’s not fixing my mouse. I’m just glad it wasn’t the keyboard. PS/2 mice are old technology that in my limited experience “just work” the large majority of the time, except this time it “just doesn’t”.

Virtually all of those situations are met with puzzlement and the suggestion to reinstall and/or reboot by the tech support of the world. I’ve been tech support, and I hate that approach because it doesn’t tell you how you got there or ensure you won’t get there again, though occasionally I have little option. Incidentally, that’s one of the things I dislike about the Mac. Fewer knobs and settings to fiddle with to fix things when they’re broken. I agree all the tweaks shouldn’t be presented to the user generally, but they should be accessible somewhere. Windows does a little better, though also much worse, if you have any experience with the registry (of doom!). Linux does better still, though again, much worse, virtually every knob and dial is available to a linux admin, you just have to know what where to find the knob, where to find the changes it makes, what to look for, and how to read what you find.. A lot is documented, and if you’re so inclined, you can probably go read the code, which you’ll have to do if google doesn’t pan out. Of course, now you’re a theoretical administrator who has all that time to fix the problem, and it’s probably pointless since they don’t pay or listen to noncorporeal sysadmins.

Of course, there are systems for which a reboot or reinstall meaningless….

I set up powerline networking recently, HomePlug AV protocol, specific device is probably irrelevant, they all advertise “plug and go”. It didn’t work. My device was able to get an IP off my home network, but every time it tried to update itself, it failed. Could be poor circuit layout, too much distance, the unavoidable power strip I had in the mix. I relocated it to an adjacent outlet and did some testing, I was losing 14% of all pings. No explanation, no diagnostics or other setting manipulation possible. I upgraded the firmware. Blindly, I might add, since none of them mention what’s changed or why I’d want to upgrade. But it works now. More of a “it just works after you fiddle with it” situation, which is true of virtually everything.

SlingBox did the same thing. It’s been a great product for the “just works” situation, except now it’s forgetting remote codes. Error 93260000, nicely unexplained and ignored by their tech support. Forums are full of witch doctor fixes “reboot it twice and resave the configuration”, hold the power button for 5 seconds, etc. It’s only been a problem since the slingplayer 2.0 upgrade.. Which has had it’s hardware performance requirements jacked up to the point where my 2GHz laptop can’t play video anymore, even though it was doing fine with 1.5 at ~4300Kbps HD quality video, that’s now a .Net app, in case you’re one of the converted. Downgraded that, reset the slingbox, and the remote codes are working again, for about an hour. Reset the slingbox, and it works again.. Connect the next day with nothing touching it in between, and they’re lost again. It just doesn’t work anymore. Must be something in the slingbox configuration and/or box firmware upgrade, though I’ve read on their forums that folks who haven’t upgraded the slingbox firmware are having the same problem.

I’ve worked in software/hardware development of commercial products, and the issue is usually time and testing. Can’t test every configuration, can’t get every bug fixed, can’t get every feature in. If it’s a new or emerging standard, like powerline ethernet, there’s often a lack of test tools. In the end, it’s a business decision. Eventually it costs you less money to ship it as is than to continue to work on it.

So I understand the issues with making perfect products, and I take “just works” with a grain of salt, trying hard not to insert the doesn’t. If you work on such products, I encourage you to check the error codes that should never happen, expose the dials under a hood for those that need them, and try to give some minimially unique and preferably useful (to a user) output when everything goes tits up.

But it lacks something. Other languages, like lisp, prolog, etc.. have different concepts. I don’t know the computer science term for it, I think it’s “functional”, versus “imperative”, where you define what you want to happen, but not when. I think I can get a handle on it if I think in terms of actions.

Active versus reactive. C programs are active, Lisp are reactive. One might wonder how a Lisp program gets anything done, since it’s not acting, just reacting. “This R2 unit’s got a bad motivator”. But really, Lisp reacts to you, to the program being loaded, all sorts of things are around to react to.

Computers, however, do both. At the low levels of hardware, you have a CPU that responds to a clock signal and loads and runs instructions. Reality, you see, is reactive, so we put a clock trigger on it so that it’s always reacting, thus appearing active.

But that’s not changing. Well, not much. CPUs now actually chill for a while if they find an instruction to do so. In the meantime, we have an active CPU that is running instructions, and we also have hundreds of signals for asynchronous events. Interrupts for user input, system status, device communication, timers, all sorts of asynchronous stuff happening. And it’s all treated like the exception to the rule. Generally, that’s handled with fakery. Instead of actually responding to the interrupt event, you just make note the event happened, then when your regular imperative train comes around, it’ll pick up and deal with it then. And you hope that the time you spend making note is so small that there’s no perceptible loss of responsiveness.

I find it odd that when you get down to writing a GUI application or game or basically anything beyond a number-cruncher, you end up creating a special thread to actively wait for events, ironically enough. What you end up losing there is the ability to respond to multiple events.

If you get a pretty good platform going, with a good understanding of Interrupt handling and events, then it’ll probably provide a way to make your event thread, or it’s own event thread, as is increasingly common, chill out until the event actually happens, so it doesn’t go Noober on you asking if the event happened yet. Unfortunately, you’re often stuck with just the one thread, so here we are again handling asynchronous events synchronously, to the detriment of all. God help you if that thread dies or gets locked up, confused, spammed, or otherwise too distracted by acting reactive to actually react.

Now we have system designers eager to throw extra CPU cores at us, and our imperative design methods and languages, and lesser extent platforms, make it hard to do anything with or even think about except as multiple chugging-along trains, still with just one track.

Now I’m not a fan, and I never learned it, but a language like Lisp or SmallTalk seems to get things mostly right on that front. All the events are written almost as closures, and there’s nothing stopping them from happening simultaneously. Very elegant, very distributable, very scalable, for event driven things. Computer Scientists and Mathematicians get to be very happy, because it’s a minor tweak to make the language provable. But for actions, well, it gets weird again. You end up having to react to actions like the act or begin command being issued.

Just so you don’t think I’ve gone 100 miles off the reservation, think about the last webserver app you wrote. Maybe it started just generating some pages, with a database backend, but was basically doing everything on-demand. Somewhere along the line, you probably had to create some kind of service or hack or application or something to do something that needs to happen when there ISN’T a web request driving it. Update your database, delete cookies from users who just wandered away half an hour ago, invoke the Enterprise Java Bean your user requested, whatever.

It’s likely that at that point you wrote a service. Joel Spolsky writes about a “service” in his web application that waits for a user to load a special “go do maintenance stuff” URL, and the maintainer has to sit there and refresh while the thing gets “maintained” until the page returns something different. Jeff Atwood writes about a clever hack used to schedule events to run later in the webserver, using special tricks to get it to run without a user request.

It’s also likely at this point you discovered you needed the context of your application outside the webserver, which is often the reason to attempt to develop it within the web server itself, conforming to the reactive framework.

Or maybe you web-enabled your application that used to just chug. So you have it stop chugging every 30 minutes and write a special file with it’s latest status or apply another clever trick so that when the webserver is asked, it can pretend to actively generate the answer, conforming to the chug-along framework.

Honestly, it seems to me that right answer is in between these two. Write up some stuff that chugs along doing whatever it is you want done, and some stuff that responds to things that happen, and get a nice interaction layer between the two.

Last time I did it, I wrote a webservice and an application that both used the same database. Web service would show users what’s up, make changes, whatever. System service would use that information to generate tasks. It wasn’t ideal, the two really couldn’t communicate well. It was almost, but not quite, Model-View-Controller, except I had one model with two viewcontrollers. Only leveraged part of the pattern. If I’d known better, I would have done more.

I don’t know of any languages that mix the concepts. Most pick one and hack the other in. Imperatives are more popular because they’re easier to understand, functionals because they’re easier to prove and generally hard to derail.

We see it as a combination of red and blue… because we have roughly RGB retinas… but then we see 50%R 50%G as yellow, when there’s a real yellow that just triggers 50%R 50%G.. We can’t see the difference though.

But there’s no frequency of light that corresponds to purple. Makes the color wheels seem a little goofy, honestly. And suddenly bothers me to find purple on manmade rainbows, when real rainbows have indigo and violet, neither of which have any red in them.

EDIT: I recently discovered that the red cones in your eye actually do have a second peak in their response to color. Instead of a nice bell curve centered around red, it tails off more slowly in the high-frequency (green/blue) direction, and has a second, much lower hump above blue. This is why some people may see some purplish colors there, it’s signal confusion.

Violet is past blue.. past indigo.. ultra indigo… Eyes don’t work at the ultraviolet frequencies. As you move your view across a rainbow, the light goes from yellow to green to blue, then it goes more blue to indigo, then to violet, and then disappears as it gets beyond our range of vision.

Compare this artist’s rendition:

(click for large version)

To this photograph:

(click for large version)

There’s no purple at the high edge of a rainbow. There’s no red color there. Purple is the mix of red and blue light, and it just doesn’t exist as a physical color, the way white and black don’t. All the other colors on the wheel, sure, but there are no purples, no colors that mix red and blue. Just like there are no numbers >5 and <-5.

Even the wikipedia article indicates that they’re showing some electric violet color in which they’ve just added some red because violet can’t actually be represented in RGB channels.

In the photo, you’ll see some “purple” near the prism in the blue/indigo areas, which is a result of white light bleeding into those areas, the other colors have been lightened as well, to the point where the yellow is white as you get close. But it’s down near the bottom where you’ll see the blue just taper off. Red has a sharper line because cameras have lenses that aren’t transparent to red-infrared.

Obviously our artist has an issue with the whole blue-to-violet range, he’s clearly indicated a cyan color as blue.

RGB is a total scam. We lost our indigoes and violets, and have to put up with this sham of purple instead. There was a time that 0,0,255 would have been called violet, because blue was/is 0,128,128.

The whole lower right quadrant is colors that don’t exist. Notice how they’ve compressed the blue range so that the 3 first tier colors (Blue/indigo/violet) fit in 30 degrees, compressed the orange section so it’s 2nd tier, elongating the greens to invent cyan. ROYGBIV man. Not RYGCBM.

It’s not unreasonable. People are most sensitive to greens, less so to blues, least to reds. Any division that looks balanced to us would have to be biased. And we have a way to identify red+blue and red+blue+green individually, so we might as well put them on the wheel even if there’s no such thing.

Closures are Functions-with-context. Usually used in formal proofs and the like, but also used in functional programming languages like Haskell. Languages like C are called imperative because they focus more on step-by-step action.

Anyway, the neat thing about a closure is persistence, or maybe independence, depending on how you think about it.

In standard C, I might call a function:

do_stuff(with_stuff)
{
    coefficient = 3;
    some_var = rand();
    new_stuff = with_stuff * with_stuff + with_stuff / some_var;
    return new_stuff * coefficient;
} 

And the compiler will create a stack frame to call the function.. pushing some saved state onto the stack if needed, a return address, then with_stuff. Then the local variables to the function will be allocated on the stack, here they’re some_var, coefficient, and new_stuff.

When the function returns, it places new_stuff in the stack, or puts it in a register, and then returns, and the stack frame is lost. All the local variables are gone, popped off the stack. Really they’re still present, but the stack pointer is now indicating that space is available, so the next push, or sometimes the push of the return value, will overwrite them. They’re not persistent.

But they are the context of the do_stuff function. If you wanted to call it remotely on another machine, that’s all the data that you’d need to pass around and/or allocate on the remote side. If the language supports closures, then this is the neat little package that is all about “do_stuff(with_this_stuff)”.

JavaScript, as it turns out, contains closures. They’re a bit tricky to get to, but they exist. Basically, any time you create a function, you get a closure.

I don’t mean the regular function do_stuff(with_stuff) like we did before. I mean really create one. So you can modify the previous do_stuff function so that it doesn’t actually do stuff, it just returns a function that will do the stuff when you ask it to later. Kind of a cool way to defer execution and evaluation.

do_stuff(with_stuff)
{
    coefficient = 3;
    some_var = rand();
    do_func = function() {
        new_stuff = with_stuff * with_stuff + with_stuff / some_var;
        return new_stuff * coefficient;
    }

    return do_func;
}

When you’re thinking about it, you may notice that coefficient and some_var were declared, allocated, and assigned within do_stuff.. But do_func is returned, and therefore would exist after coefficient and some_var are lost. The interpreter keeps the stack frame from do_stuff around as a closure for do_func, so that when you call do_func later, it has valid references to coefficient and some_var.

And it’s unique. If you call do_stuff again, you’ll get a new do_func returned, with it’s own reference to a new stack frame from do_stuff, and it’s own closure.

Now comes the really fun stuff. Since we have a function closure in a variable, we know we can call it later. We can even build up a bunch of them and execute them more in parallel. What’s interesting is calling it multiple times. The same closure is used for all invocations. so if we call our returned do_func() once, and then call it again, some_var will actually have the same value. It was assigned just once, randomly, when we called do_stuff, then made part of the closure, and is now persistent.

And then there were two. You could, conceivably, create more than one function this way, even inside the same do_stuff function, and they’d share one closure, both able to access the same out-of-scope variables from the creating context.

Perl can do the same thing; they’re very similar languages.

A lot of people don’t know that you can write javascript on the browser’s Address line. That javascript executes in the context of the page, so if you need to do some quick debugging, you can often just throw some script onto the Address line and off you go.

JavaScript is a very nice language, with excellent features such as First-class functions and runtime code evaluation, which means you can actually create a function using the Address line and call it. Or even change a definition, move values into and out of fields, whatever suits your need.

I found this debug script using google http://www.drewnoakes.com/debug.js, though you could do it with just about anything.

javascript:eval('/* Script written by Drew Noakes -- http://drewnoakes.com*/ /* 4 Dec 2006*/ /* the div element used for debug output. created in enableDebug. */ var debugDiv; /* call this function from a script within the document for which to enable debug output */ function enableDebug() { debugDiv = document.createElement("div"); debugDiv.setAttribute("id","debugContent"); debugDiv.setAttribute("style", "display:block; position:absolute; top:7px; right:7px; padding:10px; width:300px; background:#ccc; color:white; border:solid 1px black;"); document.body.appendChild(debugDiv); writeClearLink(); } /* writes the string passed to it to the page */ function writeDebug(message) { if (debugDiv) debugDiv.innerHTML += message + "<br\/>"; } /* writes the value of some code expression. */ /* eg: writeEval("document.location"); // writes "document.location = http://drewnoakes.com" */ function writeEval(code) { writeDebug(code + " = " + eval(code)); } /* writes all of the properties of the object passed to it */ function writeDebugObject(object) { for (property in object) writeDebug(property); } /* clears the debug output. called either manually or by the user clicking the "clear" link in the debug div. */ function clearDebug() { if (debugDiv) { debugDiv.innerHTML = ""; writeClearLink(); } } /* writes a link in the debug div that clears debug output */ function writeClearLink() { writeDebug("<a href=\\"#\\" onclick=\\"clearDebug(); return false;\\">clear</a>"); }');


I know it’s a bit messy, but it’s all written in one line. Which means once you have it copied as one line, you can paste it into the Address of the browser, hit enter, and retroactively add debug facilities to the javascript running inside a page. If your script has a dummy definition for the various writeDebug/writeDebugObject/writeEval functions, and calls them regularly, then when you paste in these new definitions, you’ll get debug output.

Of course, if your script isn’t currently calling debug output functions, you can use javascript:eval("writeDebug(myFunction);") on the Address line, grab the code, change it, and then use another eval to store the new definition.

That’s all temporary. Reload the page and everything’s gone.

This is one reason you should never depend on the javascript in your page to perform validation for you. Anyone who feels like it can change the validation function.

#include <stdio.h>

int main(int argc, char* const argv[])
{
    printf("Hello World!\n");
    return 0;
}

Pretty simple. But in the software world, things change. All the time. Our helloWorld isn’t multilingual. It can’t say “Hello World+dog”. There’s at least one bug in there too. Don’t try to have it say “Hello 95%[World]“.

You could go crazy with it.. add a flag on a command line argument so that it can say “hello world” and “hello world+dog”. Implement unicode routines, hit up a translation site, and hope you don’t get a bad translation. You can get clever with it and make it read the string from an external file, so you don’t have to recompile when the requirement changes for the 100th time.

If you make it sufficiently flexible and abstract, you’ll probably end up reimplementing the TYPE, ECHO, CAT old DOS/Gnu commands.

Which brings up an interesting point. We’re training programmers to use code to solve problems. Even really trivially simple ones.

What makes CAT or TYPE better than HelloWorld? Why are we not teaching programmers that anything you hardcode like that could end up changing?

That doesn’t mean we should design HelloWorld to be much more complicated, but recognizing that there are nearly equivalent complexity implementations that are more flexible in the ways that may change seems like a good idea.

I bet there’s some statistical analysis that can be made.. relating to the odds and difficulty of changing things.. We don’t really expect it to stop printing to the screen, so there’s no reason to design it so that it can edit wikipedia or recognize kittens in a photograph.

Theoretically we’re trying to minimize the lifetime of work that the program requires.

That’s not the point. Today it struck me how weird the phrases “work harder” and “work smarter” really are.

What’s your work? Mine is largely coding and software design, minus the social tax of meetings.

So there’s a pretty simple variable substitution. “Code harder”. Which sounds insane. It’s almost meaningless. “Design harder”.
What about smarter? “code smarter” or “design smarter”. Seems like a Good Thing. Totally opposed to KISS, so maybe not.

How “smart” should code or design be? Do you really want bobs_memcpy()? Class MemoryCopier? Seems to me that it should be as simple as it can be and get the job done, and no simpler. Sound familiar?

Asking for smarter code is asking for clever tricks. Asking for smarter design is asking for higher-altitude standards. Doesn’t seem like a very good idea to me.