What's Jow Forums's opinion on the GoLang ?

What's Jow Forums's opinion on the GoLang ?

Attached: 1_yh90bW8jL4f8pOTZTvbzqw.png (600x600, 63K)

Other urls found in this thread:

youtube.com/watch?v=sX8r6zATHGU&t=50m29s
github.com/trending/go
github.com/chrislusf/glow
github.com/chrislusf/glow/blob/1121db486076a62840ab82fe4a282564c92cb8f7/flow/dataset_map.go
news.ycombinator.com/item?id=19870792
tour.golang.org/concurrency/1
github.com/ethereum/go-ethereum
influxdata.com/
nats.io/
twitter.com/SFWRedditGifs

meme language, waste of time unless you're a hyperautist with no hobbies

it's okay. the stdlib is very good and the language itself is simple enough to use without thinking about it too much. i haven't used it much though.

fuck furry logos

Writing code in Golang is legitimately fun for me. Everything just seems to work and I don't have to worry about minutiae.

On the other hand Golang has a nearly equally bad tranny problem as Rust. Though Golangs evangelists are much less insufferably smug.

BASED
Simple, good performance, nice for concurrent programming, rich standard library, great ecosystem.
Thou language itself is mediocre at best and can be verbose at times, otherwise it would be 10/10.

if you weren't on Jow Forums when golang was in beta and uriel was shilling it, you don't belong here

What the fuck is GoLang?

Lewd

pretty comfy

Easier than C for retards like me
But overall worse than Java

worse than python

It's nice I'd say. I still miss map/reduce sometimes, and by extension generics.
Also, despite the claims of simple error handling, the fact that every function returns a generic error type, together with the fact that errors.New will swallow error info, can be annoying.

Java os faster, has more battle tested libs, generics and proper error handling.

degenerate

>no generics
hahahahahahahahahahahahaahhaahahhaahahahahahahha

Why can't you map/reduce in go?

useless
not enough syntax sugar
not as fast as C or Rust

To implement proper map/reduce functions, you require either a dynamic language, or in the case of go, a static language, generics.
The lack of generics makes it impossible to implement proper map/reduce

you can't implement type safe map/reduce, but nothing is preventing you from implementing it in go

first uriel, then terry, it's all the best ones

You could use interfaces

Overhead
Might as well use a proper language like C# or Java

Better than python, Ruby, php, JavaScript, Java and tons of other meme Lang's people use.

not standout, will be forgotten when the next shiny toy comes along

Great language but very different from most others. Takes time to learn but once you understand its awesome.
The devs stuck to their guns in language design however and didn't let it become a bloated mess. This causes a lot of butthurt.

Attached: C++.jpg (557x800, 193K)

When I was starting a new project at work I scouted around for new languages, libraries and frameworks. Chose go and I'm pretty pleased, like it a lot.

I use that crap at work, it's just C for retards.

i wont use it purely because the logo is ugly and childish. i suspect it has something to do with the general infantalisation approach many valley companies take

>meme language
literally this, everyone in the world reads these stupid threads and then at tech talks all over the world they repeat the memes verbatim about 'huuur no generics' and 'muh C++ tooling'

no generics, no adts, no sensible error handling.
basically nothing that you need to be productive.

wrong. you need "generics", or rather parametric polymorphism, to be able to express the type signature of map or reduce. Otherwise there's no point.

It has to do with the fact that the wife of one of the principal designers draws creepy children books

Attached: buscemimouse1sm.jpg (1600x1596, 597K)

It's not even the logo you autist.

>Worse than Java
Sorry son, you do't belong here

at least java figured out how to have generics lmao

Interface functions have return values.

So? You still can't type map or reduce.

>at least java figured out how to have generics lmao
you been memed son

Java is a forced OO language
Go is a non-OO language

Big fucking deal, having to make a class to put your functions in is much better than having no generics.

>at least java figured out how to have generics lmao
youtube.com/watch?v=sX8r6zATHGU&t=50m29s

>sponsored by the PRC
OMEGAJEJ

Go is useless for anything big

Why are you shilling a language that's essentially an incomplete beta?
Also, the proposals that exist are worse than Java generics. Which are indeed one of the worst generics implementations out there.

I find it a nice alternative to C when I sacrifice a few microseconds of wasted time whenever I don't want to deal with memory management

github.com/trending/go
surely docker, k8s, etc. aren't big projects...

patches are welcome

Yeah there are things that aren't in base Go that could be added later. Doesn't mean you couldn't implement a map or reduce.

they aren't. kubernetes and docker are smalltime and not really complex.

Do so now, then.

unfortunately the absence of generics is a hard stop for me, and clearly a lot of other people

lol no generics

github.com/chrislusf/glow

dumbest post on Jow Forums right now

github.com/chrislusf/glow/blob/1121db486076a62840ab82fe4a282564c92cb8f7/flow/dataset_map.go
That's not the canonical map, and it's not equivalent to it either because it only accepts a predefined set of inputs and outputs.

Meme lang used by wanna-be googlers and baseddevs

And there goes the goal posts...

The goalposts remain set. That's not map because it does not implement or subsume the complete functionality of map.

Cry more

>wanna-be googlers
why do people use this as an argument?
do you really believe people use certain languages just because some company is behind them? are you projecting?

Not him, but yes. "big company is using this technology, it must be good" is a driving force in many projects, especially in start-ups.

news.ycombinator.com/item?id=19870792 it was fun riffing on """enterprise""" go

Ok, fine.
let's say you read that a language is
- easy to learn
- multiplatform (multiple OSs and architectures)
- fast
- performant (as in, doesn't use a lot of resources)
- well supported (has a big community, good amount of features supported by the standard library and so on)
- has some nice features integrated in the language itself
- proposes a new paradigm
would you think people are using it just because google is using it?

The only new features Go has integrated in the language itself are features better implemented with libraries elsewhere.

>The only new features Go has integrated in the language itself are features better implemented with libraries elsewhere.
tour.golang.org/concurrency/1

Exactly what I'm talking about. What part of this needed to be built in rather than a library function?

>features better implemented with libraries elsewhere.
how would goroutines and channels be BETTER implemented as libraries? are you serious?

Incredulity is not an argument. There's nothing special about spawning a fibre that needs it to have dedicated syntax.

A brainlets' programming language made for brainlets and still their code is less maintainable.
Would be dead if another company made it. Nothing worthwile is implemented in it. Shit tier ecosystem.

And what's worse: The mascot. Man, even some of my shit tier programmer art was better than that.

Green threads without compiler support require extremely careful programming as you always risk blowing the tiny stacks.
Unless of course you allocate a full stack for each green thread, negating most of the benefits of using them in the first place.
The other problem is that you can only call green thread aware functions on them, any function that will block will screw you up, and again without compiler support is just something you have to know.

What you need for good fibers is runtime support, not necessarily compile time support. A procedural abstraction is perfectly adequate to invoke that runtime.

Ok lang, its pushers in insufferably retarded though.

>A brainlets' programming language made for brainlets and still their code is less maintainable.
>Would be dead if another company made it. Nothing worthwile is implemented in it. Shit tier ecosystem.
Go is NOT meant to replace C or C++ directly. It does replace C for certain userspace systems programming that should never have been implemented in C in the first place. Go does directly replace Java and Python for devops and server programming. Go IS meant to be simple, Go is essentially a ducked typed language that gives the speed of development of scripting languages like Python without being a toy babby dynamically typed language for throw away scripts. Forced OO in Java is boilerplate that gets in the way of devops/systems programming and makes monolithic systems that are impossible to refactor. Anyone who likes being stuck in the Java ecosystem essentially can't program to platform and needs a plug-n-play Java-only environment

You clearly did not understand what I said.

>It does replace C for certain userspace systems programming that should never have been implemented in C in the first place
This is what I use Go for, and it's excellent for any shit that requires crunching binary data

>go_gopher only has one image on e621 and it's off-model as fuck
Truly a shame.

it pays the bill so why should i complain

Attached: 1553862210308.jpg (554x554, 30K)

That's not a fair assessment. There are some substantial systems written in Go.

- go-ethereum // github.com/ethereum/go-ethereum
- influxdb && friends // influxdata.com/
- nats // nats.io/

Attached: MFS.024-49.jpg (720x1080, 74K)

func _buildMapperFunction(f interface{}, task *Task) func(input reflect.Value) {
fn, ft := reflect.ValueOf(f), reflect.TypeOf(f)

I wonder how much time godevs spend on making reflection fast. Has there been any other language so dependent on RTTI?

Compiled language I mean.

logo != mascot

Ironically, Java were the ones that warned the Go devs not to implement generics wrong.

If it weren't for the Java devs warning the Go devs about all the problems that Java generics caused, Go might already have generics, implemented poorly.

Unironically thank you Java devs for saving Go from shitty generics implementation.

C++ templates perfected generics.

IPFS, Syncthing, ...

Yeah, that's why C++ compiles take so long that Rob Pike was able to invent Go while waiting for C++ code to compile.

Oh wait.

C++ templates barely even count as generics.

Go already has a problem with FooInt, FooString, FooFloat functions everywhere.

It's been 15 years since Java 5. If you don't know what good generics look like by now, you never will.

Impatient gopher, quality takes time
This is why they are perfect

Why not?

>general purpose language with no macros
what a waste of time. Rust is far better than Go simply because Rust has macros.

No dynamic polymorphism. They're just compile time macros. This Java interface isn't possible in C++.
interface Foo
{
/* virtual */ void foo(T t);
}

Not really, no. Those functions are generated with templates, the same way generics work in most languages.

The difference is that it isn't defined in the language spec, meaning that the Go language doesn't suffer from poor design choices.

e.g. you can already get Java-like or C++ like generics in Go, the preprocessor just isn't shipped as part of the standard toolchain.

Not much different than requiring Maven or CMake for Java/C++ projects.

>Impatient gopher, quality takes time
Yet more irony, Golang IS getting generics, the devs just want to get it right instead of vomiting out something like Java generics or C++ templates.

Quality takes time, user.

>Those functions are generated with templates, the same way generics work in most languages.
The only languages I can think of which use templated generics are C++ and its stillborn baby D.
Using a preprocessor is even worse though, did you learn nothing from C?

Why are you so aggressive, I never said anything disparaging about Go. Why are Gophers so hostile?

I initially started learning Rust as a hobby language, but realized that I maybe I should have went with Go since Go is more web focused while Rust is more systems focused. It seems like Go is a fine language to learn as a secondary one since it’s used quite widely and has job opportunities as well

I’m not sure if there is any alternative for generics in statically typed languages with minimal runtime and a primitive type system. All you can do is automate the process of generating specific code.

Rust is fine too. Go is obviously better for employment, but Rust has an outsized amount of community support for how much its actually used in practice. It's one of those languages which people are going to force into use regardless of its merits.

No this is a core design difference of go. Go builds function tables for the type at runtime - sperg family build at compile time.

Sure there is,just erase types. In terms of the calling convention you just cast the argument down to whatever interface type is the type parameter's upper bound and then cast the return value back up. It's exactly the same thing you'd be doing manually except the type assertions are inserted for you.
As for performance, monomorphizing this kind of polymorphic function where it's possible to do so is regularly done in other languages so I don't think there's a need to be wary.

Doesn’t erasing the types limit how much can be optimized? Your essentially getting machine code for the most generic operation instead of the optimal one for each type needed.
I think Julia handles this correctly with their dynamic dispatch and optional typing system allowing both specific and generic code to be mixed, but this obviously isn’t applicable to C++.