skysight-inc/HackerNews huggingface dataset:
I think almost by definition anything that is late didn't start early enough.
The actual impressive logic circuit used: http://i.imgur.com/rltt1y7.jpg
Just like a popular uproar couldn't prevent SOPA from passing.
No, we do not: "correlation does not imply causation"

And to top it: there is a strong correlation of fewer guns and less violence (Europe vs USA)
Wait.. Android goal is to provide security to novice users by taking away their freedom. Now why they want me to rely on advance solutions to secure myself.

But wait I'm novice who can't decide what is best for himself :(
Ah I see. Let's hope Google is going to move the "install apps from 3rd party sources" switch to the Developer Settings in the future.
These are cool but I wonder if they actually see a lot of use in the wild. SCUBA diver fighting shows up in James Bond a lot but I have to imagine in real life it's more efficient to just cut an enemy diver's air hoses or wait for them to surface and shoot them while they're taking their equipment off.
I'm guessing s/he's misreading your bio line in your profile.
However it makes a difference if I create 1M actors and dispatch them via reflection or if I create some of them and passing results back and forth.
actually goroutines would use static dispatching and don't have a lot of overhead.
however a scala actor is totally different than any goroutines or erlang actors, they are keeping a lot of state. a promise/future is actually a little bit better in this kind of sense, still the jvm version will actually (even when optimized) use way more memory.
Diablo 3 comes to mind as the canonical example of this, but it's a PC/console game rather than mobile. Single player mode is still run by a remote server, and if you have a bad internet connection or they have a server outage (which has happened many times) it will be unplayable.

Blizzard has been much better than most companies about keeping its online infrastructure up and running long after a game loses popularity, but even they won't be around forever.

On the mobile side I don't think that's a common strategy (Candy Crush and Angry Birds aren't going to stop working), but the purely multiplayer games like Ingress and Clash of Clans will certainly shut down someday.
The agreement is supposed to be a chain. The things in it are supposed to be related in some way, otherwise why are they together? Dumping many completely unrelated things into the same agreement so that things that should not pass have to be passed in order to do things people want is the thing so egregiously bad that it outweighs everything else. It's a chain with a link so weak it doesn't even exist.

Otherwise you could take an agreement which is net +1000, add absolute garbage to it until it's net +0.5 and then argue that we should still pass it because the net result is still positive. Which, compared to the alternative of throwing away the net +0.5 agreement and insisting on the net +1000 agreement, is net -999.5.
People who are born in such a regime usually don't get a (easy) opt-out but I digress.

That's my point - it's not useful to compare the loss of rights in states to the loss of rights in smartphone platforms, because the latter are easily opted-out.
Yeah unfortunately! A 10 year old desktop Computer running Lubuntu can be far more secure than my phone
It can be a great tool too. I think anyone who discounts smartphones as just another "consumption device" are missing part of the usefulness of the network.

I use my phone in place of paper logs for calorie counting and training. It's definitely been a solid replacement. It's probably shaved an hour a day off the odious task of counting calories, and having internet access means that I'm only a few touches away from form pointers and useful advice. I could replace it all but I'd have to start carrying about 40 pounds of books around instead.
It comes from experience. I've tried to implement such a simple protocol and it literally takes months to get all the details right. Also see the quote from Joe Armstrong in the article.
Headshot: A visual history of first-person shooters
Scraping: handling authentication
I find it amazing that the bitmap fonts that shipped with Macintosh OS 1 (and System 0.85 for that matter: different 'Chicago' and the strange 'Swan Song') still work on OS X with only a trivial modification: Splice the NFNT from the resource fork into a FontForge-readable system (7 I think?) bitmap resource fork and you are left with something that is easily exportable into a modern datafork bitmap font. I've converted them all (Taliesin and Mobile were hardest to find in their original form. I still haven't found Toronto on an install disk anywhere) and they all work perfectly on 10.11.

Here's System 0.85 Chicago being used in emacs, for example. Looks great in acme as well.

http://i.imgur.com/EuO2bvF.png
Seeting Up Webpack for ES6, React, SASS and Bootstrap
Senet: board game from predynastic and ancient Egypt
I don't understand your point.
OK but you're missing out on valuable special offers.
What I Wish I Had Known Before Pitching LinkedIn to VCs (2013)
I don't remember the particulars. But they're not that important to the nature of the issue (though recognizing them as a bad smell is) - any time you have a reused bit of code (be it via inheritance, composition, or even just a function), you run the risk of that kind of complexity. And this can be hard to spot; a function that takes an argument that it then uses as a conditional in a few places can hide a lot of complexity.

That is, if I have a (pseudocode) function

foo(bar) {
//C
//D
//D
//C
//D
//C
}

where //D indicates a line that does not change its behavior based on the passed in bar, and //C indicates a line that does (and in complex ways; if bar is of type bar1 or bar3 do X, else if it's of type bar 5 do Y, else do Z), the code has a lot of interrelated complexities, even though it's DRY. It's better to have

foo(bar) {
switch(bar)
case(...) {
foo1(bar)
}
//etc
}

so that the implementations are completely different, that even though there will be copied code between foo1, foo2, etc, it's clear what is happening, and you change any bit of foo1, foo2, etc, without fear of it breaking something else (whereas in the original, changing any of those lines marked //C could break unrelated functionality). The issues with the first, and the improved clarity and reduced coupling with the latter, holds true regardless of whether the code is in an inherited object (where the first function would translate to a foo implemented in the superclass, with the //C lines being calls to abstract methods, that are then implemented in the subclasses, and the latter function, foo would be an abstract method itself, and all subclasses implementing their own version, that is partially identical to each others'), or via composition.
Creating a Computer Voice That People Like
The Great Tech Freakout
http://devuan.org/
I'm sure the researchers responsible for analyzing the data from this survey were familiar with the concept of an outlier and how to deal with them when publishing their findings. High school students have been goofing off instead of doing what they were supposed to for as long as high schools have been a thing.
I suspect you're right, and WLW did have to modify its antenna setup due to issues with Canada.
BTW, there's a merged PR which makes Akka a lot faster; can someone measure that on OS X (MB Air or MB'2015) ?
Someone should invent "immutable programming". A paradigm where you can't delete code.

It's a bit the opposite of Vigil, a programming language who punishes functions throwing errors.

https://github.com/munificent/vigil
There's updated Akka version which is a lot faster, btw.
Totally agree. One thing that I still find really hard to maintain/delete is CSS code. More and more I feel like it should be included with components rather than in a plain .scss or .css files. It feels good to be able to delete a component knowing that there isn't css crap left behind..
Open-source online dating built with Ruby on Rails
A true coder wanting to implement things near correct with algorithm complexity (big O), will try to find how to implement the right code by taking time to research understood and time tested patterns they've learned (it is an applied science after all) and implement them.

Saying the average joe doesn't care to understand what his/her Lang is doing under the hood which will doom them to repeat complexity that many here will respond with "duh" is not justification that a Lang is better - because it supports that behavior "better".

I don't know erlang that well but I'll be damned if I don't spend the time to find out how to properly do M:N with efficient tail recursion.

If one doesn't care for efficiency at all then who cares about benchmarks?
Bitcoin Is Having an Election
Playstation 3, PSP, VHS Cover, Xbox 360 and One
Returning num instead of Promise.resolve(num) is unfair compared to .NET version ;) but I merged your PR as-is
That's awsome thanks !
In the end, isn't that all we're really doing?
How are you going to cut their airhose when they're shooting you with an underwater assault rifle?

And if you can get close enough to accurately cut the airhose, why not just stab them in the heart?
It's indeed apples vs oranges vs pies (Actors/Coroutines/Futures). Probably should make a table :)
An awful lot of the really big ones (on the scale of towns and cities) were bloody awful. Aesthetically pleasing on paper, but unliveable. Logical minds planning carefully separated zones and routes and so on in ways that looked nice on paper and created soulless cities with broken public spaces.

An excellent read on this is "Seeing Like a State", by James Scott. The chapters on forestry and collectivised agriculture are similarly interesting.
I haven't played the game, so maybe this is my unfamiliarity showing, but I thought that Clash of Clans was an MMO strategy game. In that context, how is there any meaningful singleplayer component that could work without a connection to the servers? You talk about rearranging defenses, but isn't that against other players? How could that possibly work if the server can't be reached to actually update the shared game state?
I took this survey in 2011. Teachers were not allowed to be present while we took it. There was no moral pressure to be honest beyond "answer to the best of your abilities" so as not to alienate the group. The entire room openly read the questions and people answered with varying degrees of absurdity. Whatever the results of that room were, they were not representative of the group's risk taking behavior.

Take this anecdote as you will, but it will take me a lifetime to be convinced that a faceless government form can poll the group of cards closest to a teen's chest with any aggregate accuracy.
Cherry picking! There are plenty of places with fewer guns and more violence, and where it makes no difference.
I was asking for examples of mobile apps. There are lots of reasons that the "thin client even for singleplayer" strategy is less feasible for mobile games than for PC games.

But still, I didn't buy Diablo 3, and this was one of the reasons why.
> These are cool but I wonder if they actually see a lot of use in the wild.

I wonder if a FOIA request to the Department of Defense requesting "information about any underwater combat engagements between frogmen and/or divers" would result in anything useful?
Exactly, it's not 'done' until it's cleaned up. Easier said than done, though.
I fear, implementation-wise the typical Common Lisp implementation quite a bit ahead of Haskell. In something like SBCL I can mix interpreted code, compiled code and optimized code freely. Stack traces are available in all modes, together with an advanced error handlich system able to deal with error conditions at runtime under program and/or user control. Creating new code at runtime compiled or interpreted is available all the time. Remote control (see Slime) of running Lisps via an IDE has been available for a long time.

On a Lisp Machine in the mid 80s, the error system would analyze the error, determine the author of the software system where the error happened and prepare an error mail with machine description, error description, extended stack trace ... to the maintainer's mail address. On a server machine, I would have it sending me such mails automatically...
I think Sci-fi/Fantasy authors have been interested in this topic for many years ... for instance, Piers Anthony's Xanth series, starting in the 70s.
MIT and Harvard Graduates Helping Pakistani Farmers to Make Big Money
Pretty much this.

This is the saddest industry on earth.
The Benchmark Way: 5 Partners Who Make VC Firms Look Outgunned and Overstaffed
These are all reasons why I wouldn't replace my laptop with a smartphone, but that's not what a smartphone is for in the first place.
Further off-topic, but I almost exclusively see tap used as some kind of clever way around a return line, e.g. instead of:

def build_hash_or_whatever
hash = Hash.new
hash[:foo] = some_generating_method
hash[:bar] = "some value" if whatever?
# More hash construction nonsense
hash
end

With tap it is:

def build_hash_or_whatever
Hash.new.tap do |hash|
hash[:foo] = some_generating_method
hash[:bar] = "some value" if whatever?
# More hash construction nonsense
end
end

I think the tap-form is significantly worse and I don't understand the aversion to a single line that clearly shows what you are returning.
Or the general number/location of appendixes and orifices.
Over the past year I can't stop thinking about this article: http://250bpm.com/blog:51
True, we are the ones responsible for our integrity and we often live with our mistakes, paying for poor design choices during later maintenance cycles.

Just be aware that it can be easy to get lost in a yak-shaving exercise doing your cleanup refactoring. I recommend timeboxing this phase to no more than an hour, or prioritizing one or two specific tasks so that you don't go off the deep end.

Don't forget that others are depending on you to get their work done. There may be a 2-hour cleanup task somewhere else in the code that will help your teammates far more than the itch you want to scratch here and now.
Deutschlandfunk also used to operate two 500kW (250kW at night) transmission sites until the end of 2014.
They were shutdown as a cost-saving measure (one of the two sites was even upgraded to more modern transmitters just ~5 years before the end).

https://en.wikipedia.org/wiki/Sender_Donebach
https://en.wikipedia.org/wiki/Aholming_transmitter
Some Things I Wish University Had Taught Me
Show HN: Next-Gen Community Discussion Forum Using Reputation System Algorithms
Actually, Go is at least 6 years old; the original announcement was Oct 30, 2009:

https://youtu.be/rKnDgT73v8s
That's why you should use an IDE with proper "find all references" instead of coding in notepad.
For anyone who's interested in Software-Engineering-Discussions, I even created [this community](http://www.thecaucus.net/#/content/software/heap_sort) specifically for you guys. Hope you like it!
Docker Cloud (cloud.docker.com) to Replace Tutum (Tutum.co)
Show HN: Gift your Valentine onsite car refuels (Bay Area Only)
I had thought looking at the title that this was about a benchmark on a machine with one million hardware threads, which would have been interesting. Turns out to be a job of spawning loads of unprioritized identical threads that block, do negligible work and exit. It looks like time costs are going to be almost entirely dominated by setup and tear down, Which is very nearly useless for any situation in which you expect threads to exist for more than infinitesimal time. Setup and tear down are constants. They won't dominate the runtime of most programs.
amazing there's been four posts of this story and no one is carrying it on. Of course, this is entirely the wrong forum to criticize Sillicon Valley's new imperialism, but there it is. One of the most cogent critiques I've heard of Facebook's machiavellic plan.
Efesak looks like a cool tool. Ryanlol also nifty script.

r0muald thanks!

Thanks for all the positive responses to this. Hopefully i'll have time to work on some server hardening and similar improvements soon.
Chill dude, nobody is forcing you to replace your rig with a phone.

But a little anecdote though. I seem to recall that the early Toshiba Android tablets were popular with photographs. This because their full size SD slot (and USB-A on the Thrive) allowed them to use the tablet as a on the go light table.

Similarly, tablets seems to be getting more and more use as clipboard replacements for various tasks. This because they can handle all manner of forms and documents.
*hand-picked - I don't usually correct my typos but this one is too ambiguous not to...
Apple Can’t Touch Android’s Market Share in Emerging Markets
I'll take the lack of response as an admission that you were at best unaware and are now embarrassed by your ignorance, or at worst don't actually believe what you're posting as fact on the internet.
This test was performed on a 2-core machine. I'm not familiar enough with multi-threading benchmarks to know what's standard, but that sounds suspicious to me, like the benchmark might not show how well a language takes advantage of a 32 core server.

Anyone know if that would be a problem?
What should I learn next as a programmer?
This is totally unfair. We're looking at using Rust for production workloads and cross system development.
Even after the change, there's nothing async about the "async" version. It's multithreaded, not asynchronous.
Not really. Not many people have the whole autotools/automake tool chain installed, let alone document building tools, and whatever other processing the project does (eg SQLite uses some TCL scripts). So they'd have to go and get all those, obeying any version constraints. And after all that they'd end up at the same point as getting an archive intended by the maintainer for them to build and install.
>And honestly, for a few games I've worked on for companies in the past, pirates are the only thing keeping those games accessible at all.

Microsoft in Bill Gates' era understood the importance of piracy. He said, "As long as they are going to
steal it, we want them to steal ours."

Windows Phone in my opinion is suffering because of its nonexistent piracy - sideloading was near impossible for normal users.

Imagine downloading 3gb+ visual studio just to unlock your phone.

My siblings loved my 925 but then they asked, "How do you get apps?"

I replied, "From the store."

They responded, "So, no flashshare?"

I said, "No." And that was the end of it.

I could see the stupidity in Microsoft's previous focus on low end phones targeted at emerging markets. Because emerging markets NEED piracy.
Attacking Ruby on Rails Applications (what the bad guys use)
And even if they were, what is the problem? Printed books are unapologetically devices for consumption, yet I love them.
Sure, a simple logistic regression will pick that up. Doesn't mean there is that much thought (rather, 'intelligence') behind it.

Besides, I quite happy (if I have to see ads at all) to not be shown tampons and pokemon cards. I'd much rather see things I might be interested in.
I am not implying that less guns means less violence, since "correlation does not imply causation". I am merely pointing to you that if you wanna cherry-pick your correlations (which mean nothing), I'll cherry-pick mines.
yeah sorry however I would actually use go version 1 as a reference.
everything before was changing just too often, there was go fix however still many changes. also everything before 1.0 wasn't targeted too much about performance.
also I can remember how much the template spec changed. thats what I used these days quite heavily. I have a book about go that dates 2011, and I think that was go 0.7 as far as I remember.
Didn't Rei Toei first appear in Virtual Light? In Virtual Light I seem to remember Rydell driving in downtown LA at night and getting distracted by a hologram of a naked East-Asian looking woman - who would later turn out to be Rei Toei.
I find it amusing that the photo that heads the article of the Millau Viaduct which, while truly a good example of the sort of project they are advocating, could hardly be called "urban".
This all goes to how hard code reuse is - is it worth having two very similar functions that do the same thing instead of having one function that's DRY but more complex than both.

Maybe you should have a shared function that has the similar bits of both but then when you remove pieces you have this added complexity.

Everyone can give you arguments either way...

I remember reading this beautiful explanation about an idea for a functional language where you simply install collections of methods that do specific things and each method you install should be as simple as possible and do just one thing etc. - maybe it was somewhere on the Elixir mailing lists but I can't find it!
I lol at this page every time I open it, even after all those years. Call me immature, I guess...
For myself, I find the most important thing is to have clear interfaces (contracts). That is, I can write the hackiest code inside of a module, but I will spend time upfront to make sure that what that module exposes is the cleanest I can make it.

Then, I can isolate and fix a function by itself. It may have been written to be 200 lines long, filled with hackery and half measures, but my complexity is contained within it, and the functions it calls out to (so nothing calling it should need to be substantively changed). Those called functions, in turn, may also need improvements, but my focus every step of the way was keeping the interfaces clean, so I can always get down to some base set of functionality that has no dependencies, fix that up, make the necessary fixes to keep things working in the functions directly calling them, test, and then move up to those calling functions and repeat, until I get back up to the big ugly 200 line monstrosity. Every step of the way I can make sure things are still working, and I don't have to substantively touch anything above the 200 line monstrosity until I've cleaned it up.

So by keeping my interfaces clean, I can figure out how, inductively, I can make progress.

The lack of clear interfaces is the real problem; if you don't put in the effort when writing your code to keep those clean, you end up with circular dependencies, implicit workflows and state between functions ("to call X you first have to call Y to get a foo, pass that into X, then call Z to reset the foo value"), and other nightmares, that move you more to needing a full rewrite.
At the beginning of a long project, it probably does. This is not like adding people to a late project.

Now if your project isn't easily separable in several relatively independent parts, you are screwed.
Antonin Scalia, Justice on the Supreme Court, Dies at 79
Based on my experience, this also isn't true. I added support for Ruby gems in the GNU Guix package manager. The way it was done was by creating a Ruby-specific build system that Ruby-based software packages elect to use. We have a generic model that allows for many types of specific build systems to exist that deal with the domain-specific concerns. This generic models works better than a Ruby-specific model because, unlike RubyGems, Guix can capture the entire dependency graph.

Take the Pg gem, for example. In order to build and use it, you need the libpq shared library. RubyGems can't encode this dependency, but Guix can. The recipe for ruby-pg is only 25 lines long: http://git.savannah.gnu.org/cgit/guix.git/tree/gnu/packages/...

There was a talk given at FOSDEM about foreign packages in Guix with a focus on Ruby which is worth watching or skimming the slides: https://fosdem.org/2016/schedule/event/guixmodules/