skysight-inc/HackerNews huggingface dataset:
Here's the analogy I made up a bit ago trying to explain the concept.

As programmers We build code paths. Design mazes. In the beginning the maze is simple, there's only a few paths. To make things simple we separate our ideas into many small mazes. Since they're small, it takes a short amount of time and concentration to predict the different possible paths in our heads.

Technical debt is when, due to to time constraints the decision is made that it is quicker to draw one more line on an existing maze, rather than create a whole new small maze. In the beginning it seems not so bad, you can still take in the whole maze at once. But as time goes on, that one maze gets larger and larger, and finding a successful path through it takes longer, and longer. Eventually you get to the point where you can't separate the maze because too many of the paths are built on top of each other, but you also can't manage the maze because its to large itself. That's the default. That's the rewrite.
The pitch forks are coming
> During my chat with another few people I learned that there are people who downvote in group brigade fashion whatever they don't like.

Please report the details to us at hn@ycombinator.com. We take action against users who do that.

I don't see evidence of what you describe in the thread you linked to. But if you or anyone will provide us with more information, we'll look into it.
How Risky Is That New Hire? The One Interview Question That Matters
> How can WinRT be a derivative of WPF if it's written in C++? What WPF code-base did they derive from?

They derived WPFs design and API language, along with XAML. Its not like MILCORE was written in C# either.

> So what does show a good measure of overall developers that shows the slow death of languages/devs without IDE's

It shows nothing. IDEs haven't really been a thing (they weren't that good until then) since the late 90s or even mid 00s. It is taking awhile, but its happening. We will see more language designs that don't bother with IDE independence for better features. Couple that in with the Bret Victor candy, and there is only one way to get there.

> There's also lots of value in small, wrist-friendly languages that don't need an IDE and have a good story for text-editors / command-line. You may want to check out what the dev story is for Clojure / Go / Node which support live-reloading / auto-running of modified tests and fast dev iteration times without IDE's.

I know all about those systems, and they aren't very inspiring. We can do much better than that if we don't limit ourselves to languages just being syntax/semantics/and a compiler.
Any idea of what tools, platforms and services will be available?
Not too bad, but a few things that I noticed were off (and to clarify: I've worked on Hadoop/HBase since 2011):

1. Flume isn't really a Google solution, is it? Sounds like Google is just incorporating Apache Flume into Cloud Workflow.

2. Even if Google abandoned MapReduce a while back (Urs' declaration about the same at IO seemed a bit ambivalent), IMHO Hadoop and its ecosystem are here to stay at least for a bit longer.

True, MapReduce isn't perfect, and the Hadoop implementation far less, but (again IMHO) there really isn't anything to replace it at the data scale at which these technologies operate.

I mean, there's a reason that Facebook and large non-Google companies still use the Hadoop ecosystem, yeah? :)
"Implementation defined" means that the compiler can do whatever it feels like, but that it must choose something specific and that this must be documented, and any program that invokes implementation defined behavior is perfectly well formed. "Undefined" means that the compiler can do whatever it feels like and it can be completely inconsistent and documented nowhere, and any program which invokes it is ill-formed, and programs can be assumed not to invoke it.
Financial sanctions? Buy a certificate from Namecheap and pay using Bitcoin (yes they officially accept it!) In Iran, you can obtain coins through https://localbitcoins.com/country/IR or http://www.coinava.com/

This is a very concrete example demonstrating how Bitcoin is resistant against censorship, sanctions, etc.
While a comment is probably not the right place for this, the essence IMO of FP is higher order functions (HOF). Being able to pass a function to another function, is key. And yes, even C can do this, it's just cumbersome.

From that key idea of HOF, other stuff arises, like the lean towards immutability. Which gives rise to things like recursion.

This is why functional programming in non-FP languages gets cumbersome. While they can "do" FP, all the other things you want aren't supported or require a ton of effort. Whereas in an FP language, those other things (immutability, recursion, pure functions, etc.) are treated better.

FWIW I've written a series (looking at C# specifically) on my blog http://www.atrevido.net/blog/2007/08/12/Practical+Functional...

But I think the blog may be messed up and it was written nearly 7 years ago when I was far less experienced with FP. There's probably far better intros out there.
Who knows, everyone has their own opinion about it. Perhaps it was just too many parentheses for students to deal with.
The wikipedia article [1] is a decent introduction. Functional programming is loosely-defined as a style of programming that involves using some subset of:

* Higher-order functions

* Pure functions / referential transparency

* Immutability

* A powerful type system

* A declarative style (expression-based)

(Some of the above concepts are closely related, and some people may feel there are other important ones I left out)

A functional programming language is loosely-defined as a language which makes programming in the above style possible, feasible, or easy.

[1] http://en.wikipedia.org/wiki/Functional_programming
The major features in that list were introduced as part of lightroom 5 - the only other features to lightroom itself came in lightroom 5.2 and these are small enhancements and bug fixes. All other changes are lightroom mobile, which while i'm sure they are useful, I don't consider to be improvements to lightroom itself.
That C isn't predictable or well-specified, which is a real problem when writing portable or secure code ("oh shit" moments in C code don't just give programmers headaches, but have caused tons of vulnerabilities).
It depends on how you define free will. If you define it as being 100% the cause of an action, that's impossible. There are two possible causes for an action: either you caused it, or something external caused it. If taking action X at time T is entirely the result of your choice, why did you choose it? Because of whatever influences made you the person you are at time T.

If these influences were external, by the definition in question your action wasn't entirely free will, as its root cause could be traced back to external influences. This means the person you were at time T-1 would have to be 100% responsible for the person you are at time T in order for you to be 100% responsible for taking action X at time T. The same also implies that the person you were at time T-2 would have to have been the cause of who you were at T-1, and so on recursively.

Trace that far backwards enough, and you get to the point where in order for you to be entirely the cause of your actions at time T, the person you were at time Tb would have to have been the cause of who you were at time Tb+1, where Tb is the time you were still a baby and incapable of conscious thought. This is not possible, as a baby doesn't 'make decisions' in the conscious sense, it acts purely from the impulses condition by its genes and whatnot.

Thus if you chase the causal chain far back enough in time, you see there's always an external root cause for an action.
> Would they think Python was stupid or would they be grateful that all of a sudden they could use a for loop?

They would probably be at least as mystified by infinite loops as Python programmers are by space leaks.
9 Optimizations to make your Linux Desktop fly like a Rocket
Supreme Court Uses The Bizarre 'Looks Like A Cable Duck' Test To Outlaw Aereo
I've written elsewhere before[1] about the fact that journalists give us all a skewed interpretation of what's actually going on and where the money is.

Far more of the world's wealth is flowing between companies than between consumers and companies; but those flows are only visible to those close to them. But every journalist is a consumer, so they are all "experts" on whatever the final consumer-facing products are. Hence, those products get the attention and we overestimate their importance.

[1] http://chester.id.au/2013/01/05/on-selling-to-consumers/
Having a --cheat option seems like a poor decision. Having easy access to every solution (especially as it exists in a plain text file) harms the experience of struggling through a problem until the correct answer is reached.
They're completely different. Web Fundamentals are good practices for web development, things like how to make a responsive page and what that means, etc., while Material is a guide and common elements for good mobile and web design.

A company can have several guides and guidelines on similar topics.
It's generally easy to catch segfaults. On UNIX-like systems, you can just set a signal handler for SIGSEGV. Other systems generally provide similar functionality.

The problem isn't that they're hard to catch, it's that it's virtually impossible to proceed in any sort of sane manner once a segfault has happened. You have no idea how much state got corrupted before the segfault actually happened. You have no idea what cleanup the functions currently on the stack expect to be able to accomplish before they return. You have no idea what kind of inconsistent state the data structures in memory are in.

If you're really lucky, everything is fine and you can keep on going. If you're not so lucky, stuff is corrupted and you just crash again the moment you try to resume, and again, and again, in an infinite segfault loop. If you're really unlucky, your program doesn't crash again, but proceeds with corrupted data, saving it out to disk and displaying it to the user and causing all sorts of havoc.

I actually helped out a little bit with a similar system:

https://www.plausible.coop/blog/?p=263

Although instead of throwing an exception, it simply tried to proceed to the next instruction.

The whole thing was done as a joke for April Fools' Day, because it's a completely awful idea. Making it throw an exception instead of continuing immediately doesn't really make it better.

I agree in general that segfaults shouldn't exist, but your proposed solution is frightening. Segfaults shouldn't exist because the compiler enforces bounds checking, safe memory management, and other such things that ensure that your program never attempts to access memory it can't access. Once the attempt is made, it's far too late to do anything but crash.
There are infinite loops in Haskell too. (And space leaks in python)
I don't know if the Android camera app is considered to use "Material" but it's massively unintuitive to use. It's not obvious at all that to see a picture you just took you need to swipe to the left. Nor is it obvious that the small shutter icon once you have swiped means "edit" or "refocus" or whatever.

Google's opinion seems to be "It doesn't have to be intuitive because you'll eventually learn it".
No, that's not true at all. You check before you dereference, which is completely legitimate. If b is NULL then the dereference never happens, exactly as it should be.

To invoke undefined behavior and strange optimizations, you'd need to rearrange the code a bit:

a = *b;
if (!b)
a = 3;

Here, the compiler can omit the if statement and its contents entirely, because b cannot be NULL, because the first line would invoke undefined behavior if it were.

A check for NULL before you dereference is always safe. It's when you do it the other way around that the compiler can start doing strange things.
Similarly amusing, INT_MIN / -1 will throw a "division by zero" on Intel CPUs, even though there isn't a zero anywhere in sight. INT_MIN * -1 is fine, of course (according to the CPU, even if not the language spec).
I like it! I am not a designer, just a user of Android and this looks good. I just never liked or bought the complete flatness idea. Maybe I am too brainwashed by skeumorphic buttons shadows and whatnot. But we just don't live in the 2D world, the world is 3D and shadows, textures, depths help us interact with the real world (it is there without anyone explicitly adding it in, as in objects in the world are inherently 3D).

This is sort of the middle ground. I think the pendulum has swung too far with the Windows and Metro design (and I do commend MS for being bold and going for it, that was fantastic I think). But now I think the pendulum has swung slightly back to a little more skeumorphic design, a little more shadows here and there, use some basic textures. Still flat not fake 3D buttons that look like ancient light switches but paper -- something in between.

I can't wait to see more.
I certainly never really considered just how intertwined the gut and the brain are until I was diagnosed with IBS (or perhaps a better name, the "we have no clue what's wrong with your digestive system, but it's not physical" syndrome).

About 18 months ago a number of things conspired against me: I was having a very stressful and uncertain time at work/home, and I went on a strong course of antibiotics for an infection which wiped out my gut (a known side effect). For about six months I had serious digestive problems, both bloating, gas, diarrhea, nausea, abdominal pain - real, visible, symptoms...but despite a barrage of tests, nothing at all medically wrong. I had dozens of blood tests, an ultrasound, a gastroscopy, and a colonoscopy with biopsies - nothing. At the same time, I went through a serious depression and malaise that nearly always coincided with my digestive problems.

A year an a half later, I have a lot more respect for how the gut is tied in to general mental health. I'm not totally back to normal, but I'm a lot better than I was, thanks to meditation, watching my diet (my gut is a lot more sensitive to what I put in now - previously, I would eat any old junk), and generally making that connection between my mood and my stomach.
I'm genuinely curios. My perspective on parenting might be a bit different but hearing yours might help round mine out.

I don't want to send my kids to an inner-city school for the sake of making a point but I do want to for a couple reasons. First, if no one with privilege goes there then how can privilege ever come to exist there? Second, I don't think I want my kids to grow up surrounded by affluence and privilege.

When you say it's clear that your son's education was worth every penny do you consider other pros and cons of being in a private school?

I say all of this knowing my kids are currently 4 and 2. And that my wife is much more like you than I. We'll compromise but I'm curious if there's something new I could learn here.
I am no expert of Python or Javascript, but here's some of what I love in javascript

* first-class functions

this is the first thing anyone would fall in love with when coming from Python. Python do treat functions as first class, but Python follows OOP way more strongly and functions in Python never get that level of authority as they do in javascript. Ability to define anonymous and named functions anywhere, immediately executable, fully or partially is a huge plus.

* highly dynamic: monkeypatch anything anywhere

Javascript is highly dynamic, you can override almost any property of almost any object anytime in the timeline. This opens room for all sorts of hacker. Like I worked on a fairly complex Meteor application and we needed to modify the behavior of some core meteor methods. No, using them through a proxy wasn't a possibility as we wanted to change how the app behaves overall. How would you do it? Fork meteor and roll out other version? No. Just overwrite the functions on Meteor at right time in the timeline. I know it's more hacking than engineering, but not all hacks hurt.

at many places we would intercept the objects being created in one part of the framework that would go to another for further processing and do shit load of operations on them half-way to make them work as we want (like temporarily turn mongodb cursors to model (in MVC terms) like interfaces which are more easier to work and reason with), and then forward them with original interface, properties changed to processed values.

* prototypical inheritance

I like the way javascript does inheritance. Or how we force it to. The prototypical ladder cause many problems but it also open doors for many interesting solutions which won't be that easily achievable in other languages.

* fun of writing code

Once you grok the fact that js is a functional language, accept it and start using it like a functional language, javascript is tons of fun to write. I mean you won't miss (m)any python features if you sue javascript as a functional language and make use of the functional abstractions provided by several js libraries. Just using underscore makes a huge difference.

* flexibility and extensiblity

reading prototype.js code blew my mind. You can beat, bend and extend js in whatever way you want.Yes there are several gotchas (some of the language itself and some because of browser implementations), but despite of that what javascript has to offer is remarkable. I was intrigued to read prototype by js ninja book, and it is indeed mind blowing for someone new to js like me. I am looking forward to desiccate javascript libraries which provide highly functional interfaces and macros. Ability to serialize (almost) any function and modify it and then execute at the runtime opens room for innovative solutions (and all sort of sorcery/hackery).

* freedom

python is quite liberal, but javascript takes it to another level in terms of what you're allowed to do with your code. I don't know how to express it with words, and I don't know how you can not feel it when doing a js project.
The first time I learned programming it was Scheme, and I didn't care for it - the syntax was confusing and it felt more like magical incantations than giving the machine instructions. I didn't touch programming again for several years, but when I did it was python. I found it was much more interesting, in part because of my state of mind but also because I could see the computer responding to what I told it to do and I liked being "in control" of the machine rather than the other way around (which FP can sometimes feel like). I love functional programming now and I write a lot of Haskell, but I think there's real value to starting out with an imperative language to get that "interacting with the machine" feel. It also makes it easier IMO to learn about computational complexity, systems, etc. That, and python has a ton of great libraries, an intuitive syntax, and a lot of flexibility, so I'm not surprised they've adopted it.
I agree with you. Although Material is great, it doesn't mean the quality of Android apps will be improved quickly. Maybe google need to try harder to expand the influence of his guideline.
I considered this, and figured since the solutions are stored by the program anyways, it would make more sense to include the functionality rather than to omit it. Naming the option `--cheat` was an conscious decision to discourage a reliance on it. Then again, if someone really does want to view the solutions rather than work through the problems themselves, I suppose it's their loss anyways.
I like scheme to be honest, especially the racket style of preferring define over let. Combined with well chosen variable names, list comprehensions, pattern matching and optional square brackets, all but the trailing ))))) becomes not a problem.
Apparent correction to the speed of light in a gravitational potential
One thing missing from KendoUI for me is the TreeGrid. Last I checked (a few months ago), it's still not available. It's an important component in our solutions.
MeteorJS is not a black magic
One thing I try to do is read everything that is considered well written or canonical in some way.

These types of resources tend to be informative, easy to grasp and often inspiring. They are things like books/textbooks, blog posts, tutorials(most tutorials suck though). They will usually reference other (even more canonical) resources so you shouldn't really have problems finding new stuff to read. You can pick and choose based on what sounds interesting and repeat.

This has been extremely efficient for me, and I have learned a lot pretty quickly.
If you are in the middle of the ocean with a bunch of shipping containers, it'd be nice to browse their individual temperature readings on a tablet, without relying on the cloud.
Well, the general upside to googling for an answer is that often when someone is providing you with the numeric solution they are also describing their algorithm and implementation. Having it in plain text right on the local hard drive might be more tempting with fewer benefits.

Potential Solution: store the solutions file in an obfuscated format that is easy to decrypt
I'm just talking about the incentives as to which type of restaurant to open, or more generally, which set of tastes to cater to. Do labors of love scale? No. Does it make sense to start a business that doesn't scale? I have no idea.
Google Dumps MapReduce in Favor of New Hyper-Scale Analytics System
Because 'go get' does not allow you to point to a particular revision. It downloads the latest / HEAD commit for that dependency and sticks it into ${GOPATH}. These dependency managers are all aiming to fix that problem, and some of them, I believe, transitively.
SICP is still the bible, even through Python has become the "practical" language that's also quite simplistic.
That's what I mean by implemented better as something that is officially supported. In objective-c it's a hack, it can lead to hidden surprises since code usually doesn't make it obvious that a specific method has been swizzled. And you have to deal with hidden expectations in code that you have no control over.
I think they made a mistake by making the "gets configuration parameters from the environment" specific to a UNIX/system environment. You can accomplish the same effect in a much more elegant manner using a tool like etcd or consul.

But the important part is really that the deployable unit pulls its configuration from the environment where it's deployed. There are a ton of ways to accomplish this...environment variables are one way, etcd/consul is another, you can use something language-specific like JNDI or you can even use a file with configs in a well-known location, but you really need to be deploying the same artifact to QA, E2E testing, production and whatever other environments you might have.
Might be a subtext here. Consider that there are people (in the general thought-o-sphere, not in the article or on HN) saying that 'poor people are just too lazy to be rich'. Re-read the article.

Some things will stick out, I believe. Particularly: the author says that most people feel the rich should be taxed more but cannot find institutional recourse for their frustrations due to distrust of the government. Most people would conclude that they'd do something else -- the author of the article concludes they'll do nothing.

I'm not claiming to see into the author's mind, but placing ideas in different contexts can help illuminate our own thoughts and have more considered reactions.
http://bost.ocks.org/mike/join/
That's what my university did (Masaryk University Brno). It taught Haskell in the first semester. I, already programming in other stuff, was delighted to see a new interesting thing. Other students who already did some coding (PHP usually) reacted more like W.T.F. I'd this. I can't tell about the total newbs but in the end, only 30-40% passed. But that was mostly caused by their laziness because when they repeated the class and realized that they have to put in some work, the success was much better.