Go

>>60858881
>Wtf was Google thinking?
Go was meant to be simple so that retards can write in Go so Google can spend less time, effort and money tutoring interns.

File: ferris tea.png (502KB, 486x481px) Image search: [Google]

502KB, 486x481px

It's literally a dumbed down C for pajeets and CS grad retards who don't know how to code.
The fact that it allows pointers but no pointer arithmetic should make that very clear.

>>60858917
>The fact that it allows pointers but no pointer arithmetic should make that very clear.
Wait are you serious? What the fuck?

>>60858881

>>no higher-order functions (map, fold etc.)

Oddly specific criticism of a programming language.

>>60858917
Perfect for all the CS cucks!
Now CS is even easier than a humanities degree!

>>60858962
>Now CS is even easier than a humanities degree

True, unless you minor in math.

>>60858881
I think it makes perfect sense for large companies to use languages like Go. You want your employees to be as fungible as possible, and to do that you need to prevent people from writing clever code.
For small companies is the exact opposite: you want to exploit your programmer time to the fullest, being as fast and clever as you can. The goal there is not to produce maintainable software, but to produce something that just works and then get acquired.

>>60859606

But generics is easy and has existed since the 1970s.

>>60859850
this, it's even simpler than fullblown OOP/ as easy as interfaces

>>60858881
>>no generics
make your own template engine, its not hard, no one will use it because its not needed

>>no higher-order functions (map, fold etc.)
Go has high order functions which you can pass to methods and a range keyword that will iterate though arrays and slices, having an actual function called map and fold is just unnecessary syntactic sugar

>>60860104
>not needed
>unnecessary

Might as well program in assembly because all the modern tools languages provided just aren't necessary or needed and if you ever do need it implement it yourself :^)

>>60858937
>no higher-order functions

but at least functions are first class objects - that's actually handsome.

>>60860104
You are Google-tier material, my dude.

>>60860289
:)

>>60858881
made by old fucks for junior brainlets, what would we expect?

I seen probably hundreds of thousand lines of corporate Java and much of it was pure suck. I've seen people citing design patterns writing Java interface coupling model and frontend methods (when I saw this I rejected the offer).

Go can suck to. But the sucker will probably suck less, because from day one they are forced to gofmt and to check errors and to write small interfaces.

If you ask me. If you are not able to expel the weak shitty programmers from entering the tech job market - then at least tie their fucking hands and prevent them from doing to much damage.

Actually a smart move that I welcome, because I am also shitty programmer - who is still working to become better.

File: 1495749334272.jpg (12KB, 250x247px) Image search: [Google]

12KB, 250x247px

>REEEEEEE IT'S NOT C SO I CAN'T LIKE IT
>/g/

>>60860981
C doesn't have either of those things, retard

>>60858881
>>no higher-order functions (map, fold etc.)

Actually, you can write them yourself, Go has first class functions.

...Oh wait, no generics. I hope you like specializing map and fold for every type.

>>60861050
C has macros, which at least lets you emulate generics to some degree.

>>60861115
You can have preprocessor macros in every language.

>>60861091
Luckily they thought ahead about this and added a super high tech built in syntax construct that allows you to iterate over a collection while bringing in outside scope in the enclosing block so you can supply your own accumulator values and other needed state without the need to lean on rudimentary and overly-specific FP utility functions.

But if that's too ivory tower for you, you can head back to LISP garbage.

>>60861115
>using a compile time feature to replicate a runtime feature

>>60861208
generics aren't a runtime feature

>>60858906
*rewrite
Go is this "typescript incarnate" where some retard comes up with a language Y that is basically language X but using other terms and syntax.

So now you have this hype ass new language which is again just language X sugarcoated. So what do you do? Of course, you start rewriting your entire codebase into language Y.

Fast forward a year, oh boy, it's language Z which is again just language X double coated.

>>60861397
>"typescript incarnate"

If you're going to make that comparison at least use something that fits what you're describing, like coffeescript. Adding a static type system to javascript isn't syntactical polish and it serves a practical need.

>>60861500
ah it is coffeescript indeed. sorry, I meant that one.

>>60861516
(but there was some other language on top of CoffeeScript IIRC, or between CS/JS...can't recall though sadly.)

>>60858928
I think the same is true of Pascal, but Pascal at least has some redeeming qualities.

>>60861183
You mean like cmp and jmp in assembly? Sounds useful.

Why bother writing something stateless like 3*(x+5) - 2 instead of something stateful like

        mov     edi, dword ptr [rbp - 4]
        add     edi, 5
        imul    edi, edi, 3
        sub     edi, 3
        mov     dword ptr [rbp - 8], edi

>>60858937
C doesn't have those either, but they are trivial to implement.

>>60858928
To pass by reference?

Golang was designed around being fast, easy to write, and very scalable.
Which it accomplishes pretty well. People just say "It I wanted concurrency I'd use scala!" which, sure, Scala is probably more robust, but nobody knows Scala. Go is about as easy to read as well-written Python. You can just sit down and start writing it.

ITT: samefag

Go just makes bad programmers feel inadequate.

>>60861208
Parametric polymorphism is not a "runtime feature".
>>60860104
Do you even know what catamorphisms and homomorphisms are??? Jesus...

>>60861776
>go
>requiring the semblance of skill
it's pretty much on the level of python

DUDE GENERICS LMAO

>>60861846
Python is _much_ more expressive than Go will ever be. It lets you write things as generic as the Y-combinors, while Go can't even implement a generic map.

>>60861183
Yeah... enjoy your stateful, unsafe, unsound, difficult to optimize and parallelize, shitty piece of code.

>>60861846
Yeah who needs to write programs when you can just spend most of your time fighting the language? C++ is the best.

>>60861931
the real world is stateful
stay in your functional safe space

>>60861867
This. Who needs "generics" when you have ANSI C and M4?

>>60858917
what are the uses of pointer arithmetic anyway

>>60861943
Numbers don't exists in the "real world" either, that didn't stop us to create such an useful abstraction. The concept of "state" can be encoded with monads, letting us manipulate them in a safe and pure way.

>>60861964
Looking cool.

>>60861943
So do you think of (x+y)/(z+1) as:
tmp1 = x + y
tmp2 = z + 1
tmp3 = tmp1/tmp2
return tmp3
?

Wouldn't it be great, if you could avoid naming intermediate state, and not bother with the intermediate steps so that your program fit in a single line?

>>60860225
Then use a language that does include every dubious feature including the kitchen sink, you moaning retard.

>>60861930
>m-muh extremely specific feature requirements that have little use outside of my mental masturbation
You're a proper fucking spastic if you think you can't write Y-combinators in Go. You've never tried though because (a) you've never used Go and (b) Y-combinators have no use whatsoever.

>>60861964
It allows for the compact expression of some things, often allowing you to do away with an index variable.

e.g. say you're writing an image file in C.

*buf++ = r * 0xFF;
*buf++ = g * 0xFF;
*buf++ = b * 0xFF;
*buf++ = a * 0xFF;

Doesn't that look pro?

>>60861964
Pointer arithmetic let you create highly efficient data types, although formal verification can be undecidable.

>>60862070
i think of it as
x y + z 1 + /

>>60862102
>(a) you've never used Go
LOL? Good luck trying to implement a sound polyvariadic Y combinator in your shitty language.
>(b) Y-combinators have no use whatsoever.
The fix-point combinator is actually extremely useful, specially when you write in pointfree style. Otherwise why do you think that good programming languages implement the "fix" function? because computer scientists are stupid? hahaha!

>>60862198
dude esoteric haskeller bullshit lmao

>>60862102
>> *buf++
This is undefined behaviour afaik.

>>60862102
*buf++ is far worse than just buf[0]. Use the syntax they gave you, my man. This shit is bonkers.

>>60862211
so this is the power of people crying over lack of generics...

>>60862368
You can't expect armchair language theorists to actually produce something useful

>>60858906
>jumping to one video
>on purpose mis interpreting the video
10 cents has been deposited into your account

>>60858881
>no generics
what is interface
>no higher order functions
does he need to spoon feed you fucking everything ?
https://www.youtube.com/watch?v=rFejpH_tAHM&t=797s

>>60858881
>>60858881
also slow as fuck

>>60862198
>needing this kind of shit
people like you is why software is shit these days

File: which-programs-are-fastest-firstlast.png (36KB, 512x288px) Image search: [Google]

36KB, 512x288px

>>60862468
faster than hasklel

>>60862468
(You)

>>60858881
designing a language that doesn't take me 5 days to understand.
There is a reason functional language's are extremely rarely used in actual production.

>>60862552
scheme is simple as shit

it takes less than 5 days to make your own shitty scheme interpreter

File: dlang logo.png (22KB, 1024x1024px) Image search: [Google]

22KB, 1024x1024px

>>60858906
Retards writing in a language without these sorts of higher-level features is bound to lead to pajeet-level software.

That's why D is the future. Python-level ease by default, with the option to turn it all off and go unsafe.

>>60862583
>dead language is the future

>>60862583
C# has those. And it's pajeet-level.

>>60862463
>Rob Pike chose a stupid looking cartoon that any kid could draw to represent his new language
Literally code monkey tier.

>>60862839
the Go mascot was designed by Rob Pike's wife Renee French who is a professional childrens book illustrator
https://en.wikipedia.org/wiki/Ren%C3%A9e_French

>>60862839
He actually uses the mascot as an example in the posted video of how simple things can be very expressive.

>>60858906
I thought Google only hires people who already know how to program.

>>60863905
It's one thing to shit out some quick code that "works" and another to write robust maintainable programs.

>>60858881
Go would have disapeared by now, another forgotten meme language. .. except for one thing: Docker is written on Go.

>>60861115
You can do anything with sed/awk if you care enough.

>>60862070
Like return ((x + y) / (z + 1))?

>>60862213
>buf[0]
>brainlets that can't C
That code increments what buf points to after each assignment. Shit like this is what makes C great.

>>60858881
They wanted to create a language with the CSP pattern for java codemonkeys.

And they succeed.

Go is not has pretty has Haskell, Clojure, Elixir or Scala but it get's the job done and is easy to get into if you come from OOP languages.

>>60866435
>haskell
>beautiful
you date fat obese chicks don't you

>>60864781
See, you preferred the option that had no local state or intermediate variables! So why not be consistent, and eliminate index variables in the cases of map/filter/fold?

When you have maps and folds that can operate on iterators/generators/sequences, C-style for loops are very rarely necessary, even in languages that were originally built around them like C# where people often just use Linq instead.

>>60861964
Introduce lots of bugs into your software. Not even static analysis tools can catch all them

>>60866651
she is not that fat...

I once looked up the discussion about map/fold on the official golang mailing list (because of course they use a mailing list).

One of the maintainers literally and unironically made the argument that "what, are the kids of today too lazy to write a foreach loop?".

>>60863905
> comp sci majors
> know how to program

why won't this meme die

>>60867791
They usually know how to program.

Keep in mind not every place in the world is an US diploma mill.

>>60867767
>foreach loop
Are they?

>>60864706
Yeah, docker is big, huge. It's all over the server world.

>>60862583
Post sample code.

What the fuck are generics.

>>60868339
C++ templates

>>60868381
Buzzword, please tell me what it does.

>>60858917
>The fact that it allows pointers but no pointer arithmetic should make that very clear.
The "unsafe" package allows for it, cgo allows for it.

>>60866651
Haskell is beautiful, no denial.

>>60861115
>>60861091
Go has a code generation tool that can accomplish the same.
https://blog.golang.org/generate

>>60868339
In Go they're called "interfaces" and they're easier to work with.

>>60868339
Python example:

def foo(x):
    return ("pair", x,x)

This function will work in the same way for values of EVERY type you feed into it, whether they are integers, lists, strings, or whatever you want to feed into it. In python's case this is because of dynamic typing. Statically typed language can also do this, but to do that they need generics. In that case, you would write something like:

fn foo<AType>(x : AType) -> (str,AType,AType) {
    return ("pair",x,x);
}

Go lets you do this only in some very specific cases. You can't write a function that does the same thing as this one-liner Python function:

def map_fun(fun,val_list):
    return [foo(val) for val in val_list]

>>60868659
>implying I can't do this in C with unions

>>60868659
Typo in last function, should be:

def map_fun(fun,val_list):
    return [fun(val) for val in val_list]

>>60868675
Unions in C are completely orthogonal to generics. And no, you can't implement either of the two functions lists here with just unions, if you want it to work on any possible type you feed into it. You need some way to generate a function for each type you feed into it, with no performance penalty compared to creating a separate function with that specific type as input.

You can implement similar functionality in C with some workarounds that don't exist in Go however, though typically you pay a cost in performance that you wouldn't have paid in C++ or Rust.

>>60862463
>what is interface
Not a compile time feature.

>>60858881

>>no higher-order functions (map, fold etc.)
wat? So there's no function pointers or lambdas?

>muh nerics

>>60870128
there's both; he's a mongoloid

>>60870128
You can write map and fold yourself, go has first class functions.

The issue is that because Go has no generics, you would have to reimplement map for every input and output type of the function you are mapping. Yes, it is that ridiculous, and Gotards still somehow defend it.

>>60868659
Seriously, I thought it was some advanced concept, but it simply is polymorphism.
Call it what it is, don't create new names lol.
Also, this shit has been in Lisp for centuries now.

>>60871804

Generics usually suggests a compiletime or typechecked feature. C++ example.

std::vector<int> foo;
foo.push_back("String"); // Fails because "String" is not an int.

There's no strict definition though. C++'s templates, C#s generics and Java's generics all work in different ways. They mostly serve the same purpose, which is different to the kind of polymorphism achieved with inheritance and class hierarchies, so it helps to name them something different.

>>60867226
> like C# where people often just use Linq instead.
And those people are usually wrong for doing so, because LINQ is insanely, insanely slow.

>>60862211
Lol nope, rustfag. C has perfectly well-defined operator priorities.

>>60872083

What does

 foo(i++) + bar(i++)

call?

File: EVc3Nm0.png (427KB, 770x478px) Image search: [Google]

427KB, 770x478px

>>60858881
You forgot the atrocious error handling story.

>>60872181

exceptions are evil

>>60872137
In this case you're modifying the same variable twice in two different places at the same time, which is appropriately undefined and shitty practice.

Not every behavior needs to be defined; that just leads to a bloated and confusing language. What matters is that what's undefined is explicitly defined as undefined, which in C it is.

>>60872202

IMO C went too far with undefined behavior, but I guess that just helps its portability. Would still be nice to have a clear definition for order of evaluation.

>>60872216
>clear definition for order of evaluation.
No. Don't abuse the order you dumb cunt.

>>60872187
Yes, but that doesn't mean Go's approach is any better. It's basically the same old errno with ad-hoc sugar, you still can forget to check the error state and the result is available even if there's an error. Compare it with Haskell's or Rust's approaches, where you literally can't get the result until you check the return value for errors and provide error processing in some form or another.

>>60872216
It would be nice, but with how close C aims to be to the underlying assembly while remaining agnostic enough to (hypothetically) be a write once compile anywhere language it'd really add a lot of cruft to the compiler and generated assembly to define every action you can generate with a language that lets you deal with memory directly. It's really kind of impressive how expressive C is when you look at the typical assembly produced by a C compiler. Sure there's a lot of undefined behavior, but it's made up for by being a small language.

I'm not saying C is perfect. It definitely has many flaws, and the amount of undefined behavior is perhaps one of them. however, it's really less of a deal than rustfags make it out to be, especially because it's not lol oh you can't do that surprise. C's undefined behavior is defined as such, and should be viewed as such unless you want to play with dragons.

>>60867226
>>60872063
I rarely use Linq in C#. I understand that some people really get off on it but I prefer doing it the old fashioned way as it is easier to read.

>>60872181
>>60872187
>Google: exceptions everywhere because you're retarded and code even if life depends on it
>Me: can I use plain arrays instead of your retarded slices
>G: No, that could cause the code to throw invalid access exceptions
Go: The training wheels are always on

>>60871804
Right, the formal term for this is parametric polymorphism, Implying that it has to do the exact same thing on different types, but is typechecked and gets its type filled in at compile time so that what happens at the call site is the same as if you called the function with the type specialized to what you pass into it.

It is to be distinguished it from ad-hoc polymorphism like function overloading in C++ where you just have two different functions with the same name but which operate on different types and may do something completely different on those two types, and from runtime polymorphism as in most OO languages, where the function does a runtime check of the type of its argument and typically needs to follow a vtable to find the apropriate function to call.

Parametric polymorphism requires that the function does effectively the same thing on all types typically without "knowing" anything about the type it operates on. If the function is pure you can often prove so called free theorems , since functions that are very generic may have theorems proven about them "for free" from their type signature. For example, any pure function with the type signature T -> T for _any_ type T must be equivalent to the identity function assuming that it doesn't halt (consider the specialization to a type with only one value). Haskell pushes that kind of fuckery really far because Haskell compilers like the GHC can actually use this for optimizations, and can optimize away bits that you would expect to have halted the program.

https://crystal-lang.org/

>>60862583
D is many things, including "a good programming language" and "utterly devoid of libraries". What it isn't, however, is the future. Even Alexandrescu agrees:
>Poor adoption after many nominal years of existence.
>Insiders to the D community could qualify this statement (D in its current form is relatively new, adoption does grow, etc). Yet the perception remains, and adoption is driven by perception and becomes fact. So managers and engineers are nervous about adopting a language that's been around unsuccessfully for so long. Furthermore, time works against D unless/until a major uptick in adoption becomes obvious.
https://www.quora.com/Which-language-has-the-brightest-future-in-replacement-of-C-between-D-Go-and-Rust-And-Why/answer/Andrei-Alexandrescu

>>60873195
>https://crystal-lang.org/
So shit that the example code they provide does not even work on the online "compiler."

>>60873195
recently heard about this and it looks bretty good, looks like it will be a nice replacement for php
>dat syntax sugar
>that speed
why isn't it more popular? will it ever take off?

>>60875440
You start a new http server on the online compiler, you dipshit.

>>60872137
UB, but this is off-topic.

>>60861846
At least python has map, filter and reduce

>>60860225
>le slippery slope
and you faggots think you're smarter than the average CS graduate

you are not

>>60858906
But spend more money for slower productivity?

Go with decent generics added would be a pretty comfy language desu.

File: audiblekek.gif (2MB, 290x260px) Image search: [Google]

2MB, 290x260px

>>60873047

>>60858917
>he thinks pointer arithmetic is desirable
Ahahahahahaha!

>>60878607
Eh, it can be nice to have, as long as it is relegated to explicit unsafe blocks.

>>60873195
>slick as Ruby
Stopped reading right there.

>>60878506
>Go with decent generics added would be a pretty comfy language desu.
you know any language can have generics added to it right? if there were enough people who wanted it it would be done by now, but its not, because its just a dumb meme that gets repeated over and over in every Go thread on /g/ by people who have never used Go

>>60879828
>if there were enough people who wanted it it would be done by now

https://goo
.gl/KjXlVg
ctrl+f "alternative solutions"
>reimplement the code
>use go generate
>use for loops instead of high order functions
>use simpler algorithms
>use reflect

>because its just a dumb meme
Because Rob Pike is obsessed with "harmful things" and wants to force his retarded ideals on others.

>>60861846
t. someone who used python for a school assignment twice

>>60879991
>>because its just a dumb meme
>Because Rob Pike is obsessed with "harmful things" and wants to force his retarded ideals on others.
no, its a meme, Rob Pike is not forcing anyone to not implement generics, anyone could do it, youre just repeating a stupid meme

>>60880057
>Rob Pike is not forcing anyone to not implement generics, anyone could do it
I'm sure everyone would immediately switch to my unofficial fork instead of the one backed by a huge company.
There are so many things wrong with Go that it's not even worth trying to salvage it.

>>60880093
it wouldnt even be a fork, you can add generics to Go without altering the language, youre still just memeing

>>60880119
>you can add generics to Go without altering the language
I would love to hear more about that.

>>60879991

>Because Rob Pike is obsessed with "harmful things" and wants to force his retarded ideals on others.

Rob Pike hasn't had anything to do with the development of Go in a loooong time.

Current maintainer is Russ Cox, here is what he wrote earlier this year on the future of Go which includes generics (with links to previous proposals from Go developers):

https://research.swtch.com/go2017

Go is a simplistic language, there are some very repetitive patterns (hello error checking!), but it's the most productive language I've used when working in a team, which fucking surprised me.

The language constraints mean that the code will never be 'beautiful', but we are churning out working code at a high rate with minimal fuss, and I guess this is why Go has been so quickly adopted as it has.

>>60858881
it's a mediocre language
the simplicity is kind of endearing but meh

>>60872187
why, exactly?

>>60880134
https://github.com/diffeo/gogen

>>60880266
You can also add classes to C :^)

>>60880198
>reddit spacing

>Rob Pike hasn't had anything to do with the development of Go in a loooong time.
Rob Pike was one of the original designers. Blaming him for lack of generics seems like a perfectly reasonable thing to do.

>but it's the most productive language I've used when working in a team
I am not surprised that a language designed for retards excels when being used by retards.
This is not meant to be an insult towards you but it's the sad truth about the competence of most employed programmers.

But I'd rather work with competent people using a sane language.

>>60880266
That's like saying that Java is good because Kotlin exists.

>>60880320
>comparing a whole own language that uses the same VM with a simple preprocessor

>>60880477
That's the point. A "simple preprocessor" is even worse.

>>60880320

>Rob Pike was one of the original designers. Blaming him for lack of generics seems like a perfectly reasonable thing to do.

You implied Go will never have generics because 'Rob Pike is against them', Rob Pike has zero influence in the direction Go is developing.

>This is not meant to be an insult towards you but it's the sad truth about the competence of most employed programmers.

Sorry dude, I realize you are from academia where you can sit and ponder for a week on how to best avoid side effects to have the purest implementation, but in real life we actually need to produce working code in a timely manner, with time being money. So the language which produces working code with the least friction wins, and here Go performs fantastically well, which is why it is seeing such quick adoption.

>But I'd rather work with competent people using a sane language.

Stay in academia, in out in the real world no one is interested in hiring a language-snob.

>>60880639
>ponder for a week on how to best avoid side effects
Just like with every other skill, you become better and faster at pondering the more you do it.
You have to spend a certain amount of time designing and then redesigning systems but soon you'll be able to quickly produce good and maintainable designs from the start.

>the language which produces working code with the least friction wins
Pretty much every language supports the style Go forces you to use.
The thing that makes Go suitable for retards is that it doesn't have any features you could abuse.

>>60858881
>no higher-order functions
kek GO eternally BTFO

>>60881067

GO has high order functions you retard, OP is simply as stupid as you are.

>>60881208
>try to implement reduce in Go
>have to use interface{} and reflect
>Go made the same mistake that Java corrected 13 years ago

>>60875599
>why isn't it more popular?
It is very, very new for a programming language. It isn't even version 1.0 yet.
>will it ever take off?
Too early to tell. The devs sure are trying to make it take off, and they've got a few smaller companies on board,

>>60880639
>you can sit and ponder for a week on how to best avoid side effects
You don't have to if you have a language that helps you avoid them.

>>60883369
>It is very, very new for a programming language
Rust and Elixir started around the same time. I mean sure, they're backed by larger corporate and whatnot but Crystal is barely even discussed/shilled on /g/.
I have a huge hard on for webperf so I hope it can eventually supersede php/python/node