skysight-inc/HackerNews huggingface dataset:
>Similarly, computer programs today are increasingly diverging into a state where there is a tiny amount of extremely performance critical code, and a large amount of code where performance is so good on our hardware today that even horribly unoptimized code has no noticeable effect on performance.

>Thus, optimizing compilers are useless on the first type of code (humans are better), and useless on the second (performance doesn't matter).

Even today, in practice, this is a false dilemma. Consider Postgres, Firefox, or Photoshop for that matter: I expect the user-experience of these products to be significantly degraded when compiled with -O0.

The trouble with this analysis is that it assumes that a codebase is a static, finalizable goal: it will be written, it will be done, and then it is perfect. And that might be true of... oh, I don't know... qmail. But the development of most software is an ongoing process, and the tradeoff between developer time and runtime will never go away: nobody in the video-game industry would consider for a second the idea that performance-critical code doesn't need to make deadlines! A great deal of performance-critical code is written with a deadline, by people who would never pass a tenure hearing. If you can eliminate all "hot" parts of your application by linking assembly libraries, even today, you're in a very, very small minority! The amount of hand-written assembly in the wild is so small that unless you work on [cryptography, scientific computing, emulation, embedded] you'll rarely cross paths with it.

The call at the end of the presentation for an "interactive optimizer" of sorts is a bit of a non-sequitur: we might ask as a necessary prerequisite the demonstration of any system which can effectively compete with (∆t ≤ 10%) hand-written assembly on any problem of a significant size. This extremely-tuned linear algebra optimizer ("AUGEM"):

http://xianyi.github.io/paper/augem_SC13.pdf

demonstrates that it can beat g++, but no comparison with OpenBLAS is given (the researchers used an old version of GotoBLAS, which is sort of unfair by their own admission). Can human-parity ASM can be generated efficiently with an interactive compiler? I have no bloody idea.
> I find this whole backlash against p-values pretty confusing.

Plenty of research (not in particle physics) uses the cut-off of 0.05 instead, misunderstands the p-value as "probability that the result is not real", and also ignores the fact that a p-value of 0.05 can too often be reached by making a variety of choices in experimental setup and data analysis. When the headline calls it a "Tool to Sift Research Fudge from Fact", NHST wasn't doing this job well at all, and wasn't really designed for this job in the first place. There are far, far too many people who seem to think that p<0.05 means something is a "research fact", which is a failure of statistics education as well.
There was an article in the past. Well, that's just how Wikipedia is. The Node.js article, for example, has only been undeleted by an admin because someone mentioned it in some "Wikipedia is lame" thread on Reddit.
97% of people born tomorrow have limited freedoms. Tiebout can fix
Thanks. That makes your comment about MCU-based systems that much more intriguing. :)
Yeah, it's easy to be a little too conversational sometimes in these comments, which leads to misunderstanding. In retrospect I get the feeling everyone understands the limitations of the hardware here.
"OMG, /bin/sh increased in size by 191x from 1974 to 2015!" seems like the byte-counting equivalent of people who lose their minds about "YOUR FOOD HAS CHEMICALS IN IT WITH COMPLICATED NAMES!". Both sound impressive and might make you worry - and both omit important facts that would greatly reduce that effect.

For instance, 191x growth since 1974 seems steep until you realize that the corresponding storage has grown from, say, 10.5MB (capacity of an RL02 for the PDP11) to ~1TB; a scaling of 100000x over the same period. That's not even really comparing apples-to-apples; the RL02 was not the sort of thing you'd have on your desk.
There are no paid repo's, all repo's are free. The costs are very limited (low single digit thousands). We pay for it with money we get from on-premises subscribers. We think this will be like email, the storage costs can be offset with other income. Instead of advertising we're thinking about offering a marketplace (similar to what Heroku does). But that is a long term plan, for the next few years we're focussed on growing it.
I grew up only having to be home by dark, too, but putting a label on what used to be normal but is being lost is actually a GOOD thing! It's not sad. It lets you track the concept's popularity, and makes for catchy slogans like "Free range parenting is not a crime".

Without a catchy label, even those who believe in it (like me) have a hard time finding words to speak up whenever a helicopter parent is around.

Because it was so natural in my own childhood, it seems self-evident that children don't need constant 24/7 supervision (and it may actually be harmful) and so I find myself grasping when I encounter someone who believes the opposite (and there are plenty). A nice sound bite like "free range parenting" just might be the tool needed to combat this trend.
> which sometimes gets us ridiculed by statisticians

You get laughed at because you have this huge luxury at dissecting huge amounts of data, running the experiment billions of times.

Do you understand that in most disciplines, you don't have that luxury?
Not a game programmer but, impression I get is a number of games use interpreted languages as glue. Certainly sound to me like thee is a dichotomy between must run fast at all costs, and must be flexible speed matters not at all.

I think game programming is an area where a high percentage of the code base needs to run fast, even if it's not run very often. If it causes the frame rate to slip, the user is going to notice.

In my case, embedded, optimizing for size is everything. And usually only a very small portion of the code needs to run fast. One problem that people are running into with optimizing compilers is with embedded often you are interested in the physical side effects of your code, not it's mathematical end state. Optimizing compilers are increasing not respecting the former in preference to the latter.
Here's a link to add Emacs keybindings to Word on Mac OS X. Hopefully it's still accurate.

http://emacsblog.org/2007/02/18/emacs-key-bindings-in-ms-wor...
I'm going to answer about band movies, here are my favorites: The Commitments, Josie and the Pussycats, Begin Again.

The Commitments for the scene where the venue tries to screw them on pay. Josie had me at "Take the Chevy to the levy." Begin Again for that second pass through the song. All three are great throughout, but I love those particular scenes.
> Similarly, computer programs today are increasingly diverging into a state where there is a tiny amount of extremely performance critical code, and a large amount of code where performance is so good on our hardware today that even horribly unoptimized code has no noticeable effect on performance.

> Thus, optimizing compilers are useless on the first type of code (humans are better), and useless on the second (performance doesn't matter).

It seems to me that while speed may not matter much anymore, power consumption matters now more than ever before (the proliferation of computers that are run off of batteries). If you're computer spends less time running code and more time idle, even if we are talking about milliseconds that the end user won't use, you might use noticeably less power over the course of several hours.

The difference between "the phone ran out of power when I was still 5 minutes away from home" and "the phone ran out of power after I walked through the front door and kicked back for the evening" may be the difference between "the battery-life on this is shit, buy [competitors product]!" and "no complaints".
Well, SCTP gives you messages as first class citizens if you like, or a stream like TCP, multiple channels per connection and many other nice features.

It's mostly used inside telco networks. But unusable for consumers. The routers/modems that people have in their homes don't NAT it, many cellular network blocks it, etc.

An incompatible overhaul of TCP would face the same issues, unless you implement it on top of UDP.
First Exclusive Interview with Matt Gajkowski of Tiko3D
I'm pretty sure the Bible prohibits Jedi marriage.
Would you say that your personal experience is generalizable to many/most people of color?

If, say, someone from another company who's visited your offices for a day later refers to you as "that negro in product development," would it be typical that other people of color would take no offense at that use of language?

I'm curious about it. I don't have that lived-in experience, so all I can do to understand is ask and listen.
I don't think you need looping or flow control, even for a general-purpose language; what you really want is the ability for almost all the code you write to be in terms of "step functions" with the flow control lifted out (e.g. edge functions in finite-state machines; recursive functions that recurse using a Y combinator instead of knowing that they're calling themselves; cellular automata where you only get to define the local transformation, not the automata itself; etc.)

In other words—in the same way that Haskell hides IO "within" the implementation, giving the programmer an encapsulated abstraction in the form of an IO monad where it's effectively immaterial whether real IO happened or not—you could have a language even purer, where you only get to specify comonads, and the definitions of monads (where all non-halting behavior leaks into the language) themselves are abstracted away and inaccessible to the language programmer, except perhaps within the equivalent of Rust's unsafe{} blocks.

In such a language, what monads were used to run the program would be up to the implementation—thus allowing the same program to be given unbounded resources, or bounded resources, for any given resource, as a run-time-configurable decision.
I wonder how they managed the zero RTT connections? How would that ever work?
Yeah, it's a great sentence! Refreshing alternative to those sad articles about crafting yourself into a productive tool for your boss's pleasure...
I like these kind of announcements: dat open source bravery on a Gihub README.
"unpaid emotional labor"

Term of the year, that right there. Shamelessly borrowing and reusing.
ffmpeg only writes inner loops in assembly, and doesn't suffer too much. There would be speed gain in a few situations, but it's just not worth it when it would be so much harder to change the code.

But inside inner loops, you don't need to change code, and assembly can be easier to read and write than C. Have you seen Intel's C SIMD intrinsics? They're so ugly!

> C compiler are getting comparatively worse at optimizing for current hardware than an expert in assembly.

It seems to be Intel's opinion that optimizing compilers for specific desktop CPUs is not worth it. GCC and LLVM have machine-specific models for Atom CPUs, but almost nothing for desktops, even though Intel engineers work on those compilers.

They're probably right, since most people are running generic binaries.
Not sure which statistics you refer to, but one explanation is simply that many pedestrian accidents (falls) are very old people. They fall, they break pelvis, they are immobilized, they die.
What about private citizens that had correspondence via email with Sony people and are now in that public database? They should have a right to privacy.
People keep saying that they're obsessed with it, yet I've had better results running an (admittedly, quite old) booking system under dosbox on Linux than on Windows post-XP. And I regularly advise people to try LibreOffice when Word refuses to open old documents properly. YMMV.

They also didn't hesitate to break pretty much all TCP/IP using userland with the firewall transition in XP SP2. Which was the right thing to do at the time, mind you, just not terribly conservative.

Linux still runs a.out binaries (and that transition was in only in '96), but they still have quite a bit to go in comparison to a S/360 which runs JCL programs from '78 unmodified. That's obsession for you.
> Boeing 747's are complex systems; it's not acceptable if one fails occasionally.

You're right that 747s should not just fall out of the sky. However, parts of 747s fail constantly. In a machine that complex, they are guaranteed to have some downtime. A well manufactured 747 will fail cleanly and safely and recover smoothly.
Yup. Got that backwards.
I think this conversation is incomplete without considering the economics of the Mike Palls of the world. Yes, there exist experts who can write hand-tuned assembly that dramatically outperform optimizing compilers. More importantly, a well-designed algorithm can outperform an optimized version of a poorly-designed algorithm by several orders of magnitude; far beyond what we can expect from constant folding and function inlining.

You'll note that the domains to which these experts apply themselves tend to be those which affect millions of people and are critical to broad swaths of industry: everybody needs a faster BLAS implementation, and the economic impact of faster TLS implementations measures in the hundreds of millions of dollars [1].

But there is a very long tail of people writing performance-sensitive software for domains which cannot attract the time and attention of experts but for whom GCC and the JVM, for example, deliver tremendous gains.

In many cases, you might say the metric to optimize is not battery usage or throughput, but rather 'thinking time'. If a biologist is held ransom to the attention of one of a handful of experts who is capable of hand-optimizing a novel data-processing technique, that biologist will be significantly handicapped in what they can measure or explore. An optimizing compiler that can make their proof-of-concept code run "fast enough" is quite powerful.

[1] https://people.freebsd.org/~rrs/asiabsd_2015_tls.pdf
"Guice may not show up on any profiler as problem - but if you slow down object creation by a factor of 40x, something you may do thousands of times per second for the life of your program, you are degrading performance across the board."

If your profiler doesn't point right at the thing that you're doing 40x slower thousands of times, either your profiler is BROKEN or that isn't actually a bottleneck.
Oh exactly, sounds like there is ways of getting around the government mandate.
I'll add this about Scrivener: It is a tool that needs to be learned to understand it's inherent usefulness. You're are ultimately writing in plain text, Scrivener is there to help organise, categorise, and to go full screen for distraction free writing.
Only between Jedi of the same gender. And species.
For some reason this is the first explanation of Roman numerals used in chord progression that made sense to me. Thank you!
>>Partially free

That kind of says it all. Read different things from different places. No one single coherent documentation.
Since we're moderately off-topic:
I once made a gnuplot script that emulates the look of a Bloomberg terminal. Super hacky, but it works:
http://folk.ntnu.no/asmunder/bloom.gnu
and you need this file as well http://folk.ntnu.no/asmunder/fader.png
> He then goes on to rebut other comments with simple bald assertions (like the luajit author's one) with again, no actual data.

I assure you, the LuaJIT case is real.

Here is data about LuaJIT's interpreter (in assembly) vs. Lua 5.1's interpreter (in C):

http://luajit.org/performance_x86.html

It's true that these are completely different implementations. But Lua 5.1 is one of the fastest dynamic language interpreters already. There is not room to optimize it 1.5-5x further, like you would need to catch LuaJIT's interpreter. And as the link above shows, the LuaJIT 2.0 interpreter beats Mike's own LuaJIT 1.x JIT compiler in some cases.

Mike's post made lots of specific and concrete arguments for why it's hard for C compilers to compete. Most notably, Mike's hand-written interpreter keeps all important data in registers for all fast-paths, without spilling to the stack. My experience looking at GCC output is that it is not nearly so good at this.

Look at luaV_execute() here and tell me that GCC is really going to be able to keep the variable "pc" in a register, without spilling, in all fast paths, between iterations of the loop: http://www.lua.org/source/5.1/lvm.c.html

I don't agree with the talk's overall point, but if you are skeptical about pretty much anything Mike Pall says regarding performance, you need to look harder.
Things like MySQL and PHP have bad reputation nowadays but Facebook shows impressive use cases and improves the technology more and more.
Love me some NOVA. Got me interested in science as a kid. My favorite episode is probably the one with the Bose-Einstein condensate.

Sucks it looks like their website only supports flash.
Yep I definitely think there is an argument to be made that our current press does not publish enough details (numerous incidents of big press delaying publishing of big stories at government request), but I feel like the Wikileaks "publish everything" model is on the other end of the spectrum and it's not the solution. There needs to be a middle ground and responsible review/disclosure.
Awesome. You're following in some big footsteps: http://akkartik.name/post/28672493
From the security page: "A HMAC-based symmetric authentication, followed by an asymmetric RC4 stream cipher is supported."

RC4 is WEBSCALE!

Well, and insecure.
The point is that all of the time spent running code is spent running only a small portion of code -- This is still case 1 listed above.
There are a bunch of languages like that. I've just done a project in HOL, where all functions must terminate. Proving that functions terminate is a pain in the backside, because for any trivial structurally recursive function you write (easy to prove), there's also a function that's nothing like that and will just be a waste of your time.

Also, without a lot of work, you'd get very little out of evaluation models. In particular, the only disadvantage at the moment is that you can't strictly evaluate arguments where the function isn't strict in that argument. That's cases where the argument might not get used. I don't think it would get you massive improvements that you couldn't already get in most cases by simply producing specialised versions of the function.

The big advantage is that you can prove more interesting stuff about your code (with again more effort). See Agda, where you can (for example) write a zip function that won't typecheck unless both lists are the same length.
I was expecting to see in the examples:

$ wrongcommand
error
$ fcuk
command not found
$ fuck
TV Companies Will Sue VPN Providers “In Days”
Most people do not know this. I think everyone on HN knows this because we run these systems and know how easily they can be tampered and monitored.
That issue has an alias you can use:

I just added an additional alias for testing.
It simply outputs the command fuck would execute:

alias tryfuck='thefuck $(fc -ln -1)'
Harmonics. They resonate well together because they have some common frequency. 13 equally spaced notes wouldn't match on multiples of 2, 3, 4 and 6.

Example: The major scale (C, D, E, F etc) are the notes 0/12, 2/12, 4, 5, 7, 9 and 11. You'd expect the 6th note to sound nice, wouldn't you? Wrong: The scale is logarithmic.

A nice C chord is made of 0th, 4th, 7th/12, which are 523Hz, 659Hz, 783Hz. Notice how the second frequency is 125% higher and the last 150% higher. So they have harmonics in common and it makes them sound well together.
> That's the place to put it

Won't work for cooking or any other activity that involves grabbing things. Though I guess you can work around this by requiring something like a long/firm-press on the ring to put it into the tracking mode.
I realize it is popular these days to hate on Mongo, but the FUD is getting a bit old.
The interesting problem is that if you set a strict significance threshold but have a sample size that is too small, you will still sometimes correctly get significant results, but the effect sizes will all be exaggerated.

If the sample size is too low, the only effect size big enough to be significant may be one that is much larger than the truth. So you only claim significance when you get lucky and exaggerate.

This is actually an enormous problem, and it probably affects physics too. Many medical and biological papers tout huge effects which turn out to be completely wrong -- not because their result was a false positive but because it's an exaggerated true positive. Sample sizes tend to be hilariously inadequate in soft sciences where each data point costs thousands of dollars.

I call this "truth inflation," although I don't know if it's been discussed enough to have a common name. It's heavily discussed in my book, if you're interested in seeing why the backlash against p values is so widespread: http://www.statisticsdonewrong.com/regression.html#truth-inf...
Could those be specified in comments in the file? Most development nowdays is done in an IDE that could intelligently "hide" the comments when you're just reading the code, and then when you're looking at optimizing the code you could start annotating things that way.

A similar approach is to use #pragma directives, though many languages do not have an analogue to that.

Java Annotations are probably wrong. The compiler can benefit from more freedom (and finer grained detail), so for Java comments seem like a better choice to me.
The Godfather, Part II
Even better: use org-mode.
since the getters/setters advertise the type of the internal data structure

No, they don't - that's the whole point. You can change the type of your internal data structure however you want, but as long as the getters and setters accept and return the same type, your contract remains the same with your clients.

since the setter is public, you don't have any protection of your internal data structure anyway since anyone can modify it

Of course you do. You can check invariants in your setter before applying any changes, and throw an exception if the passed value violates them. You can take a lock in your setter, to ensure that the passed information is applied in a thread-safe way. Again, this is the whole point of encapsulation.

Another comment mentioned that the JVM can JIT this problem away through inlining; I honestly do not know if that it is true—if it is, then great

The JVM can do this, and much much more, at runtime. Basing your optimisation advice on what a systems programmer might have told you 20 years ago is a really bad idea. All good JITs and compilers have inlined small functions for a very long time now. The JVM is particularly impressive in that it can do that for virtual calls too.
Has Chase Been Hacked?
URL:
https://www.chase.com

Safari:
https://www.dropbox.com/s/mmsp63xws9m84xo/Screenshot%202015-04-17%2016.28.58.png?dl=0

Chrome:
https://www.dropbox.com/s/yzbka9gcjn7r8ay/Screenshot%202015-04-17%2016.29.36.png?dl=0