bff's comments

Smart and automated homes are closely related to my research so I'll chime in on this. Even though the technology exists to do lots of cool things no one has built a modular system that you can mix and match pieces to.

Right now each "smart" feature would be completely separate from the rest so you can't amortize the cost of each one. So if you want a home security system, an automatic door and window locker, and an item tracking system you will need to pay for and install three separate systems. Since the utility of some of those systems just isn't that great people only install the system that has the highest economic benefit -- the home security system. Everything else costs too much for too little benefit.

You can always use the slackware-current packages to run with software that is newer than the last release.

Campaign money also comes from people though, so if enough people care about an issue then even politicians who only care about raising money will respond. A quick google search shows that a large amount of Obama's money comes from individual donors (http://www.opensecrets.org/news/2011/10/grassroots-donors-sw...) so he has a strong incentive to do popular things.

Someone else posted that people who raise more money tend to win elections, but this could also be caused by the more popular candidate raising more money. People might also be more willing to send money to a candidate if they think that candidate will win since no one wants to waste money on a losing candidate.

The software process that develops the applications are very different. An avionics system must be able to operate autonomously, must have robust fault detection and tolerance, and must interact directly with many hardware components.

Web apps tend to layer on top of other systems and can reuse a lot of code. When I worked on avionics software we had to develop everything, from the hardware drivers for memory modules to the drivers for the display and all of the controlling systems for each of them. A high-performance web app just needs to perform well enough - at some point you can add more hardware. In an avionics platform you have specific weight, cooling, and power requirements that limit your total hardware capability. They are really very different.

Not really - a lot of the technology that NASA builds ends up being used in other areas, from materials science to computer engineering.

Don't get too excited just yet - actually putting a sensor on everything would cost a huge amount of money and anything besides a passive RFID tag or barcode would need a battery. Consumers would need to pay an extra few dollars for everything and would need to replace batteries on everything they own every year or so. These protocols don't really do anything - the research community has bounced stuff like this around for a while. Someone actually needs to build better hardware before the Internet of Things vision actually comes true.

"Evidence-based" means that you tie statistical outcomes to procedures as apposed to doing what you think might be right based on your limited life experience (which is biased).

For example, let's say there is a test that checks for a birth defect that must be treated or it will result in infant mortality. Let's also say that the test causes infant mortality one time in 10,000. Whether you perform the test has to do with the statistical likelihood that the fetus will have the birth defect - if the likelihood is less than the probability of the test killing the baby then you shouldn't do it.

It's probably easier to use that much less power for the same performance than to push the same power in and get higher performance. On smaller size scales power leakage and heat dissipation become bigger issues so you might not be able to push the same amount of energy through as with the larger scale chip.

I feel compelled to disagree with people who insult C++ for the fun of it. In response to what you said, the STL is optimized and fast. You shouldn't be using that many smart pointers because allocating memory on the heap is usually not the best solution. If all you want is perl regex then you're right, perl would be the better choice.

Return types can't always be deduced since they can be ambiguous - imagine an if statement where one branch returns a float and the other returns a double. The desired return type could really be any numeric value since the types can be converted so the return type does need to be specified. Since C++ has overloaded functions the compiler can't just look at the function that the result is being passed into to determine the type either.

I thought the same thing when I starting working with the new standard, but I've really grown to enjoy a lot of the new features, specifically the new pointer types, rvalue references, initializer lists, variadic templates, and better support for functional programming via binds and lambdas. C++0x really does fix a lot of things that were broken on awkward previously, while also expanding support for memory and speed constrained systems via things like std::array. For me, this stuff breaths new life into the language.

I've been using them for a while now (gcc has support) and they're not awkward. The ability to specify scope is actually rather nice and most of the time you'll either leave the scope empty with [] or pass everything in by value [=] or reference [&]. The return type of the lambda function is also usually detectable by the compiler so you only need to specify it rarely.

What would stop special interests from buying a new candidate every cycle? They help the candidate get elected, the candidate crafts legislation to the special interests' benefit, then the special interest hires them as a lobbyist when their term is over.

I much prefer Zeno's Republic, where everyone is equal but strives to be wise.

Really, I think that there is no such thing as a perfect government, only a perfect citizenry, because the power of a government is always derived from the people within it. A philosopher king would not be able to maintain power unless either A) he was omnipotent or B) the people allowed him to remain in power.

This is actually an active research area so a google scholar search can turn up interesting stuff from various security conferences. Here's a summary of what I've read and heard about:

If a chip has unecrypted personal data stored on it an attacker can easily gain access to it by stealing the device. If encryption is used throughout the chip then side channel attacks can usually break the encryption. This requires something like an oscilloscope, some resistors, and a soldering iron. The danger of this attack to a consumer depends upon what's stored on the RFID chip since the consumer will notice if someone has stolen their device and will have it disabled in short order.

To clone a tag that doesn't use encryption, for instance a tag that just sends an ID, you'd need a reader to query the tags and some device to copy the responses. This is probably the easiest attack but the reader, which needs to transmit a strong radio pulse and then listen for a response, either needs to be very large or in very close proximity and you could protect a card in your wallet by surrounding it in a metal mesh (which forms a faraday cage) so it's not clear how dangerous this could be in the wild.

If the communcation channel is encrypted then an attacker could listen to the query and response from a legitimate reader and RFID tag and could then replicate the legitimate response later. However, if there is any timestamp or counter involved this won't work.

Rutgers Winlab is has also been testing a sensor based approach to detecting open parking spots. They're using a sensor on the car to detect open spaces and measure their sizes to see if they're suitable as parking spots. The professor leading the project There is an article that talks about it here: http://www.technologyreview.com/communications/24497/page1/ and the lead author of a paper explaining it is here, in case anyone is interested in reading about it. The paper title is ParkNet. http://www.winlab.rutgers.edu/~suhas/

For that range it's probably using active tags, which is why they cost so much. On the other hand passive readers often cost a few thousand dollars and have tiny ranges so I think that active systems end up being cheaper in many deployments.

I'm working on an active tag system for my phd actually, and our readers only cost as much as our tags and have the same range but they still cost somewhere in the $30-$50 range depending upon how many we make at a time. In a few years we'll probably have the cost down to a dollar or so in mass production but your projects will need to wait a while.

Another thing left out is solder flux. Some surfaces might be too small or too hard to reach and heat with the iron so I put flux onto the surface first and it causes the solder to flow into that area more easily. For instance, if you want to solder a thin wire into a small hole getting the solder to flow into the hole around the wire is difficult. If you put some flux onto the wire first and then slide it into the hole the solder will flow along the wire and will fill the hole nicely.

I've heard arguments to the contrary, for example that deflation encourages people to invest their money under their mattresses. If money you hoard loses value then you feel a stronger need to invest it, which is better for the economy as a whole. Without that incentive once a person reached some level of wealth they would sit on their money instead of putting it into a nice retirement fund that puts it into the stock market.

The value being passed in java is the value of the pointer, where the original pointer value cannot be changed by the function. This is pass-by-reference. Think of pass-by-reference as a special case of pass by value where the value of the pointer to an object is passed rather than the object itself.

If I wanted to write a function that accepted a vector and returned a slightly altered version of that vector I would make a function that does a deep copy and would return that - without ever needing to call the copy constructor myself. I think that it is nice that C++ gives me that option. I don't think that any language is flawless and it's clear that one programmer's feature is, in this case, another programmer's flaw. Keep in mind that this applies to your favorite languages as well.

Edit:

It occurs to me that the distinction is important in multithreaded programs as well. Beyond just worrying about whether or not the underlying data structure is thread safe, passing something by reference might mean sharing memory between two CPUs which can easily lead to a slowdown as the CPUs need to repeatedly flush and resynchronize what's in their cache. Thus unless I have specifically built a thread-safe class whose data has a real need to be shared between between threads I would send data from one thread to another by value rather than by reference.