skysight-inc/HackerNews huggingface dataset:
I've seen this happen first hand. I joined a lean startup full of smart hackers building software in a fast-growing industry. It was great, and we made a load of money. Then problems started happening, and we blamed people: incompetent, tired, one-offs, whatever.

Then our customers started getting serious and regarded these events as unacceptable, just as they became statistically certain, and impossible to manage out. So costs have gone up, processes multiplies, checks increased. And now lean startups are nipping at our heels...

Think medicine.
No sarcasm on my part. There is no problem reconciling any part of my statement. Why does it seem strange to you for a Christian to be interested in Mars? The scriptures teach that God created the heavens and the earth and the stars and by inference the planets. I find them very interesting, as apparently do the good folks at NASA and their sponsors the U.S. government.

The rest of your comment then wanders off further into the very attitude that I was commenting on, so thank you for illustrating my point. Discussing creationism does not lower the level of discourse, rather, dismissive attitudes such as yours, stifles intelligent discussion. You could have asked how I came to transition from professing evolution to embracing creationism, but instead you use words like misguided. I don't see any evidence that you'll care, but it was a thoughtful process and we could have discussed it. Looks like my personal policy of silence is the less misguided one.

Outside of my day job, I am a pastor (check my HN profile), so I also work on solving actual problems in my community and my congregation.
Thanks for the compliment but my simplistic summation of game theory and
group psychology still needs a whole lot of work. ;)

As for how to fix it, that's a remarkably tough question, in fact, it
might be a formally "undecidable" (unsolvable) question but that doesn't
mean a better partial solution can't be found. Either way, writing up
my thoughts would result in a painfully long post, and I'm not sure
I would make much useful progress towards potential improvements.

More importantly, I have already derailed tokenadult's submission; it's
clear that he wanted to know both the personal and perceived biases
are around HN, rather than look at the root cause of those biases. It's
fair to say I let him down by examining root causes. If you asked me
what color the sky is, and I answered with the physics causing sky color
on various planets, then you wouldn't have gotten the answer you wanted.

An important part of overcoming bias is knowing what the biases are.
"The scripting languages" is a very broad category. I think Python is rather different from Tcl, AppleScript, csh, JCL, MATLAB, and VBScript, to name but a few well-known scripting language. Ruby is definitely closer to Smalltalk (a non-scripting language) than it is to PHP (a server-side scripting language).

So I don't understand your comment about it being a narrow language space.
"The most common form of payment is Medicaid, a tax-funded public service. In Los Angeles County, the economic impact is even more pronounced, costing $66,000 on average, the increase likely due to the high cost of health care in the state, says Frank Sorvillo, a University of Los Angeles professor of epidemiology."
Faker - PHP Library to generate Fake data
As an American who believes the last one (and moved to Denmark), I haven't felt that HN posters generally agree with me, unless you mean purely on social issues (e.g. discomfort with religious conservatism and support of gay rights). On economic issues there seem to be a lot of libertarians around, tempered mainly by a vocal group who're unhappy with the healthcare situation for freelancers and startups.
Listen to Music Curated by Music Experts
> it's the only language without any deal breakers

Interesting thought. Can you elaborate?
Thank you Sarah and Sarah for starting all this & paving the road for us. The workshop team loved doing it, and we feel very proud be to furthering the mission you gave birth to.
Kevin Rose interviews Chris Sacca
Technically, your second code example is using 2 spaces for indentation ;)
Python has been my favorite language for many years, while the last few months at work I've been writing a lot of JavaScript. I've found that JS has exactly one advantage over Python, which is usable function literals. And that turns out to have a surprisingly large impact. It's convenient and natural to create "anonymous classes" that use closures to store their state, while in Python you'd have to manually create classes and manually copy the variables in __init__. I really wish Python could gain something like that while retaining its many advantages.
That only "works" for the global scope, or by chance in some cases in the local scope if you do a star-import within the local scope (yeah…)

I don't consider that working, it's a piling up of hacks. Which is great when you need them and they work, but...

Also, there's a simpler way to implement your snippet:

globals().__setitem__('spam','eggs')
I learned python first, and I have the same complaint about ruby. When I was attempting to learn ruby, the subtle differences between blocks, procs, and proc.news, or whatever they are, seemed arbitrary and required too much thought to understand for my taste. In my brief exposure to ruby, that was symptomatic of a general trend in the language that there seemed to be many ways to accomplish a task, without a clear reason for the distinction. That's fine if you're writing code, but imo that's a feature that makes reading a language more difficult.
Clojure also lacks deal breakers. Python was my least hated language until Clojure.
Hm, I posted it so I would get redirected to the HN disucussion on this. Did no-one post it already? I actually accidentally wrote "Kevin Smith" at first, haha.
Related: https://www.coursera.org/course/neuralnets starting on 24 September 2012.

Does anyone here will do this class?

I'm currently doing the ML class, so I'm not sure.
Yeah most likely. Maybe sunglasses as well as prescription frames?
Agreed! I'm also a pianist, but because I started young, I was lucky that my parents and teacher forced to me practice technique all the time. You should check out the Liszt exercises, they will make you strong and fast: http://books.google.com/books/about/Liszt_Technical_Exercise...

With coding, there was no such outside pressure, so until I joined Yipit, I had tons of bad, hacky habits. In order to get to the next level, I had to rebuild from the ground up and learn the fundamentals really well.
> When I want OOP, I play with Smalltalk. Or Self.

I'm reasonably sure there was an implicit "and be productive" in there. Smalltalk and Self are neat, but they don't do well on the get shit done test.

(Yes, I know it is possible to get shit done in those. Compare the difficulty of getting-shit-done in them to an environment like Java or C#, and an unbiased source is going to have to admit they fail pretty hard if only because of stuff like Maven or, to a lesser extent, NuGet.)
GPG is well-vetted. The encryption here is GPG.
You only have to list self in the declaration, you don't have to pass the instance to itself.

Borrowing masklinn's example:

>>> class Foo(object):
... def __init__(self):
... self.n = 42
... def bar(self):
... return self.n
...
>>> f = Foo()
>>> f.bar()
42
You're missing his point. pass looks cool and is the 'right' way to do it from a unix perspective. However for the vast majority of people out there, 1password and others are much more usable because they can access them from their phones without using a terminal and automatically fill in passwords with their browser.

It sounds like pass has the potential to do these things as well, and I would prefer to use an open platform over a closed one, all things being equal. Just recognize that there are tradeoffs.
> When I was attempting to learn ruby, the subtle differences between blocks, procs, and proc.news, or whatever they are, seemed arbitrary

As well as blocks not being first-class objects. Especially knowing a smattering of Smalltalk, that still feels weird.
I think you are further along the path than the OP is. This has come up several times recently in various forms [1], basically analysis paralysis is a bad thing, it interferes with getting things done. Its quite reasonable to analyze things, and then to stop when the future benefit is small.

[1] http://www.hnsearch.com/search#request/all&q=analysis+pa...
It's sarcasm. njharman would have preferred mkdirs.
Well yeah. But (apparently?) the x-axis label only pertains to one of the lines (dotted), while the title pertains only to the other line (solid), but inaccurately! Hence the confusion, and the question: Can you tell me which of the the interpretations I suggested for the solid line, which may have an inaccurate title and no x axis label, is correct?
The "Occupy Mars" t-shirt is awesome! :D
My least favourite part of python (I'm overwhelmingly a fan, and it's probably my favourite language after Clojure) is the deliberately limited functional parts. Take list comprehensions, they work for simple things, but when you want to make it more complex, it wont let you break it over multiple lines, so you have to rewrite it into a for loop. Makes debugging awkward.
I think part of the problem comes from them being so close syntactically and semantically, it puts the second one you learn in the uncanny valley, just close enough that your brain tries to reuse previous knowledge, just far enough that it can't and you get frustrated. I think that's especially the case if you don't have many languages under your belt.

When going from Python to Haskell, or Ruby to Erlang, you can't get confused between the two.
It does take a while to build understanding. Maybe the reason many people's understanding is so "fragile", as Feynman observed (http://books.google.com/books?id=7papZR4oVssC&lpg=PP1...), is because they don't spend enough time building it and so they only have surface-level understanding.

But once you get over the initial hump in whatever area you are digging in to, once you've explored it from every angle, you'll be able to move faster and make better decisions.

Rich Hickey spent a year researching and building his understanding before writing Clojure, and another before Datomic. This practice would seem to go against the lean startup methodology, but maybe we shouldn't be starting a startup until we have done this for the technologies we are using.
map and filter still exist. reduce was demoted into the stdlib instead of being builtin in 3.x.

list comprehensions generalize to other types (generator expressions (aka "lazy sequences"), set comprehensions, dict compresions)

Compare this syntax (using dict comprehensions in 2.7):

{k:v for k, v in something.iteritems() if v == 3}

to this syntax using map/filter:

dict(filter(None,
filter(lambda x: x if x[1] == 3 else None,
something.iteritems()))

More frustrating to me is that there isn't an imap/ifilter builtin (I understand that it's in stdlib, I'm just lazy).
or `mkdir(p=True)`, maybe
It may be the case that Red was created for the reason you state, but it simply doesn't appear to have the necessary momentum. And that's unfortunate, because REBOL does not have a lot of interesting and smart features, such as having mini-DSLs ("dialects") for things like GUIs.

To date, Red can't even run without already having REBOL installed on your system. The project has been around for almost two years now, and only a few days ago has it successfully been able to do the program "print 1".
> it wont let you break it over multiple lines

?

result = [
(value, process(value), process(key, value))
for key in generator
for value in generate(key)
if some_condition(key)
if other_condition(value)
]

or did you mean something completely different? Maybe the problem of not being able to use statements in comprehensions (or lambdas)?
What's right with smalltalk and self that's wrong with c# and java? This is a serious question asked out of a desire to learn the answer.
Loved the youtube clip
Thanks for putting up the email subscriptions
I had a PDA with a similar strong arm CPU, it was dog slow for complex pages with opera. Of cause I can't rule out the os as the culprit.
I wrote something like this a couple years ago[1]. I also attempted to support ball-to-ball collisions. I rarely do any graphics type programming so this was a fun diversion.

However, the simulation would slow down considerably after adding a few dozen balls. This was largely due to the quadratic nature of my naive collision detection. In order to remedy the speed problems I implemented[2] a quadtree I found online to assist me in culling a lot of my expensive collision checks. The bounds of the quadtree sections will appear as you begin to add balls.

Unfortunately the quadtree wasn't the performance savior I expected it to be. I didn't notice a dramatic improvement in the number of balls I could support. I also introduced a bug with the quadtree version where certain collisions are missed entirely.

Perhaps I should revisit this simulation and see where I was off.

[1] - http://jsfiddle.net/simucal/RvA9w/33/

[2] - http://jsfiddle.net/simucal/RvA9w/
This was figured not by Hebrews (ancient Israelites), but by ancient Egyptians.

Cysticercosis was endemic in ancient Egypt. Pork was a
staple food for common people in Egypt, but priests had strict dietary laws and they knew that Cysticercosis caused by tapeworms from swine.

Ancient Israelites just adopted a lot of customs from Egyptian Priestly caste, like circumcision, calendar and dietary laws. Not surprising, considering Moses was raised as Egyptian.
When I read about geeky law, the first thing come to my mind is "Moore's Law".
Just a side note for people like me: CYA is cover your ass.
3 of the 4 are good.

The last is not. Reed's law is a extremely optimistic version of Metcalfe's law which gives clearly nonsensical results. And Metcalfe's law in turn seems to be overly optimistic. See http://spectrum.ieee.org/computing/networks/metcalfes-law-is... for evidence that the real scaling law tends to be more like n log(n). (See http://www.dtc.umn.edu/~odlyzko/doc/metcalfe.pdf for several other lines of argument leading to the same result.)

Note that when I say "tends to be" I mean that, depending on the details of a social network, the scaling law can differ. In particular a network that relies on relative strangers having interactions with other relative strangers, as happens with eBay and Airbnb, is going to scale much closer to Metcalfe's Law. By contrast one that depends on developing a circle of friends, such as happens with Facebook, the scaling law will be closer to n log(n).

Disclaimer, I have a bias here since I'm one of the co-authors of the n log(n) law. (Andrew Odlyzko did all of the work. And then we found out that Bob Briscoe had independently arrived at the same conclusion based on data that he had access to at British Telecom.)
O/R modelling interlude: PostgreSQL vs MySQL
Although you can also (and that can be rather neat when e.g. mapping or filtering) use the method as a function, if you get it from the class:

f = Foo()
Foo.bar(f)

note that it will typecheck the first argument to ensure it's an instance of `Foo`, it's not a function, it's an unbound method:

>>> class Bar(object): pass
...
>>> b = Bar()
>>> b.n = 66
>>> Foo.bar(b)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method bar() must be called with Foo instance as first argument (got Bar instance instead)
I've been heavily involved with python and javascript for most of my programming life and find them to be very similar. It's a joy to write in either language.
Wait, you password directory is stored unencrypted. Not the way to go.
BASTARDS | The Hacker News - Security Blog
I'd like to think/hope that no one would ever judge a language on it's FTP library =)
To elaborate on masklinn's answer, you need to add the @classmethod decorator to get a class method instead of an instance method.
You can use it to make websites, do scientific computing, NLP, email processing, datamining, big data, etc. If you're just trying to throw up a website then Ruby or Javascript are fine, but if your backend involves lots of different types of computing then Python is pretty much your only option. So if you have an idea for a minimum viable product but you don't really know where you want to take it two or three years down the road, then it really just seems like the most pragmatic option.
Well in my case foo = Foo(); print foo.bar will print 1, so it does 'kinda' work as a default value. And that's ok, I just remembered there to be some case where it didn't behave the way I expected it to (e.g. instance member assignment overriding the content of another instance), but I wasn't able to reproduce it right now.
I realize I'm pretty late to the game on commenting here. I don't comment often. I've been on HN for 1558 days and have a karma score of 7. But here are my thoughts.

I use reddit for entertainment purposes (for the most part) and I use HN for educational and inspirational purposes. That was why I started using HN and it is still why I do.

Sure, as the community has grown, there have been more comments that add no value - but they are just more obvious now. It isn't that hard to ignore them and to find the meaningful or useful comments.

On the surface the "cost karma to post" idea sounds great - it certainly wouldn't have much effect on me - but I agree with the various others who think it would discourage unpopular but still very useful and (at times very correct) comments.

If the price to pay to get a well rounded discussion is the presence of vapid commentary - then I'm willing to continue to pay it.
Just define a nested function above and call it in the list comprehension.
https://developer.mozilla.org/en-US/demos/detail/bananabread - seems to be quite performant for a javascript 3d fps.
Right, I meant using statements, sorry. It's been quite a few months since I wrote python, so I think I've forgotten most of the details.
There's no need for a super class to have a len() method. I don't get your reasoning here, Python is not a statically typed language.
Same problem - I have to rewrite my lovely list comprehension instead of just adding a statement to the body.
Indenting with spaces is like carving your own girlfriend out of a block of pine. And insisting that everybody else make out with her.
> If Carl had the presence of mind back in 1998 and open sourced enough of the Rebol eco system to be useful for web platform development, then /index.r rather than /index.php might have been one of the most popular default documents in the world.

Not only that, the price point is incredibly high at $249.00. I say this as a person who actually has a REBOL/Pro license. It was never clear to me what the business model for this product was, especially since the free version of REBOL was often more up-to-date and feature-complete than the paid product.
The irony of your crushingly ignorant post nearly killed me.
Red was announced and started last year in March. It's basically 2 languages and until last month development was going towards compiled low-level dialect Red/System. I was actually impressed by speed of things moving in Red/System and many members of small REBOL community contributed to it. (It had GTK bindings, ZMQ, port to android, while it was still in development).

The announcement this week about "print 1" is about the fact that now the "Red" (higher, rebol-like level) language is also at the brink of working.
I didn't say it had passed, I said it was competitive... there may be some edge case scenarios where medium format film is still justifiable.

But when you factor in the convenience and availability of products like the D800, 5D3 and 1Dx, and combine that with the cost and quality of compatible glass, medium format starts to look like a marginal call indeed.

(Bear in mind, medium format DIGITAL is another thing altogether. That stuff kicks the pants off any of the pathetic baby toys made by Canon and Nikon.)
Lower syntactic and semantic overhead, pretty much all of the language semantics are built from two properties/behaviors (and hooks into the interpreter): blocks and sending messages.

Sending messages are method calls, the difference is mostly contextual. Blocks are first-class functions with closures and nonlocal returns. That part's important when you're trying to implement e.g. loops (otherwise you have to add flags or throw exceptions, as in Javascript).

In Smalltalk, iteration is a message and a block:

aCollection do: [item|
"process item"
]

but that's not exactly rare these days. On the other hand, a conditional is a message and two blocks:

aBoolean ifTrue: [ "code if true" ] ifFalse: [ "code if false" ]

A repeat loop is a message to a block on a block:

[ "dynamic condition" ] whileTrue: [ "repeat while true" ]

and so's a try/finally:

[ "a piece of code which may blow up" ] ensure: [
"error recovery code" ]

or a try/catch:

[ "a piece of code which may blow up]
on: SomeError
do: [ :sig| "error handling" ]

What this means is that there are very few special cases in the language, and the user of the language has the same power of expression as the designer of the language (much as in Lisps or Forths), the only limit is the hooks into the runtime but that's about it.

Also, message cascading is a minor but way cool (and pretty much unique) feature of Smalltalk, it lets you have your cake (return interesting values from methods) and eat it too (chain calls):

someObject
aMessage
; anOtherMessage
; yetAnOther
; andOneMore

will send all 4 messages to the same `someObject` no matter what the previous message returns.

That tells you what the language's priorities are.
Moore's law as commonly understood (single-threaded computing power doubles every X amount of time) is already false.

Moore's law as originally stated (number of transistors per chip doubles every X amount of time) is probably only true for a short while longer.
> Well in my case foo = Foo(); print foo.bar will print 1

Of course it will, Python's attribute-resolution (as do most languages) tries the instance, then the class, then the superclass, then... why wouldn't it work?

> I just remembered there to be some case where it didn't behave the way I expected it to (e.g. instance member assignment overriding the content of another instance)

Only two way I see for that to happen:

1. Re-setting the member on the class itself, not the instance

2. Or having the member be mutable and mutating it, since it's set on the class it's shared by all instances.
"It's far from the metal"? No it isn't. It has ctypes, which is one of the best FFIs I've worked with. I wrote a trampoline-injecting kernel debugger in it. I don't love Python, but that answer disqualifies itself.
A Note on Convertible Debt
It's not 'just' the work of Photoshop tho. There is a link to ones closer to the original in this discussion thread, and those are still extremely impressive.

All in all, I stand by my statement. These are accurate depictions of the color at that time, and as ludicrous as it seems - my brain is blown away that there was so much color. I know obviously there was - but years and years of my visual representation of that time period tries to tell me differently.
Agreed. I would be interested to hear thoughts on this as well. As an example, if Coca-Cola uploaded its secret formula to a Dropbox, the damages resulting from a data breach would seem to be immeasurable. But I'm sure Dropbox's TOS limits damages to cost of the service (no extraordinary, consequential, etc.) Is this amount what's at issue here, or is there something I'm missing?