Hacker Newsnew | past | comments | ask | show | jobs | submit | more lambda's commentslogin

Doesn't matter. A few wrong characters can easily be brute-forced. Once you have enough of the characters, you can just write a program to try modifying a few of them until you get a key that works.


So, how long has SCTP been around? And how many consumers are actually able to use it?

The problem is, IP and TCP and NAT and firewalls and BGP and OSPF are all fairly fundamental facts of the network we operate on. There's no way to unilaterally move to something else without, well, breaking the internet. IPv6 has been around for 17 years, and we're running out of IPv4 addresses at an alarming rate, yet IPv6 still has single-digit (or less) penetration.

The advantage of MPTCP is that it operates over what look to any observer as regular TCP connections. This means it's compatible with all of the NAT and firewall technologies that know how to deal with TCP, while still giving you the bandwidth and reliability advantages of utilizing multiple paths.

I'm not really sure how your example about PMTUD is supposed to support your case. That's an example of a technology that doesn't work within the constraints of the network as it's actually built, in which ICMP is not something that can be relied upon. The whole point of the MPTCP hack is to make it compatible with the existing network, and fall back gracefully to a single path TCP connection if that doesn't work, rather than something like SCTP which simply doesn't work at all if you're behind a NAT that doesn't know what SCTP is.

What session state that is "fundamental to security controls" does MPTCP lose? There's nothing that I can think of that you could do with MPTCP that you couldn't do with just two or more single path TCP connections. I'm also not sure why you think that QoS would be particularly impacted by multiple paths; you can always just use a single path and leave the second path only as a fallback, and then the QoS story should be exactly the same as you had originally, just with higher availability. Does SCTP do something special to make QoS work better over multiple paths? And why do you think that MPTCP assumes that you know the network end-to-end? Everything I've seen about it's design seems to imply that they were very careful to design with assumptions of the most degenerate possible network conditions that are still successfully able to transmit plain old TCP.

Multipath TCP isn't something that Apple just created unilaterally; it's been in development at the IETF for years with several implementations on different operating systems, and lots of experimental data to back it up. I think it's an excellent attempt at getting a working multipath solution out there, that doesn't require boiling the oceans like SCTP or IPv6 do.


I wasn't advocating SCTP - I was simply using it as an example. Anyone can use it, just like any other protocol. Most operating systems support it today, but again, not advocating it as the "replacement", just using it as an example.

There are no bandwidth or reliability advantages of using multiple path IF you have constraints of network devices upstream. Why? Generally because upstream you're going to be traversing the same endpoint path as you converge. You may have disparate paths for a number of hops but generally your Internet connections on, say, mobile and cable will be geographically tied to the same region (let's say Chicago). There is no guarantee here for reliability (especially if both hosts are NOT multi-homed) - and if there is a problem the closer it is to the destination will exponentially increase the chance that the path for both ends up broken. Beyond that MPTCP doesn't "look" like regular TCP connections - they are regular TCP connections. The only magic is on the source. Where MPTCP solves problems is 1) in wireless handoff situations where the end user doesn't want to drop a session 2) avoiding setting things up like link aggregation in a DC environment (although this means multiple L3 paths must exist which is also additional infrastructure in most cases).

PMTUD was an analogy. It is something that's implemented everywhere and doesn't work. If organizations don't want MPTCP to work - they can very easily stop it through network controls. By default most session aware devices (firewalls, load balancers, etc) can break MPTCP by default since if they don't have the entire session they often will not allow the traffic.

The bases tenant of MPTCP breaks security models by splitting same session traffic over multiple TCP sessions. If part of a conversation goes through firewall A and the other goes through firewall B you lose context. If your firewall is L7 aware you will likely break the application tracking component. I am fully aware that each subflow is it's own session (in terms of setup/teardown) - however new security technologies will need to do extensive corroboration to fully understand flows across disparate parts of the network, and yes there is fallback for when things break.

I don't think MPTCP assumes anything. My point there was that if all the stars do not align you went through extra overhead to do nothing. Back to PMTUD - it's great when it works, but 99% of the time it doesn't.

Finally I realize that Apple has not created this. I've tested MPTCP in operational environments back in 2010 (and have been following it since 2009). The point is, I've seen it in operation and it's very niche focused on where it will showcase significant advantages. It is excellent work, I don't discount that. The reality is, however, that it's not what everyone is making it out to be. I've used it, I've implemented it, I've tested and researched it. Just because Apple is testing it - doesn't mean anything.

Ultimately I feel that closed minded statements around BGP and OSPF are half the misunderstanding of the fundamental problems. LISP is far more prevalent than you likely realize and nobody is boiling the ocean on that front and finally - IPv6 has far more than single-digit penetration. I'm pretty sure you pulled that one out of thin air. Over 40% of my home Internet traffic is IPv6 - just FYI.


I'm not really sure why the article mentions both Multipath TCP and network coding. They are very different techniques at different layers of the stack.

Multipath TCP is a way of making what looks like a single TCP connection at the socket layer actually be transmitted over several TCP connections over the network, allowing transparent sharing of bandwidth between links and roaming or failover from one link to the other. It's an actual protocol, designed to be transparent to applications and compatible with all of the hardware and software out there that mucks with TCP connections (stateful NATs and firewalls, proxies, etc) by making each connection act just like a regular TCP connection.

Network coding is a technique for reducing the bandwidth used in broadcast applications or applications over very noisy channels. The basic idea is that rather than sending packets directly, you can send the XOR of various packets (perhaps the XOR of new packets with packets that you already know the recipient has because they sent them, or that the recipient has already acknowledged), and the recipient can do some basic linear algebra to solve for the contents of packets that they haven't yet received based on ones that they have already received. This can allow you to reduce bandwidth usage in broadcast applications, and reduce retransmission round trips over noisy channels.

The problem is, it seems better suited for channels that have those characteristics (noisy and broadcast channels), which describes link-layer wireless protocols, but not transport layer protocols like TCP in general. And to apply it to something like TCP would require fundamental changes in the protocol, changing how ACKs are handled to have them reply not based on a single packet but based on how much information they are able to solve for based on the packets received so far. I'm not sure you could do it in a fully backwards compatible way that would make sense for end-to-end multipath TCP.

And as far as I can tell, the network coding research mentioned is, well, just that, mostly research, while multipath TCP is already a series of RFCs, a few experimental implementations, and at least one deployed implementation.

It seems like this article is just trying to connect this research to the recent story about multipath TCP in iOS 7, when there really isn't any direct connection between the two. It sound more like a fluff piece about a professor's research than anything actually interesting (and frustratingly, it doesn't seem to actually link to the research that it mentions either, nor even provide enough a citation to find it).


> and frustratingly, it doesn't seem to actually link to the research that it mentions either, nor even provide enough a citation to find it

Citations don't sell. Sex, violence, and realistic-sounding, baseless, faulty journalism does. Welcome to the 20xx's. :)


Disappointed that this holds for TR too.


Why? When is this a useful thing?


I once had to decode an ASCII based datastream that was encoded something like this:

* the first 14 characters were the length of the data stream in ASCII, padded with 0

* after this came the records - each record started with the size of the record, including the record header

* the record then had each field start with a letter that indicated what sort of record it was - integer, float, character, variable string - all were encoded in ASCII

* variable records were the letter "V", then a 14 byte length

Yes, the format was awful. But you asked when that would be useful. There's your answer.


You could still do this even if strings were encoded in UTF-8. Just define the length of the record to be the length in bytes.

This is why most modern programming & serialization languages (Go, Python 3, Protocol Buffers, Cap'n Proto) define separate byte[] and string types. Some things are just binary data and should be treated as such. Other things are encodings of world languages and should also be treated as such.


You don't show how O(1) random access is useful here. You show a standard length-prefixed stream encoding.


Why? The concept of a "character" actually becomes a lot less meaningful as you add support for all of the world's writing systems (and even all of the features of even the Latin alphabet, such as diacritics and ligatures). Between combining characters, ligatures, case mapping rules that map one character to many, and so on, you realize that actually, there are very few cases where you want to address a "character" as a single independent entity. In fact, for almost everything you do, just acting on a string of bytes is more useful than trying to act on characters individually.


For one, recall that the HURD project was started before Linux. At the time, there was no free Unix-like kernel they could work on; the rest of GNU had been developed on proprietary kernels.

> I feel like all the years of dev work on HURD could have been better spent on other projects, but it's not my time :(

I don't really think it's nearly as many developer years as you think. HURD isn't that big a project; it's a few people, working on what they want to work on. Most of the actual development effort goes into the Linux kernel.

There's room for more than one free kernel out there. Heck, there's room for a lot. There are still people using and developing FreeBSD, NetBSD, OpenBSD, DragonflyBSD, Darwin, Haiku, ReactOS, and more.


This. If you read RMS' announcement for GNU [1] it had to have a kernel because in 1983 there wasn't a kernel. And an "operating system" was defined as its kernel, its compiler, and the tools around that and using it in day to day work.

So it starts first on a compiler, then to basic libraries, and then to a kernel. I applaud the team for continuing on the path set forth in that announcement.

[1] https://news.ycombinator.com/item?id=6457525


How do you enforce that with Git? Any time you create a branch, it's local until you push it.

But anyhow, just give people private repos on the server. What I do is push my private WIP branches to my home directory on the server, and once it's ready for code review and merge, push it to the central repository.


Cleaning up your history before merging is important. For one, before you merge you should usually have someone do code review. No one wants to do a code review on a branch that has a bunch of false starts, typo fixups, debug print statements being added and removed, and so on. Code reviewing a branch that breaks something and then fixes it three commits later is a real pain; you sit there puzzling over the first commit, wondering how it could possibly work, and writing up a big explanation for why they need to fix something, then you go on to a later commit and realize they already fixed it.

Furthermore, dirty branches lose you a lot of the power that having a good, clean history gives you. When you do a blame on a line of code, to figure out when the last change was, do you want to see the "fix whitespace to match style guide" commit that someone insert in the branch at the end, or the actual meaningful change that occurred earlier? If you don't squash your commits to deal with these kinds of issues, you lose a lot of the power and convenience that good history gives you.

There's more. One of Git's most powerful tools is bisect, but even in a VCS without an automated bisect, doing it manually can be useful to (I've done this in SVN before). If you have a regression, but have no idea what caused it, it can be very useful to bisect your commits; find a known good version and a known bad version, then go to the commit halfway in between, test that, and depending on whether that commit is good or bad, test the one halfway between that and the known good or known bad commit. Keep doing this until you find the commit that broke your code. But this process is seriously impeded if you have a bunch of half-done commits that implement a part of a feature but break something else that's fixed up three commits later.

The "history of experimentation" nature of VCS history is just not all that interesting. Think of your VCS history more as an extended form of comments, that document why everything is the way it is. If you actually wrote comments on every line describing why you had changed it in a particular way every time you changed it, your code would wind up being more than 90% comments in not too long. Most of the time, you don't need to see this; but when you are left wondering "hmm, why is this the way it is?", good history is invaluable. The experimental changes in between aren't all that useful; if you got any information from them, then feel free to summarize that in the cleaned up commit message after you've squashed them out.

Now, that's not to say that you should always produce perfect history while working on a branch. Feel free, when you're in exploratory coding mode, to make lots of checkpoint commits, experiments, and so on. Just clean it up before you present it for review and merge. The nice thing about Git is that you have your own local branches that no one else ever has to see, clean things up quickly and easily with "git rebase -i", and present a much nicer history when it's ready for merge.


man, do I agree with you... I'm new to git, our whole company is... Every time I have to go through history, it is one big mess with a lot of intermediate stuff. It is a pain to work with.


So stop committing non-workable intermediate stuff and finish what you're doing before committing. I fail to see how it's "a pain" to have a history of everything done.

If you want to mark new features or releases, use tags for that.


No, you should never be afraid of committing anything you have at any point in time. Git works as a development tool as well as a central VCS. As long as you have committed something, it will be restorable in case you overwrite it or delete it. Telling someone to wait before committing is a bad idea. They may get a lot of work done and then inadvertently lose it somehow, permanently. Instead, you should commit often and then use interactive rebase later to clean things up. You want to be able to have the freedom to switch branches, navigate history, and work on multiple features/bugfixes at the same time. You're restricting your ability to do these things if you wait too long to commit, and you're increasing the danger of losing your work.


There's no need to squash commits with rebase. Ever.

Whether you commit often or not does not change the fact that rebase is unnecessary to keep a clean history of features/releases and obscures real commit history.

You can have a clean history of features and/or releases with tags, without destroying commit history.


Explain to me how tags get me to an understandable view of my DAG so that I can see clearly what has been happening to the code, by whom, and why. Tags are just labels put on commits. How can I get a clean view of the history by feature? Do you put a release tag on every single bug fix and logical change that someone makes? Why would I go through the hassle of putting a tag at the tip of every single code reviewed chunk of changes? Why would I want all of these tag names cluttering my git log alias that shows me the history? How are tags going to compensate for the endless bubbles of "merged master into master" that inevitably clutter up the graph when people don't bother to rebase? How do you tell git bisect to skip all the intermediate bullshit meandering commits between the countless tags?


> Explain to me how tags get me to an understandable view of my DAG so that I can see clearly what has been happening to the code, by whom, and why.

That's what the commit history is for. If you don't like seeing merges use git log --no-merges. You can use rebase to avoid seeing merge commits, but it's awfully unnecessary with the nasty side-effect of destroying history.

I was suggesting tags as way to keep an alternate history of features or releases. Features can be developed in separate branches for them, but you could tag features when you merge them in if you want an easy history of feature merges. You can list tags by date, use prefix's for sorting, etc.


The history of tags happens at the release level. That is not granular enough. The history of every last little typo fix is too granular; it's just worthless to preserve. Using tags for every merge isn't all that useful; you already have the merge commits for it.

What you want is a logical sequence of correct changes (or, as correct as anyone could tell at the time; of course no one's perfect).

If you you have to do code review, track down a bug by bisecting a commit history, or figure out what patches from one branch need to be ported to another, you want to have good history. False starts and fixes to typos from previous patches have no value; in fact, they have negative value, as they obscure the interesting information that a good history provides.

Cleaning up history really doesn't take that long. When something is about ready to merge, take a quick look through the history to figure out which patches are redundant or logically belong as part of previous patches, do a "git rebase -i", and squash them into the appropriate patches. In the process, make sure your commit message are actually good enough that someone doing a code review can actually follow what you're doing (no "fixed a bug in this function; fixed a bug in that function"; actually explain what you fixed and why your fix is the right one).


> What you want is a logical sequence of correct changes

Precisely! :)

> make sure your commit message are actually good enough that someone doing a code review can actually follow what you're doing

Yes, this is a very important point for rebasing.


What do you mean that's what the commit history is for? That's what a DAG is; that's what I'm talking about. You know what the DAG is, right? I don't want to exclude all merge commits when looking at the DAG. I merely don't want to see all of your "merged master into master" bubbles because you can't be bothered to clean up a bit and rebase before pushing your changes.

I don't know what you're going on about with this "destroying history" as if the sequence of your little typo mistakes are some kind of precious documentary that needs to be preserved in case some forensic expert wants to trace every step you made along the process of adding a widget. You might as well go find a system that records and tracks every key you type, because after all, every time you hit the backspace key, you are destroying history.

Tags do not keep alternate histories. They are simply labels on commits. You use them to mark certain commits as releases, you do not use them to track every logical change to the codebase. They are used sparingly to track the occasional version number bump as a result of a sufficiently large number of changes. These version tags do not provide the granularity I need when I look to see what is happening on a single branch at any point in time. To add them to every non-trivial commit as a way of distinguishing them from the just-dicking-around commits would be ludicrous.

edit: One more thing. I think it is absolutely silly to say in one comment "stop committing non-workable intermediate stuff and finish what you're doing before committing" and then turn around in another comment and talk about how rebase has a "nasty side-effect of destroying history". You do realize that all the editing and polishing you're doing before you make your commit is the same type of destroying history that would happen if you made small, incremental commits and then cleaned them up with rebase, right? The only difference is that your way is way more dangerous as far as losing history is concerned, and you're not taking advantage of any of the benefits of Git in the process.


> There's no need to squash commits with rebase.

Squashing is not the purpose of rebase. Rebase allows you to clean up history. Sometimes, that means _separating_ large commits into smaller, atomic ones. Sometimes that means re-ordering things to make more sense for the reader. And yes, sometimes, an atomic unit requires squashing two or more commits together.

Commits should be logical units of the codebase, not units of developer productivity over time.


You can easily squash those experimental commits and have "incremental, atomic" commits in history. What it gives you is the freedom with a clean slate after each commit. And no stashing doesn't work because the next experiment might depend on the last one. Not happy? Interactively rebase HEAD~n and get rid of all the experimental stuff. Changed your mind? Git reflog is your friend.


> When you do a blame on a line of code, to figure out when the last change was, do you want to see the "fix whitespace to match style guide" commit that someone insert in the branch at the end, or the actual meaningful change that occurred earlier?

    git blame -w # works with git diff and git show too
(You might also be interested in --word-diff=color for git diff and git show)


The example was "whitespace" but the point was "trivial subsequent change"


Well, why not a concept of 'soft' and 'hard' commits (or sub commits, or major and minor)? Let people do what they must, let the logic behind it stand, and give a nice clean history by ignoring the soft commits unless you explicitly access them?


Precisely! This is a great explanation. I'll link to it in the future. :)


I wouldn't think that bubbly windows with cheesy drop shadows and gee-whiz transparency effects would be the right choice for an operating system, either. And yet look at the last decade's design trends there, too.

Honestly, a somewhat playful humanist sans looks just fine in context, and a lot cleaner than many other trendy OS designs recently.


I have to agree with you on that. I was really looking forward to iOS 7 being a step forward in that regard, but it's as bubbly as anything else, and inconsistent to boot. At least Helvetica is nice and neutral.

I think the word for all of this is kitsch.


For one thing, evolution can sometimes work by going through several stages, of which the intermediate are not particularly useful but not harmful either. By mere chance, they happen to last long enough for the actually useful changes to build on top of them. For example, see Lenski's long term evolution experiment with e. coli.[1] He's spent 25 years breeding several populations of e. coli, and freezing samples every 500 generations or so (every 75 days). After about 20 years, he discovered that one of the strains had evolved the ability to metabolize citrate in an aerobic environment, which e. coli normally can't do. Going back to the historical record, unfreezing some of the past samples and repeating the experiment, he found that sample from after generation 20,000 could re-evolve this trait, but clones from before that time could not, indicating that there was a potentiating mutation that that particular strain had had shortly before generation 20,000, which the other samples did not have. Further evidence has shown that it may have actually been two separate potentiation mutations.

Beyond that, however, proto feathers would have probably been useful for insulation. They seem fairly similar to down feathers, which are great insulators. Given the the feathers were also colorful, they may also have been decorative, and used for catching the eye of potential mates.

1: https://en.wikipedia.org/wiki/Escherichia_coli_long-term_evo...


But we don't know that those potentiating mutations didn't have some kind of benefit on their own, so that doesn't do much for the question of how proto-feathers provide enough benefit to stick around and spread long enough for the next several million mutations to arrive and turn them into feathers. Is insulation adequate for that?


If you take a look at the Lenski paper[1], it says:

> The potentiating mutations are not known to confer any phenotype amenable to screening, so there is no simple way to distinguish between potentiated and non-potentiated clones.

Now, that isn't conclusive evidence that there was no benefit on its own, but it doesn't sound like there's any evidence that it did provide some kind of greater fitness. It sounds like all evidence shows that the original mutation didn't provide any particular phenotypic change on its own, it was only after the later mutation that it had any measurable effect.

Now, with dinosaurs it's much harder to tell. We obviously can't do any kind of controlled experiments, or observe them directly. But we can offer up a few potential explanations. One is that some mutations can occur without either helping or harming, but later on another mutation can lead to something useful.

Or there may be benefits conferred by proto-feathers. Remember, in addition to their similarity to down, proto-feathers are somewhat similar to hair, and may provide many of the benefits that hair provides: warmth, colors which allow either catching the attention of mates or blending in to the background, better sense of touch (you can feel something before your skin brushes against it), better sensation of the wind, and protection from things that may scrape or cut you.

According to Wikipedia[2], the insulation and display (colorful feathers for attracting mates) hypotheses seem to be the more probable. Obviously, we're not going to solve this by speculating here on HN, and it may be that the reason can never be conclusively determined because you can't go back in time to run controlled experiments, but based on the evidence we have those theories sound reasonably plausible.

[1]: http://www.ncbi.nlm.nih.gov/pmc/articles/PMC3461117/ [2]: https://en.wikipedia.org/wiki/Feathered_dinosaur#Primitive_f...


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: