Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Why OO Sucks by Joe Armstrong (2000)

cs.otago.ac.nz

Post reply on HN
Print view View original

361–370 of 396 posts

Re: Why OO Sucks by Joe Armstrong (2000)

#361

Post by hota_mazi »

jhomedall wrote: post #360
hota_mazi wrote: post #345

Earlier quoted context omitted.

It's a language that's aimed more at research, producing papers for conferences, and financing the EPFL and its PhD students than at users in the real world. There's absolutely nothing wrong with that, by the way, I love studying all the advanced concepts that Scala has pioneered over the years. But it's also the reason why it's largely in decline and why Kotlin has taken the industrial world by storm: because it is…

I've used Scala in production environments, and we never had any problems with it being too academic. SBT sucks, but that's another issue. Kotlin doesn't have typeclasses (something you get as a side effect of Scala implicits), ADTs, or true pattern matching (along with exhaustivity checks). In combination, all of those allow for expressive, easy-to-read code that, in my experience, tends to have few bugs. Kotlin is…

A step backward to you is a step forward in pragmatism for the rest of the world.

I understand the value of higher kinds and I'm comfortable with Haskell, but it's pretty obvious to me why Kotlin is succeeding where Scala failed.

Sometimes, improvements in programming languages are reached by having fewer features, but Scala is a kitchen sink that was always unable to turn down features, just because their implementation would lead to more research papers to submit to conferences.

As a result, we ended up with a monster language that contains every single feature even invented under the sun.

Re: Why OO Sucks by Joe Armstrong (2000)

#362

Post by bad_user »

foobar_ wrote: post #269
bad_user wrote: post #248

Earlier quoted context omitted.

C++'s vtable is also late binding, since you don't know which implementation you're calling until runtime. And there's no such thing as "extremely late binding". > In C++, for example, the only kind of late binding that you have is abstract classes and vtables. That's not true, you can always have a "send_message(string id)". Few people do it because you lose static type safety. And some languages, like C# and Scala,…

> That's not true, you can always have a "send_message(string id)". Few people do it because you lose static type safety. And some languages, like C# and Scala, have dynamic types that allows for the "method_missing" protocol and such features are very unpopular. That is the difference. If every class in C++ had only one method - send_message and each object is an independent thread, you will get how Erlang works. Th…

What? This has nothing to do with functional programming.

FP needs polymorphism too and as a matter of fact FP tends to be even more static.

In FP we have type classes, built via OOP in static OOP languages.

> Infact having just method you no longer need Polymorphism / Interfaces.

That’s false.

Re: Why OO Sucks by Joe Armstrong (2000)

#363

Post by overgard »

layoutIfNeeded wrote: post #328
overgard wrote: post #109

Earlier quoted context omitted.

> Binding data and functions together beats operating on global data visible to everything. One of the big wins of OOP is less exposed global data. ... These things are unrelated. Just write functions that don't operate on global exposed data? You know, like, function arguments.

>You know, like, function arguments. That's a good idea! Although... I wonder if you would get tired of passing around the same piece of data between such functions all the time? Here's a crazy idea: what if we pass the data implicitly to such functions? Like, we could pretend that the data was passed to the function as a hidden argument, and we could call this argument "self" or "this"! :O

Or! You could just pass in a data structure without methods! The problem with global variables is implicit dependencies, and with “this” or “self” you now have slightly scoped implicit dependencies. I say slightly because you still have to worry about base classes. It’s the same problem just more contained.

Re: Why OO Sucks by Joe Armstrong (2000)

#364

Post by foobar_ »

bad_user wrote: post #362
foobar_ wrote: post #269

Earlier quoted context omitted.

> That's not true, you can always have a "send_message(string id)". Few people do it because you lose static type safety. And some languages, like C# and Scala, have dynamic types that allows for the "method_missing" protocol and such features are very unpopular. That is the difference. If every class in C++ had only one method - send_message and each object is an independent thread, you will get how Erlang works. Th…

What? This has nothing to do with functional programming. FP needs polymorphism too and as a matter of fact FP tends to be even more static. In FP we have type classes, built via OOP in static OOP languages. > Infact having just method you no longer need Polymorphism / Interfaces. That’s false.

It's not. You can use multiple dispatch.

Re: Why OO Sucks by Joe Armstrong (2000)

#365

Post by patrec »

patrec wrote: post #175
Misdicorl wrote: post #128

Earlier quoted context omitted.

It's frustrating to read this thread and your comment kind of crystallized this for me so I'll respond to you. Using an array without having to (manually) calculate the size of the objects contained within is like the major triumph of OO. This is a getter that you almost certainly use constantly. Please try to consider your statements and potential counter factuals before spraying nonsense into the void

> Using an array without having to (manually) calculate the size of the objects contained within is like the major triumph of OO. I've used arrays in countless OO and non-OO programming languages, and I do not recall ever having to manually calculate the size of objects contained therein – what are you talking about? Only C requires crap like that, but precisely because it doesn't have first class arrays.

Downvoters, care to elaborate what you think is wrong with the above? Literally even fortran can do better than

   size_t len_a = sizeof(a)/sizeof(a[0]);
or

   my_pseudo_foo_array = (foo*) malloc(len * sizeof(foo));

Re: Why OO Sucks by Joe Armstrong (2000)

#366

Post by alankay »

DonaldPShimoda wrote: post #354
alankay wrote: post #344

Earlier quoted context omitted.

An interesting and unfortunately true commentary on the lack of civilized behavior using technology that actually required a fair amount of effort -- and civilized behavior -- to invent in the first place.

Yeah, it's definitely disappointing that we have to worry about things like that, but that's the nature of the beast I guess. I hope you don't take any offense at my skepticism! For what it's worth, I'm happy assuming you're the real deal because being a cynic all the time is no fun and I have no specific reason to believe otherwise at the moment; I just also wouldn't be surprised to discover it's fake haha. Also, I…

Merrill Engineering Building! I'm glad it is still around. Those long hallways were used as a "display" to unroll the many pages of Simula machine code listings down one corridor so that three grad students -- including me -- could crawl over it and coordinate to try to understand just what Simula might actually be (the documentation in Norwegian that had been transliterated into English was not understandable).

Re: Why OO Sucks by Joe Armstrong (2000)

#367

Post by Gibbon1 »

patrec wrote: post #365
patrec wrote: post #175

Earlier quoted context omitted.

> Using an array without having to (manually) calculate the size of the objects contained within is like the major triumph of OO. I've used arrays in countless OO and non-OO programming languages, and I do not recall ever having to manually calculate the size of objects contained therein – what are you talking about? Only C requires crap like that, but precisely because it doesn't have first class arrays.

Downvoters, care to elaborate what you think is wrong with the above? Literally even fortran can do better than size_t len_a = sizeof(a)/sizeof(a[0]); or my_pseudo_foo_array = (foo*) malloc(len * sizeof(foo));

You're not wrong. Even BASIC was better than this.

Re: Why OO Sucks by Joe Armstrong (2000)

#368

Post by tootie »

revvx wrote: post #178
tombert wrote: post #72

Earlier quoted context omitted.

Admittedly I'm somewhat of a FP fanboy, but I seriously cannot disagree with you more on this. Functional Programming (and Logic Programming) are better than other paradigms because, unlike Java (or C++, or C#...) there is an emphasis on correctness , and the people working on FP compilers (like Haskell and Idris) are utilizing mathematics to do this. No idea on your opinion on mathematics, but to me Math/Logic reign…

> I realize that I'm picking on Java, but Java is the biggest target when it comes with OOP as the industry understands it. I personally cannot stand having to create fifty files do to something like a database wrapper, and in Java that's effectively the only way to program. I had this experience once in a Rails shop. A simple database table mapped to a CRUD API endpoint would take from five to ten files. That amount…

Step 1 is to use a static analyzer. Enforce null checks and finals and such. I think cresting a lot of files only hurts up front but I will give up more keystrokes in favor of unequivocal stack traces any day. Also javadoc is the best.

Re: Why OO Sucks by Joe Armstrong (2000)

#369

Post by dragonwriter »

Misdicorl wrote: post #128
weberc2 wrote: post #95

Earlier quoted context omitted.

I don’t think I’ve ever seen a useful “Getter” abstraction...

It's frustrating to read this thread and your comment kind of crystallized this for me so I'll respond to you. Using an array without having to (manually) calculate the size of the objects contained within is like the major triumph of OO. This is a getter that you almost certainly use constantly. Please try to consider your statements and potential counter factuals before spraying nonsense into the void

> Using an array without having to (manually) calculate the size of the objects contained within is like the major triumph of OO.

Er, aside from C and ASM, few non-OO languages require that kind of manual effort. That's not a triumph of OO, it's a triumph of using just about any language that has an approach to memory management above the level of assembly.

Re: Why OO Sucks by Joe Armstrong (2000)

#370

Post by tombert »

blub wrote: post #350
tombert wrote: post #292

Earlier quoted context omitted.

>You'll notice that it's virtually unheard of to use any FP languages in critical software. Erlang powers around 40% of the world's phone networks; and if it's not mission-critical I'm not entirely sure what is. For that matter, Whatsapp is also written in Erlang and Jane Street does trading applications in OCaml. Without making a judgement on whether or not they should , both Whatsapp and Jane Street create very lar…

TLA+, SPARK, Frama-C, PROMELA, Astree, even plain C or C++ and a heavily safety-oriented process are used when correctness is important more than any of the FP languages you've mentioned. In fact, by mentioning Erlang and Ericsson, you exhausted the only case supporting your point. Maybe if you tried hard, you could come up with a couple more. Now let's do the same exercise for the languages and tools I enumerated an…

I don’t know anything about SPARK or FramaC, but TLA+ isn’t a programming language, and you can use it to model distributed functional apps just fine (I still do).

Even if the Erlang/Ericsson stuff is the “only case” (It’s not) I do not see how that makes my point less valid; Erlang was specifically design for systems that cannot fail. Telephones are just a good example of that.

Post reply on HN