I first saw it on http://cdtdoug.blogspot.com/2009/05/wascana-is-over.html. I don't have the links I found later but that post and its comments all say the same thing.

Why do people keep repeating that? Even Microsoft's own developers admit that their C/C++ indexing is primitive and broken, while Eclipse's CDT, which has had maybe 0.0001% of the funding and man-hours, is already far superior.

Was elementary school hard for you, with math skills like that? Try to keep up:

500 * 500 = (5 * 5) * (100 * 100) = 25 * 10,000 = 250,000

If it doesn't, it is still far better for your software quality to use cpp (literally, the C preprocessor) to get assertions into the source code. There is basically no alternative to assertions, except for expanding them to a manual if each time, which is *still* better than not having them at all.

If you aren't using RAII semantics, you aren't really using C++, but C+-. If you're using RAII and sane integrity guarantees, exceptions avoid a lot of redundant and bug-prone code.

Even the most primitive data flow analysis would help track that down, but if the code isn't written with assertions all over, you never really know if it's consistent with assumptions or only fooling you all along. I don't write anything without assertions these days.

I for one completely agree. As someone for whom generality is code porn[1], it's been my experience that every little extra bit of generality introduces an order of magnitude more code. In practice this should still save you code compared to repeating yourself for every case, but at some point the costs outweigh the gains and you have to draw a line.

[1]: I like to combine C++ templates and polymorphism. Most people don't, but if you're willing to battle those demons, you can make extremely reusable code, that's still type-safe at compile time. I'll take Scala over that any day, but it's a fun exercise.

Let's say that programming is /already/ composition from a hierarchical tree of components, and that the most basic components (that we care about) are CPU and device instructions. Then let's say that above that level we have system calls, low-level functions, resource abstractions, classes, domain-specific modelling, etc. and that all of this is a perfectly valid composition of components.

Then let's say that the only difference you actually want is to put all of this together with a graphical editor instead of a text editor. Is that fair to say? If that's all you want, then learn to write code, because that's a lot more practical. You're the one that's wrong, not the industry.

If you seriously want components to be designed specifically for graphical composition instead of logical composition, well, that's when you know you're in the wrong industry.

You are ignoring, either through sheer ignorance or a commercial agenda, the wealth of literature and experience on how incredibly impractical it is to shoehorn complex logic and relationships into graphical forms, and especially how difficult it is for a human to interpret (let alone manipulate) the result of such a transformation. Return to the material plane and learn to program correctly, or stay out of the industry.

Well sure, you're from the past. It's best you get used to admitting that.

So who do you think will be writing the "components" for your magic system, and the infrastructure to make the system executable, designable, testable and usable? We have been progressing to increasingly high level code (and in some cases, as you say, component architectures), but the amount of code being written and maintained continues to grow, not shrink.

So the amount of code is growing, and it does more per unit mass, and software engineering skills are increasingly valuable and applicable, and you think this is a trend towards the elimination of code and software engineers? You may want to check your water and food sources for contamination.

What have you done to your Firefox to make full screen mode use anything less than the full screen? In mine all bars are hidden until the mouse cursor reaches the edge of the screen. Almost every modern graphical open source application has a full screen mode, with the notable exception of Eclipse (based on SWT, having no portable way of making a true full screen window).

It's your decision if you buy a car that does not allow a substitute stereo. However, Microsoft specifically required its third-party vendors to sell only Microsoft operating systems and to bundle only Microsoft Windows on computers. So for a very long and critical time, the only way to buy a computer was to buy one with Windows already on it, and that's a huge part of how Microsoft got its market share. These "agreements" are fundamentally anticompetitive and illegal, and apparently a very good business strategy.

There is a theoretically robust test against obviousness, and it's that if basically any reasonably competent worker in the industry could have come up with the same idea, then it's not supposed to be patentable. This is completely useless in practice because the patent examiners are very far from being competent workers in the industry, /especially/ in our industry, and so, to them, anything more sophisticated than a checkbox seems like game-changing innovation.

This is how I play SC1 with Linux-using friends. We all run OpenVPN (I host) and bridge VirtualBox interfaces to it. Using that, we don't even need the forcebindip hack that most Windows users are stuck with :)

Right, because each game client is going to submit to bnet a complete list of all of its interface IPs, including VPN and wireless connections, and bnet is going to be able to decide with only that limited information which precise subnet to ask each client to broadcast on, even though it has no knowledge at all of the topology or technology involved for each device, or even if the apparent subnets on each machine are part of a connected network. There are so many ways it can all go wrong, I would be genuinely surprised if they decided that was the right way to provide the "experience".

The best compromise would be to have each client elect a network interface to use for LAN play, and submit only that network interface's IP. You wouldn't be able to do this with aliased interfaces (many IPs per interface), but maybe you could with bridges (many interfaces per IP, though Windows does this exceedingly poorly). Giving users so much frustration and potential failure points *just* for anti-piracy, something the real hackers will subvert in a matter of days anyway, is exactly the kind of mistake Blizzard will not make.