should I learn this?
is it well designed?
is it useful?
what are the money making prospects of this language?

>>105665224 (OP)
No
No
No
No

At least it's not Python.

>>105665224 (OP)
>should I learn this?
Yes, it will take you less than a day to learn the whole thing, so you little to lose.

>is it well designed?
Its simple to a fault, so there are things from other languages things you might miss, but there are very few things that are outright "bad", there are almost no gotchas that I can think of. If you can get over having to do if err != nil { return err } every other line, you will have little to complain about.

>is it useful?
Very. It has performance on par with Java, can interop with C/C++ with almost no effort for the parts where performance matters, but it has the initial development speed of python, but that speed keeps going even when things get more complex. The standard library is probably the best in the business, and there's a huge open source ecosystem around it, so you can knock together web crud in an hour or two that will keep working even when you actually get a meaningful number of users.

>what are the money making prospects of this language?
I mostly write in it nowadays, and my TC is just shy of 200k USD, but I also do a bunch of cloud and sysadmin stuff as well. It works very well as a language for moving beyond "code monkey" to "actual engineer".

As far as it's usecase, yes, it's good.
It will kill python (and that's a good thing).

>>105665224 (OP)
>should I learn this?
Yes.
>is it well designed?
No.
>is it useful?
Yes
>what are the money making prospects of this language?
Good

>>105665224 (OP)
>is it useful?
for google
>what are the money making prospects of this language?
depends on your h1b

>>105665224 (OP)
I’m using it for backend, and I like it. It’s compiled, but without the boilerplate clusterfuck that Java has become, and it doesn’t have the AIDS dependency hell that Python does. it’s pretty straightforward for AWS Lambdas.
I don’t really get the hate this board has for it. Is it just because it’s from Google?

>>105666389
As a wise man once said, an idiot admires complexity. If you build your personal identity around understanding and using something highly complex, then something new comes along that does 90% of what it can for 10% of the complexity, you're going to lash out at it, because it has effectively erased who you are.

>>105666389
>I don’t really get the hate this board has for it. Is it just because it’s from Google?
No. Golang is not simple it's more like rudimentary, an incomplete language masquerade as a simple one.

>>105666389
there's a difference between simple as in elegant and simple as in unga bunga grug brain. go is the latter and just leads to a different kind of complexity where you have to reinvent every damn thing

>>105666389
students and FP cultists love to masturbate about language features, it makes them feel intellectually superior (even though they are nothing more than glorified technicians lmao)
actual tech workers love to produce useful software.

>>105665224 (OP)
it was a literal meme for the (many, many) years it literally didn't have generics. It's okish now but not really the best for anything in particular.

>>105666845
pre-Generics Go was literally a less featureful language than every modern implementation of Object Pascal

>>105666860
yet companies and people already had shipped a LOT of software made in Go at the time.
curious, isn't it?

>>105666845
Every time someone posts something like this I imagine them to be the kind of person who failed high school math and tells himself he doesn't need it for SWE anyway.

>>105666905
>programming languages = math
keep telling yourself that.
meanwhile, actual mathematicians laugh at CS kiddies lmao

>>105666917
>actual mathematicians laugh at CS kiddies
Actual mathematicians write code that would make Indians retch. Doesn't stop them from being higher IQ than (You) though.

>>105666539
how does go simplies writing software? it doesn't.
the only thing that is simple about go is compiler implementation.

>>105666922
>they don't need to masturbate over language features to make useful programs
thanks for proving my point, retard
now go masturbate about your favorite FP lang elsewhere

>>105666943
Go is extremely primitive compared to other employable languages, yet developers in those other languages don't ever seem to get bogged down in this mythical "academic masturbation".

>>105666929
It has an out of the box build system that is nearly impossible to mess up (no makefiles, linker errors, bloated shit like maven), makes compiling to pure static binaries trivial (no glibc version horseshit), uses source control for dependency management (no pypi or npm shenanigans), provides a standard library that provides basically anything you need to write modern software (don't need 32 spring dependencies for a web "hello world", don't have to roll your own date/time, json, etc), uses unicode for all text (no worrying about localization), and it either disallows, or flat out does not provide the the ability to make mistakes that even experienced developers make.

>>105666929
>>105667428 (cont)

C is complex because just getting it to build takes effort, both because of no build system, and the hilarious notion that imports are done by literally copy-pasting someone else's source files into your own, and because you then have to manually download any other dependencies and manually pass their locations as make/cmake flags. Even when you get it to build, getting it to run is a chore, because worrying about glibc versions is no different to worrying about JVM, python, or node version.

C++ is complex because it has all the problems of C, but on top of that, it keeps adding shit, so its an entirely different language every 5 years, yet has to support all of the garbage of all the previous standards.

Python, Node, and Java are complex because you need dozens of dependencies to do anything, and god help you if you have version conflicts, to say nothing of the mess you sign up for with OOP, plus the fact that they are either actually dynamic like python, or functionally dynamic, like Java, because everything inherits the god class.

Functional languages are complex because require abstracting so far from the hardware that getting decent performance requires either bending the language into an unrecognizable shape, or just giving up and implementing the important parts in another language, and now you have two problems to solve.

Go just makes things work. It has problems, sure, its not the best language in any one respect, every other major language out there has something about it that makes it better than Go, and yet, something catastrophic flaw that makes Go still the clear choice for most cases.

>>105667443
anon, don't spoonfeed retards. you might end up converting them and things might end up getting worse as these dumbasses take over the development of Go

>>105665224 (OP)
> Brain-dead simple syntax
> Great stdlib
> Loads of libraries
> Decent enough C inter-op
> Compiler compiles around 100k lines of code per second (so pretty much instant).
> Green threads make it really easy to do stuff in parallel.
> Very fast garbage collector.
> You can embed assets into the exe file making distribution a breeze
It's well worth picking up. If you're a solo dev I can't think of a better language to use if your aim is to shit out products.

>>105665224 (OP)
>should I learn this?
Yes, it only takes a weekend and then you have it on your resume and there's a lot of jobs available.

Has anyone tried the 100 days of golang, is it any good? As a newb to programming im going to give it a try.
https://www.geeksforgeeks.org/blogs/100-days-of-golang/

>>105665224 (OP)
Yes to all
Its about as comfy as you can get
Getting it installed takes like a minute and learning the language takes an afternoon
Give it a go

>>105666389
People who shit on it dont actually make anything
Most of the loudest voices on this board are nocode larpers

>>105666922
I've studied math and no, most of us don't use Haskell, LISP or whatever. Most of my peers in school used either Python(for numerical computation) or MatLab, personally I use Go just fine because it's easy to write/read, it compiles fast and it has good performance.

No math major(except for FP spergs) likes functional programming, it's a joke paradigm and It's a stereotype that mathematician want to program using category theory and abstract algebra(btw Haskell category is not a real one).

>>105666389
>I don’t really get the hate this board has for it.
Most of the feedback I've seen for Go on this board has been positive. Sounds like you might have been coming across people who have been memed into using C for everything.

>>105665224 (OP)
Why use this instead of c# if you're fine with GCed language?

>>105669959
I like solving the same problem using only a fraction of the memory

>>105665355
This.

>>105671226
Imagine wanting to program in more primitive language with worse dev experience to save 20mb of 32gb of memory

>>105671368
>Imagine wanting to program in more primitive language with worse dev experience to save 20mb of 32gb of memory

containers are usually given <1gb ram.

also, as a C# dev i can tell you it doesn't matter how "good" the language is because your coworkers at every single fucking job will just create AbstractProxySingletonFactories. You simply cannot give this type of freedom to the average developer because they will create a pile of shitheap. Go does the right thing by taking away the features necessary to create this type of cancer even if it would give a 10% productivity boost in capable hands (less than 1% of .NET community). Also managed runtime languages failed. Java and C# will stuck around but no one will make new ones anymore. it's a failed experiment. Look at all the new languages coming out: rust, zig, hare, odin, jai, vlang, swift..... all of them are strongly statically typed, they compile to native code ahead of time and they don't support exceptions. Everything is an object failed. heavy managed runtimes failed. exceptions are just goto's on steroids and they failed

>>105671368
you act like a computer only runs one program at a time. a computer has 100+ processes running at the same time and those 20mb's add up. you are simply admitting the only usecase for your language is your app thats the only thing running on a server.

>>105671436
>Look at all the new languages coming out: rust, zig, hare, odin, jai, vlang, swift
A bunch of tranny shit nobody uses?

>>105671909
truth hurts. not even microsoft is using C# anymore. they chose to rewrite the typescript compiler in go instead of C#. they chose to make their new terminal text editor in rust instead of C#. they are rewriting key parts of azure infrastructure to rust from C#. They killed hololens. They killed xna. They killed kinect. They killed the windows phone. They killed silverlight. All places where C# shined. in the meanwhile microsoft does not even dogfood their own shit anymore. they give you blazor but all their webapps are electron + react.

>>105671436
>AbstractProxySingletonFactories
It's true shit like this is common in c# but it's a culture problem and not what language allows or not. You could do similar crap in go.
>rust, zig, hare, odin, jai, vlang, swift
The only ones that are even used are rust and swift, and the second one isn't used for anything else than apple. The rest of them is literally what?
>they don't support exceptions
Go's panic, recover, defer is literally try, catch and finally.
> Everything is an object failed
You can use structs and static functions in c#, it's, again, a matter of culture or programming style or whatever. There's nothing wrong with using objects if you avoid inheritance.
>managed runtime languages failed. no one will make new ones anymore
I doubt that another one will be made too because what's the point. There are 3 big vms with a couple of languages each, why would anyone create new one and be decades of development and research back. The only compiled static languages that don't run on one of those vms that matter are c/c++. The rest of them, including rust and go, are basically irrelevant as of now, a niche of a niche.

>>105671436
return is goto on steroids
defer is goto on sterioids
destructor is goto on steroids

managed runtimes are future and still be a future. nobody really cares about another memelang#110. the web is powered by managed runtime, and it has exceptions, so is python, 2nd most popular managed runtime in the world.

>>105672248
U mean locked down goto?

>>105665224 (OP)
yes
yes
yes
jobs relating to cloud & server-side infrastructure and web services and so on, some back-end stuff like java

>>105672041
>Cope the post

>>105666988
>yet developers in those other languages don't ever seem to get bogged down in this mythical "academic masturbation".
Strangely, they don't seem to actually make anything either. When was the last time you or I used something written in Ocaml, Lisp, or Haskell? Meanwhile Go code is firing every time you hit a google search.

Rust and Go won

>>105672248
return, defer and destructor's are structured programming because their control flow is deterministic. exceptions are not

all of these wildly successful C# libraries have been rugpulled and turned into paid products by the way.

identity server, fluent assertions, automapper, mediatr, masstransit, imagesharp, questpdf, avalonia

>>105672466
>When was the last time you or I used something written in Ocaml, Lisp, or Haskell?
I said employable languages. C# is a very complex language and yet the .NET job market completely mogs your language.
FP weenies live rent free in every gopher's head, and that is why we call you retards.

>literally the only languages are go and haskell

>>105665224 (OP)
>what are the money making prospects of this language?
we're hiring two or three cloud systems engineers, don't be afraid to apply if you don't know everything
https://job-boards.greenhouse.io/runpod/jobs/4142227008

tempted to pick it up simply for the job prospects. it doesn't really appeal to me otherwise

>>105665468
everything here is correct, never touched go in my life before but it just werks. You generally understand what's going on in the codebase just by simple inspection

>>105672519
it seems that everything that isn't if, else, return keyword appears to be underteminstic in go programmer's mind.

>>105672932

How hard is go to master if I know erlang and elixir?

>>105672932
Value-based errors are perfectly fine. The actual problem is that the Go developers are such anal retentive faggots that they refuse to add any sort of syntactic sugar for it.
If you want a laugh, read the Go dev blog's most recent post: https://go.dev/blog/error-syntax
>we found a way to fix this massive design defect!
>we're not gonna use it tho lol get fucked

>>105672977
So what's the difference between throw and panic?

>>105674118
Panic halts program execution immediately.

>>105674118
Functionally, very little, its a way of suspending control flow and resuming it somewhere non-local. In practice though, it is very different in how its used.

Panic is a supplemental way to handle errors, and is generally only used when control flow crosses an api boundary from within a framework, libraries are strongly discouraged from panic-ing if they can, and frameworks only recover because they cannot guarantee that the code they call into won't panic. When using errors as values, there is never any ambiguity of what will happen when an error occurs, and panics are reserved for truly exceptional situations, usually programmer errors like null/nil pointers, out of bounds array access, out of memory, or the like.

Meanwhile, when exceptions as the primary error handling method, it requires extra inspection of the code to figure out what the code will do when an error occurs, and even to figure out where an error could occur. Exceptions have to be made very complicated to handle all the different ways to handle an error, and which errors to handle.

Panic/recover is deliberately clunky and opaque, because it is only needed for situations where there really isn't much you can do other than log it, return a pre-baked response, etc, and hope it doesn't happen again, but you are able to keep the process going.

>>105674272
Completely untrue. Panics can be handled, and even handled recursively.

>>105674349
whats the point of handling a panic if its not gonna terminate the program?
why not use just errors in that case?

>>105674118
go and rust differentiate between recoverable errors (Result<T> or value, error = something();) and non-recoverable errors (panic). in languages with exceptions there's no distinction. or rather, they are all recoverable.

>>105674408
out of bound access panics, otherwise u would have to check for error everytime u access any memory which would very be expensive for every little gain since it basicly should never happen.

>>105665224 (OP)
it's a shitlang

>>105665468
>so you little to lose.
saar

>>105665224 (OP)
>should I learn this?
Yes
>is it well designed?
Haskell is exceptionally well designed. Tho I don't see anyone using it in production
>is it useful?
Yes, you can do most webshit with the standard library and net.http
>what are the money making prospects of this language?
if you're learning programming for the solve purpose of getting a job you should quit and go into engineering or some other field with more stability. Learn a language because it's fun.

>>105666917
>meanwhile, actual mathematicians laugh at CS kiddies lmao
most mathematicians could be programmers. Most programmers couldn't be mathematicians

>>105674408
in context of http server, "a program" is a request handler. you may want to terminate the request, but not the server.

exceptions is a useful mechanism to terminate certain behaviors without killing the whole execution process.

>>105675062
errors are values that should be handled as such

>>105674408
>>105675025
Also, in some cases, code can be much easier to read and maintain if you use panic as an exception. Generally this is if you're doing some kind of operation that involves deeply nested iteration and whose work can be safely discarded if you hit any error, like parsing. In that case, you have a bunch of unexported functions that could hit errors that bubble up to a single call point, and you can have that single call point recover from any panics downstream. That makes the lower-down code much more terse and understandable. Of course, it doesn't have to be written like that, it's just a valid option given the natural shape of the problem.

The JSON parser in Go works this way IIRC.

>>105673034
Sounds like the real issue is that it's obnoxious to add fmt.Errorf() to decorate each of your errors, such that returning err itself is preferable.

>>105672977
if you have trouble understanding exceptions, then imagine that compiler just adds error as additional returned value of every function, and injects if err != nil after every function call. you just don't need to type it manually.

this gives you the following reasoning:
* all functions throws (you dont need to make it visible, because it is reduntant)
* there is exit point after every function call (you dont need to make it visible, because it is reduntant)
* finally blocks exist to handle exit points

C and Go. It's as shrimple as that.

>>105675299
>Unfortunately, as with the other error handling ideas, this new proposal was also quickly overrun with comments and many suggestions for minor tweaks, often based on individual preferences. Ian closed the proposal and moved the content into a discussion to facilitate the conversation and to collect further feedback. A slightly modified version was received a bit more positively but broad support remained elusive.
Read between the lines and you quickly realize how disingenuous they are. Of course you won't get universal consensus for a language change, if they cared about that they sure as hell wouldn't have added Go's generics, which are so badly designed that they feel almost spiteful.
They will never fix Go's defects because in their minds, Go does not have defects. It is a moron's Platonic ideal of programming.

>>105665224 (OP)
Idk about the simplicity. Shitting out code in java is way easier for me.

>>105675725
how many times do we have to repeat this... simplicity is not ease of use. Python is easy tho it's not simple, C is hard (for an indian) tho it's simple. Simplicity means less abstractions, less abstractions means you understand how your code actually works, which in turn leads to less bugs and more debuggable code. OOP by definition is a massive overbloated abstraction that is an absolute mess to work with, ESPECIALLY if you follow all the "clean code" ways to do OOP abstractions.

>>105675768
C ain't simple. Python ain't simple either. Golang ain't simple

>>105675797
simple as

>>105675816
Lisp. C is complex because of rules made by the committee and a lot of UB, most people think that it's simple but they ignore a lot of implicit things C is doing under the hood.

>>105675874
C translates neatly into assembly, and what the compiler does under the hood is irrelevant, you can write a compiler for C yourself in under a week.

>>105665224 (OP)
Yes, it's very nice and straightforward.
I don't see why you wouldn't.

>>105669226
You can learn all that in 2 weeks. You don't need 100 days.
Up to "concurrency" you can learn everything in 2 days. After that (advanced concepts and projects) you need more time to grasp the concepts and truly understand them

>>105675956
>C translates neatly into assembly
Hmm

>>105676078
it does tho, if you discard compiler optimizations you can 90% of the times know the assembly generated based on the C code, which is not the case for other languages with more abstractions layers

>>105665224 (OP)
I learned go 5ish years ago because everyone on /g/ hated it, so I wanted to try it. It quickly became my favorite language and now I make $150k/year writing only go. It is dead simple, sometimes to a fault admittedly. You can get shit done so fast, it compiles fast, and the performance is "fast enough". Just give it a shot anon so you can learn if you like it, who gives a shit.

>>105676295
How did you get a job?
Was it hard, like did they ask too many advanced questions or library-related questions?

>>105665224 (OP)
I find it so funny that retards in this board let obvious malicious retards influence their opinions on things, like in this case, a simple and easy to learn programming language.

>>105665224 (OP)
do the Go tour: https://go.dev/tour/welcome/1 or learn from this book: https://www.golang-book.com/books/intro

>>105676301
Reach out to recruiters at companies that you know are using go. I didn't actually do that for this company, but a recruiter reached out to me on linkedin. I wasn't asked a single go-related question in any of the interviews. I asked all of the go questions to the actual devs and hiring manager at the final interview, which I think got me a lot of "bonus points". All of my leetcode-style questions I did in python because go is frankly awful at that.

>>105676367
Congrats.
I'm looking to get a Go job myself, I've been studying for the past year.
But I'm also sending Python resumes because there's not a lot of Go jobs here (most of them require previous experience and Docker knowledge)

>>105676414
Docker isn't too hard, I also use it often. Definitely worth learning. You should obviously try to get a job in your favorite language, but still getting any experience on your resume as early as you can is valuable. Good luck anon.

>>105672510
You will never be a woman. Get your disgusting hands away from my chudlang.

C
Go
Erlang
Shan’t need anything else unless it’s domain specific (SQL)

>>105665224 (OP)
It is good but it tends to get high on its own farts. Definitely learn it, though, it's better than the alternatives.

>>105674499
Yea but you can return Result<T> in any lang, it's just a convention. And go can recover from panic which is basically a catch.

>>105672510
Cute pic.
Rust is this autistic crap headed to c++ land.
Things that annoy me about go (today).

No unions.
bool “true” can’t be used as 1 for many computations that need that, like computing words in a certain number of bits.
Elses have to be cuddled. Fuck.
Hello world is 1 MB. Why?

Might try tinygo one day.
Already switched to pcc from gcc the other day.

>>105678350
Because it's including a runtime and garbage collector in that 1mb. Tinygo does it in 10k with everything stripped out.

>>105672510
>tfw no CGF

>>105678519
The assembly code go generated looked on par with C except for some bounds checking calls which I could NOP out if I cared enough. Used objdump. Never used it before.

I tried godbolt but import fmt kills the compile on cpu limit. Nice! POS.

>>105666389
Go has some very regarded design decisions and the worst part is they stem solely from the language creators huffing their own farts
Some examples:
>the absolutely retarded error handling
>no generics (the pushback on this was so big they had to walk that one back and actually implement generics kek)
>using an actual date for formatting, good luck memorizing it lmfao

>>105672014
One guy chose to rewrite tsc in go and he got fired for it

>>105672014
Retard

>>105679360
not an argument

>>105677767
Do you get high on other people's farts?

>>105678649
>the absolutely retarded error handling
I didn't ind it that bad. Multiple returns are fine.
in 2017 our C++ fellows discovered hacks to allow multiple returns and they rewrote stuff to be one big function with 8 return values and one argument to specify what function it was. Yes, they’re retarded.
>no generics (the pushback on this was so big they had to walk that one back and actually implement generics kek)
Again, coming from a C++ shop where generics were abused, I never wanted to see sny more templates. In go, I didn’t use them except for a couple of template one-liners to fix deficiencies in ‘go’… seems fine, don’t need it though because I can use CPP with ‘go build’ if necessary.
>using an actual date for formatting, good luck memorizing it lmfao
Not sure what this means, it sounds like I will be annoyed when I encounter it

>>105681944
>Multiple returns are fine
if _, _, err := c1.WriteMsgUnix(wb, nil, a2); err != nil {
t.Fatal(err)
}
if _, _, _, _, err := c2.ReadMsgUnix(rb2, nil); err != nil {
t.Fatal(err)
}
if _, err := c2.WriteToUnix(wb, a1); err != nil {
t.Fatal(err)
}
if _, _, err := c1.ReadFromUnix(rb1); err != nil {
t.Fatal(err)
}
if _, err := c3.WriteToUnix(wb, a1); err != nil {
t.Fatal(err)
}
if _, _, err := c1.ReadFromUnix(rb1); err != nil {
t.Fatal(err)
}
if _, err := c2.WriteToUnix(wb, a3); err != nil {
t.Fatal(err)
}
if _, _, err := c3.ReadFromUnix(rb3); err != nil {
t.Fatal(err)
}

Totally fine amirite fellow sois
>mfw this is the most concise way to write this in go

>>105682045
If ur that annoyed just recover the panic but u will lose context like u would with normal exceptions

>>105682170
>the only way to write concisely and clean in the language is to use retarded hacks everyone says are a big nono
Thanks for proving my point
>like u would with normal exceptions
Gobabby never worked with a real language

>>105665224 (OP)
>should I learn this?
Yes, primarily because it's very simple and takes a low amount of time to learn
>is it well designed?
Absolutely not
>is it useful?
I don't know, I use Go for these small projects that I don't really feel like "deserve" to receive a fully featured good language and I regret it every time. And yet I keep using it, something about it is appealing, goroutines probably.

>>105682197
I prefer error as values everyday, u just complained about shit u don't care about

>>105682317
But it should be Either on which you pattern match and not this if err != nill crap

>>105682314
for me, it's because it's fast and concurrency is trivial, perfect for script and small programs
like you, I don't use it for sufficiently large systems

>>105665224 (OP)
>is it well designed?
It's simple and there's no magic. I've heard it described as a 'chainsaw' of a language with no elegance(not having any sophisticated error handling has been a persistent sore spot).
>is it useful?
If you want to design a CLI tool like docker, kubectl, hugo, trivy, etc. then it's an extremely good choice. It's also great for writing server handlers and data transforms.
>what are the money making prospects of this language?
Almost anywhere Python can go, Golang can also go and be more performant. The one exception is being an embedded scripting language, but anything standalone I've mentioned like server software or CLIs you'd write in Python can be written faster in Golang. Plus, because Golang is simple, the transformations are pretty straight-forward.

for all the gofags: IGNORING COMPLEXITY DOES NOT SOLVE IT

>>105665224 (OP)
this retarded beaver looked at the evolution of programming languages and just said "nah, I'd win"

>>105675253
In the context of go this makes sense, but in general why use a language construct meant for handling exceptional events for simple control flow (it is called panic after all)? For example in elixir you can throw and then catch a value if you need to break out of a deeply nested call, to bubble an exception you can use raise and rescue. If go is a ‘simple’ language why have panic mean more than one thing?

>>105665224 (OP)
I hate how retard golang library is, it's like a mixture of suckless + more incompetence, for example gzip implementation is very straightforward but also it's times slower than a modern zlib implementation, my guess is that other part of the golang library are also slower than original implementations.

>>105681944
>Not sure what this means
These are the time package's constants:
const (
Layout = "01/02 03:04:05PM '06 -0700" // The reference time, in numerical order.
ANSIC = "Mon Jan _2 15:04:05 2006"
UnixDate = "Mon Jan _2 15:04:05 MST 2006"
RubyDate = "Mon Jan 02 15:04:05 -0700 2006"
RFC822 = "02 Jan 06 15:04 MST"
RFC822Z = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
RFC850 = "Monday, 02-Jan-06 15:04:05 MST"
RFC1123 = "Mon, 02 Jan 2006 15:04:05 MST"
RFC1123Z = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
RFC3339 = "2006-01-02T15:04:05Z07:00"
RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
Kitchen = "3:04PM"
// Handy time stamps.
Stamp = "Jan _2 15:04:05"
StampMilli = "Jan _2 15:04:05.000"
StampMicro = "Jan _2 15:04:05.000000"
StampNano = "Jan _2 15:04:05.000000000"
DateTime = "2006-01-02 15:04:05"
DateOnly = "2006-01-02"
TimeOnly = "15:04:05"
)

Instead of using placeholders like %d, time formats are written in terms of the reference time Layout: Monday, January 2 2006, 03:04:05 p.m., UTC−07:00. This has the benefit of showing you what the formatted time will actually look like.

>>105672510
holy waifu

>>105684056
you argue over semantics. none of this matters once you realize that exception is just the same error value, delivered via language built-in dedicated error path instead of conventional "return" path.

does it really matter how you get the error object?

>>105682045
> If _, err := foo(x); err != {
I’ve never seen two if conditions like that.
Nice, I’ll start using that if my old go version supports it. Thanks.
Yeah, those returns are a bit over the top.
I came from C so, I’m desensitized to it.

> you'd write in Python can be written faster in Golang
Let’s leave python programmers to python as a retard containment facility.

>>105684236
Everything but 2006-01-02T15:04:05
LOL!

>>105684909
>Everything but 2006-01-02T15:04:05
Use RFC3339 for that.

bump

>>105684533
I understand the control flow, my point is that it would be simpler for the human reading the program if ‘panic’ didn’t signify two things; an early return from a nested call, or an unexpected event that should crash the program if unhandled. Go equates small syntax with simplicity, but I don’t think the two are the same.

>>105665224 (OP)
good morning saaaaaaaar

>>105687006
Hey buddy I think you got the wrong thread. Java{,script}'s two blocks down.

>>105665224 (OP)
>should I learn this?
Yes
>is it well designed?
Fuck no
>is it useful?
You can write software in it
>what are the money making prospects of this language?
It's this generation's java