skysight-inc/HackerNews huggingface dataset:
According to these guys, everything complex is harmful and everything simple is great. I want to start learning Assembly to finally understand the whys of programming on a hardware level. Is Assembly harmful? Any simpler and thus better alts? Or is Assembly a simpler version of some other ugly, threatening monster? Oh, btw, where's the best place to learn it?
There is no scientific proof Hep C can be sexually transmitted, many studies have concluded [0]. It's a little concerning the author of the article, an OB/GYN doctor, is asserting otherwise.

My British education, from the 90's, taught me the risks of HSV and HPV transmission occurring despite barrier methods (condoms). I'm assuming seeing as this is being voted up that this isn't something taught in America?

[0] http://www.ncbi.nlm.nih.gov/pubmed/15128350
> then let the lunatic fringe on their side do what comes naturally to them.

Sure. It's not explicitly about donors, but the fringe have no problems taking advantage of things like this.

http://host.madison.com/news/local/writers/steven_elbow/wisc...

Long story short, the Scott Walker recall petition was public, and people were targeted if they signed it. There's a good piece on NPR's This American Life about it.

http://www.thisamericanlife.org/radio-archives/episode/509/i...
"With its hotel, offices, restaurants, apartments and observation deck, it is also an all-in-one mixed-use development, built on a busy transit hub. The point is that something better was possible in Lower Manhattan."

What, exactly? Sure, it came in well above budget and five years late -- but it works just fine in conjunction with the plaza in front of it.

All they need to do now is get the passageway under West street connected to the Fulton Transit Center.
What does 'faster with OO' mean? Is there some implementation detail that is tied to, or heavily associated with, OO?
"... a computer model should be structured along three dimensions: data, functionality and events":

https://news.ycombinator.com/item?id=475241
The spire is especially galling. How much money did it save? 0.5% of the total cost?
Earth Is Being Protected by Invisible Space Shield from ‘Killer Electrons’
I am definitely going to use embedded SQLite in some of future prototypes. The only problem is that SQLite doesn't, to my knowledge, support all of the features I'd like Julia to support -- including columns that contain arrays, dictionaries and even complete tables. But, that said, it supports >90% of the features I'd be interested in.
> I guess I could be happy in a language that just has structs and functions, and some help in form of pattern matching, multimethods and so on.

So pretty much Rust you mean?
Stating that object orientation doesn't help customers isn't the same as proving it, or even arguing it. How has imperative, or any other kind of programming, helped my customers?
This looks like a feature that LnkedIn could incorporate if it ends up being useful. From the candidate's standpoint it's a lot of duplicative work because much of this info is already on LI.

Also, for the tech industry, isn't it always assumed that a tech candidate is open to a better job whether or not it's obvious on the LI account. So I don't know how useful it is to keep your own employer from looking. If your employer believes that at any given time 80% of its workforce is vulnerable to turn over I think it would probably treat it's workforce better. Would Zynga have treated it's programmers better if it knew that many of them were ready to bolt?
How many people are actually living entirely off passive income from interest, dividends, and capital gains? I feel that goal—which requires millions of dollars in investable financial assets—is only realistic for a tiny percentage of the population.
What other way do you help the end users in your language design other than making the language easier to make good products with? Nothing you said makes any sense.
My pet peeve is how these brilliant architects end up writing so much code that does nothing. These 1 line functions just end up calling another 1 line function. At some point someone actually has to write the code. You know, that thing that actually does the work.

I always figured OOP programmers actually hate coding because they try so hard to avoid actually writing code that does work.
He taught me how to deploy Rails apps, and with his help I figured out what I needed to get a production environment running on Windows. Then he asked me to contribute what I know to https://pragprog.com/book/fr_deploy/deploying-rails-applicat... (out of print now).

He's one of three people responsible for turning my career completely around back in 2005. He always paid it forward, and I have always done that myself since.

He was amazing. Honestly, we need more of that and less "you're doing it wrong."
Switzerland has had a fraught relationship with immigration in recent years, check out these jaw-dropping election posters:

http://img.dailymail.co.uk/i/pix/2007/09_01/SwissSheepL_468x...

http://www.theepochtimes.com/n2/images/stories/large/2009/02...

In 2009, they passed a referrendum to ban the construction of new mosques with minarets, accompanied by even scarier posters:

https://www.ithaca.edu/depts/i/SVP,_Stop._Consider_a_Minaret...

So to an outsider, this result is a pleasant surprise.
I feel that OO imposes some semblance of structure using an intuitive semantics most "average" developers can grok (Not crazy stuff like Monads) , thereby allowing Pointy Haired Bosses to treat devs as commodities to be replaced at will.

Java is a language right at the sweet spot on that continuum. Just advanced enough to prevent most stupid bugs but also mediocre enough that most devs can grok it.

In the words of one of its creators :

"We managed to drag them half way to Lisp"

And how would you program an enterprise Java App without object orientation ?
OOP and FP are not in opposition to each other. FP considers objects to be at different granularity than your typical OO language does. So the real problem stems from the fixed granularity of the objectionable (heh) of typical OO languages leads to mutable state, which leads to unnecessary complexity.

In the end, typical OO leads to type systems which lead to noun discrimination which are ontologies, which reflect world-views. You don't want to get any of that on you. The more successful type systems stop at grouping aggregatable functions. Look at Go. Or Clojure. Those type systems are as good as it gets to me but I've never written a line of Smalltalk or Haskel, so someone set me straight on that.
I think you'd be quite happy in Rust, if you substitute trait methods for multimethods too.
I know the facts, but the statement makes it look like we should just relax and embrace it "Oh, you know, the stats say you are gonna get it anyway", not in my experience.
Elizabeth Lauten's Website Hacked, or GoDaddy Fail?
And because of the friendship paradox, your partner probably is.
What's the advantage of a ton of wealthy people moving away from Geneva?
OrderFlowFx Its like taking money from a Bank
NASA to Launch First Orion Spaceship Test Flight This Week
I'm somewhat surprised that this is not common knowledge in the US. I think if you're in the medical field it's common knowledge, but not among non-medical people.

The explanation is simple, herpes and hpv can exist on skin not covered by a condom, thus it can still be transmitted.
Infix notation in Haskell is close, except that most of the time if verb syntax is convenient you're expecting side-effects.
>To understand what just one overloaded method call does, I have to often read through a dozen of different files. Context sensitive IDEs don't make it much easier. Simply grepping files at command line is often the fastest way!

Right click -> Find all references / go to definition don't do that faster than typing out the grep command?

You said mutable state makes it harder to understand, and you said exceptions make it harder to understand because they're hidden gotos (which if statements and while loops are too), but didn't explain either. In my experience, exceptions have been a very simple, helpful, intuitive component of control flow.
Yep along with Spigot, as mentioned by _jomo, there's also a new project called Sponge that is replacing CraftBukkit from the ground up, building on top of Minecraft Forge (a modloader) rather then as a standalone mod like CraftBukkit/Spigot. Its still in pre-alpha though, and there are a LOT of things unimplemented, compared to Spigot which is a fork of Bukkit.

Another popular option is Glowstone, which is an open source implementation of the entire minecraft server, rather then a mod. Glowstone already supports plugins written for the Bukkit API (separate from the CraftBukkit implementation that got DMCA'd) and there are plans to support the Sponge API when its more mature. I can't speak to its stability/completeness though. It looks like there isn't any redstone or physics yet? That shouldn't be a huge deal for most creative servers, but YMMV.
It's a bit buried in the article, but I think that's one of his main points:

>Stripped of prospective cultural institutions, as well as of street life and housing, the plan soon turned into something akin to an old-school office park, destined to die at night — the last thing a young generation of New Yorkers wanted.

America has something of an obsession with single-use areas. Everyone lives in one zone. Commerce goes on in a different zone. Industry somewhere else. It's a big contributing factor in why a lot of places have ended up as dangerous wastelands at night; no one lives there, no one shops there, no shopkeepers keeping an eye on the street, no one out walking the dog or going out for coffee.

So when a new landmark building goes up on a piece of valuable real estate in Manhattan, it's a bit disappointing that the conversation ended up along the lines of "You know what'd be nice here?" "What, a coffee shop and a neighborhood grocery store?" "Nah, a giant bunker."

Not to say it's the worst thing ever, but we could have done so much better.
I love the banana analogy :).

“The problem with object-oriented languages is they’ve got all this implicit environment that they carry around with them. You wanted a banana but what you got was a gorilla holding the banana and the entire jungle.” – Joe Armstrong
Why? Because in Switzerland almost all you need is 100'000 signatures and we have to vote. And this is the response from the voters. I know no one who even remotely considered voting yes.

We have a lot "emotionally votings" recently and it really starts to annoy me. I don't like how this anti everything is starting to grow.

edit: of course it's 100'000 and not 50'000, thank you thallian
Video Game Reviewer Is Contacting the Mothers of Her Online Harassers
Developers are users. In fact you should consider your first user as the developer, since systems are still being written by humans. That said, you're right, object-orientation does not serve the humans. Neither does the semi-colon. Or the for loop. Or ...
It's only slightly oversimplifying to say that OO was invented for a GUI, namely Ivan Sutherland's Sketchpad in the early '60s, and then developed with direct correspondence to physical objects in mind (Simula 67)

- http://en.wikipedia.org/wiki/Sketchpad

- https://www.youtube.com/watch?v=USyoT_Ha_bA

- http://en.wikipedia.org/wiki/Simula

- The Development of the Simula Languages in HOPL I if you can get it, else http://phobos.ramapo.edu/~ldant/datascope/simula%20history.p...
Largely overlooked is that unprotected oral sex isn't really safe:
http://en.wikipedia.org/wiki/Sexually_transmitted_disease#Tr...
One of the co-founders replied within three hours on a Sunday to this inquiry with a notification that a code-change has been pushed such that this issue can't happen again.

I am impressed.
Ideally, unless your customers are other devs, OO has nothing to do with your customers.
What makes you think your partners would tell you if they were promiscuous?
Ah, that's a very succinct reason. Because my needs are somewhat ordinary, I often forget about the notion that columns might be anything other than vectors containing single values. I wonder if some of the more complex datatypes could be added to SQLite in the same sort of way that Spatialite has added geospatial geometries as column types. In fact, I wonder if some of those geospatial types might be abused to push past the 90% use case barrier.

Hmm... Now I'm wondering what level of extension to SQLite would be required to create a shared library that could be plugged in to any of the various languages that need dataframe functionality. DataLite?
It was an initiative motivated by FUD and protectionism.
You should be using pre tax numbers for expenses.
OOP has the same relationship to programming that formalist literary critique does to writing: the willful denial of connection to reality. When you're solving a problem that's connected to the real world--perhaps you have a deadline, or a live human being will use your program at some point--it's often better to just go ahead and build something that works and can be easily explained to the person who will maintain it in the future.

As with formalism you should know how OOP works and how seriously others take it, so you don't get into fights with your relatives at Thanskgiving.
Java is arguably not an OOP language. It's a class-oriented language. It became OO only since 1.8 JDK.
He means pattern matching functions, which are idiomatic in Erlang but "dirty" in Haskell (where you would want to solve it better with a type class, or something else more general).

Erlang

myfun({duck, "My Duck's Name"}) ->
dosomething;
myfun({dog, "My Dog's Name"}) ->
dosomething;
myfun({cat, "My Cat's Name"}) ->
dosomething.

Erlang also has arity matching (this function is different than the one above it):

myfun({cat, "My Cat's Name"}, cage) ->
dosomething.

Case statements are one way of doing that but those are considered a messy style in Erlang because they end up nesting so deeply - keeping it all out in small little functions and using pattern and arity matching is the "right" way.

You can do the same (except for arity matching) in Haskell with function arg pattern matching and Haskell also has some very nice projection tools for it too:

Haskell

newtype Name = Name { unwrapName :: String }
data Animal = Cat | Dog | Duck deriving (Eq, Show, Ord)

myfun :: Maybe Animal -> Name -> String
myfun (Just a) (unwrapName -> name) = (show a) ++ "'s name is: " ++ name
myfun Nothing _ = "No animal given!"

> let n = Name "Fido"
> myfun (Maybe Cat) n
> "Cat's name is: Fido"
>
> myfun Nothing n
> "No animal given!"

There are many problems with that function and I could probably eliminate the multiple function clauses and reduce it to one clause by getting rid of the pattern matching and using the maybe function:

myfun :: Maybe Animal -> Name -> String
myfun a (unwrapName -> n) = maybe default formatAnimal a
where
default = "No animal given!"
formatAnimal t = printf "%s's name is: %s" (show t) n

That would be the more idiomatic way I would do it - pattern matching isn't "bad" in Haskell and you'll see it used quite often in utilities and libraries. It's considered good form to move stuff like that into a utility and give it a clear name (like the maybe function above that takes our formatAnimal function) then use that in your application code so it becomes obvious what's going on.

Pattern matching, deeply nested ifs and cases, etc... are somewhat hard to parse for the eye.
Congratulations, you just discovered the great RISC vs CISC debate.
Exactly.

As in any situation, to understand what someone is saying, you have to know who they are talking to.

People who hate OO always refer to overly bloated systems that treat OO as a philosophical foundation, something to be religiously adhered to. I'm sure those systems exist and I'm sure that they're horrible. But, y'know, it's just awfully nice to have an easy way to define structures and functions that operate on them, and the ability to use some structures interchangeably with other, related ones.

Objects or Haskell-like records, I'm happy with either. I like multiple inheritance but mixins are pretty neat too. Encapsulation is a good thing, but I could probably learn to live with any kind of decent modularity and separation of concerns. Et cetera.
I think you mean Zurich, not Geneva, see http://www.swissinfo.ch/eng/cantons-weigh-up-value-of-lump-s...
It's 100'000 signatures in 18 months for a federal popular initiative.
And I am really glad this one did not make it.
I would consider myself lucky that someone with the word 'architect' in their job title on my team wrote code that did nothing. Careful what you wish for.
I agree. My bet is that modern communications media make things easier than before.
Can you give an example where what I provided was incorrect?

- Car payments are the same

- Gas is the same

- Insurance is the same

- Vehicle wear and tear is the same

I'm sure I made a mistake somewhere or overlooked something...
Better parking !
I have seen architecture skyscrapers in Assembly, Clipper, C, C++, you name it.

It is something that is part of enterprise culture, it has nothing to do with programming languages.
You need a Segway to get around down there. Want a cup of coffee? Just a 10 minute elevator ride and 4 blocks walking to get to only shop in the building. Don't want Patisserie Financier? 4 more blocks, and you have to cross the west side highway.
> Right click -> Find all references doesn't do that faster than typing out the grep command?

Yes, IDE is not generally faster. Find all references is not faster for me in most real life scenarios. Typing grep command is just arrow up, ctrl-something to get the cursor to right position, type something, hit enter. Piped to less, I hit / to search within the results. Done right, results from grep appear pretty much instantly, no waiting. Some operating systems are much better for this technique than others, due to cost of dealing with small files.

> You said mutable state makes it harder to understand, and you said exceptions make it harder to understand because they're hidden gotos (which if statements and while loops are too), but didn't explain either. In my experience, exceptions have been a very simple, helpful, intuitive component of control flow.

Whenever you call some method (or overloaded operator), it can throw. The fact is completely hidden from the context in front of you in C++.

In Java, you do know what might throw, because you have to declare it. On the other hand, the cost is high when anything you call changes the exceptions it throws. Or more like, it's set in stone.
BLACK FRIDAY SHOPPERS
And first of all, learn (in general, not you) that OOP doesn't mean the same to all programming languages, before complaining about OOP in general.
Some way to save the file?
The article is well written but I'll pull out probably the most important stat: of the canton’s 201 former lump sum beneficiaries, 97 left, amounting to loss of CHF 12.2 million in cantonal tax receipts (avg CHF 126k per person).
Making complex things is easy
Your n=7 sample size is considerably smaller than pg's presumably n>=700. Be careful drawing conclusions from such a limited subset.
A Different Eulogy for RadioShack
Gas beats the energy of density of batteries by a huge margin. That alone is reason to continue work on traditional combustion engines and/or hybrid cars.
To echo what I said in the post, I think using Nullable as the representation of missing values is the right strategy. I think it achieves sufficiently strong performance while also providing a lot of other desirable features.

As for other things that we've done well, I think the Distributions package is one of the best designed interfaces to probability distributions I've ever seen in any programming language. I don't know if Go supports value types, but the existence of value types in Julia allows each distribution to have its own distinct type without having to pay any cost for maintaining object identity. When combined with Julia's ability to do multiple dispatch, the Distributions package allows one to encode analytic knowledge about probability distributions directly into the type system. And existence of parametric types lets you talk about things like location-scale families in a natural way.

I'd also encourage you to look at the optimization libraries that have been built for Julia. The language makes it easy to do automatic differentiation, which is probably the most under-utilized tool in all of scientific computing. In general, I think there's really high quality work being done on optimization -- which I see as essential for enabling ad hoc statistical modeling.
Discover Flask – Test Coverage with Coverage.py
I assume there are real inertia issues with moving, probably where with step functions at certain levels of wealth.

Moving at all has inertia, moving to a new city in the same country has a lot more but I suspect moving internationally has the greatest. And the Swiss are a rarity in that they are one of few countries where native speakers can go to nearby countries and still be (mostly) understood.

So it's worth discounting the "if we raise taxes they will all leave" theory for my money
Agreed. What I see as the core principles of OO (ad-hoc polymorphic dispatch and abstract data types) are present, useful and important in the FP world too. OO helped to bring attention to these ideas even if it didn't capture them in their purest and most general form. So I think we should be careful not the throw the baby out with the bathwater when criticising OO.

> Pattern matching in functional languages solves this [polymorphic dispatch] in a different way.

Pattern-matching doesn't give you late binding / ad-hoc polymorphism though, so while it's useful to replace static if statements or case statements, it's not a full replacement for OO's polymorphic dispatch. For that you need things like typeclasses in Haskell or multimethods in lisps.

Wadler's famous expression problem is quite relevant here:
http://homepages.inf.ed.ac.uk/wadler/papers/expression/expre...
ROI Survey
Generally what we're talking about is the ability to say something like "for all types X which satisfy a predicate P, we have this code". The ability to quantify over "all" types is a key property of dependently typed languages. Likewise, a lot of Haskell's ability to simulate DT languages comes from its ability to reason about HKTs.

In a DT language you have something called a Pi type which is a bit like a function type. An example would be to compare the types of two functions which, essentially, determine whether two integers are coprime

coprime1 : Int -> Int -> Bool
coprime2 : (a : Int) -> (b : Int) -> Maybe (IsCoPrime a b)

The important part is to look past the syntax and note that IsCoPrime is a type which depends upon the values of the first two arguments. Another way of reading this is as follows

coprime3 : forall (a b : Int), Maybe (IsCoPrime a b)

this emphasizes that the type of `coprime3` is quantifying over all values in Int.

Then we can take this idea to the higher-kinded level by looking at the type of, say, monoids

monoid : forall (A : Type),
{ zero : A
, plus : A -> A -> A
, leftId : forall (a : A), plus zero a = a
, rightId : forall (a : A), plus a zero = a
, assoc : forall (a b c : A) , plus a (plus b c) =
plus (plus a b) c
}

Here we can see that the `forall` notation lets us freely abstract over "all types" just like we previously abstracted over "all values". This continues to work at every level. For instance, we can note that `monoid` above is "a type of types" or maybe a "specification" and we can abstract over all "all specifications" as well

specProperty : forall (S : Type -> Type), P S
That comment. It made my day. It's one of the finest comment on HN
You make a good point in a society where you can dictate to everyone what they buy.
My question for these sorts of lawsuits is relatively simple. Given that companies can spend money on these lawsuits, or on increasing convenient and cheap ways to get content to people. I'm curious which is a better return, dollar for dollar?