I think you mean to write, "... and when the economic downturn hits, cutting IT staff will save the jobs of others."

Given how IT staff get harassed to fix everything, and blamed for everything broken, I would suggest an idea floated during my days as a university student.

See, we had these "Programmers On Duty", or PODs, many of whom were volunteers, who would look at your program, and attempt to help you find what was wrong. This was pretty much a thankless job, and anything you broke, and they couldn't fix, was considered their fault. (This was the late 70s era of punched cards, and computer printouts, with actual terminals a rare and coveted tool -- the POD had an office with, you guessed it, a terminal -- a CRT to boot, so one would not have to keep trying to use the back of discarded printouts in the DECwriters. The attraction of POD duty was access to that terminal, in hopes it would be a slow day.)

A bunch of us thought that PODs should be issued distinctive uniforms as well: superhero-style costumes actually. Ostensibly this was to distinguish them as members of a rare breed: people who could debug programs quickly. In fact, the intent was to shield their identity lest the be pestered to provide help while off duty.

The problem isn't the lack of paid overtime. The salary reflects the job, and it rather all averages out... as long as you're responsible for your work, your mistakes, and the work and mistakes of any subordinates you might have.

Where this model breaks is when you become accountable for the mistakes of others who are not your subordinates, but your peers.

IOW, you think you can enjoy the long weekend, because your work is on track. But no! Doofus-peer screwed up really badly, and is too dumb to fix it by the Tuesday deadline, so you get to play hero... without remuneration. That part rather sucks. The worst part is you realize that if it isn't fixed, the company can suffer, and hence you will suffer, through no fault of your own. So, refusing is rather like cutting off your nose to spite your face.

Then there are shops where bugs are assigned to those who have demonstrated an ability to fix them quickly... and where any bug you fix is presumed to be a mistake YOU made, and therefore reflects badly on you come review time. A certain company in Redmond is notorious for this -- the skill greatest rewarded is not good work, or an ability to fix the mistakes of others, but the ability to deflect work to others.

I once worked in a place where, after a full day, had to pull an all-nighter to fix someone else's screw up. Well, the job was done, I left around noon, and got docked a half a day vacation for doing so.

Not all shops are like that, of course, and I'm quite pleased about where I work now. But, enough are that it's off-putting. Combine the presumption that the good will fix the work of the bad with incomes that attract the incompetent and management that often can't tell the difference, and it can be a recipe for a real sweatshop. The only solution is to keep one's eyes open for better employment in such circumstances.

The upside is that we get to do something we actually enjoy. The deterministic behavior of programmable electronics (becoming indeterministic only when events can't be sequenced to the necessary temporal resolution) draws those with rational minds. For those of us with a good theoretical background in the mathematics behind it (and often one or two degrees to back that up), architecture positions pay well. I've been in the biz since 1975 from the ripe old age of 14.

The downsides, however, are many:

1) Often management doesn't understand the subtle reasons behind a problem, or why a particular solution that is easy and obvious is completely "wrong" (or at least inconsistent with future requirements).

2) There is no paid overtime. Salaries generally compensate for this, and frankly professionals SHOULD be expected to fix their errors on their own time (and their own dime). However, that does not work well in environments where workers are fungible: doofus A messes up, and expert B is stuck cleaning up the mess, often in "crisis mode" on his own time. YMMV depending on the shop. Good people tend to leave bad shops, though.

3) Academic training has given way to "trade skills". I am appalled that many undergraduate programs focus on the IDE or bloated library of the day, instead of fundamental algorithms and classic processor architecture. Add to this the fact that many non-experts can't tell the difference between the skilled and the not so skilled.

Still, I wouldn't do anything different.

... it was from outside the gate of the Palomar Observatory in California around midnight with a clear sky.

We purposefully drove there from San Diego so they could see a really starry sky.

Until the first hospitals for deliveries were set up the death rate for women in childbirth was around 16%.

I'd say those would be dicey odds for anyone delivering without emergency equipment or trained medical staff nearby,

Now, if a midwife was to have performed the delivery, this mother to be was likely deemed "low risk", so sampling bias will apply if we look at "home births where the midwife was late", but giving birth is not exactly risk-free.

The dilemma is that one might actually want to hear the band in question, or patronize the particular establishment, but the entertainment is just TOO DAMN LOUD.

I like loud music... in moderation, when I'm in the mood.

Yet, at the ripe old-farty age of 48 I find my hearing far more sensitive than that of my peers, and even my 16 year old daughter (who I'm forever admonishing to turn down the TV, music, etc. because it is TOO LOUD. She, OTOH complains she can't hear it, and risks a vicious circle of ever-louder music and hearing loss).

It's so bad that sometimes the sound in movie theaters is too loud for me.

The problem her is the background and skill set of "the next slob".

Do I include a treatise on the merits of sliding window protocols in an implementation of a TCP stack? It makes sense if "the next slob" know nothing about networking, but is smart enough to learn. Of course, the PHB will expect us to be "interchangeable" when this is clearly not true.

Or, do I dare presume that someone called upon to maintain network code will be happy with unsigned long wnd; /* sliding window */ in a structure as adequate documentation?

Often one does not even know the scope of a piece of code one is given, or what presumptions were made about "the next slob" by "last slob".

But. by far, the largest problem appears to be aggressive documentation to the level of the "lowest common denominator" expected to maintain something of the "trees" of a program, with little regard to the overall "forest" of them.

Clearly, the theater can request deletion of the parts of the movie that were recorded, but nothing else. Sounds like some frame by frame masking is in order.

I remember very clearly a tale of similar woe involving an amount of flesh to be cut, but no blood to be spilt.

Why yes, anything to distract from that film would have made that part the best three minutes of the movie.

My daughter owes me big time for seeing it with her.

Yes, but electrical stunning and subsequent shooting of a bolt through the head is not "cruel" or "unusual". That's how we "humanely" slaughter cattle.

So, I think there's a lot of "wiggle room".

True dat. My daughter dragged me to see it.

'Course I dragged her to see 2012 (WHICH I WANTED TO SEE BECAUSE OF THE SPOOFED TRAILER), so I suppose we are even.

Yay, spaceships?

Yay, Spaceships! (except they weren't)

Either the programmer does the "work" (tracking memory (languages without built-in run-time garbage collection), structure layouts (assembler programming)), or the machine does the work.

If the machine does the work once at compile time, there is no run-time overhead (think mapping structs and function arguments to memory offsets and stack frame offsets). If the machine generates code to do the work at run-time, there is run-time overhead (think virtual function delegation and base clase fixups, particularly with multiple inheritence).

Garbage collection involves run-time overhead of letting the machine track when something is no longer referenced, either because the programmer is too lazy, or can not know, or is prone to get it wrong: debugging the garbage collector is easier than debugging every program that manages memory, and that effort can be leveraged for all programs that use the garbage collector... at the expense of run-time overhead even when it is not necessary.

Smart compilers can help: pointers to dynamic memory that does not have references passed to objects or functions that affect internal state can be recognized and the related objects destroyed when the pointer leaves scope (think auto_ptr in a function). You pay the run-time garbage collection overhead only when it is "really necessary" for some value of "the compiler is not smart enough to tell".

Pointers take so many flavors, and unfortunately, most languages upcast them freely to the most general type (often losing the distinction between something allocated dynamically and not, and something that "someone else" has to handle the reclamation of... or not).

you have pointer to foo, pointer to foo on the stack, pointer to foo dynamically allocated, foo being the i't element of an array inside an object bar that is either on the stack, dynamically allocated, or static, etc. What to do when you no longer need to reference what your pointer refers to often depends on type information you either don't have, or can not be known. Operations on pointers therefore justifiably call for a virtual dispatch table... for those pointers where they may be of different flavors. And, then you have to be able to tell -- you don't always need the overhead (think of a pointer through an array that you walk and then no longer need).

I sense that language support for the various kinds of pointers is lacking, or where it is possible, upcasting to lose type information is too easy (Heck, C++ will let you take the address of anything, and wham! you've got a bald pointer. You can prevent this for specific types by overloading the address-of operator, but you can't prevent the programmer from defining a type that doesn't have an explicit one, or require all types to derive from a common base.

Well, I understand our anarchist friend's angst that rights are lost if not defended, but they are reciprocal: I don't own the public lands in my town, and it is reasonable that they be administered by elected representatives of the townsfolk and I should respect the rules related to their sharing... so long as they do not infringe rights I actually do have.

Just because I have the right to peaceful assembly does not mean others are obligated to provide me a place to do so.

Even fundamental rights, like speech, are not absolute. Prior restraint, though abused, is warranted, in narrow circumstances, when the speech would otherwise reasonably be expected to cause irreparable harm. You can shout "Fire!" in a crowded theater, but only if there is a fire there: surely a panic will ensue, but the risk of injury of trampling is less than certain death by fire. If there is no fire, such panic-inducing speech is harmful.

Private property yes. But it was also a "public place". Special laws generally apply in such circumstances: owners can ask people to leave (and they are trespassing if they don't), but the presumption is that the public are welcome.