skysight-inc/HackerNews huggingface dataset:
I didn't feel like going into that level of detail, but since you brought it up you are right. ISPs were using tools like Sandvine to detect bittorrent traffic and throttle it down to unusably low speeds. The ostensible reason was that the Bittorrent protocol was using a ton of data transfer (that the customer thought they had bought, boo hoo) and that the packet storm was causing the performance of everything else to drop to shit quality (legitimate.)

I guess QoS could mean many things to many people, but in this example, I think it was techinically incorrect for them to say they were doing it for the performance of the network when they were dropping the speeds to far below what would have simply stopped the bufferbloat problem. They were mad because people were bittorrenting rather than just sending an email now and then and checking out a webpage.

So when I say FUD, I mean you can justify a lot of rotten shit to prop up your business and call it QoS. I may be wrong because this is not my area of expertise, but you can prioritize packets based on protocol in ways that keep your network working without engaging in draconian throttling and caps. I mean, if the argument is that NN means everyone can bittorrent at full speed even if it makes the entire network run like shit, well then I would be against Net Neutrality too.
How to make Ruby very (very) fast?
Can you tell us how you made a ruby programm very very fast, and what is the limit?
I think my main problem with git (though I use it) is that things that should be simple are mind numbing hard. At 2:00am when I working, having to read pages and pages to decide if git pull is the right thing is just painful.

I never felt that type of pain with SVN, it more or less just maps to directories.

To each his own I wish there was the right way to use git in 50 words or less. If I need to read a book to correctly use it ... grrrrrrr.
The smartest thing I ever did was join a men's group. It's not depression-focused per se, but in my case it became something of a depression support group. I wish I had done this 20 years ago, and I say that everyone I meet who shows an interest.
Any good tutorials on VirtualBox and Vagrant?
Maybe one could use SR (http://en.wikipedia.org/wiki/Superresolution)?
This is precisely our target state vision and where we are making significant progress in development (including an innovative pricing strategy). We would love to talk if you're interested, please feel free to email us at miimicteam@gmail.com
Yes or just human spammers in low labor cost countries.

https://www.youtube.com/watch?v=oVfHeWTKjag
I'm not entirely sure but I am pretty certain siliconc0w was being sarcastic...
Is a long article, I am sure some bits are more accurate than others as it will be made up of several sources and I cannot be bothered to fact check the entire piece, sorry.

The conversation I referenced was something I had previously read in a different article and it was quoted specifically to make a point about the assertion "We don't need people who inspire others to suicide and homicide in the name of religion.", namely the point that not only do the leaders on both sides do that, but Bush tried to do it to the leader of another nuclear power, in the language of end-time theology.

Which isn't just a bit off-key, but rather is completely fucking bat-shit.
Yes. That is farming Facebook accounts. :/

If I had meant "creating Facebook accounts", I'd have stated that. This is a technique that has been used before on various blackhat forums.

Generally farming is getting people in countries with cheap labor to go out and perform the action for you. Mechanical Turk is one way to do that.

e.g. Term in a different way:
http://www.blackhat-seo.com/2009/captcha-farms/

Captcha Farms do the same thing but with a private pool of cheap labor.

Gdb, I was trying to be circumspect and not spelling it out so some script kiddie didn't go and immediately use the technique.
Show HN: One-time redeemable download codes as a service
No one is denying the notion that coding can be helpful when writing algorithms.

But it doesn't follow that programming a machine is necessary for writing algorithms.

The machine can be and often is as much of a distraction as it is a tool when teaching CS.
> I can't also see any practical solution for a separation of concerns. Some users could e.g. work only on translation and need only to checkout XML files and push them back to the repo. With Git, that would have to be a separate repo.

I am far from being good with Git yet but why couldn't the translator simply branch out and only merge back his XML files ?
How does that work from my phone?
Even if he was, we aren't :)

Thanks!
I don't think anyone who takes issue with the fading-out of downvoted comments (like myself) thinks the mods are doing that directly. Rather, the effect makes no distinction between downvotes for mere disagreement (which are allowed anyway, but I think shouldn't be) and downvotes of rude/spam/obvious low quality posts, etc. In other words, there is as much a spectrum of quality for downvoting and upvoting as there is for commenting.

The effect takes what is, in essence, a purely subjective subset of user opinions and applies it against a user as a global censor. While the effect does appear to converge towards what is probably a correct result over time (in that correctness implies consensus opinion), the complete lack of context combined with stifling the visibility of discussion seems to be both heavy-handed and unfair.

Bear in mind, also, that text posts are faded by default, because pg assumed allowing users to post long form content would only lead to them using the forum as a blog. This suggests an almost antagonistic attitude towards user participation which is offputting to say the least.
Used both SVN and GIT on different types of projects. Gotta admit, it's been a little harder to get used to GIT. It has a more complex interface and ways of doing things.

However, it feels like comparing SVN to GIT is like comparing horses to automobiles at this point.. Yes, a horse can heal minor damages without a mechanic, your car can't. And it can swim if need arises, good luck with a car on that.

Woudn't choose a horse for anything serious though. Maybe for fun and sports.
Finally an AngularJS validation library that doesn't suck
This is required to create the intended light field, but the light field approach isn't the only one, you can do simple deconvolution also. I wonder how well that would work.
The worst part is that U.S. banks are issuing "chip-and-signature" cards and NOT true chip-and-PIN cards. This is so Americans aren't inconvenienced having to remember and enter a PIN.

Combined with a smartcard reader, Cardpeek [1] can be used to see which verification methods (and their priority if there are multiple) a card supports.

A list of what types of cards banks are issuing is maintained by the flyertalk forum as a Google Spreadsheet. [2]

[1] http://pannetrat.com/Cardpeek/
[2] https://docs.google.com/spreadsheet/ccc?key=0Ani-u3tGk5hedGR...
These are extremely superficial reasons to criticize git, leading me to believe that the author knows very little about git internals. I'll take the first critique and leave the second to someone else...

You can't pull a portion of the repo because the current state of the repo is built from the tree of commit diffs... This and the fact that git itself is a hash database leads to very efficient use of space. If you want a single folder within a repo, why isn't that folder its own repo?

Between that, the passive aggressive ;-) and the unfortunate advocacy of SVN... ugh.
What's the part that makes it more secure? Where are those details.
> But -- to the refutation of your core argument -- it's definitely never insinuated in TG that the ideas don't exist independently of the programming. Such an insinuation, that geometry does not exist independently of a programming environment, is as absurd as the notion that algorithms can't be written without a machine.

Was that my core argument? My original comment (as pointed out by the omnipresent DanBC) was poorly phrased, and was rephrased as:

https://news.ycombinator.com/item?id=8126115

> If you can teach the student to think precisely and unambiguously about a single algorithm, the unrelenting logic of the machine is no stumbling block; quite the opposite, actually.

Of course it isn't a stumbling block, logical thinking is required for both, which would also explain why they are both difficult.
I guess I disagree then, because when I think of QoS, I think of what has to be done to keep a network and services on it working smoothly. I consider it a violation of net neutrality when a packet is blocked or throttled for political or business reasons, but not when a packet is blocked or throttled to keep the integrity and functionality of the network intact. Where this still intersects with politics is when an ISP makes claims like that what its customers use the network for is itself causing problems, which really is a business problem--if all your customers are using Netflix and it's choking your network, that's not a technical problem per se--it's a mismatch between the features your network offers and the features your network users desire to use. Which is a business problem. So I am against the usage of QoS as a FUD tactic, that is to say, "we have to throttle your traffic because you're abusing the network by using it."

I don't consider technical QoS decisions to be a violation of net neutrality, because everything that is permitted is not good. I can saturate my upload with bittorrent traffic so that it makes looking at websites unusable. Dropping my bittorrent upload just enough that it doesn't cause this problem doesn't violate my rights as far as I'm concerned.
> It was a colleague of Noyce's, Robert Moore, who first realised how quickly the power of computers would multiply. A few years after that first silicon chip was created, he predicted that the number of transistors on a chip would double roughly every two years.

Gordon.
Really amazing how we can easily understand the form and motion from a few moving points. This other demo is really neat as well http://www.biomotionlab.ca/Demos/scrambled.html
Nitpick: It's just Git, it's not an acronym.

I agree git has a more complex interface - I think I've read it described as "not quite user-hostile, but only expert-friendly", which I think fits.

That said, I think the model of how commits work is far more intuitive than anything else I've come across. A commit is just a diff and a pointer to the commit that came before it, and a branch is just a pointer to a particular commit.
I worked with LiveCode a few years ago (it was called Revolution back then), adding features to an existing warehouse management system, and found it to be kind of a pain in the ass. It wasn't terrible, but using it was not an experience I care to ever repeat.

What would you want to build with it? Based on the alternatives you list, I'm guessing you're looking to develop games or applications with a non-traditional user interface. If that's the case, then I suggest looking at QML & Qt Quick — it's a better and more productive platform than any of your listed options, IMO.

OTOH, if you're looking to develop platform-native-looking productivity apps for both desktop and mobile, none of these are especially good choices, but LiveCode might be the best of a bad lot. (QML would be better, except it currently doesn't look or feel native on mobile — that's supposed to change in the next release for Android, but for iOS it's going to continue to utterly suck for at least another 6-9 months, if I understand their development roadmap correctly.)
Perhaps the issue is that there's no technical barrier to them messing around with something else, perhaps by accident. (And if you try to deal with this by playing around with filesystem-level write positions in the repo, then they can't pull down new versions of the rest of the project either.)

The only really clean solution is to use submodules (or the newer variation on the theme, git subtree). But those aren't entirely smooth either.
Nice story. I had an original Messagepad (patched, I assume) which was pretty much useless (it sucked a set of batteries dry in a few hours).

I used a Newton Messagepad 2000 for five years or so, and recorded meeting notes and contacts almost exclusively on it. (The 2.0 text recognition engine seemed to have been made for my handwriting.) It was a fantastic (but limited) device -- it ran for about a month on a set of alkalines, and actually had decent connectivity (it was one of the few devices that could print using IRDA). I had both the pretty horrible Newton SDK and even a native dev tool (NewtonBASIC) that I messed with from time to time (although it sucked compared to VB).
Thanks.

Corrected my post. For some reason I thought failure point was outside of the actual switch appliance.
That sounds about right. Initializing the variables to the first two elements in the array is something very few people think to do. Most people set them to 0, which obviously doesn't work if the array doesn't contain at least two positive values. Of course, Blackthorn is also right that it's language-dependent. Most languages give you negative infinity, or treat null or false as negative infinity in comparisons, which makes things simpler.
Technically, a commit is a _snapshot_, not a diff.
I've seen one (in Austin) that uses internet-connected thermostats: http://austinenergy.com/wps/portal/psp/residential/offerings...
leading me to believe that the author knows very little about git internals

Needing to know about the internals of git is a flaw of git, not a feature.
He's saying that "pulling a portion of the repo" is one of his use cases, and not being able to do that gets in his way.

Pointing out technical reasons why git doesn't do the job he wants doesn't make it useful for him, it just points out why the problem is hard to fix.
I was thinking more of reversing the app or running it in an emulator.
> There seems to be a misunderstanding of the word algorithm here.

I can assure you there is none , the misunderstanding is with my original comment: 'writing an algorithm'.

> You may know non-computer algorithms as "routines" or "procedures".

Like the algorithm "make a nice, hot cup of coffee", which is executed billions of times each day by biological computers known as humans.

EDIT: wrt my naff spelling.
I'm not 100% sure how the total karma is calculated, but IIRC if you downvote someone from their user page, it does not really count. The idea is that if you're hunting to downvote/upvote all posts from the same user, you're probably up to no good.
If you are doing web development in Tokyo, your salary is probably between ¥400,000 and ¥800,000 per month.
> These are extremely superficial reasons to criticize git

They are use cases which matter to the author. That's basically the opposite of superficial.

> If you want a single folder within a repo, why isn't that folder its own repo?

The author addresses this -- because the folder is not significant enough to warrant the overhead of placing it in a separate repo.
Some people like git pull, but I prefer git fetch. This gets all's the history from the remote repo without applying any changes. Then you can run something like 'git rebase -i origin/master' which is where I think git can really shine.

There is an excellent link out there that explains git in layman's terms. I think it's called git for hackers or something of the sort. It's much easier than the docs in my opinion.
You can't pull a portion of the repo because the current state of the repo is built from the tree of commit diffs... This and the fact that git itself is a hash database leads to very efficient use of space.

Sure, but knowing that is essentially irrelevant if your workflow involves a need to check out a partial tree, and Git makes it (hard|impossible|unwieldy|whatever) to do that.

If you want a single folder within a repo, why isn't that folder its own repo?

Because needless proliferation of tiny repos is a problem in its own right?

and the unfortunate advocacy of SVN... ugh.

There's nothing unfortunate about advocating SVN, if SVN is a better fit for your workflow - and by extension, presumably, someone else's workflow which happens to mirror yours.
1. OK, I'll reword: you'd rather people not back up their opinions financially?

2. Begs the question: do you consider that everyone who doesn't support gay marriage is bigoted? Also: https://yourlogicalfallacyis.com/personal-incredulity
Nitpick: A commit is not a diff, it is the entire tree. Any diffs you see are computed, not stored.

You can export a commit as a diff+pointer-to-prev-commit, but when git imports it, it gets turned back into a full tree.
Perhaps then being offensive isn't a good criteria to judge something by then.
FYI: someone has modded you down because the compiler is crashing when it compiles the C++ code, not because it is written in any particular language.
"Doctor, it hurts when I do this" does have an answer of its own.
What!? The scenario you described doesn't make much sense. Why would you need to read pages to determine if git pull is the correct command to use?
Screw Yo App. Text matters
Cause it binds you to a particular company, protocol, etc. This is open source, and does not create a single point of monitoring.
Git is overrated.

Other problems include:

o Complex, confusing terminology including multiple non-obvious names for various components.

o Huge number, about 148, of commands with many sub-commands that often do non-obvious, even unrelated things.

o git rebase enables users to rewrite history which subverts what should be the main, if not only, function of a version control system.

o Git has been bundled with code review systems like Gerrit which encourages developers to rebase heavily to create a false history presenting themselves as fantasy 10X programmers who don't make mistakes, debug, engage in trial and error, or all the other things developers actually do. When a bug does slip through as if often does despite the supposed quality-control benefits of code review, then reconstructing what happened from the rebased "history" can be a nightmare.

o There are numerous commands to do similar, overlapping but nonetheless different tasks. If for example you want to back up to earlier versions of code you can do git revert, git reset --hard, git reset --soft, git checkout -- <SHA>, git checkout <SHA> -- all of which do different but overlapping things.

o A supposed virtue of git is that it makes it extremely easy to create "branches." This often leads to a proliferation of branches, making locating changes and reconstructing the history of changes extremely difficult. A change can occur on a local branch on one developer's computer, be rebased into another local branch and then finally rebased or merged into the shared "master" branch.

o Cryptic hexadecimal SHA for identifying commits instead of sequential numbers for individual files as well as snapshots of the entire project. Even if you track down the tricks to compile the SHA into a program or file name, the SHA is not sequential making it difficult to know which version of a file or group of files is in a program.

o These many flaws in git and its command line interface have resulted in a proliferation of third-party add-on tools like the Android project's repo utility, gitk, magit in Emacs, sourcetree, many of which fail to fully wrap the complexity of Git forcing users to both master the wrapper tool and the Git command line especially on more complex projects. Some of these GUI/wrapper tools like Android repo seem to have serious bugs as well.

o Lack of backward compatibility with RCS-style version control systems like Subversion. Instead of building on 30+ years of success and experience with RCS-style version control systems, but extending them sensibly for distributed projects, Git took a "reinvent the wheel badly" approach.

o A fanatical, cult-like following apparently mesmerized by Linus Torvalds that is unable to recognize or acknowledge the many obvious problems with Git.

Yours truly,

Bit by Git
As a fun aside: Freud died in 1939, just 75 years ago. I know HN's demographic skews young, but I'll bet there are people reading HN who were alive at the time.
Ultima Forever to shut down on August 29
> Impractical for single repository of libraries

Submodules?

I actually think an entire repo of libraries is the wrong way to go. With the git model, we have however many repos acting as the source for these libraries. This repository that contains all of these submodules can then be the arbiter of which version should be included in the release.

> Yes, some will say - but this is good - centralization is bad... Well, it depends. If you can spend time to figure out who is who, then it will work for you.

And this problem doesn't exist with SVN? Sure, maybe if you are the sole publisher of all these libraries it might be ok, but with most real world examples, there exists multiple contributors. Now they need to go through you when there needs to be a specific update to that library. With git, the maintainer of the repo of libraries(submodules) just updates the specific submodule to whatever release works for their tastes.

Most of these complaints sound like an SVN user having some pain when trying to think in git.
I didn't say we would kill the item. We don't close ongoing discussions on duplicate posts.
I actually do that job too. That horror falls under the umbrella of "deployment."
Something I found last week that crashes with clang-503.0.40:

template<class T> class foo
{
public:

~ foo()
{
}

foo &operator = (const foo &rhs)
{
foo::~foo();
new (this) foo (rhs);

return *this;
}
};

int main(int argc, char * argv[])
{
foo<int> a, b;
b = a;
}
Nice App, hope to download it soon ! No registration really? it's awesome
I was very surprised to not see Jason Mitchell at Harvard Univeristy's attack on the concept of replication: http://wjh.harvard.edu/~jmitchel/writing/failed_science.htm

The thing is amazing to read, in the "someone who thinks he's a scientist actually wrote this?" sense, like this gem:

Because experiments can be undermined by a vast number of practical mistakes, the likeliest explanation for any failed replication will always be that the replicator bungled something along the way.
How is this different than say, Twitter or even Facebook Pages?
Best practices are to not use pull unless you certainly know you should.

Things should be fetched then merged with two separate commands.
A benefit of git, for which I can forgive a lot of git's flaws, that was not mentioned in the conclusion is the light-weight branching. The ability to quickly make a branch, experiment, branch off that, merge back, cherrypick commits from another branch, etc. makes me more efficient by spending less time worrying about affecting stable code with experimental changes.
Both of the statements in that link are just tautologies...

You can teach computer science without teaching coding. And you can write algorithms without testing them on a computer.

So the tautology that "you can't code if you can't code" isn't a particularly important pedagogical insight when it comes to teaching CS, since CS != coding.

> Of course it isn't a stumbling block, logical thinking is required for both, which would also explain why they are both difficult.

Right. And I'm saying that, in my experience teaching, it's better to teach CS and then let programming be something that kind of just falls out of that naturally, as opposed to focusing on programming itself.
Something like r/askhistorians is even stricter and excellent as a result.
Will do! We're hard at work right now but will reach out.