[1] This actually turned out to be a major blunder on the part of the defense. See http://www.wired.com/2014/10/silk-road-judge-technicality/
799 karma · joined March 25, 2012
[1] This actually turned out to be a major blunder on the part of the defense. See http://www.wired.com/2014/10/silk-road-judge-technicality/
Just because a technique is sustainable at prior population levels doesn't mean it will be sustainable in the future. Slash-and-burn was used for thousands of years and is now one of the main causes of deforestation. Bottom trawling has been used for almost a thousand years and is now considered directly responsible for fishery collapse. Humans have been responsible for the extinction of thousands of animals through unsustainable hunting practices that occurred thousands or even tens of thousands of years ago.
> Also, modern cultivation techniques can strip the produce and soil of essential vitamins and nutrients. So yes, in some cases, the "inefficient" and "unsustainable" farms yield more nutritious and eco-friendly foods.
Actually modern farmers are very, very careful about keeping high quality soil because it results in higher yields and spending less on fertilizers and pesticides. 60 years ago, farming "the old-fashioned way" we had things like the dust bowl.
They've already started monetizing and seem to be doing pretty well. The "Discover" channels are pretty expensive and drive a LOT of traffic (Buzzfeed gets 21% of it's views from Snapchat[1]). Additionally, ads are inserted into "live" stories and you can buy extra filters as well. As far as I can tell none of those steps have alienated their userbase. Of course, the teen/tween crowd tends to be pretty fickle, so we'll see if they can pull it off long term.
[1] http://www.businessinsider.com/buzzfeed-gets-21-of-its-traff...
> The point is that in a synchronous design the delays have to be multiples of a clock cycle.
Not really, you can pretty much always do rebalancing between stages so that you end up with a multiple of the clock. And if you can't, you can locally skew the clock to borrow time between stages.
> Also it takes time to schedule instructions. In a simple processor with a 5 stage pipeline you can simply stall the entire pipeline, but since you stall all other instructions too, this is costly.
This is an unrelated higher level architectural distinction then asynchronous vs synchronous. The scheduling cost doesn't go away when you use asynchronous circuits.
Also why is stalling bad here? If the circuit takes 16 gate delays on some inputs and 6 gate delays on others, it doesn't matter if we use async or sync design; a fast operation behind a slow operation is still going to wait (stall) for the operation in front of it to complete. That's just a fundamental property of in order execution (which again, isn't related to async or sync circuits)
> And in a modern superscalar out-of-order processor, stall is even more expensive and you cannot reschedule all instructions for the next cycle at the end of the previous cycle because rescheduling is too complex.
What? In canonical OoO design, the default is stall! An instruction will only ever proceed to the next stage if it's dependencies have been satisfied. When a stall happens you don't need to reschedule because the instruction won't have been scheduled in the first place!
The important part from the grandparent was this:
"Ideally, it might also mean you don't need to design your pipeline quite so carefully: in a clocked design, a single slow path slows down the entire pipeline; in an asynchronous design, that one particular path may be slow, but that doesn't slow down everyone else."
Which is true! If you do a bad job of balancing your pipeline stages (or can't balance them statically because of variation/whatever) then the single slow path slows down the entire clock. However, when you can rebalance the pipeline statically, as in the example give, there's no reason that you have to design your pipeline to wait for the slowest path.
But perhaps I misunderstood the example; let me know if I'm missing anything.
You can do the exact same thing in clocked designs as well. The AND produces a "ready" signal that allows it's output to skip the stages needed by the ADD side (or conversely, you can have the ADD side produce a stall signal that stops the pipeline). You can actually see this in modern processors - some instructions can take variable amounts of time depending on the instruction arguments (notably loads and stores, but also sometimes multiplies and divides).
I (unfortunately) did this as a T.A. in college. Despite being well versed in the material and caring quite a bit about trying to teach I used the "this is easy!" line as well as falling into many other teaching traps. I think part of the problem was that I never had a problem learning the material (I came into college with a fair amount of prior experience) so it was hard to relate when people had trouble. The other problem was without being formally taught about how to teach, it's hard to get feedback on what's helpful and what's counterproductive. For instance, it wasn't until I took a class with my girlfriend that I realized how much I interrupted or talked over other students when they asked questions. Without direct feedback I would probably still be doing it.
Regardless, even in this thread there are people who claim to be from small schools and have not experienced physical violence. I'm not saying it doesn't happen, but I do think it's far, far less common than Hollywood would have you believe.
The vast, vast majority of violence that happened at my school (and we had a fair amount) was between unpopular, non-nerdy kids with homelife problems.
VLIW has been around for a while (Itanium is probably the most famous "general purpose" example) and has failed to gain traction outside of GPUs and DSP (ie not "ordinary code").
Modern x86 and high performance ARM cores are almost unrecognizable compared to processors in the late 90s, much less the 80s. (Also, ARM was founded in 1990, not the 80s).
> While I have no doubt that the implementation of these architectures has improved to reflect modern manufacturing capabilities, this still suggests that there is room for architectural improvements in performance.
There are still performance improvements to be had, but it's not going to be anywhere near the performance scaling of Moore's law. The rate of architectural improvements is also slowing down as well (and increasingly only applicable for a smaller and smaller fraction of workloads).
> I can imagine there beyond other classical devices that can compute certain functions more efficiently than a pure transistor based solution can.
Like...? Quantum is 10+ years away right now and unlikely to get fast any time soon. CMOS has had decades and billions of dollars invested in scaling; it's going to be a long time before any of the current "CMOS killers" (virtually all of which are still transistors) reach parity.
Interestingly, I remember hearing about this exact problem in the context of Swift's closures; if you want type inference, you need to leave off the parens around the parameters. This is mainly done (IIRC) because it's easier for the parser.
[1] http://blog.reverberate.org/2013/08/parsing-c-is-literally-u...
You can already do "using ClassX", but yeah, the package management story in C++ isn't great.
There's a proposal for modules in C++[1], which should help, but as far as I know that's not going to be in C++17. Clang already has a (different) version implemented as well[2].
[1] http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n446... [2] http://clang.llvm.org/docs/Modules.html
However, your original comment made it sound like we had direct confirmation of that fact. I hadn't heard that before, which is why I was interested.
For reference I've googled every combination of "nsa apple mobile OS leak" I could think of and couldn't find a primary source.
Do you have a link to a leak that shows this? I couldn't find anything with a simple google search.
Pretty much. "Textbook" branch prediction isn't really dependent on the actual data, but on the global and local branch history. If it sees a loop is taken 9/10 times and there's no particular pattern, guessing "taken" is a pretty good idea.
> Which buffers?
If you're assuming the strings are not cached, probably the load-store unit (LSU), which keeps track of outstanding loads and stores.
> Does it stop speculating at some maximum number of branches?
Not that I'm aware of. With out-of-order execution you'd use something like Tomasulo's algorithm, which won't stop speculating until the reorder buffer (ROB) is full. In this case, the ROB is usually much larger than the LSU, so I'd think that would be the limiting factor.