skysight-inc/HackerNews huggingface dataset:
I'm on 3.8.6. So will have most of the benefits. The temptation with sqlite is that it is so well maintained to only do cursory testing with it, so might drop this in.

Interestingly:

> A full 10% of the performance gain has come since the previous release.
>There have been a lot of changes.
Porting a Clockwork Brain to Android Dev Log #1
The genetics of coffee consumption
I'm really looking for some feedback on SocialPilot and would really love to make something that everyone wants.
No user data lost in Yahoo server hack
Porting a Clockwork Brain to Android Dev Log #2
Bingo.

Key question to ask yourself: assuming you had a good team that could talk about things, if the other three guys on your team wanted to try something new, but you thought it was a bad idea, would you keep an open mind and give it a good shot? Or would you dig in and come up with the 74 thousand reasons it sucks?

There are a lot of really smart guys out there that can argue any subject from any angle better than anybody else in the room. They view conversations as debates and discussions around direction as something that can be "lost" or "won". There's a right and wrong answer, and these guys are almost always right.

Don't be one of those guys.
Rolls-Royce RB211
The Nobel Prize in Physics 2014
> It seems incredibly unimaginative and frankly egotistic to think that you can make generalizations about overall Chinese culture

Why? What does it mean "generalizations about overall Chinese culture"? Are you claiming that in China there is only a collection of small, unrelated cultures, and no shared core? The whole point of the concept of "culture" is to observe that such generalizations do exist, and they drive many common behaviors in societies. That's why sociology of culture (http://en.wikipedia.org/wiki/Sociology_of_culture) is a thing.
I don't want to be that guy, but why don't you try Go? It's the perfect server side language IMHO.
More of this. This endless debate about what is better - functional or OO is leading nowhere. The OO side is winning, since the majority of the industry is using it. The way to tear down the OO "hype", is by replacing things used in the industry with better alternatives written in a functional language.

Git (C) has eaten up both Darcs (Haskell) and Mercurial (Python), even though Python and Haskell are "clearly" superior languages, according to some.
The advantage of understanding performance perception
THE ROLE OF THE ENTREPRENEUR IN a CAPITALIST ECONOMY – Pragmatic Capitalism
Mean-stack.io: Source for MongoDB, Express, Angular and Node.js Related Content
I was reading the BBC story about Turing's Bombe beating out Concorde in a UK mechanical engineers poll: http://www.bbc.co.uk/news/uk-england-beds-bucks-herts-295126...

And therein found a mention to the RB211 with the following mention:

The Rolls Royce RB211 engine received 11% of the vote.

It was developed in the late 1960s but cost miscalculations led to the company
going bust in 1971.

The Wikipedia has the best summary on this period that I could find, but I also thought that this event might be of interest to people on HN as it combines both a story of engineering as well as the story of a business going through massive change: http://aerosociety.com/Events/Event-List/1754/The-History-of...
Secunia Emphasizes Patch Importance During NCSAM
Turing's bombe pips Concorde in mechanical engineers' poll
Nobel Prize winner John O'Keefe concerned over immigration policy
Note: I am not the author of LuaRocks (https://news.ycombinator.com/user?id=hisham_hm is), just a user.

Regarding distribution, what OS are you talking about? LuaRocks is available in Homebrew for OS X and as a package in most Linux distributions. Windows build looks a bit more painful but I don't have experience with that OS.

Regarding per project trees, there is no such thing as what exists in Python with virtualenv, but you can certainly do this:

$ mkdir my_project
$ cd my_project
$ mkdir rocks
$ luarocks-5.2 --tree="./rocks" install haricot

This will install the latest version of Haricot and all its dependencies (in this case LuaSocket) in the local tree regardless of whether you have them system-wide. Note that you can change this behavior (http://luarocks.org/en/Dependencies) but the default dependency mode is "one".
Not sure about on stage but there's a few film depictions related to the Milgram experiment - http://en.wikipedia.org/wiki/Milgram_experiment#Media_depict...

And looks to be a stage play based on Zimbardo's Stanford Prison Experiment - http://en.wikipedia.org/wiki/Stanford_prison_experiment#In_p...

http://entertainment.ie/theatre/feature/ABSOLUT-Fringe-2012-...
I think the issue is revenue and not user forgetting about the website. People remember sites years later. The problem is the business model. People are not willing to pay for the services of a travel planner which is expensive to build, which means your revenues are affiliate or ad based. This is not enough to support the dev costs.

I've just read many comments that show getting traffic is not an issue. Yes it might be more competitive but lots have gotten traffic. The common issue I see is that none of them have been able to generate enough revenues to support themselves, even with good traffic.
One of the major points of the article is the "no True OO Programmer" fallacy:

this is my experience whenever I argue against Object Oriented Programming (OOP): no matter what evidence I bring up for consideration, it is dismissed as irrelevant. If I complain that Java is verbose, I’m told that True OOP Programmers let the IDE take care of some of the boilerplate, or perhaps I am told that Scala is better. If I complain that Scala involves too much ceremony, I’m told that Ruby lacks ceremony. If I complain about the dangers of monkey-patching in Ruby, I’m told that True OOP Programmers know how to use the meta-programming to their advantage, and if I can’t do it then I am simply incompetent. I should use a language that is more pure, or a language that is more practical, I should use a language that has compile-time static data-type checking, or I should use a language that gives me the freedom of dynamic typing. If I complain about bugginess, I’m told that those specific bugs have been fixed in the new version, why haven’t I upgraded, or I’m told there is a common workaround, and I’m an idiot if I didn’t know about it. If I complain that the most popular framework is bloated, I’m told that no one uses that framework any more. No True OOP Programmer ever does whatever it is that I’m complaining about.
Lennart is producing lots of software that many people find useful to solve real problems.

If you don't have these problems you're free to not use them.

If your distro maintainer choose to integrate with software produced by Lennart it's because it either solves real problems for them or are simply too dumb to be trusted.

In the first case it would be appropriate to trust the decision of qualified people, but if you fall in the latter care you're still free to change distro given the assumed incompetence of your maintainers.

I still don't see how this makes Lennart a troll.
When they started testing out EPO illicitly on cyclists in the early 90ies, a number of young men died of heart attacks in their sleep, because their blood got too thick.

Having some rules and regulations doesn't mean no one dopes, but it does curb how much goes on, which likely is beneficial to everyone's health: not even the dopers can take all they would were there no rules.
inventerior - A unique way to discover new apps
inventerior.com is a new platform for sharing your mobile's or tablet's homescreen with the world. Upon upload of your screen the site will automatically detect the device of the uploaded screen and will even recognize the installed apps. Even if not everything gets recognized from the get go, like when there are lots of folders on the screen, you can tag more apps easily in a facebook-style manner.
This is a really well written article; full of great, reusable tricks and techniques in reverse engineering.
Clear screenshots, humorous yet technical content, neat results.
Hats off to you, sir, keep up the good work and I look forward to reading more of your tutorials.
Mediocre and bad code tends to multiply entities. On a small scale it's usually redundant global and local variables, or just plain stupid code like this:

if (NULL == lpDataPointer)
{
/* Return FALSE */
return FALSE;
}
else
{
/* Return TRUE */
return TRUE;
}

Now give the same programmer an OOP language and see what happens. Even a bigger disaster masqueraded as an OOP system.

I know I kind of repeat the author's True Scotsman's metaphor, but my point is, you can't kill a return operator or, say, code comments just because the majority of code around us tends to misuse it. Unfortunately for the OOP paradigm it makes multiplying even bigger entities easier, and at the same time its learning curve invites lo-fi coding.

Who's to blame?
I know it's a nitpick, but it irks me to no end to see things like "about a tenth of one per cent (.125) of subjects". Particularly so when it's in articles submitted to sites, like Hacker News, whose audience presumably instantly recognizes "an eighth of one per cent" when they see it.
This looks great! Do you mind answering a few questions?

When this product was created? How many customers do you have? How do you market your product?

Thanks!
Ah, apologies. Misread.

Still could be better, though - with a reset link that then creates a new password.
No, you can use environment variables to choose at runtime (first paragraph of http://luarocks.org/en/Config_file_format)
From TFA:

Please note that, below, when I refer to a multi-paradigm language, such as Scala, as an OOP language, I am specifically referring to the OOP qualities in that language. And I would like you to ask yourself, if you use a multi-paradigm language to write in the “functional” paradigm, are you actually gaining anything from the OOP qualities of that language? Could you perhaps achieve the same thing, more easily, using a language that is fundamentally “functional”, rather than object oriented?
It is an IBM-sponsored integration tool, with a focus on small IOT-type devices and REST APIs (though it doesn't preclude anything else you can write a JS connector for). It's based on Node.js and is intended to be run on-premise (or even embedded).
The big problem I see is that planning does in a lot of ways remove the essence of travelling (see The Art Of Travel by Alain De Botton). The best trips I've been on have been largely unplanned and taken on a day to day basis which flies in the face of a single up front plan which is built once and referred to throughout the trip.

What I do see a market for are the tools which sit in the middle and enhance your ability to plan once your in a location. Tools like:

- flight management
- hotel booking management
- local knowledge resources
- tools for connecting with locals
- language tools

A lot of these are already available in various forms through dedicated applications. I use kayak, hostel bookers, app in the air, wiki travel plus local subway and language apps. Whether there could be an advantage to it all being in one place I'm not sure but the tools on their own seem to do pretty well once you've put together your toolset.
Of Berlekamp factorization algorithm
Instagram will change default oEmbed behavior to 'rich'
I wonder what most of those optimisations were? In particular, are there any that are general enough to be worth knowing about, or even worth including at the compiler level?
How is this work funded? Are these developers working full time on SQLite, or is this work done in developers' spare time?
Sweet! Thanks for the tip. looks like EFF just got another donation for $6.54 USD, and thank you Zach for donating your software for charity!
Did someone call it a priSe?

It was only a prise when Obama got the Nobel Peace one.
M'eh. Yes, Scala has flaws but I feel like this talk makes too much of minor annoyances. Ultimately you make an engineering decision about platform. Do you want decent performance, lotsa libraries, and a modern statically typed language? Scala is arguably your best option at present (yes this can be argued with; no that isn't an interesting argument to have). Maybe we'll all be using Rust/Haskell/whatever in 5 years, but in the meantime I got code to write and products to build and I'm using Scala for better or worse.

Specifically:

- Code on slide 3 has typos. (Yeah, that's minor)

- Lambdas are slower than Java 8 -- that's because Scala currently supports Java 6+. Java 8 has been released for 6 months. This is a ridiculous complaint.

- Heavy in terms of concepts -- another ridiculous complaint. If you want to keep on writing Java, keep writing Java. If Scala didn't bring new stuff to the table it wouldn't be interesting.

- Implicits -- agreed they can be misused. Type classes are the way forward.

- I don't understand many of the "very ugly" complaints. Yes, collections have lots of methods. Is this surprising? Yes, library code may be written in an abstract way. So what? Yes, DSLs look like DSLs. Yes, abstracting over arity is a problem in all statically typed languages. etc.

There are valid complaints to be made about Scala. I feel this talk demonstrates a lack of understanding of the language, and many of its complaints are in fact misunderstandings.

To me the biggest issue this talk reveals is that if you come from an OO background (which I assume the author does) then learning Scala will require a change of mindset. I don't think it is fair to make this a language complaint though. Scala makes it fairly obvious what you're getting yourself into and, as I said above, if you wanted to keep on writing code the way you have in the past it's not clear why you are using Scala in the first place.
With a type system that's weaker than Java's? Look at e.g. the way spray handles HTTP headers; it eliminates a bunch of errors that are in some sense trivial, but almost all bugs are trivial when looked at in the right way. You just couldn't do something like that in Go.
The same goes the opposite direction, though. While I'm sure your actual arguments are more cogent, simply complaining about something specific isn't an argument against OOP in general.

And I doubt that anybody claims Java isn't verbose, or that the IDE "handles" it--regardless of who's doing the typing, Java is verbose. The only people that hold up Java as a good example of OOP are people that don't really know any other version.
Tower of hanoi, code shared in algolint.com, your online algorithm practice tool
I think people under-estimate incremental improvements a lot. My tai-chi teacher told me that eastern culture is more about "putting one sheet of paper on another", there is slow and steady improvement. Western is much more about "big bang approach", make it or break it.

SQLite has been around for 15 years, they never shifted their purpose and were constantly improving. You get almost perfect product at this point.

I work on in-memory db which was evolving similar way. Now after more than decade of small improvements, it is faster than java collections, despite doing serialization and its own memory management.
And this is one of the problems with "optimize later".

If you have a large project in Python, for example, far too often there isn't any one spot that has massive gains if you translate it to C. It's the death of a thousand cuts.
Adobe Digital Editions spies on you, ineptly
An amazing choice of something that is used daily, which unlike many Nobel price level physics, everybody can relate to. Generations of physics students will be raised by this particular choice.
That's semantics. Linux may "just" be a kernel, but almost all distributions come with the same set of "curated" GNU utilities. With BSD, the only real difference is that the kernel and userland teams have significantly more overlap.
Want an Easy Life? Try Canberra, Australia
Git's success has probably little to do with its implementation language.
It seems to have a similarity to other cases of justifying behaviour based on secret information post hoc; i.e. post hoc "constructive evidence" or "constructive cause" to perform searches or road stops, based circuitively from NSA and/or CIA information which can't/won't be revealed to a court.
There is a point in my presentation that says that some of these annoyances are easy to overcome in a real project. But some of them aren't.

As for the misunderstandings - the "bad" parts are ..bad. The ugly parts may not be bad, but are ugly (which is subjective, and I think it's implied it's subjective)
Anonymous E-mail Privatoria
Secure FTP Privatoria
The business jargon word for this is "kaizen" - process of improvement through gradual change.

http://en.m.wikipedia.org/wiki/Kaizen
Often the argument is that if languages are superheroes, Scala is trying to be one with all the possible superpowers. When you learn how to use them and have control over when to use them (and for good or bad), everything will be a breeze. But the assumption that everyone will spend time learning the right ways and not use in production before achieving zen is impractical.
Another day, another FP evangelist.
Maybe, but it's just a generic statement about programming, it has no real value in a critique of Scala specifically. Part of the beauty of any flexible language is you can go back and refactor it down to a more elegant solution as you learn more. That doesn't mean you have to boil the code down to a point where it is largely impossible to read any more in Scala than any other language.

There are real pain points in Scala when you try and scale it from single developers to teams working on a project and most of them are to do with the flexibility of the language.

I think all companies working with Scala end up settling on a sub-set of the language that they are happy with. In that sense, the bad is irrelevant: you are never put in a situation where, say, you are forced into using implicits (apart from light use in external libraries like lift-json) so if you don't use them you never suffer their downsides. If you obsess over parts of a language you don't even have to use... then well I'm afraid I have nothing but scorn for people like that.

At team-scale then your main pain point is trying to get style of writing that everyone can get behind. Code reviews can be painful when developers with different ideas on how to solve a problem butt heads and pull requests turn into "That's not how I would have written it" instead of critiquing the actual code presented.

The tooling and compiling I completely agree with. SBT is a horrific mess. I don't have a single good word to say about it.
You should try Luminus, which concentrates all the basic libraries for web development.
Not as rich as Play! or Django but sufficient for doing a lot of things. It's also a great way to learn Clojure smoothly, it's far more accessible than Pedestal for a beginner.
Flexible Particle System – Code Optimization
How long will we have to wait to get this version usable for our CoreData apps in ios ? Is it possible to include it manually into our app or are we dependent on ios releases ?
Re "well within the safety margin":

> EDF was granted permission by the regulator in the summer to relax its graphite weight-loss limit at the Dungeness reactor in Kent from 6.2% to 8% after it came close to breaching the original safety margin.

> Hinkley-B and Hunterston-B are also getting close to their higher 15% limits, too.
Nope, original spelling of the topic said "price".
Everthing detailed:

http://www.sqlite.org/changes.html
By "50% faster" what they actually mean is this new version requires 50% less CPU cycles than the former for doing the same task. In real world I think you will not get your program to run "50% faster": disk io is often the bottleneck in the database area.
I don't have a fleet of systems like Google but on the several few thousand servers I look over, I see the number of ECC errors is lower than that. It is however a strong power law distribution, many servers (>70%) see no errors at all, and a few have so many that they are unusable, some are in between and have undetected performance or other impact.
not going to say it is 100% of their time, but they are paid to work on it.

You can see five consortium members on the front page of sqlite, the cost of a consortium membership appears to $75,000/year[1]. That's enough to pay developers.

[1] http://sqlite.org/consortium_agreement-20071201.html
> the Milgram experiments

Although the electric shock is the better known one, Milgram has suggested I believe three of the most impressive experiments in social psychology that I can think off:

- measuring the diameter the small world using postcards (for a fashion magazine; that experiment could only be replicated by Facebook)

- he inspired the Stanford prison by Zimbardo.

But doing “bad experiments but good plays” was something he was aware, hence his and the rest of the field insistence to do more, to know better. Reproducing it, be it with flawed game-show observation, getting back to experiments notes with a different perspective (Milgram was understandably concerned if a subject would, under thread of a handful of dollars, still proceed; an experimenter who wants to find excuses has a different point of view) is part of the same effort to understand not just how it happened, but how to avoid it, too.

> Milgram became more interested in the control than the test.

That is a staple of cognitive psychology, and that instinct has led to measure spectacular impact from increasingly negligible factors: the one I like to quote (it is not very well known, made at my alma mater in Nanterre near Paris) has an Ultimatum game played after subjects are told to say whether they prefer a Klimt painting to a Delaunay, against players that agree or not.
Whats Syntax diabetes referring to by the way? I didn't get it from the presentation, and googling yields, well, diabetes information.
Your way of educating people about Clojure isn't particularly helpful. Don't make sure that people miss out a really good language, instead take this opportunity to share [personal experiences or impressive writeups about] how awesome web frameworks are on this side of the grass.
Scala gives you an excellent way to go about changing your mindset though. I feel like functional logic at a granular level wrapped in OO structures is a very logical way to go about building the kinds of software that Scala is being used for.
Buildweb.com domain auction, only 3 days left
The font on this websight makes this totally unreadable...
Pwnie Award 2014 (best song): a NSF/PDF polyglot
Saw some Scala at a conference recently. The guy was demonstrating using it to do TDD.

I lost track somewhere in the first ten minutes or so, but it looked like he was importing/using multiple DSLs and helper libraries. After I lost track of the exact details, I started scanning for the gist of what he was doing.

After an hour, he had what looked like the most massive clusterfuck I've ever seen in a project file -- all to do something that would take a dozen lines or so of simple FP script. Seemed like every functional thing he used was either also an object or had to be bolted into an object graph for it to work. The project file had scores of things in it.

This did not leave a good impression. It reminded me of when I saw my first C/Win32 app and realized you needed a couple hundred lines of code and several files just to say "hello world" -- except this was a couple orders of magnitude more complex. It was a god-awful abomination.

Hopefully Scala projects are not like this.
I think there is a similar flaw in your argument as follows.

You: OO is flawed because of x

Me: But OO language a doesn't have a problem with x

You: Ah but language a has problems with y

Me: Yes but language b doesn't

etc...

You conclude OO is inherently flawed

I conclude that there are now languages without flaws...