For example, I may spend a great deal of time working on a concept, and arrive at an inventive solution, only to discover, when telling someone else about it, that it’s already been invented.

I myself have done that to others, told them their ideas already exist. I know Jeffy’s come up with a few.

After my most recent encounter with this problem, while working with a NAT traversal technique, I became annoyed at my education.

I’m wondering whether because I am not fully briefed and up to date with the goings-on of the fields in which I am attempting to create, I need to pursue a greater education, and evaluating what I’ve already had as incomplete.

But today I was reading a comic, and another possibility occurred to me. Independent Invention and Non-obviousness.

Theoretically issued patents have satisfied the non-obvious clause, so any joe contemporary in the field shouldn’t be able to come up with it. But maybe when I spend days thinking about it, and come up with an answer, it still counts as non-obvious.

But it’s still independent invention. It seems to me that creating something that happens to be patented by others but totally unknown to you should still count. Still allow you to benefit from it, and possibly now fail the obviousness test.

Under that logic, someone who is only partially educated in the field experiences greatest advantage. On one hand, they’re not familiar with pre-existing solutions to the problems they’re encountering, so they waste time working on them. On the other, they could reinvent just about anything and use it carefree. But if we are to consider development of the field, and we assume that we’re fully versed, all the new technology is in non-obvious development along the same paths as have already been followed. History tells us that while much development happens along these lines, it is more the natural progression of the field than the sort of developmental leap that tends to happen when not versed.

There seems to be a natural point at which an invention is no longer non-obvious, and the point at which it is independently invented would seem to qualify. More to the point, techniques that would otherwise be considered public domain, and presumably taught in schools,

Under current law, that’s still infringement.

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.

Seems to me that there’s a finite number of lawns to mow. There are economies of scale, and it’s well known that when providing a service or doing business, that results in a natural monopoly.

So if you push it all the way out, you have “MicroLawns INC”, that owns all of the lawn care business. Maybe there’s room for specialty? OK, that seems to be happening in the medical profession.. each doctor is a specialist, and the fields of specialty are rapidly narrowing. General practicioners are more and more rare, just because the development of new fields has been so aggressive.

So the extreme situation there is that everyone’s job is unique. Everyone works as hard as they possibly can on the thing they’re absolutely best suited to do, because anywhere that someone else can do better becomes grounds for them to outcompete you.

The monopoly would be composed of such people, so that the gestalt entity can handle all such situations, and thus compete better than a standalone individual.

There’s a lot lost in the fray.. no matter how diverse the menu of options, preferences are also diverse.. If every need shares that diversity, then there’s an unending list of meetable needs, which can be met optimally but not exactly by one provider. And that has a margin for improvement.

In a lot of ways, it’s a multidimensional market. I’m speaking in general and more abstract terms, but we’re all familiar with the idea, to use another context, of buying a new computer. Dozens of parts and features, you decide what you like or want, look at what’s available, and choose something that’s imperfect but close enough.

So there are a lot of margins… availability of information, availability of service/goods providers, mutability of aspects of the need..

Specifically, I’m trying to look at the situation in which those margins disappear. Because I think that’s what happens when the American dream is executed by all players until there is no more benefit possible to any player..

Further, I think as the game progresses, it becomes more and more challenging for the individual players. Jeffy’s got a thousand ideas on how to make a good product or make something better, like his automatic plant waterers.. But he can’t compete with wal-mart or sky-mall.

I do believe there are upper limits to an individual’s ability. So what happens when you have someone who, trying as hard as they possibly could, fulfilling all the potential they have, has nothing to offer?

It’s easier to analyze with world of warcraft toons, because they have a finite set of abilities/attributes, a definite maximal ability, yet still participate in an economy. My paladin can’t become a better engineer than the best engineer on the server. Someone’s already got every recipe and max skill. There is a limited need for those people, assuming any of them will be happy with 10% of the available business, after the minimum availability is 10, there’s nowhere for my paladin to peddle. Wow still has margins of locality, but we can narrow it to the number of major cities reasonably. All that’s left is price, and we all have the same lower limit of costs, somewhere it’ll come down to the minimum gold value of playtime. (Sweatshops anyone?)

I wonder how close we are to that today.

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.

Seems to me there should have been a few questions on that civic literacy quiz about why it’s good to be a citizen.

I would love to have seen a question “What is The American Dream?”

Because it seems to me that there’s been a shift. I spoke with a friend recently regarding Rights of Stewardship. Specifically, why we, as Americans, are allowed to be here and have the opportunities we do, and others aren’t. Immigration type stuff.

I’ve previously been lax on immigration; the US already accepts a huge influx, and obviously there’s interest in more. Most of the anti-immigration sentiment I see is regular bigotry and greed. Much of the real issue in my mind, has been the load on social services. Costs to provide public services, such as police, road maintenance, mail delivery, etc, increase with the population. Illegal immigration, which I’ve not specifically addressed, costs as much as legal immigration, but without the returns of tax collection.

That’s one reason the border states CA/TX/FL have higher sales taxes, to derive income from otherwise untapped people.

Which had left me in the position of being pro-immigration. Opposed to illegal immigration, of course, but in favor of general immigration provided the social services scale appropriately. Which just means that we accept whatever we can. Maybe that’s already true, I don’t know.

Recently, however, I’ve been thinking. Thinking about what entitles we citizens to be here and voting and not others. Strong in my mind is the reminder that we too have not been here very long. Colin made the point that other countries could certainly have followed the path that we did over the last 300 years. Had the policies we had, the culture, people, and resources, they could be where we are too. While much is debatable there, the single most important thing is the people, because they determine much of the rest.

I’ve read “People have exactly the government they want”. And it seems to me there’s some truth to that, once you get past the initial problem of knowing what they want, and knowing what their actions will give them, they continue to perpetuate the ideals that make their country what it is today.

What sets early America aside from other developing countries, at the time it was developing, and continually today, was the ability and desire for people to make something of themselves. That is “The American Dream”. Though if you read the wikipedia article or other references, you’ll find that it’s grown to mean you can make your life anything you want it to be through work and choice.

Seems like a lot of Americans today want independence. The ability to do whatever they want with nothing required of them. Ironically, yet predictably, they don’t want to work to achieve that.

So part of every American’s civic literacy is that dream. What entitles us to this country is that difference. That desire to work to better our lot, the ability to do so. I rather suspect many would rather win the lottery.

I suspect my Immigration policy has changed along those lines. As has my social program policy.

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.