skysight-inc/HackerNews huggingface dataset:
And there: http://www.yosefk.com/c++fqa/web-vs-fqa.html

As for the "subjective" part, it doesn't really weaken the argument of the FQA. I estimate most of his "subjective" claims are subjectively true for most programmers.

When something is subjectively true for a sufficiently large majority of the relevant group of sentient beings, asserting its truth, period, is common usage.
Who's talking about selling it?
Publisher Closure Puts 2600 in Limbo
Laws can be made in any way they like. The argument is not in how laws can be made, but in whether they are any good. This is an argument about quality and usefulness of law. As Knuth puts it, "Man-made laws can be significantly helpful but not when they contradict fundamental truths.".

You are right that the method for deciding on what parts of math are subject to patent can be wholly external to maths and not pay any attention to mathematics whatsoever, however what Knuth is saying, and I would tend to agree with him, is that this would be folly.
Your in depth analysis of his emotional state through blog posts?

Exactly what is a "normal" life? and what adjustments are required to achieve it? What kind of trouble did he have with those adjustments?
An o-shibori (hot towel) service. They're common in Japanese restaurants, and when I visited Tokyo in the middle of summer, I looked forward to the hot towel almost as much as the meal. You could resell or lease the equipment and provide daily laundry / sterilization service.
I think you're using the editor's modality wrong.

ESC is not used to exit from Insert mode. ESC is used to switch from any mode back to Command mode. In fact Command mode is also called Normal mode. You should spend 95% of your time in Normal mode and use the other modes when you need them.

I suggest binding `kj` to ESC since it allows you to quickly make a change and continue browsing your code. Take the following session:

* Browse and spot something that needs to be changed

* Type `ci(messages, callbackkj`

* Keep browsing with `hjkl` as you're in Normal mode

While it may seem weird, I've yet to find an occurrence of `kj` in a program in years of using this binding and my hands haven't left the keyboard. The cognitive weight is zero as well (at least after building muscle memory).

Now, I believe it depends on the kind of programmers you are. My coworker is the kind who types in a lot of code and rewrites a lot of stuff. I'm the kind of rewires things and make subtle changes after spending a lot of time reading it. In other words it works well for me but probably wouldn't for him.
Yup, this certainly needs work.

Myself, I was very skeptical, until one day I decided to start my new project in Python 3 and quickly realized that everything isn't that much ruined. Couple of pull requests here and there, could be worse (after reading some of the more... opinionated blog posts I expected something truly catastrophic).

But the new goodness in 3.4 is totally worth it, in my opinion.
But what outcome are you aiming for with your comment?

The prosecutor does share some responsibility, as does Aaron, as does MIT, as does JSTOR, as does the general judicial system and environment that allowed this to happen.

Doing a drive by 'He only has himself to blame' style comment, is ignorant at best, and out right trolling at worst.
> Feature 0: Matrix Multiplication

It’s not really a feature, it’s an operator that can be overloaded. That is, instead of using `mymodule.dot(a, b)`, you can use the much less readable `a @ b`.

> Feature 1: Advanced unpacking

> Refactor your functions

The given example is a bad refactoring, because it moves away the function’s self-documentation.
The growth data chart over the last 2.5 years is very interesting. Thanks for sharing that.
Related, and also interesting (especially as a response to "TinyGL is a lot faster than Mesa"), is Mesa's llvm rendering backend llvmpipe. It compiles the rendering pipeline to llvm bitcode which is then compiled to machine code. It makes use of multiple CPU cores and SIMD instructions. The result is surprisingly quick software rendering of anything OpenGL.

Key differences to TinyGL: Mesa llvmpipe implements "all" of OpenGL and GLES2 (That is, everything that is implemented in Mesa works with this backend) and the rendering is accurate.

I have not done a head-to-head benchmark, and I don't think it would be that interesting since the two libraries are from entirely different ages.

The existence of llvmpipe was part of the rationale for Qt5 to require OpenGL (GLES?) for rendering [1]. Qt5 has no other rendering backend.

[1]: I remember this from the beginning of Qt5 development, which is so long ago that I have a hard time finding a quotation. Maybe I can use this Phoronix article as backup: http://www.phoronix.com/scan.php?page=news_item&px=MTA5ODc "The Qt developers praised the CPU-based Gallium3D driver and will be relying upon LLVMpipe when no GPU hardware driver is available. They say that using LLVMpipe is working better than any software rasterizer of their own. " "LLVMpipe remains too slow for OpenGL gaming (...), but it's good enough for a tool-kit and composited desktop."
Even now that I'm practically married to SublimeText, I can't stop using classic mode and I still sometimes end up in vim by force of habit.
Meeet.co – Meeet connects developers and designers working on side projects.
Android was in fact meant to work this way, with apps providing such functionality through intent filters that match the PICK or GET_CONTENT actions.

But Android is also supposed to work through ContentProvider components that enable access to databases. Sometimes you need more than a PICK action performed by an external app. As in the case when you want to make an alternate implementation of a contact picker.

This is why the issue has to be addressed directly, by making many if not all permissions optional, and settable per app. Handling a SecurityException is not burdensome. Much of the permission overreach is due to crappy "behavioral targeting" data collection that doesn't really work. Nobody will miss it.
I get that message from within Australia... we don't even have the bandwidth to scape a website ;-)
Completely disagree, and I'm really not sure why you're characterizing their decision to base on Debian/Linux as a "mistake" (it's going very well so far).

>I think they should have adopted Android as a desktop environment per se (like Keepod [1] for example).

Android is not a desktop environment. Just as there are numerous desktop environments for Debian/Linux, so too are there numerous desktop environments for Android. There is no one clear standard on either platform. Valve wouldn't escape fragmentation by using Android; they'd merely embrace another kind.

>Using something like Docker, I could have been running Android-SteamOS on my laptop and still been able to get RoR+Postgresql working.

You can do precisely the same thing with Debian/Linux. In fact, that's precisely what it was designed for.

>the huge fragmentation in the desktop linux world (cue the Systemd Wars) is hard to work around

The systemd wars are over. Systemd definitively won, full-stop. Besides, what on earth does that have to do with Steam? Why should it need to have any insight into that level of abstraction?

> But Android already has a single driver (Google)

This isn't an advantage; it means that they have less flexibility. Why do you think Google itself chose to base Chrome OS on Gentoo Linux, instead of working with someone like RedHat? Flexibility and freedom.

> Steam could have built a viable desktop Android based SteamOS.

They already did — on Debian. Exactly what makes you think they regret their decision? Seems to be going very well, so far.
Neeed.com fully support Svpply export
What's ^Home / ^End? If it's moving to the beginning / end of a line there are vi shortcuts for that: ^ and $.
C++14 has a good share of the problems of C++98, while adding its own. It's not like C++ ceased to be the most crazily complex and the most deadly trapped language in widespread use.

I'll grant the FQA as such is outdated, but irrelevant? C++ was a huge mistake to begin with, a giant waste of time at the global scale. (Things are different at the individual scale, because network effects.) Having a heavily documented case for the oblivion of C++ is a good thing.
I completely disagree. They've already (mostly) solved the fragmentation issue by bundling a set of libraries with Steam that roughly resemble Ubuntu 12.04, and I've run Steam on just about every distro out there and had good experiences.

The desktop gaming industry doesn't want a pre-existing developer ecosystem like Android has. It wants something like it already has on Windows, and more and more game engines are supporting OSX/Linux as build targets.

I just can't imagine playing Dota2 on Android and have it perform better than on Windows (which is currently the case for Linux), and I can't imagine porting it to Android would be easier than porting it to Linux.
Perhaps accepting the normalized injustice and oppression within the society in which you were socialized is a precondition for emotional stability. Maybe that is why so few of us are willing to question it. Just a thought.
Added in edit: Why do you think the last version must be faster?

In short, if you implement these things on multi-core machines, then no, it isn't obvious that the last algorithm will be the fastest. With modern experimental parallelizing compilers on suitable hardware, the exact algorithm matters, and these show significantly different results.

I spend most of my time working on "odd" hardware configurations, and as a result, sometimes these more "interesting" algorithms are the ones I immediately turn to rather than doing what others think of as instantly obvious.
First you'll learn how to orientate around text quickly using normal mode, then you'll start playing with tabs, splits and buffers to search between multiple files, and then you'll start using registers to save phrases and regular expressions to search directories. At that point you'll never want to leave Vim again.

:wq
What about exercise?? Seems like a glaringly missing piece of data.
Are you sure you are not missing the point? Whether curated or not, the expectation of users certainly is not that it's curated according to facebook's interest of the day, but according to their own interests (that is, to reduce noise, not to influence them), and whether perfect or not, people certainly do expect and counteract lying in ads.

Also, just because ads are generally perceived with some scepticism, doesn't mean that certain kinds of ads aren't unethical as well. In particular, ads that exploit methods of bypassing rational thought might indeed be unethical, and certainly are not the same as just general self-interested advertisement. And despite what you claim, manipulation is actually not a defining property of ads - if you have a product to sell that is actually a rational thing to buy, advertisement can use perfectly rational thinking in order to pursuade you to buy it. Just because much of end-consumer directed advertisement nowadays is trying to sell bullshit, doesn't mean that advertisement can only be used to sell bullshit.
It got Ned Stark in 20 questions, and Jacques DeMolay in 22.
+1 for the Pen Japan idea!
The language is sort-of functional. It's as unfunctional as possible while still highlighting immutability.

The key is to focus on what you can't do. Pointers in C do provide a similar UI to "boxes" that I was describing. But their plain values aren't the same. Consider

int main() {
int x;
x = 3;
x = 4;
printf("x = %i\n", x);
}

$ gcc test.c -o test
$ test
x = 4

Here, I am still able to treat the value `x` as a "box" because `x` is not a name but instead an actual int-sized memory location on the stack. Here's a similar fragment in Haskell

main =
let x = 3
in let x = 4
in print x

$ ghc --make test.hs
$ test
4

Now the difference here is that each of those bindings (namings) of `x` have a context delimited by the indentation. In particular, names only have meaning within a delimited scope. In fact, the `x` bound by the inner let is completely different from the outer one. The fact that they share the same name means that the inner one shadows the outer one within the scope of the inner let.

We could demonstrate this with the following program perhaps

main =
let x = 3
in print ((let x = 4 in x) + x)

$ ghc --make test.hs
$ test
7

Here we can plainly see that the context where `x` names 4 is only as large as that inner, bracketed `let ... in ...`. After we leave that scope, `x` reverts to naming 3.

The trick with figuring out FP is that it actually feels more restrictive at first. It's a typically higher-level form of expression. You can obviously simulate it all in C (FP languages might even compile down to C) but the goal is to determine what kinds of things can be expressed in the FP language itself.

To learn more, I highly suggest learning just the basics of Haskell or OCaml. Scala would probably suffice as well, though I don't know it as well to say.

Generally, the idea I'm talking about is often called "immutability" (though it's slightly different). Programming with immutable things tends to be easier to reason about because names do not change what they refer to within a context (like x changing from 3 to 4 in the C program).
> Well, pretty much any time that Java, C# or Go are being used, C and/or C++ are also being used. We can't forget that their major implementations are built with C and/or C++, along with much of the underlying software they run upon or interact with.

I don't agree. If someone is programming in Python, they are programming in Python. They aren't programming in C, in addition to Python, just because the VM or whatever is programmed in C. If some language displaces C or C++ in some niche, then it has displaced it, even if the VM of the implementation of the language happens to be written in C or C++. The important distinction, I think, is what people are programming in.

This is like saying that "nothing has proven to be viable alternatives to cement for building houses" when talking about building entire houses with cement, if the foundation of houses are always made up of cement. The fact that the rest of the house can be built with other materials like wood or bricks is a crucial point, in that context.
It depends where you come from. If you started with the typical C-influenced programming languages, sure, the last one is not only obviously the fastest (edit: on a normal computer), it is also the first one you would write. But things are different if you are used to write in functional lisp-like languages, and one can clearly see that he is coming from that direction (using recursion as first try, knowing reduce, …).
Why would fragmentation in the broader Linux ecosystem affect the narrower SteamOS platform? Valve can safely ignore Linux fragmentation.
Yeah it's a strange discount system as it is totally based on the raw count of items, disregarding what they cost to send. As I get closer to that 1000 limit I will definitely get more and more motivated to bridge that final gap by any means.

Now a shipment usually costs me around $3 to mail. At that 1000 threshold the discount will suddenly go from $0 to $300. Sending an empty envelope would cost about $1.
"It's the actual writing that's two characters more (start insert mode, write, exit)." Makes sense. Asking for permission to type in a text editor feels counter-intuitive, but I'll give that a try.
Now this is terrible and with HOPE around the corner even worse!
I would expect that for a vector of things in Python, iteration would be fastest. The array is in memory, right there. Spooling up a series of parallel threads (and in Python, establishing the right locking, whatever that is...) just to distribute a bunch of ADD operations seems like a waste of time.

If the problem domain is indeed massive and needs to be parallel, okay. But the introduction was about doing some simple image processing, so the direction that this guy took with parallelism surprised me.

I wouldn't call this a waste of time (I learned some more Python, which is nice). But I think I would have had this done in a minute or two and moved on.
I think we are the only 2 people writing keyboards so early :)

Did you find a way to get ALL the inputted text from the text field?

Thanks!
I share your concern about GC pauses.

LLVM bitcode provides no security guarantees whatsoever though. It has raw unchecked pointers. You can even cast arbitrary integer values to pointers and dereference them. In PNaCl, security is provided by the NaCl layer beneath the LLVM layer.

It's an interesting idea, to have an OS kernel with processes/etc sandboxed from each other with NaCl sandboxes instead of traditional protection mechanisms. I wonder how the overhead compares.
49% !
Well, there's a myriad of blog posts about great packages for Emacs, so that covers everything pre-existing.

Add MELPA to your package sources, then just M-x list-packages here and there and check out anything new that looks cool.
Now, I believe it depends on the kind of programmers you are. My coworker is the kind who types in a lot of code and rewrites a lot of stuff. I'm the kind of rewires things and make subtle changes

Interesting, I was thinking something similar - suitability for maintenance vs from scratch.
That sure surprised me, I would have rooted for reduce. May be lambda overhead is screwing it up. Could you try the reduction with

from operator import add

I cannot try it out on Colin's version of Python, however on

Python 2.7.6 | 32-bit |
[GCC 4.1.2 20080704]

from operator import add

def sum1(l): return reduce(lambda a,b:a+b,l)

def sum2(l): return reduce(add,l)

The times to compute sum1(l) and sum2(l) on xrange(3333333) are

11.69s and
6.38s

respectively.

So sum2 is about twice faster, which is expected. The timings are the minimum of 5 runs. Given Colin's reduce was about twice slower than his for loop, there is a fair chance that the updated reduce will beat the for loop occasionally.

I was surprised that trying the same on an array turned out to be marginally slower than using an xrange. I would have expected the array to be faster. xrange is possibly faster because it can be held in cache whereas the array would definitely spill outside, although I expected locality to be a win.
I know this is a minor point but using 'gg' to move to the first line is easier than '1G'.
You can clone a repo without an account
You may want to check r/emacs on reddit. People discuss about new packages there. If someone knows other resources, please let me know as well.
Would this work with ads? Organic, free traffic from HN and blogs is nice, but it seems more like a low probability gamble than something you could count on. Your growth is going to be random and you really can't do any projections.

The lifetime value of each subscriber is really high, so it seems to make sense that you could spend $XX in customer acquisition costs.

I've wanted to do something similar for a while, but this is really my only sticking point.
The author started in vi, which has no gig as far as I can tell.
> I really believed that manual memory management, large and convoluted class hierarchies, obscure template programming, cryptic exception handling, and pointer tinkering was necessary in a language and, of course, to get good performance you had to use C++. What a complete lie.

It was a complete lie. Fortunately, none of that stuff precludes you from using C++.
I'm working on a trading platform. Using Go + MongoDB.
I am the only person in my office that uses Emacs. Everyone knows vim. Everyone loves vim. You think you're the crazy one?
You realize your criticism of D has nothing to do with the language itself, and everything to do with network effects, and first-to-market effect? Of course D lacks the widespread adoptions of C++, it's a newer language! The same goes for your criticism of Rust.

If I were moved by these objections, I would conclude that we shouldn't even try to overthrow established programming languages. Heck why not embrace Status-quo Bias altogether?

About Java & co, you need to realized that most C++ code out there didn't need C++ (or D, or Rust) in the first place. The projects that are (i) very demanding to the CPU and memory, (ii) need a complex solution, and (iii) can't possibly separate a few bottlenecks in C from a high level language with a good FFI (Python, OCaml, Lua, Haskell, Lisp…), are uncommon. Some of those projects have incredible impact, but they are still uncommon.

Java & co are for projects where it was a mistake to use C++ in the first place. They don't compete with C++ on its own turf, they just take away territory C++ should never have controlled.
Organic traffic from blogs, HN and Google is really the only thing I've found that works. I have tried several paid advertising campaigns, but they usually end up costing nearly $100 per conversion. Maybe the ad copy / targeting could be optimized enough to get below LTV, but doing those tests would be very expensive.

I've sort of abandoned the idea that there would be some easy way to just get traffic coming in. It's more a fight for finding and retaining each subscriber. Also ads aren't completely on autopilot either, as channels change. When you buy some ad space, it might work OK at first but then work less well in the future as visitors to those sites have already seen your ad. So have to keep following if each purchase still makes sense.
What is it that makes "most modern Linux apps" not run on 32bit? Last I checked, pretty much all packages were available for both x86 and x64.

If you're talking enterprise use, sure, some app servers might need more than a few GB, but that's a memory problem, not strictly a bitness problem.
The slow death of India's democratic traditions
How Developers use vagrant for integration tests
> The corollary in a medical experiment would be, would a healthy person want to undergo an experiment that could make them sick?

Yes, many people would willingly volunteer to take experimental drugs that

i) might not work

ii) might uave severe side effects

because those people are dying and want some months more life.
If you're one of the 0.01% whose app cannot run on Linux, or needs a very specific patched version of the kernel to run, then sure, I agree.

Who knows, maybe Citrix has something to sell that makes the author's opinion very "important"?
All 476 (with graphics) are over here: http://kmkeen.com/local-euler/
NASA Turns World Cup into Lesson in Aerodynamics
Secret Web Assets(SWA)-bestcbstore.com
This generation needs better martyrs.

As for waking up the community to do something? Which community? Certainly not this one. This community goes out of their way to elect their own oppressors and justifies the vilifying all those who on the other side prior to any election. Yet they have the gall to turn around and claim they are oppressed? Look, when you willingly, nigh joyfully, watch as they take over your healthcare you cannot then truly expect privacy can you? You cannot suddenly expect that they really care about you do you? Your just one wrong protest away from being in jail.

Hence the term slacktivist, which applies to most of those cheering Aaron on. Never walked a protest line in their life, but ooh they may have downloaded a song they didn't pay for.
Someone created an HN for ideas called Firespotting and though it got some initial traction, it didn't really take off after that. It's a good idea but needs some more people to really start effectively validating ideas.

http://firespotting.com/
I second this, EU4 and Crusader Kings 2 are amazing games which runs perfectly on Linux. Only thing you may want to do set noatime to fix the problem with slows start up.
Interview with Adrian Cockcroft – Cloud Pioneer
Vim really is an editor: It's designed around changing existing text. Inserting new text is just one of the actions you can perform, and you can combine that action with other modifiers, like "5ifoo<esc>" results in foofoofoofoofoo -- 5 repetitions of "insert foo"
Bathroom UX, part 1: The air plane flush button
Sandstorm – Personal Cloud Platform