HomeLog InSource

notes.public

[View] [Short] [Hash] [Raw]

2014-09-16

hash://sha256/073f3deda89d46cf954ca8ccfd69174b40304e2b0b0515f999bca89d05452ddf[#]

https://news.ycombinator.com/item?id=8316809
zaphar

I’m sorry you got the impression of that there is a strong bias against admitting problems. I haven’t seen that bias at all myself.

lol.

Keywords: humor, self-awareness, arguing

https://news.ycombinator.com/item?id=8316678
enneff

What I dislike worst is the denial of the Go community and creators, claiming that generics are too complex and that you don’t really need them.

That’s not the claim. The claim is that generics add complexity to the language and its ecosystem. That, I’d hope, should be an undisputed claim.

Go’s lack of generics is a design tradeoff. The occasional piece of awkward code is worth the overall reduction of complexity at an environmental level.

That sounds like what the claim was claimed to be…

Keywords: Golang

I don’t even use C++ and I’ve never used generics but this thread is really selling them to me.

https://news.ycombinator.com/item?id=8317816
nknighthb

Like PostgreSQL and OpenBSD, I’ve been permanently turned off Rust because I never want to be left at the mercy of a community that invests so much time in harassing and insulting others.

I stand back from the flamewars but Postgres and OpenBSD seem like very solid, high quality projects to me. In fact, this improved my opinion of Rust a bit, lol.

https://news.ycombinator.com/item?id=8318039
voyou

It’s almost like someone read Paul Graham’s “blub” essay[1] and thought, “what would it mean to take seriously the idea that blub is the best language?”

Everyone knows that building abstractions has a cost - the cost of building the abstractions themselves, the cost of figuring out the particular abstractions employed in a given project, and the cost of comprehending a language flexible enough to support these abstractions. The hope is that the cost of abstraction is an investment: the time you put in will be rewarded in faster development when you put the abstractions to use. But at some point increased abstraction is going to give diminishing returns.

I think this is true too. “A language without abstraction” isn’t a slight against C.

C maxes[#] the optimizing compiler. C++ maxes the language (or the developer, depending on how you think about it). Maybe this is what abstraction actually looks like: finding new places to extract gains from. Haskell and Java try too, although they aren’t very successful in my book.

Golang maxes… conventions? That’s why the compiler errors if you have an include you don’t need, and (apparently) doesn’t encourage abstraction. Or you could just say it maxes language simplicity, which explains garbage collection too.

It doesn’t seem to be working. Maxing simplicity means that a lot of people won’t even be happy. It’s the whole “everyone needs a different 5% of the features in Microsoft Word.” And Word is probably more popular than Notepad even amongst laymen.

Not a bad analogy AFAICT.

And for all that simplicity you don’t actually get much to show for it. A fast compiler (although supposedly D’s is just as fast). Not sure what else.

Where are the next set of gains going to come from?

I’m ready to say “nowhere” (or “somewhere besides programming languages”) because of finite depth and diminishing returns. C++ will gradually be cleaned up, C will gradually get slightly faster, and that’s about it.

Basically, JITs briefly revived interest in programming language design (I’m aware Go is compiled, but it rode the wave), but in the end they didn’t pan out.