No dependency management

good post.

>return true if true else false
lmfao fucking retard what are you doing

>it's far from a meme language
Go isn't a meme language, it's THE meme language

why Haskell in the bin?

Lets not forget
>"It's a C replacement! xD"
>Garbage Collected
>Is slower and uses more memory on average than bloated C++ or Rust applications
benchmarksgame-team.pages.debian.net/benchmarksgame/faster/go-gpp.html

>c-tier error handling
come on, C error handling is far far worse
>no dep management
well, at least it's comming
>no default variables
explain
>bad performance
kek, this is what happens when you roll your own compiler backend

>explain
functions default parameters, like developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters

>OO is the most natural and logic way to program,

XDDDDDDDDDDD

> everything is a fucking object that has its data and it can be modified using its own API aka methods

Time is not an object. Chair has no API.

>OOP is the only good way to build large scale distributed systems.

No. Take a look at Plan9.

how about that you retard?

t = new Time()
t.AddDay()
t.SubMonth()

and

chair = new Chair()

chair.BreakLeg()
chair.FixLeg()

And that's dumb, you need to think like a computer not a human, there's data and there's functions processing the data, why would shit.process() be better than process(shit)?

why is haskell in the bin when it literally has none of those problems

>chair.breakLeg()

The chair itself won't probably break pr fix its leg, somebody else would.

somebody.breakLeg(chair) and
somebody.fixLeg(chair)

>no dependency management
?
>no generics
can get ugly but not essential
>no compilation with unused variables
should not be a problem
>no ternary operators
can get ugly but not essential
>no default variables
what do you mean
>extremely verbose
citation needed
>c-tier error handling
should not be a problem
>not OOP and still not functional
not a bad thing
>project has to be inside GOPATH or you won't be able to include local packages
it is package based development
>performance overall isn't that much better than Node
citation needed

Attached: g3xw9thb8bd11.jpg (500x499, 40K)

>haskell

Attached: e58.jpg (500x370, 26K)

The chair object is responsible for its own internal state, so I don't agree.

there's no easier way to identify larping non-programmers than those that bash OOP

Attached: bjarne17.jpg (500x335, 23K)

That's exactly why OOP can't be applied to everything. Chairs can't break their own legs and they especially can't fix their own legs. Not everything has a tidy analogy.

a much better thread died for this

that's not the point you fucking retard. if a function changes the state of an object it is a method of that object. it has nothing to do with your fucking metaphors.

>>no dependency management
>?
There's no package manager, or proper versioning, or anything really.

>>no generics
>can get ugly but not essential
It's essential if you don't want disgusting repetition, and having a real type
system helps with code quality and not making retarded mistakes.

>>no compilation with unused variables
>should not be a problem
I would agree, but linters should not act like that, same goes for code
formatters, unless the language you're making is for literal babbys.

>>no ternary operators
>can get ugly but not essential
Yeah I don't know why that user even cares about that, everything being an
expression (including if/else) is way better than having ternary operators.

>>no default variables
>what do you mean
I think he means no default parameters.

>>extremely verbose
>citation needed
It is pretty verbose compared to other languages.

>>c-tier error handling
>should not be a problem
It is a problem, there are way better solutions to the error handling problem,
and what Go picked is not it.

>>not OOP and still not functional
>not a bad thing
It is, because it doesn't support any paradigm where you can properly abstract
things and uphold invariants.

>>project has to be inside GOPATH or you won't be able to include local packages
>it is package based development
Why is there no package managment then?

>>performance overall isn't that much better than Node
>citation needed
Yeah I don't know where that guy is taking this from.

Come on man... It's very unrealistic for chair to fix it's legs...

you have very severe autism

It would be more like EntityThatProcessesChairs.Process(chair) instead of entity_that_processes_chairs_process(entity_that_processes_chairs *etps, chair). See OOP is about entities having their own state, affecting state of others by passing messages. Processing chair probably doesn't change the state of chair itself (and if so, it will be with chair's setters such as break leg and fix leg). Inheritance, polymorphism and interfaces is just a form of type system that fits this design.

>return True if hasTernaryOperators else False
What the fuck is this shit

anyone who calls them ternary operators instead of conditional expressions should die in a fire
I bet you're the kind of guy who mixes statements in them too

At least golang doesnt calculate at a glaciers pace lmao.

DOA

this

Pure OOP is fucking retarded though especilly the type used in languages like C++, where your code becomes an unmaintainable web of bullshit after a year or so.

The best route to take is functions applied to objects. When x happens, y object does z. It's simple, makes sense, and makes code way easier to maintain

Go is for people unaware that you can statically link in every language.

Go was literally designed for idiots. Here it is straight from the horses mouth.

Attached: rob pike on golang.jpg (1024x683, 253K)

>The best route to take is functions applied to objects
that becomes an unmaintainable web of bullshit too, that's why OOP was invented

>why would shit.process() be better than process(shit)?

It's not better and this is a point that flies right over the heads of brainlets who only use/advocate for languages that have single dispatch object systems.

In the shit.process(), process is a function that takes a single argument, 'shit'. The implementation of process which is chosen depends on the type of the first argument only. This first argument is given special syntax because it's special, it is the only argument that will dynamically effect which implementation of process is picked. This is single dispatch.

In a multiple dispatch object system (such as Julia's or CLOS), no argument is privileged, they all factor into the dynamic dispatch. As such, shit.process() can be written process(shit), and if you later need new implmentations of process like process(piss), you can do that. You can even do process(shit, skittles) and both of those arguments will factor into the dynamic dispatch of process.

Single dispatch is for smooth brain peasants.

CLOS is the only good OO system.

Almost right. Julia also has a good object system, and there are a few CLOS-lites out there like Guile's GOOPS.

meanwhile C++ needs 5 years of experience for entry-level job and even committees misuse the language features horribly

>This first argument is given special syntax because it's special,
it's just regular function overloading.

>Brian Kernighan is an idiot
Oh wintoddlers...

>no dependency management
You don't need dependencies. Everything is already in the standard library.
>no generics
Are you writing a generic collection/library? You shouldn't because everything is already in the standard library.

>it's that "Guyyys let me be around, I'll write a documentation" guy

What other language is he fucking talking about that would be brilliant? He named every major language actually used by people. Fucking assembly?

And as I understand it, GO was built for multithreading (or whatever they decided to meme-name it) more so than anything else which may have some value.

when did elgoog reprogram him?

Attached: 1532983842974.jpg (1500x1210, 425K)

this pic is full of bullshit

When they hired him.

Attached: 1432370868060.png (838x1044, 414K)