Slashdot Mirror

Because yoga makes white supremacy - obviously: https://www.kzoo.edu/praxis/yo...

I'm going to go have a white privilege shame spiral and maybe overeat some Hagen-Das... Or should I have Ben and Jerry's - oops, never mind: http://www.dailymail.co.uk/new...

I'd have to disagree. Fixing a Blaster infection on an XP involves removing the virus, which takes perhaps ten minutes, then patching, which is perhaps another thirty minutes. All of this can be done by the end user given sufficient instructions, or by a hired college student.

Moreover, at Kalamazoo College (where I work), we mandate up to date av software. Period. We don't let them on the network until we've verified that fact. Manpower intensive? Perhaps. But I'd humbly suggest that if a school as small as ours can manage it, so can MIT. I mean, reformatting? I can understand the concern over a root-level exploit, but there's an effective solution that's far less draconian...

The lone genius may just be an anachronism.

According to Fred Brooks' classic, The Mythical Man Month, you should build your team around gurus, not try to integrate them. This guy may have been a dud but gurus are still worth looking for because they can be as much as 20 times more productive than other programmers when used properly.

They are cheaper, even when highly paid, not only because they are more productive but because they reduce project management problems since fewer programmers are needed.

A better approach than recruiting gurus may be to take good programmers and make them better and mediocre programmers and make them good. You can achieve this objective by training, incentives and sometimes just asking a programmer what he needs to be better. A manager who tries this approach should steel himself for what he may hear.

What the heck did a math degree every [sic] have to do with programming?

Math has a lot to do with programming, especially if you analyze algorithms and optimize them. This is how you discover that, for large arrays of values, Quicksort is way faster than insertion sort, which is faster than bubble sort, and why. (Check out this site for a demo.) This is how you find really clever ways to speed up multiplying really huge matrices, and when the payoff is big enough to warrant using the "clever" algorithm.

Granted, you don't need the piece of paper (i.e., the degree) to have the mathematical knowledge. But the degree is a credential that lets other people know that you know what you're talking about, to some extent. It's a yardstick, however flawed it might be. This is why many employers in my area are now eschewing self-taught programmers for those with real Comp Sci (or related) degrees.

On a personal note, I have noticed that many self-taught programmers feel they are somehow superior to those who actually busted their chops learning things like compiler theory. They often sneer at those of us who wasted our time getting that piece of paper. But you know what? Those of us from theory land often have this knack for finding better ways of doing things, and we even (gasp!) have some very nice skills at creating good abstraction frameworks. The down side is, we sometimes don't follow-through issues to their logical conclusion. After all, in academia, as long as something works, you've proven that it's doable in theory. No sense wasting time making it better, when you could be pursuing your next big problem to solve.

To speak to the original point, I think there will always be room in this world for the highly skilled programmer, someone who has both a theoretical foundation and the industry experience to make it practical.

In many ways, Pascal was a better language, but Pascal had some inane limitations that stemmed from Wirth's academic orientation....

The problem is that, once students learned Pascal, they tried to do everything in it, rather than going on to a 'real' language. This human quirk is precisely why many companies will try and get their products into schools and universities -- once people get used to product 'X' they'd rather pay the price of staying with it than learn a new, possibly better, system.

If you look at Pascal as a light-duty 'introductory' programming language that was supposed to be easy to write compilers for (probably in a language other than Pascal), then it makes LOTS more sense. (e.g. the lack of compile-time math is fine if you want to actually discourage people from using pascal in large systems, and it makes the compiler a bit easier to write). The only place that Pascal really fails is that it's actually 'good enough' that it didn't completely discourage students from using it on real world problems.

...one interview with one Microsoft exec, apparently. It appears that the exec even drew the Java parallel himself, which is irrelevant because Java, for all its good intentions, was released as a buggy, inefficient Sun product, while Linux was polished for quite some time before Redhat splashed it all over Wall Street. Even if you want to compare Linux to Java on the principle that they're both "Microsoft Competitors," which is itself somewhat iffy, Linux beats Java in the two very important ways:

• It's not buggy, and
• It's not slow.

So, the complaints made against Linux as "the next Java" are pretty baseless. Furthermore, I'm sick of seeing people misrepresent the Mindcraft benchmark! Frankly, the test in question demonstrated that Linux currently does not scale as well on multiple processors as does NT. The exec turned this into not one, but two "problems" with Linux, ie that "it lost in the benchmark" -and- "it doesn't do SMP." Which are really the same problem; cute how he worked it in twice.

The main problem with articles like this is that things MS execs say have an uncanny tendency to come true, especially when they get printed (apparently) without any other background research to determine whether they have a basis. And there's no good way to undo the damage; no one reads retractions or corrections, even if we could get them to print one.

The idea of Linux as another Java, though, is enticing in a kind of different way; obviously, programs are never going to be binary compatible between different Linuces, but Linux is actually doing quite well in covering a whole bunch of platforms with good Source compatibility. IMHO, i think the ability to "Write once, Compile anywhere!" (c) is the next best thing to what Java was supposed to do. So maybe Linux really is the next Java. But i think this time it's working :)

(sorry about posting anonymous; I don't have my password at work. Contact rkent with comments.)

Some of the ideas and innovations you mentioned should rightly be credited to Douglas Englebart. They worked together, and Englebart wasn't the only one on the team, but the work at PARC came after the work done in the late 60's at the Stanford Research Institute.