And this is why privacy advocates try to push for pervasive cryptography. If everyone's traffic is encrypted, then use of crypto doesn't bring suspicion on you.
This is why I'm somewhat dubious about Tor. While it can be a valuable tool, by it's nature it routes you between 3 other machines, which may be spread all over the world, thus substantially impacting performance. It can't really be used by the general population, as opposed to, say, encrypted email which if implemented well would have negligible impact.
It can't really be used by the general population for some web browsing, but it can easily be used for a variety of other applications.
Most mobile traffic, for example, could probably go over Tor. All background data syncronization could go over Tor. Email and IM could go over Tor.
Assuming you still use a general-purpose computer, and try to execute code on your own CPU rather than someone else's whenever possible, it's easy to have most of your applications (email, RSS, IM, data sync) go over Tor without your noticing.
3-5 anonymous hops wouldn't be a bad thing in the future, say ~5yrs assuming continued investment in better broadband infrastructure as well as investment in Tor nodes.
The performance drop could hypothetically be unnoticeable to the user. Just as most TCP handshakes are.
This has to become a movement indeed towards pervasive cryptography. Tor's design isn't the real problem. The lack of Tor nodes/efficient broadband is the real problem.
At some point, you need to ask what you mean by 128 bit. When people talk about an 8 bit, 16 bit, 32 bit, or 64 bit processor, they are actually generally conflating two or more things. There's the size of general purpose register, the size of the data bus (how much you can load from memory in a single transfer), the size of the address bus (how many lines you have for addressing RAM), and the size of pointers. In many machines, these have been the same, though for example, 8 bit processors frequently had 14 or 16 bit addresses and busses so they could access up to 16 or 64k of memory; but there's also, for example, the 68008 with 32 bit registers, a 16 bit address bus, and an 8 bit data bus.
So, when people talk about 32 or 64 bits, they generally mean two things: the size of general purpose registers, and the size of addresses.
There's basically no need for addresses beyond 64 bits, at least for quite some time. With 64 bits, you can address 16,384 petabytes (16 exabytes) in a single process. Since the biggest single machines I can find these days support a maximum of 4 TB of RAM (if you filled it with 32 GB DIMMs that aren't yet available), we have a long way to go before you will need more than 64 bits of address space.
Furthermore, increasing address size can hurt performance. If your pointers are all 128 bit, they take up twice the space as 64 bit pointers. There have already been plenty of workloads that show a reduction in performance when ported to 64 bit machines, just because the 64 bit pointers fill up so much valuable cache space. In fact, for this reason, Linux even has support for the x32 ABI, which uses an x86-64 processor in 64 bit mode but only uses 32 bit pointers, so they can take advantage of extra registers available to x86-64 without paying the price for the larger pointers. https://en.wikipedia.org/wiki/X32_ABI
So, there's no benefit to 128 bit addresses and lots of potential downside, so it's not going to happen for quite some time. How about for data, though?
Well, most software doesn't really need to work with integers or floating point numbers larger than 64 bits, anyhow. For lots of applications, 64 or even 32 bits is sufficient. Public key crypto can frequently take advantage of large integers, though it generally needs even bigger integers, like 2048 bits, so you generally have to do bignum arithmetic anyhow.
Lots of the gains that you get from working with larger types come from working on vectors of smaller types. But for those purposes, chips have had 128 bit registers for quite some time. SSE, introduced in 1999, included 128 bit vector registers, which could be treated as 4 32 bit integers (AltiVec on PowerPC had introduced the same idea a few years earlier; the idea of SIMD has been around in supercomputers for many years). Later extensions like SSE2 expanded their use to allow you to treat them as two 64 bit floats, two 64 bit integers, 8 16 bit shorts, and 16 8-bit bytes.
So, for the only use case for which it's particularly valuable, working on vectors in aggregate, we've had 128 bit registers for quite some time. We've had 256 bit registers for a couple of years now in the form of AVX. Now this promises to expand those to 512 bits. There's no good reason to expand your addresses in the same way; at that point, you're just wasting space.
Up voted. Although 16 exabytes is less overhead if you are memory mapping persistent storage rather than just RAM which makes increasing sense with SSDs. 64bit addressing is still plenty for most scenarios for some time to come though even if this approach is taken.
When will developers start to understand that backwards compatibility is one of the most important goals of any software system? Randomly introducing something that is backwards incompatible in a minor point release is simply unacceptable.
A huge amount of complexity in using and deploying software comes about because of very narrow version requirements, where due to combinations of backwards incompatibility and necessary new features, there are very narrow windows of software which is actually usable. Add in dozens of different packages, and you are frequently left with a situation in which there is no single set that will all interoperate.
The Linux kernel has a very reasonable attitude: you don't break userspace. You just don't do it. I wish more tools would adopt this attitude. You just don't break your API, ever. No backwards-incompatible revisions, ever. If it's backwards incompatible, it's a new piece of software, not an update.
I realize that this is fairly idealistic, but having experienced so much breakage with non-backwards compatible software, and had so much better experience any time people make an actual honest effort to preserve backwards compatibility, I really hope that more developers start to consider backwards compatibility one of their primary goals, only to be broken if absolutely necessary, and only with a major version change or entire renaming of the package.
Actually GNU make is not a good target. Historically make has been extremely careful about backwards compatibility. The "bug" here is that the Makefiles were relying on an undocumented feature.
In general yes it'd be good if developers paid more attention to backwards compatibility.
Sure, they were relying on an undocumented feature, but it's not like the GNU Make developers didn't know about this. They explicitly called out the backwards incompatible change in the release note; they knew they were breaking compatibility.
My point is that even undocumented features are an important part of backwards compatibility. If there is software out there relying on it, breaking it and saying "well, they were relying on an undocumented feature" doesn't actually help your users at all. Is your goal to ensure that developers do everything the way you tell them to all the time, and punish them if they don't? Or is your goal to provide software that your users can use to do their jobs?
I disagree, when using undocumented features, the burden is fully on the developer using these features.
It is how the world works, when you use undocumented features in every aspect of life (e.g. not following the rules) it is great when you get away with that, but don't expect the world to bend their rules to accommodate you, that only happens when a majority goes that path, and often it doesn't even happen then.
No, how the world works is that you satisfy your users or your users go someplace else.
Microsoft gets this. Linus gets this. FSF and GNU, while I love their ideals, are apparently a bit too ivory tower to actually get it on things like this.
In theory that sounds great, but as we've seen with make, the end result is that the users of make just didn't upgrade. If that's not a desirable outcome for you, then it's on you to prevent that. No else is going to.
Which change are you referring to? Excluding outright bugs, there were no undocumented features that changed in 3.82.
There were several outright bugs; without a patch (that most distros apply), it would SIGABRT during the Android build, perhaps this is what a few people are referring to (I am unaware if this was the only problem with building Android on 3.82)
The most significant backwards-incompatible change was changing how pattern rules are selected if there are multiple matches, but this is documented.
Perhaps you are thinking of wildcard expansion, which has the undocumented feature of returning a sorted list? That wasn't actually changed, it was marked as a "Future backward incompatibility" that would be changed in the next release.
I can't help but think that this approach is similar to Microsoft's, and appears to have led to stagnation. It must have some upsides for developers, but I'm not sure is a winning strategy in the long run.
The goal is to produce a re-implementation of the #9 Ticket to Ride IV card (https://en.wikipedia.org/wiki/Number_Nine_Visual_Technology) which is a fixed-function graphics card released in 1998. As they say in the first paragraph, "The reason behind this was to provide a binary compatible graphics core for vertical markets: Medical Imaging, Military, Industrial, and Server products."
This is not something that will be remotely competitive with modern GPUs. Their $1,000,000 stretch goal would be to implement a modern shader engine, but given that they aren't offering any actual hardware, I'm not sure how they hope to get to that point.
You've got it. The $200k level gives you a 2D graphics card from 1998. It looks like their original target market was people who want an embedded emulation of this sort of ancient system so they can run DOS, Windows 95, or ancient Linux/X11 on it. Markets in which changing the software is horribly expensive due to compliance costs.
(I'm impressed that article is still up from 2000!)
$1m is not totally unreasonable for the shader-based design at commercial rates. Last time I did a back-of-the-envelope calculation for a shader-capable fully open graphics card delivering working silicon, I came up with two years, $2.5m, and a hiring shortlist.
I missed the 'history' paragraph. I remember the glorious #9 days. But this is so old I'm thinking it would be easier to have virtual driver translation. Even with overhead a phone gpu could outperform easily.
Probably best to list both the original URL, and some kind of link that has an archived version (either your own, or from the Wayback Machine). And of course include the date as well. With the date and the original URL, you can always use the Wayback machine or some other archival service like WebCite to attempt to find an archived version.
No citation is guaranteed to be readable after a certain amount of time. All citations are merely a reference for identify the resource that you're looking for, and you need to find it yourself in a library or from the publisher. But the publisher may not exist, you may not be able to find libraries with copies, etc. So, you can only do so much.
But if you cite the URL and date, and at least one alternative way to access the content like the Wayback Machine or WebCite or your own, you give people a pretty good chance.
Perhaps there needs to be a peer-to-peer web citation database that publishers, libraries, and individuals can join. When a book or journal contains a web citation, the publisher archives a copy of that page in their database. When a library or individual buys a book, they can pull the archived copies from the publishers. This will ensure that as long as someone out there who has a copy of the book has also maintained their web citation database and is on the network, you can pull the citations from them.
I believe that archiving of publicly available material, as archive.org does and Google's cache does, is considered not to be copyright infringement (as long as it obeys the limits in robots.txt and noarchive meta tags), as it is sufficiently transformative. So this shouldn't be a problem unless someone explicitly requested that the page not be archived, in which case you probably shouldn't rely on it for a citation.
I'm more comfortable with the path syntax, and polygons are pretty much the same as a path, except that you would prepend M and append z to the list of points (for certain buggy renderers it might be necessary to put an L inside, too). Paths have handy shorthands for horizontal, vertical and relative movement, though.
If you're more comfortable with it, that's great. To someone who's not already comfortable with it, points="0,10 20,10 10,0" is a lot more obvious than d='M0,20h20L10,0'
It's not really the most flexible option. It allows you to make only a fairly limited type of triangle, only pointing in one of eight directions.
If you want compatibility with older versions of IE, use both SVG and VML, depending on the browser (VML for IE 8 and earlier, SVG for everything else). This gives you a lot more flexibility (you can draw any polygon, arc, or bezier curve that you want), and compatibility all the way back to IE 5.
Sure, you can treat this as a hack to support older browsers. But with modern browsers, or once those older browsers fall to low enough market share, just embed SVG.
If you want to include it in your CSS, you can include it via a data URI, though you need to embed it as an actual XML document (within an HTML document, you can skip the namespace and use HTML syntax which doesn't require quotes around attributes) and can't include line breaks so the syntax is a little bit more cumbersome:
> 1 - We'll lose the W3C. We'll have to either create another standards body, or go back to the 90's situation when nobody agreed on anything.
We already lost the W3C once for about 10 years. Remember XHTML and XHTML2? Those, and a bunch of special purpose not particularly interesting niche XML standards (P3P? XML-FO?) were pretty much all they worked on for a decade or so. It wasn't until the WHATWG was formed by some browser vendors who wanted to start working on a standard for features that users would actually want, rather than what architecture astronauts thought would be a nice design, and the W3C realized that's what people were actually interested in and so replaced XHTML2 with HTML5 based on the WHATWG spec that they actually became relevant again.
Now, I will have to give credit that there were still a few groups at the W3C doing work relevant to the actual open web, such as SVG and CSS. But given how the WHATWG took over work on the HTML standard and actually did work towards a standard that was useful and relevant to browser vendors when the W3C went off the rails the last time means that I'm not too worried if it goes off the rails again this time, you can always form another standards body if it becomes irrelevant. You just need to be sure to recognize this early on, so you don't waste too much time and effort waiting for the W3C to get its act together again.
> W3C realized that's what people were actually interested in
So, with XHTML, the main thing is that people just wanted their web pages to work like they always had; they didn't want to deal with adding slashes to make their web pages XML and strict parsers and whatnot.
But with P3P, what people want is Netflix and Rdio on all their devices (such as ARM-based Samsung Chromebooks).
Frankly, I prefer the sound of standardized DRM to everyone rolling their own ala the 90s; with any luck it'll mean fewer formats/keys that need to be reverse engineered and whatnot.
First of all, I think you have gotten P3P confused with EME (or whatever the new term is). P3P, the "platform for privacy protection" was just one of my examples of previous useless stuff the W3C has worked on (it was basically a schema for describing a website's privacy policy, with dubious advantages over simply linking to a privacy policy in the footer).
Second, none of the proposals for EME that I've seen actually address the issue of being able to play the same content across devices. They aren't a standardized DRM scheme; they are merely hooks for proprietary DRM schemes, essentially a way to allow proprietary DRM schemes to hook into the HTML5 media player rather than having to use the plugin interface and implement the media player in Flash or Silverlight. It's basically just a plugin API for plugins that provide only DRM, leaving the rest up to the browser.
Don't think that this is meant to actually increase interoperability; a large portion of the "value" of DRM, for those who promote it, it the ability to have various lucrative exclusive contracts with particular cable networks, hardware vendors, and so on. You're just going to see more "Live NFL - a Samsung exclusive!", not actually be able to get Netflix on any device you want.
If it worked across any device, then it would need to work on open devices as well, but of course if the device is open you can bypass the DRM. So it's always going to be based on licenses, that only certain vendors can get if they promise to implement DRM securely and not give users full access to their own devices.
> They aren't a standardized DRM scheme; they are merely hooks for proprietary DRM schemes, essentially a way to allow proprietary DRM schemes to hook into the HTML5 media player rather than having to use the plugin interface and implement the media player in Flash or Silverlight. It's basically just a plugin API for plugins that provide only DRM, leaving the rest up to the browser.
Exactly: its a specification for a constrained plugin API focussed DRM, so that browsers don't have to either maintain a common general purpose plugin API (e.g., NPAPI) or, alternatively, have browser-specific APIs in order to meet content-owners demand for a DRM-supporting delivery channel.
This is why I'm somewhat dubious about Tor. While it can be a valuable tool, by it's nature it routes you between 3 other machines, which may be spread all over the world, thus substantially impacting performance. It can't really be used by the general population, as opposed to, say, encrypted email which if implemented well would have negligible impact.