skysight-inc/HackerNews huggingface dataset:
Article is written by armchair pundit with zero internal experience but who thinks he knows how Google works better than the person who ran the company for a decade. Title is obviously a link bait to invite flame wars. I guess he needs to pay his bills by writing these kind of junk. The guy doesn't understand the first thing about experimentation: It's normal to fail 100s of times before you can have blockbuster success. Also people who think search business is just web search have no clue about what search business is. In today's world, if you want to build a search engine its not enough to index the web. You need spell checker, deep links, answers, image search, map search, local business search, video search, controlling presence on mobile. You can't be a one-hit wonder, you need to excel at all of these areas if you want to be search business.
I didn't see it in the linked paper, but how do the runtimes compare? (Did I just miss this?)
> Rust has the same problems, and the solutions don't seem to be entirely clean.

There's no entirely clean solution, just as there is no perfect GC algorithm. There's a big design space where the type-system restricts aliasing, and pointers carry static type information about what they can point to. Rust represents one point in that design space, one tuned towards memory management. There's all sorts of other design points: http://ilyasergey.net/papers/ownership-survey.pdf.

Most of the work in this area has actually been done in a Java context, and focus more on access control than on memory management. These other type systems can enforce properties that are useful for encapsulation, but aren't necessarily all that useful for memory management.
So there seem to be 2 separate issues this post is addressing.

1. A lot of JavaScript frameworks are being released
2. JavaScript frameworks are being updated too fast.

His biggest example, the Angular 2.0 split, is of the second one, but he seems primarily concerned with the first one.

I can see the first one being a problem primarily for developers keeping their skills up to date. The fact is that once you've put a decent amount of code down into an application, you're not going to be constantly switching frameworks. Maybe do it once, but otherwise the applications that are already built will stay on a stable foundation. So for developers working on a single or stable set of applications (not client work), this shouldn't effect their actual work. There may be an issue of skill decay if employers are constantly looking for the latest and greatest, but outside the Silicon valley bubble, I still see a lot more jQuery and Backbone job postings than Ember or React.

As for the issue of frameworks lacking stability, I frankly don't see that. Yes Angular is making big breaking changes. But otherwise? Let's look at the other 6 biggest front end libraries/frameworks.

jQuery has been fairly stable for a few years now, with minimal breaking changes.

Underscore has been very stable, albeit growing with competition/help from Lo-Dash

Knockout and Backbone have evolved slowly while remaining small and very small respectively.

Ember has a very clear process for moving their framework while allowing actively developed applications to stay up to date in a reasonable way.

React is still pre 1.0 and that's something you should know going in.

Basically if you started a project with any of those technologies (or angular for that matter) at some point in the past 3 years, you've probably had a pretty easy time in adjusting as the library specific concepts have changed.

I just don't see the idea of "Frameworks are evolving too quickly" as being particularly compelling. There's a lot of information out there. Yes if you want to know it all and always be using the newest shiny thing, it will probably be too much. But none of this is preventing anyone from actually building useful things today.
"Prefer dedicated libraries to monolithic frameworks", this is the money quote for me.

I got burned a long time ago when I wrote a large personal project using ExtJS (~1.2 i think). Breaking changes, coupled with a kitchen sink mentality soured me against large frameworks.

It's vanilla JS with a few small very targeted libraries to fill in the gaps from now on for me.
For me too :-) I'm guessing, it's a reference to this:

http://eclipse.org/jdt/core/

See also:

http://stackoverflow.com/questions/3061654/what-is-the-diffe...
How would you design something like :

Person --> Full Time Employee --> Manager

Person --> Contract Employee

Without inheritance assuming that salary calculation is the only thing which differentiates them.
I wouldn't have posted the item if it hadn't struck an area of interest with me. Digging into the backgrounds of pretty much all involved (Woodley, Lynn, and Thompson), I'm finding most of the negative associations of this area of focus are supported. I'm not saying "don't look at this", but if you do, do look at it with a full awareness of the biases which are frequently present in such work.

I've got my own views on what the world going forward is likely to face, and much of it isn't pretty. What I don't bring to bear on that though is any preconceived notion of who is likely to survive or gain proportionately (though I've got some ideas of winners and losers to some regards).

The question of how intelligence tracks as selective pressures change is an open one. As is the question of what types of intelligence are most advantageous. As I commented below, evolution isn't teleological. There isn't some ideal life form we're purposefully evolving toward. It's chance variation, selective pressures, and, occasionally, a vast slate-clearing and general reset, much of which is up to chance as much as anything.

What's beneficially adaptive can change exceptionally quickly.

Recent research on the Chicxulub meteor impact suggests, for example, that the event created a global firestorm as debris from the impact re-entered around the globe. Surviving lifeforms were those which could shelter underground or under water. Adaptations to large size of dinosaurs were, for the period of that firestorm, exceptionally maladaptive. Following the event, though, new lifeforms evolved into empty niches and formerly small mammals increased in size. Until humans spread around the globe and began pressuring and hunting megafauna into extinction.

Round and round it goes.
This only refers to frontend JavaScript and reflects the opinion of a dev who hasn't been using JS all that long. Angular was never that great a framework, it's popularity was by and large because it came out of Google. It's far too tightly coupled to the DOM and was therefore destined to have problems as HTML and browsers evolve.

Npm is stable, Backbone is stable, Node is stable, Gulp is great, and devs like myself who have seen trendy frameworks come and go (Batman.js and jQuery templating come to mind) are still using the same great composable tools that were better designed from the start.

Backbone (and my favorite, Spine) are built on more loosely coupled components and can be used on applications which have no DOM, such as Canvas games or native mobile apps. Browser fragmentation has been an issue since the dawn of JS -- and these days the JS ecosystem extends far beyond the browser.

Take a look at the mature tools for front or backend that major companies rely on and be glad that the open-source nature of JS produces so many options and rapid evolution.
Facebook, Google, and Twitter’s War for App Install Ads
I wonder if we need any JavaScript framework at all, given how far JS has come in recent years, yes, I use an MVC framework currently for the apps I'm building but I'm writing more and more of my apps these days using nothing but vanilla JavaScript(ES-6 to be exact) and the dom apis, and I'm not depending upon any framework. (well, I use traceur but only because ES-6 support is not fully baked in to all browsers). IMO the frameworks that are all out there today are simply too big and try to do too much for you. The only libraries I use from time to time are underscore, d3 and moment.js.
You might know the difference between a bond and a bond fund, but there's nothing in your post that highlights the distinction for the readers who don't. As an example, you state:

> I’d also recommend investing in a bond index fund. Bonds tend to do well when stocks do poorly, and vice versa, so investing in both will tend to reduce your risk.

Notwithstanding the fact that "bonds tend to do well when stocks do poorly" is a vast oversimplifcation[1], "I’d also recommend investing in a bond index fund" is far too general a statement to be considered actionable advice.

This is not actionable advice either:

> But there is a simple trick to minimize your taxes: buy municipal bonds for the state where you live. For example, Vanguard offers municipal bond funds for many states, including a bond fund for California.

Vanguard offers multiple bond funds for California (there's an intermediate-term and long-term). Which one are you referring to, and why?

If you followed the title of your post ("Nine hard-won lessons about money and investing") and didn't package your own lessons as "advice" (your words, not mine) for everyone else, I think folks would have responded less critically to it. Instead, you ironically dissed financial advisors while providing "advice" far less detailed and actionable than one could expect from even the most mediocre or inexperienced of financial advisors.

[1] https://media.pimco.com/Documents/PIMCO_Quantitative_Researc...
I think alot of the devs today have grown up with all this frameworks on top of other frameworks. The problem is you lose power with every layer of abstraction. It's the price you pay for it. They also abstract at too low a level, especially since browsers have caught up. They don't need provide a new custom ajax for instance, XHR as implemented in the browser works quite well without imposing an arbitrary syntax on top. So I think people have moved increasingly to vanilla. We've come full circle with the opinionated frameworks and some people are frustrated and where do we go now?

Web components are the most promising development, because the preferred approach in sw development has always been isolation/separation of concerns. This is pretty much the opposite of the JQuery style. In theory you can separate using JQuery but in practice still in 2014 you cannot look at source in any moderately complex web app and understand what's going on. Ultimately, its going to have to be a DOM/JS mix (Those aren't going away for a long time) but they never got it quite right. The web component frameworks are the best thing going for the future.

IMO they should be declarative, that is - in the HTML - but programmable, and that's the way things have been heading. So in 10 years we'll still have the DOM and JS (although it would be interesting to have more languages easily usable in the browser). As Polymer evolves it (or some equivalent) will make it into the browser.
Yeah, I agree. I lost faith in Angular (Even the 1.x). From now on I'll be using React for the view and a mix of amazing smaller libraries for the rest.
“Nirvana” by Adam Johnson: 2014 STEFG Short Story Award Winner
Generally people that don't like explaining what they mean to a computer.
A lot of SE Asia and Latin America can be done for 400-700 per month. It's possible to reduce this further.
It's worse than trying to write a paper on the Teh tribe in the Amazon in Microsoft Word with autocorrect. The relationship between query terms and results is complex and opaque.
Funny you should mention that, I just got an external custom programmable USB keyboard from XKeys. I got the 68 key version with the jog dial.

I can launch apps, I have shortcuts for:

- most frequently used apps (including 3 browsers)

- common shortcuts (command-R, Command-Shift-I, Command-Q)

- one-touch window control (resize between 4 preset widths)

- a numpad specialized for inputting numerical CSS values

And then the rest are like shift keys that change the function of the shuffle wheel. The wheel can scroll, change screen brightness, move the cursor, select text, change volume, zoom in browser and more.

Here's a quick screen capture of me using it on my first week having it. Everything you see here is contolled from that one extenral keyboard, no alphanumeric keyboard or mouse used for the duration of the recording,

https://m.youtube.com/watch?v=NRcyHuMKCRI
That random statistic is the precise economic definition of productivity.

http://en.wikipedia.org/wiki/Workforce_productivity
Kind of out of topic, but when one changes gender at some point in their life, do you rewrite their whole wiki page saying "she" instead of "he", or should you mark the transition after the official change of name/gender only ?
This'll easily do it for $2.13 -- 256 KB FLASH + 32 KB RAM on a 40 MHz 32-bit ARM processor.
http://www.digikey.com/product-detail/en/MB9AF314LAPMC1-G-JN...

Microcontroller RAM is expensive, but FPGA RAM is even more-so.
This is a valuable article that I read thoroughly when I was re-reviewing search trees. Nobody wants to spend 60 hours learning a new tree only to have it fail to live up to its promise. I'll summarize what I know (or think I know) about trees here, since it may be of use to anyone who had enough of an interest to check out the above article.

Sedgewick claims that LLRB trees are simpler, but this is hotly contested. Most of the sources I read said that LLRB trees were more complicated, often a lot more, than regular RB trees. All of the timings I found suggested that LLRB trees were slower than RB trees. Looking at the code, and at the detailed timings, I tend to agree that LLRB trees are slower and more complicated. If there is an explanation/implementation which realizes Sedgewick's promise of simplicity I have not seen it, and it isn't in the published LLRB material.

If you need a tree that is slower and simpler than an RB tree, with a similar implementation, you could look at AA trees instead.

My opinion however is that, in terms of practical applications, there is no reason to learn RB trees today instead of AVL trees. If you do research in data structures, RB trees may be worth knowing. I think the prevalence of RB trees is due to several factors:

1. RB trees are featured in the common Cormen algorithms book in lieu of AVL trees (a mistake). RB trees are also featured in the Sedgewick book.

2. The Cormen book shows how to implement delete for RB trees. Knuth's AVL description, and indeed most AVL descriptions, omit the delete method, which is a serious oversight. This has caused many tree implementations to avoid deletes or avoid AVL altogether. You can verify this via Google or GitHub. While Knuth initially had good reason, ultimately omitting delete was a mistake.

3. Plenty of theoretical conjecture predicts RB trees are faster. Actual benchmarks show that AVL trees perform better, or at worst, about the same. (If anyone has data that shows scenarios where this is not the case, I would be interested to see it.)

This is an unfortunate state of affairs, as the AVL tree appears to be a strictly better tree than the RB tree. The height is bounded at about 1.5x optimal instead of 2x optimal. You could argue the AVL tree is roughly as difficult to understand and code, though I would say it is simpler and more natural. The AVL tree performs generally better in actual benchmarks, and substantially better in certain important cases (sorted inserts).
Paragraph 3 of his Wikipedia page reveals that he considers North-East Asians to be about 6 IQ points more intelligent than Europeans, based on a study he performed in the 1970s.

So he would appear not to be as uncomplicated a racist as the parent comment implied. Which is a blow, to be sure; but I imagine that if we sling enough mud, some will stick, so there's hope for our noble smear campaign yet!
Fair enough. Of course, the counterpoint is that for others who do not have that particular reaction, the overall effect of having less intersecting lines (better separation between characters and text decorations) is one of less clutter, and, arguably, heightened readability.
Goodness. My apologies for instigating a terminology war, I should not have been so imprecise.

I think tel is mostly on the right track of what I mean when I compare Racket to traditional ALGOL languages, but it is also true to say that Racket is not strictly non-imperative either: it is ultimately a multi-paradigm language, just one that culturally leans harder towards a functional-declarative style. My early projects were just as lousy with mutable state and in-order processing as anything I wrote in Python; but I got better.

I think what really drove me to Lisp and FP languages was the notion of nearly everything being first-class values, from functions to objects, and it's this quality, compared to the tedium of building yet another !"¤&¤&! constructor pattern that really attracted me. This, plus things like macros, the way the language allows for function composition so readily, is what made Lisp feel like 'how programming should've been all along' for me. Haskell as well induced that same reaction in other ways (mmm ... curry ...), though I'm still not entirely convinced that such strict purity is practical.
Chandler Carruth “Efficiency with Algorithms, Performance with Data Structures”
> "this is nothing like the Zimbabwe situation"

Um, yeah. Think you've misunderstood.
It's really handy for some use cases. For example, if you are writing documentation involving XML, you might put your example XML in CDATA sections. The way CDATA works is also far simpler than XML's predecessor, SGML. I'd say it's a good feature.

It sucks that there are some shoddy libraries out there, but oh well.
I'm confused. Is there something else in another language with better solutions for IDE, dependency management, dependency injection, etc.?

Honestly, you just listed some of the best reasons to use Java.
>> Whatever time was saved by the developer when writing the Python code (if any) were lost many times over as dozens of users had to wait ten times longer each time they fished through the logs.

I was first exposed to Python in 2002. The sentiment in the quote above is reminiscent of the reasons I came back to Java. With a little Bash and some Java or a little Python and some Java I can do pretty much anything I need from system services to web to rich clients.

Edit: Great article.
By using small libraries – components with a dedicated purpose and a small surface area – it becomes possible to pick and mix, to swap parts of our front end stack out if and when they are superceded.

This is the problem with front-end dev in a nutshell. Everybody is mixing and matching their own solutions which makes it impossible for an ecosystem of higher level, reusable components to emerge. Compare this to iOS, for instance, where I can go pick and choose from a huge online library of prebuilt components and be fairly confident I can just "pod install" them and go. I'm not a fan of Angular but it was a good thing for there to be something like a de-facto SPA framework standard. I can only imagine how upset business owners that invested heavily in Angular 1 apps are feeling now.

If web developers are serious about mounting a challenge to the rising tide of native apps, they need to build some consensus and agree on some durable foundations. In the end elegance and novelty count for nothing if you don't have a healthy, stable ecosystem upon which businesses can depend. It's sad to think that the freedom that makes web dev so appealing may also turn out to be its fatal weakness.
pdfs, or at least as many as one guy could find: http://www.reddit.com/r/compsci/comments/2nuz75/great_works_...
People who paid attention to Rails upgrade issues over the years saw issues with heavy frameworks that abstract a bit far from the input & output.

Simple libraries often mean less maintenance headaches, more flexibility, and better productivity over the long term. YMMV of course ;-)

Exoskeleton looks like a promising microframework replacement for Backbone.js - http://exosjs.com/

---

Edit: re: downvotes. I know, sometimes it hurts to hear there are other ways that may be more optimal. Been there. Developing software is hard sometimes but it's a craft :-)
If it denied you efficiency in the name of dogmatic safety, you'd just go back to using C++.

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. This claim does not appear to stand scrutiny. If 10% of a browser has to be "unsafe", the language is seriously flawed.
I'm amazed that shortly after Y2K most everyone switched their paper forms and handwritten dates back to two-digit years. Humanity never learns.
Software Craftsmen Are Arrogant, Slow, and Dogmatic
Do you mean border bottom in conjunction with reduced line-height as a solution for link underlines? Or something else?
lgtm?
Something like...

Person HAS A IEmploymentRelationship
ContractEmployment IMPLEMENTS IEmploymentRelationship
FullTimeEmployment IMPLEMENTS IEmploymentRelationship
FullTimeEmployment HAS A IDirectReport
Manager HAS A Person
Manager IMPLEMENTS IDirectReport

And then salary() is a polymorphic function declared by the IEmploymentRelationship interface, where FullTimeEmployment instances use the manager somehow, and ContractEmployment doesn't.

You can even put some sugar on that by having a salary() function on Person that calls the salary() function on its IEmploymentRelationship—but I wouldn't, for the same reason I wouldn't denormalize a relational database.
There is an online editor/REPL/tutorial at http://www.tryfsharp.org/

You will need the Silverlight plugin.
I see your point, but I have a counter assumption that individual letters without spaces between will not ever be linked that cancels it out for me.
I think the first flight of a rocket which actually flew with an aerospike engine was in large part a university project - http://www.astronautix.com/engines/garspike.htm .
Great suggestions. Do you have a web framework suggestion, e.g. something with templating?

I like Play, but that's 'cause I use Scala. It has a Java version, but IDK how good it is.
I've played with Weboack for toy projects. Do you have one Webpack project that builds and watches all your React apps, or do you treat each separately? I have a larger project on my todo list, and I'm considering doing a Rails API and a single React app for everything on the client (including URL routing).
Or a native backend?
How do they deal with name changes after marriage? same thing.
Compare this to iOS, for instance, where I can go pick and choose from a huge online library of prebuilt components and be fairly confident I can just "pod install" them and go

I believe this is the one of the main motivators behind web components
Yes, AAARGH indeed.
Someone has to be last I guess. And BN has done a few things to stay relevant. They have the Nook, which is a decently popular e-book platform. I think ultimately they will go under though, or at least close up their retail stores. The demographic that likes to shop for physical books at a bookstore is an aging one.
> the genetic inferiority of non-white people

The first sentence in paragraph three of his Wikipedia page (http://en.wikipedia.org/wiki/Richard_Lynn) states that an experiment he conducted in the 1970s revealed North-East Asian people to have IQs on average 6 points higher than Europeans.

Certainly an interesting position for a person who "argue[s] for the genetic inferiority of non-white people" to prominently advocate.
It would be weird if these speakers existed without there existing anyone who knew this stuff.
Just in case you're serious, he's been doing security for ages. As well as other interesting things - check out http://lcamtuf.coredump.cx