Go: 1 Thing I Would Change 

YES i was right, go’s specific choice to leave out proper enums I will never understand or forgive

And pattern matching

iota? why iota use another fucking language

@@irfanfauzi8704 yes!!

There's a reason for leaving out enums though (I also haven't watched the video yet) In a language with real closed enums, there's no way to add a new value to an existing enum with a lot of uses through a large codebase. You have to rely on documentation to tell people to always include a default: when they pattern match on your enum, or resort to hacks like __DONT_MATCH_ON_THIS_VALUE as one of your enum values, if you know you want to be able to extend in the future. Go takes the position that enums should be extensible by default. This means the compiler can't check for exhaustive switch statements by design.

ikr. they've basically just recreated the same conditions that led to modern java.

@@raianmr2843 that aint modern java bro, modern java is sealed interfaces with switch expression pattern matching (yes, java has sum types, hello), but if we are talking about generics, modern java isnt out yet even (see project valhalla)

HAHAHAHAHAHAHAH

Go enums feel very similar to enums in C, but without a keyword. In C (not C++), enums are also just named integer constants and provide no safety.

@@alexanderdaum8053 Yes, but at least their syntax is consistent with the rest of the language and doesn't have a magic keyword called iota somewhere in the middle. If they want it to be just constants in a trenchcoat then they should at least commit to that.

that is what _should_ happen

it's a shame modern editors can remove all 4 with one keypress. only 1/4 the fun!

you don't have to use JSON.parse to get the issue you can just const a: number[] foo = [1, 2, 3]; and then pass it into a (number | string)[] function on top of that, JSON.parse just makes everything much harder

@@ThePrimeTimeagen Yeah, the (number | string)[] example is really good to showcase that.

You're missing the point. JSON.parse shouldn't return *any*, it should be *unknown* instead. TS has many such escape hatches to silently turn off the type checker or even develop false deductions. If you don't consider these to be the flaws of a typed language then I don't know what to say to you.

@@raianmr2843 I agree that JSON.parse, as well as the .json method from the fetch response, should all return unknown instead of any.

Are you trolling?

@@nikalisten you don't know how much bs each function provides because of the shit docs right? Yeah I would want to change that asw

Enum classes, std::array, vector, and string, namespaces for god's sake! Hot take: you should never program in C. Namespaces ALONE is enough of a reason to choose C++. If you don't like all the other stuff C++ brings to the table then don't use it.

⁠​⁠​⁠@@lucass8119Damn chill out lol. For low level purposes (embedded, os etc), C is still preferable in many cases. Most of C++’s additions aren’t useful in those environments and the rest aren’t worth the added complexity to the tooling

@@theoaway Its really not preferable, because even if you remove 99% of C++ there's still huge additions there. Could you even begin to imagine how much cleaner the Linux source code would be if it utilized namespaces? No more confusing names! Or enum classes. They're literally just C enums but... typesafe and readable. Just a direct upgrade. There is exactly one reason only to still develop in C: interop. C binds to other languages with very little effort because its the super old standard. This is why GTK has bindings for everything under the sun and Qt has... python only.

@@lucass8119 I’m glad you brought up the ABI, because that’s only one part of the portability issue which is where C wins every time. C is much simpler than C++ and the language spec is far less ambiguous, so you get far more portability and flexibility across different compilers. This is especially important for more obscure hardware where there is likely no reliable C++ compiler, if one even exists in the first place. This is a big drawback especially for memory constrained environments where you’ll basically just be writing C anyway with a few additions. The tradeoff just isn’t worth it for many, especially since a lot of your arguments are about readability which is very subjective. You personally might find the linux kernel more readable if it were to use namespaces, but many kernel developers would be less than thrilled.

@@theoaway I think the kernel developers would be less than thrilled, because of the negative associations with C++. But the thing is people hack together C++ solutions in C all the time, using macros. Its incredibly unsafe and error-prone, but they still do it. Going back to GTK, they have an entire object system written in C macros. It's not a stretch to say that is MUCH less readable than simply using a language that includes those features, namely C++. In fact for GTK it was SO unreadable they implemented their own language, Vala, as a wrapper around their C OO system. It seems to me most complex C systems long for the features of C++ but refuse to adopt it. Instead, they opt for implementing generic data structures with macros (C++ templates), polymorphism with void pointers as struct member (C++ virtual), inheritance with Macros, and on and on. It's all very perplexing to me. Surely C is a simple language. And yet, it is used and abused with hacks just to achieve simple built-in features of C++. And the cost is great. Debugging is now SO much harder, because your source code changes without you knowing through macro abuse. Side effects happen when you can't see them, objects inject themselves into scopes when there's no assignments, simple function calls can fail with a seg fault.

i’ve only eaten bushs baked beans (the kind with the little bacon bits) for the last 3 months

two subpar ways go devs are meant to cope with the lack of comptime 😂

That makes more sense to me. It bugs me that people ask for some kind of concept that is not enumerating, but a definition of a set with its possible values. And they have an audacity to call it "real enums", go has real enums.

Unique is not equal to insane. I programmed a CDC Cyber-170 mainframe and had to remember to "rewind" my source code files after each compile before I could edit them. This was unique but not insane.

"We do not want to break the ecosystem. Go 1 and Go 2 code must be able to interoperate in programs with ease."

i hear you, but that isn't always an option. have you ever worked with a type that is a union of several other events, `Event`. the next thing you know your LogEvent array has a VideoFrameDecodeEvent in it. much sadge

@@ThePrimeTimeagen Nah I know the pain man, just messin around and pumping the algo fo ma boi

@@ThePrimeTimeagenyou can create a utility type for that, never worry again.

@@ThePrimeTimeagen but from the function's perspective, there's nothing wrong with this except not being able to optimize. if the function is making the requirement that the param should be any array that includes strings or numbers and a caller passes in an array exclusively with numbers , from the function's perspective it was already going to have a logic fork if it did anything specific on those types. this makes sense in javascript to me. in rust of course i would expect these types to be completely different types. and you would also have guarantees as the caller in rust about mutation. but since typescript has no such mutation guarantees, and many other reasons you know of, typescript will never be rust. and that's definitely okay for example , this TS function changes dramatically with slightly different function signature ex.1 const foo = (args: (number | string)[]): (number | string)[] => {...} ex.2 const foo = (args: readonly (number | string)[]): (number | string)[] => {...} the former implying that this function might add a string into the caller's Array

This

i am unsure if i purchase this as truth that because go isn't the best leetcode program means that hidden complexity grows. go has a weakness, rust has weaknesses, typescript has weaknesses

You don't like container/heap 😭😔

Its not null its nill höhöhöhöhöh I kid.

I think tabs would be more popular if it wasn't a width of 8 spaces by default (I understand there's history here but whatever). w/ an editorconfig it doesn't matter but seeing it in the web without tab-size configured is very, very jarring, especially with 2-4 spaces being most common nowadays

@@cowslaw tbf, I normally configure it to 8 width anyway

@@kuhluhOG average tab user

@@cowslaw It's nicer on the eyes in the long term

Just need more tooling that just flips to tabs during builds, compiles, or commits, like how git will do line-feeds with very little effort. If it's not on my work surface I don't care if it's tabs or spaces. Like when doing web-dev two spaces is ideal to keep things from going offscreen. tab indentation just gets to be too much even when doing things like giving element attributes their own line.

I am selfish.

@@wagslane and that's good. We all need to be, to a degree. I do agree with you that simplicity beats complexity, just disagree as to what kinds of complexity are necessary, or maybe just exceptions to the rule. Generics, simple generics, not something crazy like C++ has, are in my mind a necessary feature of statically typed languages.

agreed. it's great for defining flags and stuff. the entire point of iota is you can't care about the actual number it is (e.g. serialize it). if you want the max number for validation add something unexported to the bottom of the iota. this being said i 100% agree Go needs sum types.

You're missing the point. It's like saying C++'s switch construct is great because it lets you do this this and this when Rust's match expression is clearly a better designed and safer construct. Iota is a subpar excuse that only exists because Go lacks a straight forward means for compile time code execution. These issues aren't noticeable to people who've only written code in the language being criticized. In languages like Rust and Zig you don't *need* iota to achieve this. Iota sticks out like a sore thumb in Go's attempt to be a language with a finite set of universally applicable constructs with more than one use, which is ironic because this is the same point they bring forward when dismissing worthwhile proposals to the language from the community.

I'm not missing the point, but thanks

That's true, but what I meant was the definition of the type really is the same. It's still all ints

It's definitely a leaky abstraction. Go will let you add two Colors just fine 😅

i thought it was too

But that's just the because it only provides two levels of visibility: public and private, not because its case sensitive. Replacing the case sensitive rule by a single keyword pub (but no protected keyword) for public identifiers would provide all the advantages in simplicity and just make it more explicit.

basically odin minus the concurrency model

@@raianmr2843 really? Maybe i should check it out

But that's recent addition to language.

@@GreyDeathVaccine So what?

number[] and (string | number)[] are different types. every language since the dawn of time has seen that. the fact that you have to add conditions under which the programmer should program means that you have created a bad type system. "if you would just program pure functional programs" - copium

myThing (number[]) ends up with a string in it "420". That's indeed quite crap.

@@ThePrimeTimeagenbut in typescript they're different, but one inherint from the other.

It doesn't seem like total crap to you because you're more used to structural typing. In TS's point of view, number[] is acceptable because it fulfils the (string | number)[] contract. But the only reason TS chose to be this way is because it's hosted on JS. This is essentially a type system compromise that almost no other typed language has to deal with.

So what? Mutability is not bad, only Rust and Haskell coomers think that

There seems to be a misunderstanding. Go has types *and* literals. Your version of the code throws an error whereas this will gladly be accepted by the compiler: package main type Color uint8 const ( Red Color = iota Green Blue ) const NotAColor uint8 = 128 func giveMeAColor(c Color) {} func main() { giveMeAColor(Red) giveMeAColor(128) //

​@@raianmr2843 Good point, I did not think of that, since the point of Enums would be to not input raw values. I guess you could combine the approach of not using iota to define the enumeration. And then make the function parameter a pointer, that way you cant put in literals and the compiler still can handle the type checking. Not ideal, but far of from the mess and huge overhead, that the article describes. package main type Color uint8 var ( Red Color = 1 Green Color = 2 Blue Color = 3 ) var NotAColor uint8 = 128; func giveMeAColor(c *Color) { } func main() { giveMeAColor(&Red); giveMeAColor(&NotAColor); // Throws error as before giveMeAColor(128); // also throw error, since you cant take the adress of litteral like that }

WAIT A SECOND

Minus great concurrency :D

it doesn't make sense no amount of copium makes sense. number[] and (number | string)[] are two different types. plain and simple

You kinda can-ish lol - dotnet for example typeof(List).IsAssignableFrom(typeof(List)) this would work but not using "is" (so basically runtime still but ey) But yeah I do agree I wish the type system could be better, more strict and more intuitive, but ey, still better than JS XD Besides once you kinda get used to the fact that TS basically treats them as a subtype of the union instead of as another type, it's not bad. Feels icky tho when you're in a position where you need to jump between languages. I honestly can't believe python has better typing than TS now lol List[Union[int, str]] != List[int]

​@@cpuccinothat doesn't work? List is invariant over T. IEnumerable for example _is_ covariant because it only supports reads and not writes. In general, any datatype supporting both reads and writes should invariant, so widening number[] -> (number | string)[] shouldn't possible, but number[] -> ReadonlyArray -> ReadonlyArray should be.

Oh yeah nice catch, forgot about that.

@@ThePrimeTimeagen In typescript (number | string)[] is a array of string or number, number[] pass that validation if you wanna make that only you can pass a full array of string or full array of number do this: ```ts const a: (number | string)[] = [1, 2, 3, "sd"]; function example(arg: string[] | number[]) {} // Argument of type '(string | number)[]' is not assignable to parameter of type 'string[] | number[]' example(a); ``` This will error!!!

That doesn't get us compile time warnings :(

rust does both with same enum syntax, since enums are tagged values you just assign which number is the tag after the equals sign

What?

@@GrantGryczan - en.wikipedia.org/wiki/%C3%89variste_Galois - en.wikipedia.org/wiki/Group_theory Easy and crystal clear management of *composable groups* and automated reduction at compilation is all you need from a programming language. Everything else is whim.