skysight-inc/HackerNews huggingface dataset:
I completely agree with this post that there is churn fatigue. Part of that is in libraries, but an even bigger part of it is in the tooling that people use to build JavaScript applications.

It's easy to see all of these new things flying by, combined with changes to JavaScript itself, and feel completely overwhelmed. To be honest, over the past two years, even as a maintainer of Ember, I have experienced very serious hype fatigue.

This is a large part of the reason behind Ember's philosophy of finding and implementing strategies for stability without stagnation. On the one hand, people (including us) are tired of the constant barrage of new tools and techniques. On the other hand, it would be terrible to get beaten by a competitor that discovered a wonderfully productive new solution. The Ember team has spent the last few years honing a process for dealing with these conflicting desires.

That process involves:

* six-week release cycles, so every new change is incremental and adds value on its own

* canary, beta, and release channels (just like browsers), so that people will more appetite for churn can help test out features, and get them stable by the time they ship as part of a final release

* SemVer, so upgrading across final releases is relatively painless and the biggest part of our community can take advantage of the improvements as they roll out

* having each member of the core team build apps that we care about and maintain, so that we can feel the competing costs of maintenance and keeping pace with the latest and greatest first hand

The core ideas come from shipping browsers, which have had to deal with requirements of very strong stability with an increasing desire to "go fast". The pace of new browser features has been so good, in fact, that they have been used as an argument in favor of completely breaking things and starting over.

Ironically, the browser instead shows us that if we want to avoid stagnation, we are going to have to have strategies for bringing people along. Stability without stagnation is not a paradox; it's a recipe for success.

(we talked a lot more about the nitty-gritty technical details in the previously discussed Ember 2.0 RFC: https://github.com/emberjs/rfcs/pull/15)
Asheknazi Jewish Intelligence
Grabbing the Current Browser Tab from Emacs
Your a:hover styles should also be applied to a:focus [0]. You might also want to read about why using only color to differentiate links is bad practice [1].

[0] http://www.456bereastreet.com/archive/201004/whenever_you_us...

[1] http://www.w3.org/TR/WCAG20-TECHS/F73.html
You could use outlets that have USB chargers built in. That would provide you with a hopefully steady 5v source to use. They claim 3.6A charging, so that should provide plenty of power for something like a small microcontroller or even a rPi.

http://www.homedepot.com/p/Leviton-Decora-15-Amp-Combination...
I am not sure but what is the actual harm of it?
Yeah, there's sort of an implicit begin around the whole thing, though.
Google's GSON is the one I've turned to on several projects.
That sounds like an interesting project to do in spare time. Can you link to the project description? or your universities class notes?
" While only about 3% of the U.S. population is of full Ashkenazi Jewish descent,[2] 27% of United States Nobel prize winners in the 20th century,[2][3] 25% of Fields Medal winners,[4] 25% of ACM Turing Award winners,[2] 6 out of the 19 world chess champions, and a quarter of Westinghouse Science Talent Search winners have either full or partial Ashkenazi Jewish ancestry. However, such statistics do not rule out factors other than intelligence, such as institutional biases and social networks. Undue weight is also given to the Ashkenazi statistics because people of partial Ashkenazi ancestry (half or less) are included, but only compared to the portion of the US population of full Ashkenazi descent."

Something is definitely going on here.
Just because there are more important things to do worry about than one particular thing doesn't mean no one on earth should worry about that thing until everything else is fixed.

I really need to vacuum my car, but maybe I should hold off until we resolve the Ebola outbreak?
> I expect those four guys won't keep their system in Rails forever.

For people who didn't know this, I would like to add that Twitter was written in Rails as well. They switched later on for a couple of reasons[stackoverflow].

[stackoverflow] https://stackoverflow.com/questions/9747857/why-couldnt-twit...
Yoda conditions are part of the WordPress coding standards
Maybe there's something wrong with your browser. The underline style is only interrupted slightly for descenders. It continues through spaces and other punctuation like it does normally. It looks nothing like a phrase with each word underlined individually.
No kidding. Security work aside, he finds time to take up time-intensive hobbies like CNC milling for robot parts, and has the time to write up comprehensive documents about the hobby?! (http://lcamtuf.coredump.cx/gcnc/)

Maybe he doesn't sleep.
Nash-equilibrium and pareto-efficiency are extremely technical terms, you shouldn't abuse them here to get some faux sense of authority. I say abuse because we aren't in a context well defined enough to give them an interesting meaning.
Introduction to High-Performance Computing with R (2010) [pdf]
I don't understand the argument, I've used it for several small CLI tools, it works great.
> Having the technology to live on Mars or on the Moon would enable us to settle pretty much anywhere in the habitable zone of the system. Just imagine how much real estate can be built in the form of rings or tubes with materials mined from the Moon or the asteroid belt.

To build something you don't just need raw materials. You need tools, man power, basically you need an industrial complex which currently only exists on Earth. The idea that you can mine raw minerals on an asteroid and somehow turn them into a house with a full life support is not realistic, to put it mildly.

> Also, keep in mind there are a lot of global catastrophes that could easily wipe out our civilization.

If you want to save the scientific and technological knowledge that makes a civilization, there are certainly cheaper and more efficient ways to do it than spending hundreds of billions in order to have a few people living in an hostile environment. It could even be argued that such a boondoggle might trigger the fate you were trying to avoid in the first place.
Can you expand on this? It seems like you're saying that, for example, taking all the world's oil and lighting it on fire, or (more dramatically) firing all the world's resources out of a giant cannon and into the sun, is an optimal economic strategy. I'm not an economist, but that doesn't sound right.

It seems like the optimal economic strategy, assuming finite resources, is to optimize your use of resources. Then, there is a complementary defense strategy, which is to monitor other civilizations so that they don't get the drop on you. This might also include acquiring resource pools for future use, or simply to deny them to adversaries, but it doesn't mean you need to burn through them as quickly as you can.
This is apparently based on the Jaguar port that id Software did in-house.

Interestingly, it seems to include a translation of Carmack's Jaguar rendering engine into C. The original was implemented in assembly for the Jaguar's proprietary RISC coprocessor. The processor's tiny instruction memory required that the renderer be split into 9 independent "phases", and that organization is preserved in the 3DO code.

http://doomwiki.org/wiki/Atari_Jaguar

http://games.slashdot.org/comments.pl?sid=4215&cid=1225529
Good zeitgeist. I feel compelled to give my $0.02 as I was quoted in the blog as someone who "frankly feels completely overwhelmed." However, my criticism will be more from a programmer's perspective not so much a "web application developer" perspective.

Re: the chaos/churn in Javascript, forgetting for a minute the buzz-words of Backbone.js, React.js, Ember.js, Gulp, Angular etc. - they seem all to be a fight about MVC, traditional vs. single-page app vs. isomorphic.

I fail to see how improvements in these tools actually push us to create novel projects. While one can nit-pick about React.js rendering performance in its internal "DOM diff" model or Flux's "data flow architecture" in improving code readability, but they are just buzzwords to me like words-play in a post-modern novel or art that arrange concepts in their idiosyncratic way in an arbitrary aesthetic way; although sometimes the rearrangements can be beautiful, they are ultimately shrines to themselves and their creators and subculture.

Subculture because everyone wants something of their own and ignore interoperability. Although the data model are the same whether you're a single-page or isomorphic, there is no community standard to define standards to define your data models a la J2EE annotations or code-generated one's a la Google Protobuf. Same thing with single app controllers, no standard like RESTful web service spec that's universal and interoperable like between .net/Java/Python etc. that can be applied to say, Sail/Backbone/Ember/Angular.

Postmodern because they are always self-referential to the "Ember.js"/"Node.js" way of doing thing - when they all do the same thing which is rendering HTML elements on the web browser in 2014, much like Visual Basic rendering forms on Windows 95 desktop in 1997. Never mind all the touts about performance, architecture, when the users won't care about the diminishing return of shaving off some microseconds of your AMD JS module loading or the beauty of your invisible architecture.

IMHO, instead of a race to the bottom to the most "efficient" and "beautiful" stack to render HTML, I care more about the ideas that push the web as a medium, e.g.,

WebGL (http://www.chromeexperiments.com/webgl/),

Web Audio API (https://chromium.googlecode.com/svn/trunk/samples/audio/samp...),

Web Real Time Collaboration (https://togetherjs.com/ http://www.webrtc.org/)
The upgrades have been historically been quite painful. Especially from v2 to v3.

Perhaps it's better now that the api has stabilized a bit. I've been using node.js & some Sinatra lately.

Upgrades tend to be smoother & due to less monolithic libraries. Also, the app startup time & TDD cycle tends to be faster with slimmer libraries.

It's also nice to be close to http vs the ambiguous controller methods & complicated route files.

Plus ActiveRecord is slow, especially with collections. The business logic can often be implemented in simple functions, resulting is less abstraction overhead.
"OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things. It can be done in Smalltalk and in LISP. There are possibly other systems in which this is possible, but I'm not aware of them."

Such a pity that this filtered essence about OOP was lost on me during formative years of learning OO-programming; for no fault of mine! It took me half a decade into professional programming in Java to realize the importance of these key concepts.

And the worse part is that most of the books/blogs start OO programming tutorial with examples that try to literally model the problem state using Objects (e.g., "Animals", "Shapes" etc.,).

I guess tutorials, classes just focus on these key goals and show how concepts such as "polymorphism", "inheritance" etc., are work towards achieving (or not) them. What generally happens is that one is taught about all these peripheral concepts and students are left to wonder the problems they are trying to solve.
Prison bankers cash in on captive customers
Can you elaborate? Are they just frustratingly slow?
Here's the rub though - code will not (likely) live forever. That's just the reality of software engineering.

I always have to dive into the guts of a library to figure out bugs regardless - I feel like that's essential for a software engineer to become well versed in, regardless of whether the work is in frontend or backend.

The cost of not producing at a fast enough rate is something almost no business can afford, especially in the startup world. The speed at which companies have to move are always on full thrust because if they don't move fast enough, then it costs sales, reputation, and gives competitors more of an opportunity for market entry.

Homerolling your own framework/library can be a dangerous operation, and you lose the benefits of the lessons that others have learned in maintaining open source frameworks/libraries.
Harsh! Yes, it’s an oxymoron. It doesn’t “make no sense;” it was an attempt at humor (which clearly failed).
> The history of the human race is a long succession of people contributing for something that other people will benefit from.

I hope you will acknowledge that this applies to some of the most sinister parts of this history, though.
Anyone whose website looks like this [1] has no business complaining about underlines.

[1] http://i.imgur.com/Y1MAsHt.png
Its going to be brutal on Uber (and Lyft) when the IRS recategroizes all of those drivers as employees, and both companies need to cough up the employment taxes they should've been paying. It happened to Fedex (their Ground division) [1].

[1] http://www.forbes.com/sites/robertwood/2014/08/27/fedex-misc...
"But we think Asians are smarter than Europeans" has been a popular excuse used by purveyors of scientific racism for decades. Before that, Jews were used as the "model minority". It doesn't change the basic purpose of the endeavor, which is to purport to rank the peoples of the world by intellectual capacity.

Besides, the specter of the hyperintelligent alien is useful if what you're selling is the fear of the decline of the white race. The persistent message is that permissive liberal policies are allowing low-IQ populations to come to Anglo-European nations and thrive, causing said nations to lose ground to more ethnically homogenous ones.
A Plan 9 Newbie's Guide (2008) [pdf]
The Search for Exceptional Genomes
> For applications that need to really push the performance envelope, I expect you'll need around 10% unsafe code (this is a ballpark estimate for the amount of unsafe code in Servo, last I checked).

10% seems higher than any number I've seen.

In any case, it matters quite a bit where the unsafe code is, and that's why I don't like just counting numbers of lines of unsafe code. Empirically, a large number of security-critical bugs in browsers are in layout code, often due to use-after-free. Servo core layout code denies unsafe via `#[deny(unsafe_block)]`. We do not allow unsafe core layout code to be checked into the tree; the only unsafe code in layout is general code that manages relatively simple invariants.

The question that matters is: Can you write high-performance code in Rust without writing unsafe code of your own? I'm confident that the answer is yes.
> For new work, most efforts are going forward to C# or D or Go or Java, all of which solve this problem by using a garbage collector. The claim for Rust is that it's memory-safe without a garbage collector.

In C#, D, Go, and Java, arrays are implemented as language primitives in the runtime. Their runtimes are implemented in raw C or C++ and are not formally verified. So my question is: Why is implementing an array in C as a language primitive safer than implementing it in the standard library via unsafe code?

There's a similar story for the swap operation. Rust in fact used to have a swap operation, as you suggested, but it was removed because such an operation can easily be implemented in the library. We could have moved the code back into the compiler, but how would that have made the language safer? (In fact, I would be tempted to argue that implementing language primitives in codegen is less safe, since programmatically generating LLVM IR is more difficult than writing essentially C with a different syntax.)
Didn't downvote you but since you seem to wonder about the downvotes I think they came because you jumped in in a negative way (and was wrong). I'd say that the downvotes were kind of justified here, - I want HN to be positive to creators unless they are wrong/evil.
To me, it is not at all alarming. But it might be due to my inexperience in dealing with truly huge code bases.

No matter what framework, in the end it's all JavaScript. So even if I develop a flashy app using a nice fat framework, it is still going to run unless JavaScript itself is changed.

That said, I can build an app in Angular today, and when something flashier comes out, I can code new features/modules to my app using that.
When Lord? When the hell do I get to see the goddamn sailboat?
Derivable Codebases
My stance has been to take a more static view of an applications development life cycle. So you're on an Angular 1.x app, Angular 2 is coming out in a year, your project will be launched or is already launched and you're concerned with switching.

Stop, right now, just let it go, take a step back from the bleeding edge and see that you've got all the JavaScript libraries and tools you need to put together any application you could imagine. If your imagination is big enough then you'll be hand writing your own additions in no time. So long as your applications runs on the major browsers latest-1 without issue there isn't a reason to upgrade. If you're writing a project there isn't a reason to make a framework jump, and if Angular 1 to 2 is that different, consider it a framework jump. Why feel bad about not knowing your way around when you go from one framework to another, would you feel the same going from Drupal to Wordpress? They are both CMSs, both PHP, both extended far beyond their initial goals. Angular 1 will go into maintenance if Angular 2 is that different, development will slow, and eventually you'll upgrade to Angular 3, which is incompatible with Angular 2, but after years of having a working application.

I've gone from Angular, to Kendo, to Ember, to Backbone. If you want to make an 'investment' in knowledge of front-end development learn the plain JavaScript, read through the framework you're using. Walk through the execution, that will allow you as a developer-for-hire to pickup the newest shiny on a new team with less issues.

Web development has always had this pace, whatever tool or setup you commit too, the next week someone will call you an idiot for using it. Ignore them, make something maintainable, nothing in the new framework is ever mission critical, just nice to have.
I hesitate to even begin to imagine the kinds of bugs this could lead to.
It's worth noting that embryo selection might be coming really soon http://nautil.us/issue/18/genius/super_intelligent-humans-ar...
and that will have a much bigger influence on the evolution of human intelligence than any effects related to natural selection.

What worries me much more than dysgenic effects is the fact that people in western countries tend to have a strong aversion to any discussion of genetics and intelligence, which means that these countries may end up being late adopters of embryo selection or genetic engineering technology.
This is actually more than just web components. iOS and Android have shared application architecture, tools, and navigation between screens. On the web, we'll never have "one true" solution to these problems, but the animosity towards attempts to provide holistic solutions on par with our native brethren sure isn't helping.

If you want to evaluate anew and put together dozens (or hundreds) of tiny modules on every new project, and maintain/evolve that collection over time, fine. But we don't need to tell people that something is deeply wrong if they want a full front-end stack that evolves as the web changes. Nothing is wrong with solutions that track best practices and evolve to incorporate more common problems.
Ask HN: Best, easiest, no headache credit card payment gateway for websites
What would be a good, easy, no headache, good standing credit card payment for a website I am creating.
couple of interesting links in https://github.com/devopsbookmarks/devopsbookmarks.com#inspi... -- http://unheap.com, http://microjs.com
Bacteriophage phi X174 DNA a message from extraterrestrial intelligence? (1979)
German-made ‘miracle’ machine turns water into gasoline
This is an absolutely marvelous bit of history!
Please clarify:

In the third paragraph, should the word "complimentary" have been spelled "complementary"?
How does one go about starting a space startup? A lot of YC companies are tech companies where one can go into Ruby on Rails or Java, crank something out with virtually zero capital, get the hockey stick growth and then it's a company but with space startups this definitely isn't the case. What would I need to convince investors?
Agreed, ant is solid, the build system makes sense and is clearly laid out.
Ask HN: Alan Smithee for Software?
I may request to use a pseudonym for a software project I’m involved in and I am curious if there’s a name like Alan Smithee (https://en.wikipedia.org/wiki/Alan_Smithee) that is oft-used for this sort of thing.

(In any case, I’m leaning towards creating my own.)
Maximising deprives others of the resource, optimising doesn't. I think that's the point being made.

An economy that first maximised, then second optimised, would beat an economy that first optimised, then second maximised, because the latter would have nowhere to expand.

An economy that optimised and maximised would beat an economy that only optimised.
I would say that making something fast and effectively in Python (or such languages), and then scaling their apps by rewriting them (or the core) in Java/C++, is the way to go.

Nobody should be preemptively think of Python as a bad language for enterprise apps. That's the gist that I'm getting from this article. That is total baloney.

We have written enterprise apps in Django for a lot of clients, and all of them are working just fine. Not all of them get the traffic that twitter gets, but even scaling in Python is possible, and although it may require many more servers and top notch optimizations, it's still better to have it up and running from idea to app in about 2-3 months rather than spending about a 8-12 months doing it in Java.

BTW, if I were to switch to Java for projects that have the potential to grow to Twitter's scale, what's the most Django like framework in it?
This is a nice philosophy, but with Linux's extensive suite of automated tests (zero), I'm more surprised that it ever works at all.

The other day I was "backporting" some input patches to an older kernel version. The patches all applied cleanly. The resulting source code compiled. The feature I wanted worked. But it still scares me too much to check it in.