How is this any different than Intel copyrighting x86 instruction code.

It's not very different: APIs are interface to library systems layered below the app whereas CPU instructions are interface from app to CPU below the app.

AMD has a license to use the interface (CPU instruction API) whereas Google does not for Java. The fair use argument is totally bullshit, because under that excuse some company could build an x86 CPU without paying Intel for the x86 instruction set.

they copied the structure, not the code.

Really? Class API declarations are not code? The API declarations were copied, but not the implementation, and that's still copying code exactly. Google just has a habit of not paying for copyrighted content. Let's look at some examples:

* The content Google search displays when you use a search phrase -- this might be okay because of fair use.
* Google Images
* Google Books
* Google News

So they followed the same routine and copied the API of Java (because copying code implementing API will lead to a guaranteed loss in a lawsuit).

When a user touches the screen, the x, y touch position is passed to the app. With force touch, the amount of pressure the finger exerts on the screen is also passed to the app allowing for all kinds of interesting behavior.

Why don't the cab drivers move to Uber so they don't have to pay the licensing fees

Why should taxi drivers pay thousands of Euros for the privilege of driving a taxi? That seems excessive and non-democratic. The taxi driver in turn has to charge the passenger extra to cover the high cost of the license.

The license fees should be cheap and nominal. If there are more drivers than licenses, there should be a lottery system (not a bribe system) to select which driver wins the (non-transferable) license.

where the professor, as far as we knew, existed only on some VHS tapes in the corner of the room.

Why do you need a $80-100k professor to repeat the same words over and over for 10 or 20 years? A video recording can do the job an order of magnitude better (assuming high-quality graphic models shown to augment the audio portion of the professor).

I ended up having to go to my physics TA to figure out what was going on. I remember feeling ripped off and pretty much disgusted.

With a flesh-and-blood professor, how many times can you interrupt him in class with a question before he throws you out? No many, I assume. I wish each lecture video had a youtube-like comment section where students could ask questions about a certain issue s/he is facing in that particular video as opposed to a general forum to discuss all problems.

If only Flash had been implemented in a safer programming language, like Pascal, these bugs would've been rare and few. But all the macho programmers love C/C++, so more vulnerabilities and updates for you every day.

When 5 companies have 75% market share, it's a highly monopolistic market, which will result in very high prices because of lack of competition.

You need to figure out how (politically and technically) only five companies are allowed to profit from a commodity service. Imagine if only 5 vendors made and sold all t-shirts. How high would the price of t-shirts be then?

You want to prevent a private company from offering a product for sale? I am not sure that I agree.

Why not? There are plenty of restrictions on the sale of weapons, like guns and you can't buy machine guns or bazookas. These Glass-like products are worse than guns because they can be used way more often.

I hate the very idea of Google Glass and what it could become but I do not want to ban it. I would be okay with restricting some uses of it, I would have to think about the uses carefully before I agreed with them,

The user of Glass (usually a glasshole) does not care about the privacy of others. Cameras were more benign (used mainly for security) before the advent of computers+networking. With networking, you can now permanently store images of people even if these people don't want to. Therefore the age old law of no privacy in public is no longer valid and needs to be revisited. The new laws would set boundaries as to what can and cannot be recorded in public.

But what if there's a hit and run, and some bystander witnesses the accident? What if a driver in a sports car speeds away from the cops while breaking the speed limit? There are plenty of such cases where license plates are necessary but these plate readers are abusing this requirement. I guess you can commit crimes openly when you write the laws.

It's time to rewrite the laws: the public has a right to privacy, even in public places. Stop evil, criminal technologies like license plate readers, CCTV cameras on streets, Oregon's GPS car tracking and Google Glass.

How will they know you read a page in an ebook unless they have 24/7 access to what you are reading with your ereader/tablet.

Well, the book reader software will just store the pages you read (and perhaps how much time you spent on each page) into flash storage. When you connect online, it will upload the data to amazon's servers. I gotta agree with you, fuck this shit. These people need to be forced to stop this and fined tens of millions for privacy violation.

does that mean I don't have to pay Amazon unless I read each page?

No, it's like cable TV where you pay the monthly fee even if you don't turn on the TV.

All subscriber monthly payments go into a big pot and authors get paid proportional to how many pages of their books have been read. But here's the odd thing: all authors make the same amount per page regardless of quality of writing, difficulty of the subject matter or whether it's in a niche market. That's just communistic and greedy of Amazon. Imagine a doctor, an engineer, a nurse and a bus driver getting the same wage, even though the doctor and engineer worked very hard to get where they were.

This type of pricing will encourage creation of cheap novels and reference material a lot.

"once it's bought, the seller and author are right the fuck out of the picture, and the owner can do whatever they want with it," as it should be.

That's fine as long as "whatever they want it," does not include distributing 200 free copies to other people. Because that would mean each reader only paid an average of 10 cents for the book, i.e., consumers being cheap and greedy.

A more robust solution would be using the highest bit in the variable to denote integer NaN. That would reduce your signed int32 into a signed 31 bit integer, the unsigned 32 bit var would become unsigned 31 bits, the signed 64-bit would become signed 63-bit integer and so on.

-iNaN = iNaN
iNaN + var -> iNaN
iNaN - var -> iNaN
iNaN * var -> iNaN
iNaN / var -> iNaN
iNaN | var -> iNaN
iNaN & var -> iNaN
iNaN ^ var -> iNaN
~iNaN -> iNaN

where var is either a valid integer or an iNaN.

But the more I think about it, it seems there are very few instances where we have integer divBy0 in a real program. Since most divide instructions belong to equations that are usually implemented in floating point code, there is no need to have any type of integer NaN.

For non-zero/0, infinity is the "correct" answer and anything else will give strange results.

It is not the correct answer since the correct answer is NaN. It's just a hack to avoid having to write exception handlers for every other line of FP code.

If we had to do tons of integer division, we would need an integer NaN too.

you have an easy alternative, which is a try/catch structure.

That's not easy, instead it's a nightmare. If you add try/catch near the point of division, you have to add these try-catch boilerplate code all over your code base. If you add the try-catch at a higher level (near your main()), that too causes headaches because now you have to restart and reinitialize the parts that got discarded after the exception was thrown.

It is precisely to handle these types of problems that the IEEE 754 standard uses NaN or Infinity for div-by-zero (because divisions are extremely common in FP code). That is, it is better to generate and propagate the wrong result (NaN) than it is to filter inputs and other data that cause div-by-zero, or handle exceptions in try/catch.

I do actually agree with you and would propose that signed integer formats should reserve 0x8000000

Yes, the highest bit should be reserved for nullity/NaN. Any arithmetic operation on a nullity variable should result in a nullity. There won't be any drop in performance if the CPU supports it, but the range of integers will be halved (from 2 billion to 1 billion for int32 variables). But that's not a big deal in a world where 64 bit integers are common.