TheLoneWolfling

If the time differential is too extreme it will skip ahead or back instead of just skewing.

> ...The ntpd algorithms discard sample offsets exceeding 128 ms, unless the interval during which no sample offset is less than 128 ms exceeds 900s. The first sample after that, no matter what the offset, steps the clock to the indicated time.

> This may on occasion cause the clock to be set backwards if the local clock time is more than 128 [m]s in the future relative to the server. In some applications, this behavior may be unacceptable.

And when someone embeds an entire book (that was otherwise written and they have the rights for) into the handshake, what then?

> there are cases where the firmware inherently requires copyrighted material (For instance, requiring a (copyrighted) poem in a handshake).

> Nothing says you can't acquire parts from another manufacturer, nor is there anything preventing you from performing the repairs yourself.

Incorrect.

> I'm not sure if you've been keeping up with US news, but this isn't true, at least until it's decided in court. GM, John Deere, and Ford all have the opposite opinion[1][2][3]

> [1]http://www.againstcronycapitalism.org/2015/04/john-deere-and....

> [2]https://www.techdirt.com/articles/20150421/23581430744/gm-sa....

> [3]http://news.boldride.com/2015/04/gm-wants-to-make-working-on....

> Not to mention I think it's currently illegal to Jailbreak an iPhone or root an Android, despite them being yours.

> I really do wish the US was as cut/dry as you make it seem, and I wish they cared about consumers more, but in reality, Companies get far more rights then we, as consumers, do.

For instance: parts that refuse to work unless all other parts return a handshake containing a copyrighted message.

> If you want to blow away the firmware...

False premise: you often cannot blow away the firmware, because it is either hard-coded, or signed.

And even when said premise is correct for a device, there are cases where the firmware inherently requires copyrighted material (For instance, requiring a (copyrighted) poem in a handshake).

That has been tried before: https://web.archive.org/web/20140412085458/https://revokame....

It isn't.

You have a problem. You use a regex. Now you have two problems.

Not possible. There are > 2 intersections with an odd number of streets. (Note that this includes dead-end streets)

> You can do exactly what java calls enums with classes in C#

No you cannot. You lose the single biggest benefit of enumerations - namely compile-time checking. (For instance: warning when a switch statement does not cover all cases.)

Try to do this in C#, and you'll see what I mean: http://snipplr.com/view/42422/the-planet-enum-example/. Either you end up with it being ~3x as verbose (if not more), or you lose the compile-time benefits, or both.

Again, "Please don't post on HN to ask or tell us something (e.g. to ask us questions about Y Combinator, or to ask or complain about moderation)."

So is it acceptable to post separate threads about the topic of paywalls, then? Because if so, please make that explicit. At the very least, I did not get that impression, and reading through this thread it would appear I am not alone. And - assuming it is acceptable - how? Ask HN does not seem appropriate. Tell HN does not seem appropriate. HN doesn't generally have discussion threads on their own right. We are being told that other threads are not appropriate. The HN guidelines say "Please don't post on HN to ask or tell us something (e.g. to ask us questions about Y Combinator, or to ask or complain about moderation)." So where is appropriate, then?

Also, the reason why said discussions are starting to "choke other threads like weeds" is because it is rather hard to have a discussion about something when one has to resort to increasingly-complex and quasi-legal methods (if not downright illegal in some places) just to read the content people are trying to have a discussion about.

I think it is a subject that should be brought up. I do not think that a flat-out "stop complaining about it" is the proper response - and, to be frank, it disappoints me that that is the approach you seem to have decided to take.

It very much reminds me of an ostrich sticking its head in the sand - namely, that the response of a link aggregator to more and more of the links it aggregates disappearing is to say "no it's not, there are <insert increasingly complex and increasingly quasi-legal workarounds here>, now stop complaining".

It's not just now that should be worrying, it's the continuation of the trend. And a website as major as this within its domain is one of the few that has more than a snowball's chance in Hell to divert said trend, assuming it acts in a timely fashion. But this is just waiting around like a lobster in a pot of water being slowly heated.

What bugs me is not so much caching as redundant caching.

I've seen applications that have 5 redundant caches, if not more (on-disk cache, OS cache, VM OS cache, stdlib cache, programmer-visible cache). And then you end up killing the actually-important caches (CPU caches, etc) from the amount of redundant copying required...

For one, I do not consider this OK.

For two, declaring rules and then declaring that no-one is allowed to talk about said rules sets a very dangerous precedent.

For three, pretty darn ironic that both this and http://deathtobullshit.com/ are on the front page at the same time.

Elaborate?

I find it really annoying that C# enums cannot have constructors and variables.

Look at birds. Bird lungs aren't actually continuously-pumping, but are a relatively small step away from being so.

Note that there are organisms that include "wheels" (Or rather, rotary motion in general).

It's "just" that the only organisms on Earth that do so are microorganisms. Look at flagella.

But there's nothing inherent about rotary motion that is impossible for organics to do. It's "just" that there is no clear evolutionary path from something that relies on linear actuation to something that relies on rotary actuation.

(Also, note that there are pumps that are continuous that don't rely on rotary motion. Among other things, you can have two+ sacs, each with an inlet and outlet valve that can contract and expand. One expands while the other contracts, and vice versa. There's still some variation while the changeover happens - but this can be avoided if you have >2 sacs. Alternatively, there are peristaltic pumps that work continuously that can be implemented with only linear actuators. (As a bonus, this means that you don't need a centralized pump. You can integrate it into the blood vessels themselves.)

The bigger limitation tends to be respiratory, actually. Earth has only ~21% oxygen currently. You bump that up (causing all sorts of other problems), you can have faster and/or larger critters. Alternatively, you have more efficient lungs (Note that human-style lungs are relatively inefficient. Ideally you want air to flow in one direction through the lungs instead of alternating... Birds do that, IIRC.) and/or more efficient oxygen / CO2 transport in the blood. Red blood cells are not exactly efficient. (There was an Analog article at one point about diamond spheres for artificial red blood cells. A related article, https://www.foresight.org/Nanomedicine/Respirocytes3.html, says the following "In the absence of respiration or atmospheric oxygen, a fully-O2-charged augmentation dosage consisting of 9.54 x 10^14 respirocytes could provide tissue oxygen delivery and carbon dioxide removal for 12 minutes at peak exertion and 3.8 hours at rest even during cardiostasis" "A 1-liter augmentation dose increases blood O2 storage capacity 18,000%")

Again: I prefer longer lines and shorter line height. I am aware that I am in the minority on this front.

I just wish that HTML had a sane way to allow client-side preferences (Like, say, line height and width) to be expressed.

Ah, so not misunderstanding but difference of opinion. You consider software complexity comparable at a broader level than I do. A rather fundamental difference, and we have both made our points on the matter without swaying the others opinion.

(As for the V8 engine, see https://code.google.com/p/chromium/issues/list?can=1&q=Type=.... (Note that Google does not make severe recent bugs publicly available.))

I like C#. There are two reasons why I don't use it more.

First, the whole .NET thing (Or rather, the lack of cross-platform compatibility). Yes, Mono is pretty good, but nowhere near perfect. (Although note that this is changing).

And second, enums are hideous in C#. One of the few things Java does better than C#.

Ah. A misunderstanding.

What was meant was "for each <thing X that is done by complex software>, <a piece of software S> doing X correctly is improbable enough that the existence of any piece of software doing X correctly may be considered to be impossible unless there is a piece of software that hasn't been shown to do X incorrectly".

What was taken was "for each <thing X that is done by complex software>, <a piece of software S> doing X correctly is improbable enough that the existence of any piece of software doing X correctly may be considered to be impossible unless there is a piece of software that hasn't been shown to do <any thing Y that is done by complex software> incorrectly".

An important distinction.

Hopefully this makes things clearer.

Considering that is not what I was asking for (I quote, "a functional browser that doesn't have bunches and bunches of exploitable bugs in its JS engine"), it, although impressive in its own right, is irrelevant.

(Not to mention that said software isn't available for public scrutiny, and as such I have to take the assertion that it is bulletproof with a grain of salt. I mean, even NASA has had braindead-stupid moments (failing to convert units properly? A casting error? Running out of space on the filesystem?)))

I don't mind having a filesystem that works reasonably well on most devices. But I would consider "being able to append to a file reasonably quickly" as part of that "reasonably well".

Note that it's entirely possible to have a filesystem that's actually several different filesystems with a magic selector. (I mean, block sizes and reserved block percentages and inline inodes already are along those lines)

Again, there is a (massive) distinction between Turing-complete languages and non Turing-complete ones in terms of how often they are exploited (and in terms of how severe said exploits tend to be). I don't mind non Turing-complete languages being run clientside, but do mind Turing-complete languages being run clientside, for mainly that reason. (Also, because Turing-complete languages tend to end up abused in terms of resource use).

And you can do most of a thin client, if not all, while keeping sane bandwidth use. (Note that almost all cases where bandwidth use would be excessive for a thin client in a web setting, said bandwidth use would also be excessive for a fat client in a web setting.)

It's mainly that current tech has settled on the brute-force approach of "let's stream every pixel and then try to compress it" as opposed to saner approaches (vector graphics, remote compositing, that sort of thing). But note that there are, for example, remote desktop protocols that work well (for most things) over a dial-up connection!

And now you know (one of the reasons) why I don't own property.

How long until we get a heartbleed-like attack where some software overruns its GPU buffer into a webgl buffer?

Or you have one filesystem that is geared towards dumb flash, and another that is geared towards smart flash.

I don't see why people try to design filesystems that do everything. As usual for hybrids, they try to do everything and as a result don't work well anywhere.

As long as you keep the limitations of dumb flash in mind (namely, that flipping bits in one direction is slow (things are a little more complex on MLC, but still doable)), it's surprisingly easy to design a filesystem that does well on "dumb" flash.

> I'd rather hear my fan rev up a little bit while Firefox renders a big graph instead of waiting for a server to generate a picture of one and just send it to me.

You are not me. (Not to mention I am not against doing most things client-side. I am specificially against Turing-complete languages being required on the client side. Things like charts are fine.)

I do not see why things should be done multiple times when they can be done once. You're offloading visible costs to places where they are hidden and then calling it gone.

It's magnet wire. It may appear to be all-copper, but it is in fact coated with an insulator. (It's often called enameled wire, but it really generally is a polymer coating)