Your mileage may vary in other countries...

They may void coverage of any components the upgrades directly cause to fail, but the rest of the product is still covered by the warranty by law.

Americans Don't Understand The Meaning of The Word "Vacation"

The Clapper is only two decades old. The X10 System is four decades old and much more useful. It's the original electronic home automation system.

I still use X10 to control more than a dozen lights with timers, day/night detectors, motion sensors, and manual controls. I control a few fail-safe appliances with it too. The modules and controllers are cheap and plentiful, you can still buy them new if you wish. The protocol is completely open and there are myriad computer interfaces. Most Free/free HA software will readily use X10 modules.

X10 lamp modules were a little wonky with CFL bulbs, but the massive shift to LEDs has solved that problem. LED bulbs work 100% with 30+ year-old X10 modules including dimming. The only real downside is no two-way verification (with standard modules), and the vampire draw is higher than modern stuff. (I think. Could be wrong there.)

The best parts? 100% Under my complete control with no mandatory "cloud" connection or privacy leaks or Internet-exposed firmware that will never be updated. You don't need a EULA to use it or read a Privacy Statement to see what they are stealing.

Because each Linux vulnerability is reported for multiple distributions. And because Linux vulnerabilities are found faster and therefore fixed faster. However you want to spin it, Windows is the one getting successfully exploited in multiple ways, so that new Windows vulnerabilities are hardly news any more, whereas its big news any time a hole shows up in Linux, and then very few fall victim to it.... partly because of the early and widespread disclosure, but more because Linux vulnerabilities typically require local access, login shell, etc. Whereas a dodgy flash file is often enough to take out a Windows box.

And it's still leaky as a sieve. That speaks to basic design flaws.

Yah, shove it. I typically have 500-600 tabs open and I like it that way. Just make it work.

I just grabbed the opera .deb package and installed it, total elapsed time roughly 30 seconds, and it is suh-weet. Thanks to whoever posted this for the suggestion. Chrome is really pissing me off these days. Firefox still likely be be my main browser because of vastly superior tab handling and actual open source project.

> The sample code will copy a and b twice, once to put them in the lambda closure, and then to pass them as arguments to do_something. Some may consider this wasteful (the easiest fix is to modify do_something to take the values as const references).

No, the easiest fix is for a & b to be moveable types, which they may well be, in which case one of those copies becomes a move, and all is right in the universe.

> So we all program in different dialects, and then scratch our heads when we read other peoples' code.

The practice of programming in dialects is more a function of the origins of the language than the size of the language. Stroustrup's most recent book does a marvelous job of demonstrating how little you have to know to program in C++ effectively: http://www.stroustrup.com/prog...

C++'s C compatibility is both its strength and its weakness, and the weakness primarily comes from people treating it as a bunch of add ons to C. If you scrap that attitude, it is entirely possible to be proficient in the language after a year of use and capable of reading most anyone's code (assuming they aren't shooting for obscurity) in another year or two. That's longer than some simpler languages, but it is hardly sufficient to excuse people's ignorance.

Perhaps not the best example of a successful software project. ;-)

Regarding repeatability: the language is fully deterministic, and compilers have as much of an incentive to be consistent as they do otherwise. If you can't get repeatable builds, then the problem is with your build environment/process more than anything else. Aside from hardware entropy sources, computers are, by design, deterministic, so if you can't reproduce a build it is because you haven't constructed a proper build closure. Certainly there is nothing about C++ that makes builds any more non-deterministic than say, C. Debian actually has a project for this: https://wiki.debian.org/Reprod..., and you may find some helpful information there. You'll notice nothing they've run in to is specific to C++.

Regarding code-to-binary structural coverage analysis. Certainly I can imagine the argument that as you get to higher and higher levels of abstraction, it becomes harder for humans to track all the transformations all the way through to assembly. One solution is to restrict the levels of abstraction you work with. I would argue that is still error prone and you are better off with using theorem prover type automated solutions (and in general, languages built around provability like ML or Coq) rather than manual verification. Even better would be to perform the verification on the compiler itself rather than the code it compiles. That said, C++ compilers do a pretty good job of tracking the origin of each bit of code they generate, which ought to make it easy to have the machine inform you of the origin of any particular code block, and C++ also does a great job of letting the programmer decide what level of abstraction they want to work with and only making the runtime pay for the abstractions they are using. Its stronger type safety also helps ensure that there aren't "hidden" code paths do to programmer error. Of course, optimizers really complicate this, so you may need to turn them off as you mentioned.

Internationalization. That sounds like an old project... one that predates the C++ standard (which means a lot of bad C habits are involved). C++ is actually very well set up for internationalization, particularly because it is so agnostic about how stings are handled. Languages like Python, Perl & surprisingly Ruby have made all kinds of unfortunate decisions around internationalization that make it look like you are fine with internationalization, but it actually blows up in your face. As an example, ICU is probably one of the foremost libraries out there, and its primary language targets are C++ & Java. The C++ target has the virtue that you can pretty much just drop in ICU strings in to a well structured C++ program and all is well in the world, where as the Java one is a bit of a pain to take advantage of (fortunately, Oracle periodically syncs the ICU code in with the JDK, but that means you have to wait for a JDK update to get the latest ICU solution).