skysight-inc/HackerNews huggingface dataset:
Verbosity matters for reading and maintenance far more than it does for writing. IDEs can make the writing faster, but they can't make the code as easy to comprehend as it would be in a more expressive language. And remember that lines of code is the only proven risk factor for bugs.

Most sites are not Twitter. They're not Stack Overflow. They're not even Nanowrimo. I've watched a company spend two years, dozens of developers, and over a million in ESB license fees failing to write a site that was expected to have, at peak, 100 users/day. Their competitor had four guys writing Ruby, and was profitable after the first month. Nor are the performance advantages "permanent"; even if you use Java, you will probably have to rewrite if you reach Twitter scale, because your initial app won't be clusterable (or if it is, it's massively overengineered and your business will fail). So do it the way twitter succeeded - write the first version in Ruby, and then worry about performance when you need to.

The advantage of using the same language on both sides of a boundary are real but overstated. If you have a system with multiple components, you probably need to evolve the interfaces between them, and you need to be able to upgrade without downtime. Which means you need well-defined interfaces for which you understand the compatibility implications - in other words, you need something like Thrift. I've used Thrift even for Java-Java interfaces, but once you're using something like that it doesn't matter which language is on the other side.

Still, the library point is valid, as is the point about spending time with a language. Better to have one language that you know very well than ten in which you dabble. But by the same token it's worth taking the time to make sure that language is the very best available. I use Scala for everything, and there's plenty to learn - maybe even twice as much as a "normal" language. But if I'm focusing on that one language, I can afford to take the time to learn it really well. And Scala combines the expressiveness, clarity and scripting-suitability of Python (yes, it can be unclear if you use silly method names or libraries that use silly method names - don't do that then) with the strong type-safety and performance of Java. It's a great language in any case, but especially if you want a single language for everything, I don't think anything else comes close.
The NRA has been doing this for years.
Some are that way by design. #python on Freenode is really aimed at being a support channel. Off-topic conversation is practically not allowed (they have a bot that will pm you if you type lol telling you that #python is a no lol zone.)
Remote code execution on Apache+Rails stack by exploiting Paperclip
Porting an entire desktop toolchain to the browser with Emscripten
Do it, please. Send us the link ;)
I totally get why people _want_ operator overloading - it is immensely useful when performing arithmetic. Writing `x+y*z` is easier vs `x.add(y.mul(z))` and I think everyone who had to do statistical analysis agrees.

However - I totally agree that this hack shouldn't be put to real use. ES7 gets value objects with proper operator overloading that shouldn't suck.
https://hn.algolia.com/?q=atom+vim#!/story/forever/0/atom%20...
I think it's the terminology that's mixed up, actually. Functions are first-class datatypes in many imperative languages, including Python, Go, or JavaScript, but they mostly aren't mathematical functions.
https://news.ycombinator.com/item?id=8612238
The paperwork is the code review, the test results, the QA approval, the verification against requirements, the approval to merge, and so on.

The paperwork has moved into a digital format, but it's still there.
Are Happy Gut Bacteria Key to Weight Loss?
This thing basically gives me a full brain workout. I feel a bit exhausted by a doing a couple of games. It's pretty neat tho.
>So what he's describing, beating the S&P 500 by a bit over that period, isn't implausible.

Certainly not. I suppose I take issue with having been able to do so for "decades", via only large-cap stocks.

That's implausible, to me at least. That would be all-time-great hedge fund manager type results.
> Don't make the user provide information that the system already knows.

I wish the IRS followed this advice.
Up to a point - I found the static support was quite buggy and I got the impression not many people were actually using it. Has it improved in the last few years?
Some good, some aren't, some used to not work with Python 3, some still don't work with Python 3, some reinvent the wheel died due to not being popular (sql object, pylon, turbogears), some looked relic and not worth to learn ( plone, zope).

Like the article said, it's fun and quick to hack in Python but just ain't everybody taste... especially seeing the age and the quality of some of those libraries.
I think this is the key point in the debate - weighing initial development time against ongoing development and maintenance. It's something that's hard to grasp until you've been around for a while working on real-world large-scale projects. And it's a hard thing to get the sense of when you're in school, writing throwaway code that doesn't last past the end of the semester.

When you understand this, then you can make an honest assessment - is it really important to get the first build out that much quicker? Sometimes it is. But I think it's overemphasized. The first one to market doesn't always win. And the shift from new development to maintenance happens quicker than you might think.
Scala's biggest advantage over other languages for me in terms of reducing bugs, complexity, and pleasantness have been higher kinded types. Given that F# is lacking in this, and they don't have plans to add it, I can't even see them as comparable.
Awesome! Works fine here.
https://hn.algolia.com/?q=The+Unknown+Start-up+That+Built+Go...
You can just turn that exact statement on its head and say that "the ability to recognize and differentiate between different kinds of effects in use is a feature of pure functional languages".
I agree with you that candor is often misinterpreted as meanness. You've described very well how a successful CEO who is perceived as mean because of candor may not be mean at all. So I don't understand why you completely disagree with pg about this topic.
The Case for Slow Programming
Vivid beats valid.
Long term capital gains is 15% not 50+%. Also, California bonds are far from a risk free investment which is why they pay more than 1%. Remember a 5+ year bond can have negative real returns if inflation increases.

EX: People have paid 50 k for a 30 year T bill, waited 5 years and sold that for less than 50k. The important thing to remember in such situations is just because you did not sell the bond does not mean you did not lose money.

Also The tax-exempt status of municipal bonds does not extend in all instances to the alternative mininimum tax. - See more at: http://www.investinginbonds.com/learnmore.asp?catid=8&subcat...

"Under some circumstances, a taxpayer who receives tax-exempt interest will have a greater portion of his - See more at: http://www.investinginbonds.com/learnmore.asp?catid=8&subcat... ". So that tax free bond might not actually be tax free.
Rugged, that's a good word. I've seen IRC set as default communication channel for incident management. No matter how much infrastructure is down, as long as you have a few engineers, they can either reach or set up an ircd in no time and have proper, timestamped and logged communication.
Great!

Pro tip ;-) Click "Stop cam" while making a stupid face and you can copy/paste it.
"easy bugs can be found by just reasoning about the code"

I probably live in a dream world, but I would say software bugs of the 'causes deadlock in a OS that is used in millions of devices' type should (maybe even must) be avoided by reasoning about the code. If you find that you cannot reason about the whole system at the time, you either simplify it (python's GIL is a nice extreme example; you never read about race conditions inside Python's core) or you improve your logic.

In my world, you should only need the debugger for hardware related bugs, and then, it often is a combination of intuition and sheer perseverence that solves the issue. Especially if timing is involved, looking at the system can make the problem go away. But even there, having thought about the system will help a lot. For example, your reasoning might have said "between two X-es, we always get at least one Y, so…". You can turn that into a hypothesis that can be tested easily (in theory. Practice can be quite different)

On the other hand, if you must use modern PC hardware, you get a lot of unavoidable complexity (multiple interrupt levels, drivers that you cannot all check do compliance with your model of how drivers work, etc), so you may end up with the case where reasoning about the code isn't really possible.
Maybe C based XML parsers don't, but JVM and .NET based XML parsers don't have any issues with CDATA sections.

Time to upgrade to more modern tools?
Ask HN: Micro services at macro-scale?
I am the main developer of a relatively-high throughput API - upwards of 1000 req/sec at peak times. The core app is built in Python mostly because it started as an experiment, and was never meant to handle so much traffic.

We use AWS autoscaling, and build ephemeral front-end servers to handle wildly fluctuating traffic levels throughout the day. We can be as low as 3 servers, and as high as 13 (front-end only, does not include DB/Redis).

I've been tearing off piece9s of what has become a large-scale app in to "micro-services" (for lack of a better name). Most are written in Go, as I both enjoy it and find it fast to develop in. But when looking at the future, I'm trying to decide between Go and Elixir for a port of the largest part of the app. I know Elixir's OTP layer lets servers almost work as a hive-mind, whereas Go would be better to services that could have several instances launched in parallel that are not necessarily aware of each other. Our current practice of having all front-end servers load-balance requests and have no inter-communication (so scaling down doesn't cause any real problems) seems to work well.

My question is mostly around architecture, and comparing OTP-based smart clustering with "dumb scaling" of many instances of the same small services that don't inter-communicate. I don't want to get into a language debate, but rather am looking for thoughts about building services to scale to many thousands of requests per second, and the different approaches to doing so.

Thoughts? (Edit: clarity)
Imperative requires order but they are not identical. Imperative tends to mean "sequence of instructions which operate on an exterior set of mutable state cells" versus functional which often means "set of expressions which reduce into values". Each can model the other, but let is clearly functional in this model since its meaning derives entirely from a reduction semantics.
Was going to post this, the title isn't great
Coding course recommendations from a non-technical CEO
Maybe californians don't have a sense of ownership towards their state as much as swiss people have.
There is no clear-cut definition of what makes a language functional, but popular opinion says that F#, OCaml or Clojure are functional languages, none of which are pure.
Reservoir Sampling for Streaming Data
This whole "expressive vs. performance" is a false dichotomy. Languages like Scala and Haskell are performant like Java and expressive like Python. Not to mention the work being done on JIT compilers by V8/HHVM/PyPy that are helping to close the performance gap for dynamic languages.
This is very interesting, thanks for sharing it.

I've been looking at home automation solutions and I want to make my own - I want to be able to control every switch and socket in my house, so I'd need very inexpensive nodes. I was thinking small microcontrollers (like the ATtiny85) with a one-way RF module plus a relay. I'd like to keep each node under $10 if possible. Then I'd have one (or more?) Raspberry Pi-like nodes that would broadcast commands to the nodes.

My main problem is: how would I power the modules that would control switches? I want to avoid a power brick running to the nearest socket at all costs, and a battery is a pretty bad solution. Any ideas?
Indeed, we process relative to context which is usually what you want to do
> Map<String,User> userIdMap = new HashMap<String,User>();

1.7 introduced a simplified version:

Map<String,User> userIdMap = new HashMap<>();
A+++. Would read comments again. And again.

"This is a blatantly biased article."
Those reviews... OMFG!
Justice Thomas's concurrence in Citizens United cited several examples:

http://www.law.cornell.edu/supct/pdf/08-205P.ZX1 [pdf]
At least I included the backdrop to have it be somewhat on subject.
Is there a way to discuss cards or suggest revisions?

For example: "t-distributed stochastic neighbor embedding (t-SNE) is an algorithm to convert high dimensional 2d or 3d space, where similar points and clusters are preserved. Useful for displaying scatterplots." is not correct and should be rewritten.
Quick side question on this piece of Smalltalk:

my_func := [ 'Look, I'm a function!' ].

How does the string parsing work here? I like it a lot

edit: welp, this [1] makes it sound like 'Look, I'm a function!' is a typo and should in fact be 'Look, I''m a function!' (Note the double simple quote `I''m`)

But the idea to not need to escape single quotes when surrounded by something else than whitespace is interesting.

[1] https://gist.github.com/sin3141592/602700#file-smalltalk-gra...
Isn't Java FX tackling that?
It will be nice to have this problem. Several years ago, Eliezer Yudkowsky asked Aubrey de Grey about brains filling up as they age.[1] Aubrey's answer was:

AdG: "I'm not too worried about the brain getting saturated. And the main reason I'm not worried is because I'm pretty sure that even by our age, we're already forgetting old information at pretty much the same rate that we are learning new information."

EY: "What a wonderful and consoling person you are!"

AdG: "I think that's fine. I think there are ways, of course, in which we can train our brains to store more information. I'm not even sure it's a worthwhile thing to do because we have so many extracorporeal ways of storing information these days."

He goes on to back his view up with evidence such as the reminiscence bump.[2]

1. http://bloggingheads.tv/videos/1903?in=35:23 (The HTML5 video is broken. Only flash seems to work.)

2. http://en.wikipedia.org/wiki/Reminiscence_bump
I Really found the book "Learn you a haskell" to be an really fast way to get functional programming into production.

I did not however continue to use haskell since it doesnt have key libraries I need.

I instead adopted livescript,underscore into javascript and was good to go.
Why are there 50 zillion reposts!?!?!?
IntelliJ has historically looked pretty native on MacOS X. At least until Yosemite pointlessly reskinned Aqua to look more ugly. Now I find myself quite happy that IntelliJ is not a native Mac app because I preferred the old look anyway :)

You can make the apps look native, if you really care. But in an era when web apps are the shizzle why would you even care? No web app even tries to look native. They just do their own thing and nobody cares.
Care to share more details of these companies including how the Ruby ones become profitable after a month with 4 guys on payroll? No offense but I've got to check the facts these days.. :).

Also, don't forget Fred Brooks article about the Second System. I betcha smart engineers on tight budget can hack in Java just as quick as those 4 guys and achieve the same result. My apology, Java today is as productive as Ruby on Rails.

The difference between rewriting a Rails site to Java and an already written system un Java to a more modern architecture is huge. One can slowly move from old Java architecture to the newer one but it'll be trickier from Rails to something else... don't forget the accumulated Ops experience managing jvm based app server, the devil in details for those experienced engineers who have been there and done that...
Have you actually read this post?
Ability to change or replace object instances (maybe with instances of different types) on the fly could be an example. In general, you can design incredibly dynamic and reconfigurable systems. Whether you want to or not, and at what level should you stop doing it, is certainly a good debate to have.
When did you last try it? Startup time was optimised heavily some time ago and nowadays I don't notice any real difference unless I wrote some toy app and used "time". The JVM starts fast enough that you can write command line utilities just fine.
It's not much relevant to the article as the author doesn't imply CDATA is poorly supported (and that's not the topic at hand) but CDATA sections are very common in RSS files, as a way to shoehorn text of any type into various elements, so I'd be surprised if any well used parser lacked support.. it's even more of a requirement than namespace support IMHO.
> Shouldn't a political debate be more about ideas than the people who are involved?

You don't need money to talk about ideas. The enormous sums poured into American campaigns are about something, but I'm pretty sure that something isn't the best way to run the country.

Give candidates the same amount of space to make the case for their position, like with ballot initiatives. Have them do it in writing - it makes for better decisionmaking, and it makes candidates more accountable. Maybe put these things on a leaflet that's mailed to voters, a publicly-administered one - charge the candidates at cost if you like, it's not going to be a big expense. That ought to be enough. The sound and the fury of modern political campaigns does not signify a better government.
This guy named Bernie Madoff was able to outperform the market for years and years, I hear.
I've a ZNC bouncer running on a PI. It's cheaper ;)
I'll be the first to agree that Java-style class hierarchies and duck typing don't mix well, but not every dynamic language is Python. Clojure, for example, is very easy to refactor when it's (very rarely) necessary.

Not saying static typing doesn't have it's advantages – tooling is probably Java's greatest strength – but there are other, equally valid, solutions to the problem.
I love how extensive the examples are. Great work. Would you consider post it to http://www.reddit.com/r/golang ?
You have to appreciate bombastic statements like this for forcing you to confront your assumptions. "Everything in Java? Even a kernel? That's absurd." you think, and then wonder what makes it absurd, and realize that it could perhaps be done with some modifications, and remember Singularity, etc.

But on the other hand, this is well trod ground. Everything WAS going to be Java. Remember picoJava, the bytecode-native processor? Remember Cocoa Java, for OS X desktop apps? Remember HotJava, the pure Java web browser? These things were tried, and they failed. Performance issues, especially around startup and memory usage. The weightiness of the JVM, what Jobs called a "big ball and chain." The weird foreignness of Swing apps. The generalized misery of applets. Etc.

So honest question: what's different this time?
Recently I find it harder and harder to believe that lcamtuf is just one person.
IMO, being tethered to the JVM is both its greatest strength and its greatest weakness. The JVM really is a masterful piece of engineering, but it is optimized so heavily for the server that any use case that deviates requires huge hacks to get what you want. For example, running a JIT on Android was so sluggish that Android had to design an entirely new runtime(ART).
I'm of two minds on this. Certainly it's important people find enjoyment in the day-to-day reality of their job. Unhappy people don't write good code in any language. But I honestly do thing people can have too much fun writing code. We've all fallen in love with something we've written even though it might not have been the simplest or most understandable or idiomatically sound.

Writing Python is fun. But that joy can cloud your judgement, and if we are to consider ourselves professional, we have to look beyond just that and make decisions based on our employers best interest. Sometimes that might be Python, but in my experience, quite often that's boring old Java.
Awesome! I also just discovered I can install apps on my Android phone via Chrome. I'm sure everyone knows this but I'm new to Android and just tickled. I don't miss iOS a bit.
For the case you're talking about, see Scott Adams' financial advice. I linked to it in my post.
One interesting thing: intel has been working for years on light communications between chips. Why is HP launching this first and not intel ?
I think we find slo-mo interesting because it lets us experience the very passage of present time and events slowly, rather than just perceived passage which is after the fact.So we get to see things in a way we haven't before, which would presumably be more memorable and also would slow down perception of time passing....
Though the lack of noise could also translate to parsing things in my head trying to understand what is happening in this super short code....hence it takes longer to read the code!
I think that the argument about verbosity is a subtle red herring. It's not that you just have to write slightly longer words to do the same thing. It's that you can't do the same thing at all because the underlying constructs of the language are lacking in key powers of abstraction that make it easy to simplify the problem you are trying to solve. You end up inventing whole class hierarchies and patterns to emulate things that are either just built into other languages or are easy to achieve because they offer more powerful language features (like reified generics, etc.). Java 8 helps a lot, but there are still fundamental weaknesses.

Having said that, I'm still a fan of Java. There's no other language that I can sit down and reliably navigate through someone else's code in as easily - and that comes partly because it's powers of abstraction are so limited.
It's a half mile to the subway, and I walk a lot faster than my 5yo. So I get a Citibike, put the seat at the lowest setting, he holds on to the handlebars, and I walk next to him, pushing the bike. It's not strictly following Citibike's terms of service, but he loves it, and we move much faster.
Fidelity's Oculus App Lets You Fly Through Investments
For Accomplished Students, Reaching a Good College Isn’t as Hard as It Seems
Rather the opposite. Almost all HPC (high-performance computing) systems use message passing and not shared memory. The fastest and imho best unix-like kernel L4 is entirely MP based.

So if you want to embrace high performance (and concurrent), go message passing.
Alan Kay's favor of late binding does not help performance, as method lookup at run-time dominates the cost then, but the fast systems are early bound, i.e. typed.
It is a good idea. CDC recommends the vaccine for boys too: http://www.cdc.gov/Features/hpvvaccineboys/