93
Why make it complicated? (lemmy.ml)
submitted 5 days ago by HiddenLayer555@lemmy.ml to c/programmerhumor@lemmy.ml
53 comments fedilink hide all child comments

Made with KolourPaint and screenshots from Kate (with the GitHub theme).

you are viewing a single comment's thread
view the rest of the comments
[-] TootSweet@lemmy.world 8 points 5 days ago* (last edited 5 days ago)

The Go programming language documentation makes a big deal about how it "reads from left to right." Like, if you were describing the program in English, the elements of the Go program go in the same order as they would in English.

I say this as someone who likes Go as a language and writes more of it than any other language: I honestly don't entirely follow. One example they give is how you specify a type that's a "slice" (think "list" or "array" or whatever from other languages) of some other type. For instance a "slice of strings" would be written []string. The [] on the left means it's a slice type. And string on the right specifies what it's a slice of.

But does it really make less sense to say "a string slice"?

In Go, the type always comes after the variable name. A declaration might look like:

var a string

Similarly in function declarations:

func bob(a string, b int, c float64) []string { ... }

Anyway, I guess all that to say I don't mind the Go style, but I don't fully understand the point of it being the way it is, and wouldn't mind if it was the other way around either.

Edit: Oh, I might add that my brain will never use the term "a slice of bytes" for []byte. That will forever be "a byte slice" to me. I simply have no choice in the matter. Somehow my brain is much more ok with "a slice of strings", though.

[-] bleistift2@sopuli.xyz 6 points 5 days ago

But does it really make less sense to say “a string slice”?

That’s an interesting point. You say “a pizza slice” or “a slice of pizza”, but you only say “a slice of bread”, not “a bread slice” (right? I’m not a native speaker).

[-] charje@lemmy.ml 3 points 5 days ago

its makes more sense to say "a pizza slice". using "of" in this way is from french.

[-] eager_eagle@lemmy.world 3 points 5 days ago

personally, I've heard a lot more "bottle of water" than "water bottle" in the US

this "reads from left to right" really doesn't hold up

[-] melvisntnormal@feddit.uk 5 points 4 days ago

This might be getting into the weeds a little, but to me, "bottle of water" implies a single-use bottle already filled with water, while "water bottle" implies a bottle that is made to be (re)filled with water

[-] TootSweet@lemmy.world 2 points 5 days ago* (last edited 5 days ago)

Yeah, I think "a slice of bread" is a lot more common than "a bread slice". Not to say I haven't ever heard "a bread slice" used. I'm sure I have at least a few times. It would be pretty rare, however.

Though, I'm not sure "a pizza slice" is all that much more common. Maybe there are regions where it's very common? Or maybe it's more common in certain contexts? Like maybe sell-by-the-slice pizza places might tend to refer to "a pizza slice" rather than "a slice of pizza" when talking with coworkers? (That said, I'd imagine they'd just shorten it further to "a slice" since the "pizza" part would tend to be obvious in that case.)

Also, @eager_eagle@lemmy.world mentioned "water bottle". I think if I hear "a water bottle" rather than "a bottle of water", I'm probably going to assume it may or may not be an empty bottle intended for water rather than a bottle filled with water as "a bottle of water" would imply.

Way off the topic of programming, but linguistics is fascinating too!

[-] barubary@infosec.exchange 2 points 4 days ago

Both of those declarations look weird to me. In Haskell it would be:

a :: Stringbob :: (String, Int, Double) -> [String]bob (a, b, c) = ...

... except that makes bob a function taking a tuple and it's much more idiomatic to curry it instead:

bob :: String -> Int -> Double -> [String]bob a b c = ...-- syntactic sugar for:-- bob = \a -> \b -> \c -> ...

The [T] syntax also has a prefix form [] T, so [String] could also be written [] String.

OCaml makes the opposite choice. In OCaml, a list of strings would be written string list, and a set of lists of strings would be string list set, a list of lists of integers int list list, etc.

[-] sph@lemmy.world 3 points 5 days ago* (last edited 5 days ago)

Go's syntax is vastly superior once you have more complicated signatures, then the left-to-right truly matters. For example a variable that contains a pointer to a function that takes a function and an int and returns another function (like a decorator).

In C the order becomes very hard to understand and you really have to read the thing several times to understand the type of fp:

int (*(*fp)(int (*)(int, int), int))(int, int)

In Go, you can just read from left to right and you can easily understand what f's type is:

f func(func(int,int) int, int) func(int, int) int

It's just much more readable.

See: https://go.dev/blog/declaration-syntax

[-] phlegmy@sh.itjust.works 2 points 4 days ago

If you actually use code like this you're insane.

[-] sph@lemmy.world 4 points 4 days ago* (last edited 4 days ago)

This obviously just illustrates a point, but callbacks and decorators are not uncommon. And iterators are exactly like that:

type (
	Seq[V any]     func(yield func(V) bool)
	Seq2[K, V any] func(yield func(K, V) bool)
)

Which is very readable.

[-] phlegmy@sh.itjust.works 2 points 4 days ago

Callbacks and decorators are fine, but callbacks/decorators to a function which itself takes a function pointer and returns another function pointer are crazy.

I've thankfully never had to use recursive callbacks or decorators, but it seems like it could very quickly become difficult to keep track of.

[-] sph@lemmy.world 3 points 4 days ago* (last edited 4 days ago)

I don't think it's that uncommon. Let's say you have a function that handles a request. A common use case is to add permission checks before applying that function. You can write a generic permission check a bit like this:

func NeedsPermission(f func(Request) (Response, error), perm string) func(Request) (Response, error) {
    return func(r Request) (Response, error) {
        if !check(r, perm) {
            return nil, NewPermError(perm)
        }
        return f(r)
    }
}

// elsewhere
Bar := NeedsPermission(Foo, "superman")

This would allow you to separate the permission check logic from the business logic. Though to be fair, in Go they prefer to keep things as simple as possible but it's just to illustrate that these concepts are not that alien.

[-] ThirdConsul@lemmy.ml 2 points 4 days ago

Wait until you learn about transducers (Are they in Go? If not natively, someone definitely ported them) and the abominations fp people code with them.

[-] barubary@infosec.exchange 1 points 4 days ago

To be fair, the C example could be detangled a lot by introducing a typedef:

typedef int Callback_t(int, int);Callback_t *(*fp)(Callback_t *, int);
[-] sph@lemmy.world 2 points 4 days ago* (last edited 4 days ago)

True, but that requires writing an additional definition and hides the parameter types, which can be very interesting, and you'd need a typedef for every new param combination I guess. It feels like a solution for a problem that could have been avoided by a better signature syntax in the first place.

this post was submitted on 19 Jun 2025
93 points (86.6% liked)

Programmer Humor

36707 readers
60 users here now

Post funny things about programming here! (Or just rant about your favourite programming language.)

Rules:

founded 5 years ago
MODERATORS
AgreeableLandscape@lemmy.ml
cat_programmer@lemmy.ml