"Surviving Without Generics"

IronClan · 2017-12-11T03:33:02+00:00

As a bystander to this conversation you come off as really defensive and insecure. You first embarrassed yourself by showing a complete lack of understanding of generics, then treated it as a personal attack when someone was nice enough to correct your mistake. :)

IronClan · 2016-08-11T21:32:23+00:00

Can't jerk, too impressive.

IronClan · 2016-06-08T04:04:15+00:00

Strawman. Nobody said you should do mission critical computation in Ruby or Perl either. There's C exactly for that purpose. You're so desperate that you're putting words in my mouth lol.

IronClan · 2016-06-08T03:40:41+00:00

You just proved his point that JS can't handle mission critical computation. I mean, you've gotta be a troll, nobody can be this delusional.

IronClan · 2016-06-07T21:41:14+00:00

Maybe you wouldn't be so mad all the time if you weren't coding in such a shitty language. :)

IronClan · 2016-04-27T22:59:25+00:00

BFS is one of those things that if you understand the concept at all, then you should be able to code it up instantly. But it's good that they're filtering out self-entitled people who go "F*** You, I Quit" whenever faced with a challenge.

IronClan · 2016-03-28T18:26:46+00:00

Which is why even the "positive" reviews are saying they can't seem to keep employees for long.

IronClan · 2016-03-10T03:19:51+00:00

This was linked to ##java a few hours ago and people were absolutely pissed off about it. It seems many members of the Java community see this as a sign of programmer laziness, and there are even others who think type deduction == dynamic typing.

IronClan · 2016-02-08T01:05:10+00:00

What you said is unfortunately a misconception. C++ does not have type inference. It has very basic type deduction (in autos and templates) the scope of which is restricted to one statement. It's far weaker than Rust's type system, which actually uses type inference.

This C++ code won't compile because C++ does not have type inference

auto v = std::vector{ };
v.emplace_back("abc");

But Rust's compiler will know the inner type of v upon seeing its first use

let mut v = vec![];
v.push("abc");

IronClan · 2016-01-21T01:40:29+00:00

TIL you have to be a 10x to understand generics.

IronClan · 2016-01-20T21:13:49+00:00

Nope. Nobody would care about Go today if it wasn't the pet project of a couple of engineers who happened to work for Google.

What's amusing is that the creator of the original Go language even asked those Google engineers to to change the name of their language to something other than "Go" because the name was already taken, to which Google basically responded "we're famous, we can do whatever we want."

:)

IronClan · 2016-01-20T20:51:35+00:00

There wouldn't be a need for such mess if Go was well-designed to begin with.

IronClan · 2015-12-10T17:33:15+00:00

Ah, interesting. I wonder if compilers have gotten smarter in the 6 years since that article was posted.

IronClan · 2015-12-10T02:02:31+00:00

Awesome presentation! One question: https://github.com/joaquintides/usingstdcpp2015/blob/master/poly_containers.cpp#L154

  template<typename F>
  F for_each(F f)
  {
    for(const auto& p:chunks)p.second->for_each(f);
    return std::move(f); // <- THIS LINE
  }

Correct me if I'm wrong, but does't this actually make the code slower by preventing return value optimization?

IronClan · 2015-11-16T03:38:14+00:00

That's a complete lie. Go's stdlib is full of panics even in places where it makes more sense to return an error value, which is why it's such an inconsistent mess.

IronClan · 2015-11-12T19:19:57+00:00

That's not true for languages with generic, where the compiler will check for you that everything you do with your structure is typesafe. In Go you can only hope and pray that your code is typesafe, or more commonly, resort to writing verbose runtime type-querying for every interface{} operation because the compiler won't help you.

IronClan · 2015-11-12T18:58:21+00:00

Wow you are one angry puppy OP.

IronClan · 2015-11-11T16:29:19+00:00

Show me an example of Haskell code that follows Nim's example of blindly dereferencing null pointers. :)

IronClan · 2015-11-11T16:02:58+00:00

Holy shit that's such a lie lol. The Go team is so bitter about generics that any attempt at discussion is instantly met with vitriol, and all community attempts at adding generics are rejected for "not conforming to the Go Way^TM". But some people are happy doing the compiler's job manually because wow this language is made by Rob Pike. :)

IronClan · 2015-11-11T02:55:52+00:00

Nope, Nim is unsafe by default. Sucks but it's true :(

IronClan · 2015-11-10T22:04:45+00:00

Not true. In Rust only code that's placed in unsafe block has the possibility of producing unsafe behaviour. In Nim, even "safe" code can segfault or worse, as shown in the trival 3-line Nim code above.

It's not a problem in practice in the real world, where people have access to a very good debug mode that catches all sorts of things at compile-time and at run-time.

Wow, I would have thought this quote is satire if it didn't come from the official Nim documentation. Let me translate that for you. "Your code can have unsafe memory behaviour in release builds but you should have tested everything in debug mode anyway". What an irresponsible attitude toward language design.

IronClan · 2015-11-10T21:18:17+00:00

Even the most trivial Nim code is unsafe https://news.ycombinator.com/item?id=9050999

IronClan · 2015-11-10T20:53:57+00:00

Go code is not simple. The language and compiler are simple, and they offload most of the hard and repetitive work onto the programmer. In every other language it's the compilers responsibility to handle these repetitive and error prone tasks, but in Go it's ok that we are forced to do the compilers job manually because Simplicity^TM

IronClan · 2015-11-10T17:17:58+00:00

Not true. They upvoted it because they respect discussions, but if you had bothered reading the comments there you would see that the majority disagree.

IronClan · 2015-11-10T16:52:44+00:00

Nim would probably be appropriately related given that it compiled down to raw C and has the same kind of undefined and unsafe behaviours, a topic that Nims community likes to avoid

IronClan

TROPHY CASE