Made with KolourPaint and screenshots from Kate (with the GitHub theme).
In Kotlin, you can have the type become implicit with the former syntax: let text = number.toString() (text is a String here)
this post was submitted on 19 Jun 2025
47 points (87.3% liked)
Programmer Humor
36575 readers
303 users here now
Post funny things about programming here! (Or just rant about your favourite programming language.)
Rules:
- Posts must be relevant to programming, programmers, or computer science.
- No NSFW content.
- Jokes must be in good taste. No hate speech, bigotry, etc.
founded 5 years ago
MODERATORS
char[] a; // like a boss
Enlightenment is realizing that variables don't have nor need a type, they are all just arrays of bits.
True enlightenment is realizing that variables don't exist, it's all just a sequence of bits in RAM that we assign meaning to as desired.
Ascension is realizing that bits don't exist, it's all just trapped electrons in transistors which we imagine to be bits.
Transcendence is realizing that transistors or code doesn't exist, and it's just some quarks and electrons attracted and repulsed by weird forces, vibrating and convulsing in a soup with entropy constantly rising until the heat death of the universe, of which we make futile attempts to make sense or purpose.
well, the : String is supposed to be optional right? type inference should know what it is. In truth though, return type polymorphism makes us write more type annotations than I would like.
Because let x: y is syntactically unambiguous, but you need to know that y names a type in order to correctly parse y x. (Or at least that's the case in C where a(b) may be a variable declaration or a function call depending on what typedefs are in scope.)
Can't say I've ever experienced this kind of confusion in Java but that's probably because they intentionally restricted the syntax so there's no ambiguity.
Also useful when the types are optional, like Python. Though they don’t use any let or var or anything so maybe throw that entire point out the window
My attempt of an honest answer to my best knowledge:
As @TootSweet@lemmy.world mentioned, to make a programming language closer to spoken English language, most likely (hi, Python, I am looking at you too). Which infuriates me immensely: when programming, I do not speak languages, I express data structures and operations on them, stacked one upon another. The last thing I need here is ambiguity, loose structure and information duplication (forgot correct term for the last one) that are typical to natural languages of human communication
This is how it is done:
$a = ""
PHP forever. 🤲 Amen.
You left a “can rot in hell” between your php and forever
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.
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).
its makes more sense to say "a pizza slice". using "of" in this way is from french.
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
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!
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.
If you actually use code like this you're insane.
var a string
or,
a := ""