skysight-inc/HackerNews huggingface dataset:
See my response to virulent. I believe it re-runs the parent function multiple times until all of the child ajax functions have evaluated to their return values. This probably explains why the author states that the child functions must be idempotent (edit: and the code readonly in its entirety to prevent side effects).
Set it to CD quality: 96 kbps bit rate, 48000 Hz sample rate, 16-bit resolution
That's why every framework invents its own kind of OO for it. :-(
It may be an issue of terminology.

I personally think git is simple. That doesn't mean it's easy. The issues listed in the GP comment seem to me mostly social. I think the most common problems with git stem from a more general difficulty in working with a branching, asynchronously developed codebase.

About merges... I think rebase is ridiculously overused, and people should use merges more. Clearly a feature branch littered with spurious merges is bad, but often it seems that this is taken simply to mean that merges are bad, and I get the impression that people go to ridiculous lengths with rebase etc. just to preserve an illusion of linear history even in cases where merging would be better.
you can't clone a remote repo into a non-empty directory.

from `man git-clone`:

Cloning into an existing directory is only allowed if the directory is empty.
OP here. Wrote some articles for InfoQ (which I believe operate in the U.S.) in the past and they paid me via wire transfer without issue.
If you already have some familiarity with Git, you may find this 2-page reference poster[1] helpful if you need a cheatsheet at your desk.

[1]: https://www.dropbox.com/sh/quumaubjftxik1u/AAD15CT1UrNyOuYSx...
Both of you are right. China is a bully and so too is the United States.

Superpowers bully.

So the question is about how to handle this situation between conflicting interests. We need to figure out how to keep as much peace as we can with two superpowers, and make them both agree to something they feel great about.

These aren't facts but this is how I feel:

With the opportunity to lift all of humanity from poverty around the globe in our lifetimes, and opportunities to use technology to solve physical mysteries, and with global economic trade both can prosper from I hope, I wish, I imagine that there are ways to find a symbiosis.

I'm afraid of hawks playing a game that forces there to be other hawks - of there being a race to the bottom into a cold war (whose balance and controls have been loosening - the US is not without blame here).

How do you feel about it?
> Some people consider the Datapoint 2200 the first personal computer as it came out years before systems such as the Apple II or even the Altair.

Programma 101 was being made and sold five years before Datapoint 2200: http://en.wikipedia.org/wiki/Programma_101
Ask HN: Are there any open-source bots that can “write” news articles using AI?
"go get" on its own isn't to blame -- the culture folks behind Go are trying to promote is that dependencies are intrinsically part of your code and thus you have to maintain them. I'm not going to say that version pinning harms this, but the lack of it is no reason to throw away good conventions around imports mapping to URLs, etc.

For a set of alternative package managers that are perhaps more in the "spirit of go get", see https://github.com/golang/go/wiki/PackageManagementTools
My first impression is that you're trying too many things and not focusing on what's actually important to you. Giving up on low-value activities in favor of high-value ones is a good thing.

My suggestion is to make a list of how you want to grow as a person over the next few years. Sort it by importance, and then do not do anything that's below number 3 or 4.

Taking my own advice, I really should stop reading/commenting on HN and reddit. And I know how to break this habit, so I don't have a good excuse. So, uhh, bye?
Most != all. Which version of python are you talking about? Has it been updated recently? Are there other python libraries required by the project? I could go on. There's a huge difference between "no dependencies" and "a simple dependency".
Simple and powerful data analytic framework
I wouldn't have thought that Somalia even has a stable enough internet connection / general security situation to even have programmers working remotely. Interesting to learn otherwise.
Ah okay! Will refrain from doing that next time :) Thanks!
> May be I am completely unaware of how time it actually takes to master something and setting up wrong expectations.

An oft-quoted metric is 10,000 hours to truly master a skill. Translated into the working world: That's working full time at a job for roughly 5 years.

> Have you felt this, and how to achieve your goals or master something without giving up?

When I started boxing as a teenager there was a life-size cutout of Mike Tyson in the corner of the gym. The words "Your competition is training harder than you" were emblazoned across his chest. That message stuck with me, and I still use it as a motivator. When you're ready to quit, just remember: there's someone else who wants this more than you do, and they're not quitting yet. Keep going!
For me, the hardest thing about learning Git is the lurking feeling that I have to learn it because it has become an unavoidable fad, not because it is the best approach to version management for most common use-cases.
The ironic thing is that if the technology is successful, it'll be used by nation states to claim more territory. Spratly Islands made to order, on crack. Not that a very brief frontier period couldn't be interesting on its own account, but it'll be brief if it happens at all.
Here's 2 websites that are specifically for tech jobs that provide a visa.

https://techmeabroad.com/
http://www.jobsintech.io/

If you have the skills and resume, I'm sure you won't have trouble finding a job.

Also https://remoteok.io/ is a great resource for remote jobs. Most employers don't care as long as you can get shit done and work with a team. If you are a professional full stack developer your confidence in your ability to produce will come through.

You will probably have to work more to get to where you want compared to some American counterparts, but the path is there and the tools are out there. Best of luck.
You absolutely, 100% should not start a company. Most startups fail, and the ones that succeed are often not the first venture by an entrepreneur. So if you think you'll get some validation by succeeding at starting a company, you have a far better chance of feeling even worse when you fail.

It also sounds like you're pretty young. The massive success stories, like Facebook and Microsoft, are often started by young people, but the vast majority of successful startups are starting by older founders. I believe the average age of a successful founder is 38.

One of the reasons for that is that you learn so much and meet so many people early in your career. When you start a company without working for a few years, you're starting with a disadvantage: you're missing a lot of important experience that you can get from working for someone else, especially if that someone else is committed to mentoring you.

If you keep seeing articles like "some young guy, similar to you, makes $100M selling some product you could have built", stop reading the news. Those aren't the norm, and there are often circumstances involved that you could never replicate. You don't need to be Mark Zuckerberg to be wildly successful and important, and you shouldn't even peg your self esteem to something like that.

Keep in mind that nothing is stopping you from creating side projects, throwing them on Product Hunt, HN, and Reddit, and seeing what happens. With all the tools available now, most proofs of concept can be completed in a weekend. In fact, one small test of whether you're ready to be an entrepreneur is whether you can execute some products over the weekend. If you have the passion and motivation to give up your weekend, and you can get something done that quickly and dirtily, you have at least one pre-requisite of building a startup.

Here are the conditions under which you should start a company, if you ever find yourself in them:

1. You can lose $50k+ and still be fine. You will spend an enormous amount of your own money, and you almost certainly will never get it back. Startups are a black hole for both time and money.

2. You can sacrifice most of the nice things in your life, including expensive food, vacations, nice cars, and quite a bit of your social life.

3a. If B2C: you are one of a small group of people capable of solving a common problem, and you also have the time and connections to access investors.

3b. If B2B: you are one of a small group of people capable of accessing your market. This often comes from having worked in a particular industries for years. (The market should always come first, not the idea. Be ready to throw away many ideas to get to the right one.)

4. You are very comfortable with failure, and you don't cringe when going over your failures with a fine-toothed comb in order to learn everything you possibly can and not repeat your mistakes.
>Likewise, how many will suffer today in the crossfire between criminal gangs, extremist organisations and legitimate governments? How many would suffer if legitimate governments didn't fight?

About as many, or even less.

Governments not using mass surveillance, and other forms of spying on their own citizens, implies the following benefits:

The money spent on mass surveillance is either spent elsewhere (so you merely need to find a more productive use of those untold billions to decide that the surveillance is not worth it) or not collected as taxes or tariffs to begin with.

The man hours spent constructing, maintaining and operating the apparatus of surveillance is spent elsewhere (this coincides with the benefit above, where the government takes engineering talent and uses it for more productive projects or increases the supply of engineering talent in the private market alongside a tax rebate).

The money & man hours spent by innocent people (read: people caught in 'crossfire') defending themselves from mass surveillance is free to be spent on more productive projects (whereas now it merely serves to lower the impact of the 'crossfire').

The chilling effect caused by mass surveillance ceases to exist (or is at least less in the world where people are unsure whether mass surveillance occurs vs. the world where they know it occurs for sure).

As for the detriments, I'm not sure how effective mass surveillance has been at achieving its stated goal - while I cant reliably reason about a world where mass surveillance never existed, I can say that the impact of domestic and international terrorism on the quality of life in US and Europe was not high prior to mass surveillance and that I see no good reason to believe it should have increased dramatically enough to justify both the resources spent and the loss of privacy (or even either of those separately) - but this is an argument that you need to make, I can't provide it for you.

I'm also not aware of any notable achievements of the mass surveillance programs, and although these may be classified, I doubt they exist since the US gov't still refuses fair trials to the alleged terrorists it imprisons, and if the surveillance projects had generated a significant amount of useful, incriminating evidence this would not be necessary (under the, imo, fair assumption that the reason they avoid trial is that the govt is incapable of proving guilt in many relevant).
Haven't found it yet. Nobody else is hitting this either apparently. Manually limiting the # of cores on GHC pretty much removed the issue for us, although it doesn't give me the sense of closure I was hoping for.

I'm vaguely suspecting some sort of resource contention issue. A good way to figure that out would be to run a profiled build with that many cores, assuming that's at all possible.
Tesla Energy’s goal? Changing the “energy infrastructure of the world”
Actually resources.arsc only contains the resource table (think stuff in values/ folders, like strings.xml). The layouts still have their own xml files in res/layout. It is in Android's XML chunk format though, not plain-text xml.

Interesting point - the resource table still has references to the XML files for configuration-resolving purposes, but they are only strings. E.g. getString(R.layout.main) will actually work and return "res/layout/main.xml" or "res/layout-land/main.xml" depending on the device configuration (and assuming one has the layout-land version). Vice-versa, if you have a string resource with the value "res/layout/main.xml" and say, name foo, then calling setContentView(R.string.foo) actually works.
I think we're talking past each other. I'm not really sure what claim I made you're responding to. I was responding to this claim you made, with the context of "evolution":

> ...it is practically impossible to improve through random effects.

It's true that evolution is not aimed at a specific target. I made that point in my comment.

>Randomness doesn't improve any organism or any feature of any organism: it only improves diversity...

Here is a list of examples of beneficial mutations: http://www.gate.net/~rwms/EvoMutations.html It includes things like "adaption to high and low temperatures" and "12% (3 out of 26) random mutations in a strain of bacteria improved fitness in a particular environment."

The claim is that random mutations can occur -- at some rate, low though it may be -- and are more likely to be kept through natural selection.
Freestart collision for 76-steps SHA-1
>There's very little reason to use Spring today". That, frankly, is nonsense.

We all have our own preferences. I can guess what the "very little reason means". You hear this more often in Java (EE) discussions.

The thing is that in 2003/2004 Spring positioned itself as the necessary layer to make arcane Java EE APIs approachable and usable. With their FooBarTemplates Spring wraps everything that's wrappable, and at the time it made somewhat sense. Rod couldn't wrap EJB though, and as he deemed it "unfixable" he invented his own bean model to replace that.

At some point though Java EE started improving, and then started to improve a lot. Getting first class APIs such as JPA, co-designed by the Hibernate lead himself (Gavin King).

And what did Spring do? As a pavlov reaction they started wrapping again. But the JPA APIs were brand new, perfectly well designed, and didn't need wrapping. This was the basis of the fallout between Hibernate and Spring, and a revealing moment into how Spring operated. They weren't the benevolent dictator who out of the goodness of their hearts wanted to make life better for programmers, no, they just wanted you to depend on their APIs.

Rod later cashed big time, and Springsource, later pivotal became as commercial as the "evil" corporations they tried to wrap with their APIs.

Fast forward to Java EE 7, and Java EE has tons of perfectly fine APIs that don't need the Spring wrapping treatment. JMS, JPA, Bean Validation, CDI, EL, JAX-RS, ... NOTHING of that needs wrapping by Spring to make it usable. It's perfectly fine as-is.

So this is where the often heard "there's little reason to use Spring today" comes from, and I guess that is what was meant. Today Spring is just another platform. Java EE programmers don't need it to make their life better. Programmers in general can choose Java EE, or Spring, or .NET, or whatever.

If your preference is Spring, please, use it and be happy. It's not better than Java EE, but likely not much worse either. I've seen enough Spring code and Java EE code to say it's different, but still fairly equal.

I personally think the design process of Java EE is more open than that of Spring. Both are open source projects, and both have strong commercial influences as well as community influences, but with Java EE the design process is fully out in the open and people can comment on it and contribute. This is less the case with Spring. Yes, the source is open, but so is that of the Java EE RI and many other implementations. But Spring doesn't have an open design process, where Java EE has.
> We can't even understand how our own brain works, but some of us think that we are smarter than God.

If you refuse us the right to make any claims about a god, you also refuse the right to make any arguments for it.

Obviously, ars was talking about the gods mentioned in popular religious texts. These texts make very specific claims about what their gods are and do.

Arguing about arbitrary gods is, of course, largely fruitless. However, belief in them is equally fruitless.
I like SmartGit enough that I paid $80 for it (despite the fact that it seems weird to pay money for dev tools these days). You can download it and use it free for non-commercial use, though.

I'm reasonably comfortable with the git command-line tools, but for keeping the simple things simple I really do like an integrated all-in-one visual diff/VCS client program and SmartGit is the best one I've used for git.

SourceTree (mentioned by fsk) is kind of a trainwreck on Windows, in my experience (moving to SmartGit was the result of me getting fed up with SourceTree and looking for something not as frustrating). From what I understand the Mac version works better, though I haven't used it. While the UI is quite nice to start, the Windows version of SourceTree tends to soft-hang a lot (goes into non-responsive states it eventually recovers from, but will hang for like 30+ seconds at times) and it has a lot of weird issues with multi-monitor setups (it'll sometimes randomly jump to the other monitor during pane resizing and such).
I think a big part of the reason for the prestige is the fact that path breaking research comes out of those universities. So it's kind of hard to weigh teaching heavily when choosing profs and still expect to have a prestigious university.
> The testing frameworks out there are still fairly spartan from the developer experience standpoint.

At IMVU, we built up a bit of scaffolding along these lines: https://gist.github.com/andyfriesen/43d886ce60927c69b3d1

The basic premise is that all our business actions can either be run "for real" through Yesod, or within a State-based framework that's part of our standard testing scaffold.

The end result is that it's trivial to write tests that arrange for the database, clock, sockets, and so forth to be in precisely the state we want them to be for the test, and to sense everything afterward.

Running these tests as pure State actions has additional benefits:

Since State operates by making successive state copies for each "mutation", test fixtures are easily effected by performing some actions and saving the produced state. Individual tests can start from this state as many times as desired. The state is immutable, so test interference is impossible.

Additionally, tests run without access to IO. This means that the compiler rejects any test which could forseeably intermittently fail.
Haven't run into issues with laziness yet, but, as you guys pointed out, our use-case is very short-lived. We can likely get away with some sloppiness here and there because of it. I'm sure I'll still get burned by this at some point, but at least I'll be expecting it to some extent.
Looks like a good start, but from a quick glance it is missing some Go idioms. Some cursory recommendations:

- No Makefile please, this project's build process isn't yet complicated enough to warrant one.

- Rename the App type something more descriptive like Server

- Rename InitApp to NewApp (NewXXX is an idiomatic Go constructor). Likewise with InitWorker

- Make NewWorker a method of an App

- Isolate the AMQPConnection into another library and use the design pattern in database/sql to allow users to create their own implementations of brokers

- Do whatever you can to avoid empty interfaces (aka interface{}). You may have to be clever, but really avoid these at all costs. Using them basically mentions you'll have to sprinkle type assertions everywhere in the code rather than maybe having one place where you unmarshal values.
The stability and victories of peace are also due to the US. It is the US world order. It has problems, but it's also very difficult to determine what alternate histories would look like.

Neither the US nor China are evil or good. They are both rationally inclined to their own interests, which compete. Each have their own issues and histories. The US for the most part tries to find solutions that meet ideals and at the same time meet US interests.
Wrong. Look up "History of the Somalis in Minneapolis" on Wikipedia.
Great, I'll need to mine that for ideas, thanks for sharing! Are IMVU web-services also Yesod-based?
One thing this article touches, but does not give enough attention to (maybe because it is so counter-intuitive and hard to explain) is the false positive paradox.

To put in perspective, you should only do a test if you have good a priori chance of having a positive. Even a test with 1% false-positive rate you give you back much more false positives than real positives if the a priori chance is 0.1%.

This is counter intuitive, I'm not good at explaining stuff, so I'll give Doctorow the word, through this excerpt in Wikipedia: http://en.wikipedia.org/wiki/False_positive_paradox

Probabilistics and statistics are hard, very important an counter-intuitive. Med and pre-med, and even high schools really should teach much more math than they do right now.
I get the objections to copyright and patent law, but is there a principled objection to trademark law that I'm missing here?
They are for now, but we've been whittling away at it.

We don't actually use any of Yesod's affordances except for its router. We're aiming to eventually split that off and run on bare Warp.
What company is this if you don't mind me asking?
The Dart team is working on a compiler called 'ddc' (Dart Dev Compiler)

https://github.com/dart-lang/dev_compiler

It currently targets ES6 and also comes with a more strict type checker.

Project goals:

* Effective static checking and error detection.

* A debugging solution for all modern browsers.

* Readable output.

* Fast, modular compilation of Dart code.

* Easy use of generated code from JavaScript.
Nice tutorial :) I really appreciate that it covers a lot of the bases and doesn't assume the reader will only ever run on localhost (like many others do). I'm sure given that its a good start with Django, the gaps identified in the comments here can be filled in later via google or further tutorials in your series.
For real, this sounds like it simply allows front-end dev's to scour backend APIs and lace together really slow, really brittle web pages.
They probably mean "This is so much more interesting than somebody would expect based on a description."

If someone asked me "Do you want to watch a 52 minute talk on how they move the window on side-scrollers?" I would say no. That doesn't sound like it would even be worth talking about.

But it is, and I'm really psyched to watch this video.
Smalltalk has always had lambdas in the form of block objects. It uses them everywhere and for everything, even implementing control flow constructs like if/then/else and while. It also uses them to implement Lisp-style higher-order iterators like mapcar (collect:), reduce (inject:into:), and remove-if-not (select:), which though possible in JavaScript (see Prototype.js), is generally uncommon because JavaScript's lambda syntax has historically been the most verbose of any dynamic language.

Anyone who claims lambdas are somehow new to or incompatible with OOP clearly doesn't understand OOP, since lambdas have been an integral part of the most influential pure OO language (Smalltalk) for 40 years.
Show HN: Curated database of awesome dinosaur pictures
If that were to happen, the first thing I'd want is a copy of Wikipedia.

And some BBS software :) .
Well basically, you can't as long as you're loading the web page over an insecure connection. If the .asc is loaded over SSL, then verifying the certificate should be sufficient.