skysight-inc/HackerNews huggingface dataset:
Ask HN: What is the best way to dump mongo data into Hadoop?
I have a large amount of data in a mongodb database and I want to utilize apache hadoop (not mongo map-reduce) to analyze this data. Does anyone have suggestions/tutorials/etc. on what the best way to do this is? (i.e. export mongo data to the HDFS)
Standard feasibility work for any large project? Alternately the potential that all of their explorations have application in a stack somewhere in the organisation? At any rate testing and validating / invalidating alternatives is time well spent if you have the engineering capacity.
There are lots and lots of very valid arguments for both sides of this question. Personally, I think it's both. Even if it really isn't a real problem, that doesn't matter I don't think. What matters is if you can make enough people believe it's a problem. In life, perception really is reality in many cases. I'm reminded of the old saying "when the legend becomes fact, print the legend" for some reason too.

But to directly answer your question, I think at this point the only truly honest answer is...

We'll see.
Wait, and your reasoning is that Kickstarter should just "open this one exception"? That'd be like opening a can of worms instead.
Talk to people around you (barber, barista, waiter, friends and family, etc) about the technology that they use. (smartphone, facebook, etc) The conversation almost always turns to complaining about how they wish things would work. Those are your problems to solve.
Original story from MIT News Office w/ video: http://web.mit.edu/newsoffice/2012/autonomous-robotic-plane-...
Here is HN's ranking algorithm:

(p - 1) / (t + 2)^1.5

Source: http://news.ycombinator.com/item?id=231209
App.net has a very smart business model. It's goal, at least for now, is not to have millions and millions of average users, or Lady Gagas, or Justin Biebers. It's goal is to attract industry professionals, designers, developers who are willing and who are also capable of paying $50 a year to be part of a limited network. At its early days, I think that App.net will resemble the early Twitter. Its users were people who believed in its success, they were mostly the same demographic that App.net is aiming at now and a lot of great things came of that. The masses didn't believe in Twitter, they found it useless - and it was a much better service back then, without them.
The only exception I take with this is the part about coding in an interview. My complaints there are not specific to having a PhD though.

I understand the need for practical tests like these, but whiteboard coding is not a good way to do it. People dont' typically program on white boards, they do it alone with a compiler, reference manual, and the ability to test. Put them in a room with a terminal and ask them to write a straight forward program in 30 minutes. If you have to practice for the interview, what exactly are you determining in the interview? Their ability to program? Or their ability to practice interview tricks?

Immediately discounting a candidate because they are annoyed at your question to whiteboard code also seems rash. Asking someone experienced to write the "print a string in reverse" algorithm will naturally insult them. Especially so if the candidate has a CS PhD and spent time grading students on more complicated programs, or especially if their CV includes links to public repositories containing thousands of lines of code they wrote. On the other hand, asking a candidate to sketch a genuinely complicated algorithm on the board is a reasonable question.
Startups, failure is no excuse for failing to communicate.
Has anyone around here actually used either of the above and care to comment? I would be curious to know how compatible they actually are with the average chunk of PHP code, and if not how hard it is to work out whats wrong and get it running.
It's quite vague about what is actually being provided.
Mortals simply use domainName+superSecretWord.
Wouldn’t Unity Look Better Like This?
> Facebook are looking to move PHP on.

Did Google Translate write the article?
Etsy bans sales of blood and skulls
One major problem with this scheme is that if someone steals (or subpoenas) your computer they can discover all your passwords just by looking at your shell history. A password manager that's secured by a strong password doesn't have that vulnerability.

Edit: As jroes pointed out below, this is not a problem.
What's cool here other than the fact that it seems to react really quickly is that it has no universal conception of location, like GPS.

My limited understanding of the topic is thus:

For localizing, they use a particle filter, which is basically a method that helps you figure out latent variables (in this case location) based on multiple observations.

Using the data, it creates a model of how the aircraft moves. In each "tick", you make a prediction about where the aircraft will be in the future (let's say, based on how fast you know the motor goes and which way the rudders are tilted etc). Then, you actually compare it to the data you got from your sensors (in this case a laser rangefinder) and update your model. Thus, your model is better.

The more traditional formulation of this is the Kalman Filter, which is everywhere in classical controls systems. I think the particle filter is just simpler for large numbers of variables whereas for Kalman filters, complexity increases exponentially.

edit:

Another way to look at it is that this is how robots deal with the "real world" where sensors are noisy and slightly off, actuators are unreliable and can't produce smooth and constant output etc. Instead of trying to guess all these factors, it automagically accounts for these on the fly by looking at how the robot behaves and how you expected it to behave.

edit2:

Corrections abound! Read replies below!
The super programmer does not necessarily solve a different category of problems. She sees maintanable and performant abstractions when she encounters new problems. She sees order where others see chaos.
What is the point of any information filter? I am not sure if you are being difficult or if its not as obvious as it seems to me. A lot of stories are submitted to HN everyday. I like the variety of the HN inbox but a lot of the "new stories" are redundant or just plain boring. Filtering for links with one or more upvote helps separate the wheat from the chaff.
If you don't need any special compiler flags, it's even simpler:

make temp
./temp
How hard would it be to adapt this for Ruby written for iOS using RhoMobile? I'm looking into whether to start learning RubyMotion vs. RhoMobile, and don't know much about either yet.
Why do you quote selectively? The next part is: "along with their interest in implementing PHP using invokedynamic on the JVM".

Also, JVM Language Summit, not Java Language Summit. (OP got it wrong too.) More on http://wiki.jvmlangsummit.com/Main_Page
But what if everybody did that? How would any story get more than 1 vote? Somebody has to dig through the garbage to get the good stuff right?
> But I do have a challenge for you. Surely you know a “super programmer.” You might even be one. If so, let’s hear from you or them. Tell us that complex problem that is too difficult for the rest of us to possibly understand.

I generally tend to agree, and in the majority of computation I think this is generally true. Compilers for instance I think are one thing that the majority of programmers imagine to be simply above them. While in reality they are much like the rest of the software we write.

However as a counter example, the hardest things I've ever written included a rather complicated lock-free data structure, specifically optimized for 3D effects rendering and simulation. The amount of mental capacity that took was pretty astounding, and what I took from the experience is that I'd try to never have to do something of such complexity again. I am also, however unsure if I could complete a similar task again. It did give me an appreciation that some things are just simply harder.
I agree, I often check on work machine, phone, and home machine. I can't rely on those grayed out links anymore...
I think this post has good intentions. There's some truth to it and there's definitely value in plumping yourself up from time to time. No one should be worrying about whether they're a "Real Programmer" or not. I agree that there's no value in beating yourself up or beating up your work.

That said, I think the post takes it too far, and veers off into self-congratulatory back-patting that I think is not valuable, at all.

I also think the author is wrong about hard problems, or at least managed to come up with a tautology that's not very interesting. Sure, many (and perhaps all) hard problems can be decomposed into smaller, simpler problems. But that's often not trivial, and the decomposition step often requires a lot of hard work. Even if hard problems can be broken down into smaller pieces, that doesn't always make the problems easier, even if it makes them more manageable. They still might require tremendous effort.

The example given isn't a very good one; that sum just isn't that advanced mathematics. Now that's not to say it's not Greek to some programmers, and not to pooh-pooh people who have a hard time with math; I have struggled with it a lot. But there's a lot of math that really is hard to grasp, and isn't just a question of learning the notation, which is what the sum example is really about.

The challenge sets up a straw man, IMHO. "Tell us that complex problem that is too difficult for the rest of us to possibly understand." It's asking the reader to be an arrogant ass.

"I’ve just never seen a problem that couldn’t be broken down into simple to understand components, yet."

Again, I think this just isn't a useful criteria. Broken down into simple to understand components doesn't make things easy. Here's an example, from my own dabblings: I am absolutely fascinated by programming language theory and compilers. Recently, I've been trying to get at the heart of two sub topics: parsers and types. I've been struggling to find presentations of parsers and parsing that really peels back the magic and shows how everything works, without just punting and letting Lex and Yacc do the dirty work (btw if you know of a compiler text that doesn't do this, let me know!) Yes, you can break parsing into a lexing step built up from regular expressions. Yes, you can translate regular expressions into NFAs and convert those into DFAs... and so on. But putting this together into a lexer generator is non-trivial. It's not easy, even if the components are simple. It's the same with type theory. You can write simple syntax directed type checkers and they might fit in your hand, but if you really want to understand type theory, it turns out there's a lot of math, and proofs to get through. Sure, you can decompose that into topics from set theory and so on, but this doesn't make it easier.

More and more, I think his core argument is just really flawed. There's some connection here with Rich Hickey's "Simple made easy" talk, where he argues that simplicity can be hard to come by, and how easy and simple are different... but I've written too much and will leave that as an exercise :)
Cool, but I'd trim "genius" from the title.
Some relevant videos on autonomous catastrophic flight recovery by Rockwell Collins:

Continuous AI flight after blowing off one wing:

http://www.youtube.com/watch?v=xN9f9ycWkOY

Continuous AI flight after catastrophic wing loss (showing manual/AI difference):

http://www.youtube.com/watch?v=dGiPNV1TR5k
Http://www.songspk.pk/bollywood_songs.html
Why Conference Harassment Matters
Should be trivial since document stores are less relational and the data should be relatively isolated.

You really just need to learn the subject matter, there is no magical wand for loading data from one to the other.

You understand one, then you understand the other, then you understand how to port and grapple with the data.

Just start reading.
Pros and Cons of Using Unroll.me
I'd say it's on par with the CLR, similar corner cases, similar annoyances.

The biggest problem I've had with the CLR is threads bouncing between CPUs but I'd attribute that to Windows as I worked around it with some Win32 calls to pin threads to processors.

Can't really compare to LLVM, I haven't personally encountered any of the known llvm bugs (clang to be fair) with Obj-C.
People doing the recruiting don't know anything about

1. Programming

2. Programmers

3. What makes a programmer 'good'

4. How to identify a 'good' programmer

5. How to appeal to a good programmer
This is nonsense. His key argument is that hard tasks are reducible to simple tasks, and therefore they are actually not all that hard.

Ask anyone who's implemented, say, Paxos, and ask them whether because the individual steps were easy the whole system is therefore easy. Or indeed any other distributed system. Just because something can eventually be decomposed into simpler things does not mean that it is a fundamentally simple construct, nor does it mean that a programmer who can manage the simpler constituents is competent to handle the overall system.
How is this any different than an argument against the frontpage? What if everybody only read the front page?

Addendum: (It seems tonight is be difficult night on HN. I really did not expect any responses to the rhetorical question above.)

As it is I rarely read more than the first page of new stories. With a filter like this I would help curate the new stories and would contribute more to the curating process than I currently do.
"If you're pumping out good shit, people will follow you."

Gary Vee
Desh ko bachanathai to narendra modi ko lana hai
I must be reading the wrong Python tutorials. Thank you for this
To provide more precedents and a little history:

The first C "interpreters" I know of were for Lisp machines: Symbolics' C compiler (http://www.bitsavers.org/pdf/symbolics/software/genera_8/Use...) and Scott Burson's (hn user ScottBurson) ZetaC for TI Explorers/LMIs and Symbolics 3600s (now available under the public domain: http://www.bitsavers.org/bits/TI/Explorer/zeta-c/). Neither of them are interpreters, just "interactive" compilers like Lisp ones are.

I am writing a C to Common Lisp translator right now (https://github.com/vsedach/Vacietis). This is surprisingly easy because C is largely a small subset of Common Lisp. Pointers are trivial to implement with closures (Oleg explains how: http://okmij.org/ftp/Scheme/pointer-as-closure.txt but I discovered the technique independently around 2004). The only problem is how to deal with casting arrays of integers (or whatever) to arrays of bytes. But that's a problem for portable C software anyway. I think I'll also need a little source fudging magic for setjmp/longjmp. Otherwise the project is now where you can compile-file/load a C file just like you do a Lisp file by setting the readtable. There's a few things I need to finish with #includes, enums, stdlib and the variable-length struct hack, but that should be done in the next few weeks.

This should also extend to "compiling" C to other languages like JavaScript, without having to go through the whole "emulate LLVM or MIPS" garbage that other projects like that do. I think I figured out how to do gotos in JavaScript by using a trampoline with local CPS-rewriting, which is IMO the largest challenge for an interoperable C->JS translator.

As to how to do this for C++, don't ask me. According to the CERN people, CINT has "slightly less than 400,000 lines of code." (http://root.cern.ch/drupal/content/cint). What a joke.
It would need to involve a server. I emailed Paul late last year when I first got the idea, heard nothing back, so I guess it will need to be a 3rd party server. Shouldn't be that hard, only a fork away - https://github.com/apankrat/internet-improvement-project/tre...
Bhai mere desh bachao
Thanks for the correction. Text updated.
I think it gives the wrong impression though. People don't expect to have to pay for their privacy (the level is regardless - the default expectation is that data is not being kept), so it will get people's noses out of joint.
Now that benchmark you linked has a hidden bias towards
Java. If you read the methodology listed in their FAQ, they mention they ran each benchmark for Java 66 times in the same JVM instance before discarding the first 65 results, which leaves out the initial iterations before JIT has kicked in. For servers, which perform many similar operations for each client and are rarely restarted, the benchmark you posted is probably valid. But for jobs that wouldn't benefit from JIT, Java would perform much more slowly.
Please help me understand the meaning of this correlation
I think this is really interesting.

What "working alone" means is complex. For example, at Hashable, I was effectively working alone, despite there being a wider notion of collaboration. More over, when other people came in to contact with parts of the code I was actively working on, instead of trying to work through those components together (not neccsarily in a pairing way, but just a more general collaboration), the standard was to make you change and not care about the consequences.

In a code base without tests this was a nightmare.

If / when I am next looking for a job, really understanding how a company collaborates is high up on my agenda of questions.
I am surprised more projects don't use TCC for that. It's an awesome little compiler and using it that way saves way more time over writing DSLs. Even projects that have to compile C all the time (like Lisp->C compilers such as ECL and Gambit Scheme) use GCC, which is stupid slow.
Maybe you have deep enough experience with Node to avoid the thin ice, but my experience has been one of sparsely-featured and buggy libraries when compared to their counterparts in Python, Java, etc. All languages need time to grow up, but for now we use Node as a pinch-hitter in our stack (I created a Snowflake server with great results)

Honestly, Facebook has a lot of frontend code. I don't think Rails is a bad choice for that. My experience with large systems is that they're usually not homogenous. There's no reason they couldn't implement the Rest API components outside of Ruby if that was their biggest obstacle to success.

Though I'm not sure it is, because even though you've obviously given this issue some thought, you didn't really articulate who was put off by their use of Rails?

Edit: To avoid confusion, Snowflake as in https://github.com/twitter/snowflake, not "snowflake schema".
But what if it were $0.49?
This is a much better link and admin should change the story link to this one.
yeah, god forbid they feel that their initial success could be improved upon; They should put down their tools as soon as they get their first version that works

/sarcasm
There is a case to be made that mindshare and user culture matters more to long-term success than the actual product, assuming the product meets a minimum threshold of quality. (See: the Mac user-base from around 1995-2005).

If the OUYA succeeds, which admittedly looks like a long shot for all the reasons described here and elsewhere, it will be due to capturing hearts and minds of devs and power users for the years it will take to gestate into a profitable platform, and not because it's the best value prop for either users or devs on day 1.
well, technically you're using javascript, so it's already cheating. Obviously, you have to use it, but it does break the claim of using only html/css
The difference is not really about the number of variables but the dynamics of the plant...

The classical formulation of Kalman filters assumes gaussian distributions for the variables. This makes the computations much faster since the posterior distributions is a few matrix operations away. This works fine when the model for the plant is linear (since a linear transformation of a gaussian variable is gaussian). In situations where the plant model is not linear estimates can go awry quickly.

In the case of particle filters you sample the prior distribution, simulate the non-linear plant with these initial conditions and then construct the posterior distribution by incorporating the measurements. This process is computationally more expensive than classical Kalman filtering but is more accurate for non-linear plants.
Then new links would start appearing on the front page once the current content got sufficiently old.

(To clarify: I am merely answering your question, not expressing an opinion.)
Kaplan's default rate is 17 %, Phoenix' is 13 %. If that is any guide, spending any money on that kind of school is a bad investment. For comparison, the default rate at public universities is 6 % and at private ones it's 4 %. (There are reputable for-profit colleges with default rates less than 5 %, so this isn't painting with a broad brush.)

Student loans need to be dischargeable in bankruptcy, because the only reason a bank lends to students at those places is that the creditor is backed by the law as it is currently written. If it were different the students would go elsewhere, the banks would have to find someone more profitable to lend to, and Kaplan-Phoenix-Devry would go out of business as it ought to. Society in general would be served better.

Training in the trades is a different issue. In other countries (Germany comes to mind) this is done by the employer, and it works well for them.
They would only discover the domains, not the passwords you entered. You type the domain at the command line, but you type the password into stdin.
Indeed, I suspect it's a reasonable bet that the guy (Korban) just used the apache.org page and reformatted the contents with his target audience and personal goals (which seems to be selling his book) in mind.

[Which is not a bad thing, mind you—the apache page is fairly accurate and up-to-date (at least for the major compilers), so it's better people use that as a reference than doing it themselves badly. It would have been nice if he'd included a link though ...]
That's actually a big improvement on what their website used to look like:
http://wiki.darkpatterns.org/Trick_Questions#Example:_Ryan_A...
My pet theory is simply that the technology sector moves much faster than anything in the past. Historically, companies rise and fall all the time- so then, it shouldn't be surprising if companies rise and fall quickly in tech.
Ace Maxs « ACE MAXS
Ace maxs merupakan minuman herbal kelas premium yang memiliki khasiat sebagai obat multikhasiat yang terbuat dari perpaduan kulit manggis dan daun sirsak. dimana kedua bahan ace maxs tersebut memiliki khasiat dan kandungan yang sangat luar biasa untuk kesehatan tubuh kita. Ace Maxs Obat Herbal Multikhasiat Dari Perpaduan Kulit Manggis Dan Daun Sirsak Produk yang kami…
I don't think your analysis of the incentives is accurate at all. If I were to oversimplify similarly, I'd say instead that modern incentives in CS academia, for non-tenured faculty at top research universities, heavily favor money, wherever it comes from (in large part because with budget cuts, professors have no choice). Grants are good, industrial partnerships are good, basically anything that brings in money is good. Citations are secondary, and used mainly as a stepping stone to bring in money. From that perspective, students going to a big company are good, especially a big company like Microsoft, IBM, or Intel that funds research. Students going into academia to write papers that cite the advisor are also good, but not as good as students who go somewhere that has money.
There you go -

items.each(function(){
var id = getItemId( $(this) );
- if (localStorage.getItem(id))
+ if (localStorage.getItem(id) || ($(this).find('span').html() == '1 point'))
hideItem( $(this) );
});

Apply to this - https://github.com/apankrat/internet-improvement-project/tre...
If they have enough resources, they can afford to try all options in parallel. Wasteful, but although it may seem strange, it isn't like programming language implementation engineering is expensive compared to data centers.
Eating Yourself: Innovation through Cannibalization