What simple things annoy you about your favourite programming languages?

Every language has nuances. Sometimes they can be ignored, other times they get in the way, yet other times they lead to defects. Most disturbing are simple things that are missing, something that exists in another language, or something that seems like it'd be easy to implement. Perhaps it's just a minor syntax flaw, ambiguity, or library limitation.

What are the simple things in your favourite languages that give you grief on a regular basis?

Comments

[Danol]

[D] I cannot decorate enum members with user defined attributes :/

@("This works") int x;

@("This also works") enum E {
  @("This does not work") a
}

[edA‑qa mort‑ora‑y]

Inconsistency is a plague across so many languages. Features that can only be used on certain constructs. It creates all sorts of mental overload, and results in one not using all the features where possible.

[Frederik 👨‍💻➡️🌐 Creemers]

In Python:

"Hello" "World" == "HelloWorld"

This leads to bugs when you're writing an array of strings. This happens to me especially often when writing Django settings.py files

INSTALLED_APPS = [
  "foo",
  "bar"
  "baz"
]

This sets ÌNSTALLED_APPSto["foo", "barbaz"]`. I wish this would throw a SyntaxError.

[edA‑qa mort‑ora‑y]

C and C++ both do such string concatenation as well, though I've always considered it a feature. Put in this form it definitely will lead to unintended defects.

I wonder why it's there, given PYthon has string concatenation with a simple +.

[tbodt]

Because

"hello" +
"world"

is a syntax error, since the + doesn't make python join the lines. You'd have to do

("hello" +
"world)

[Danol]

[Delphi]
AnsiContainsStr parameters order: Haystack, Needle (documentation)
AnsiPos parameters order: Needle, Haystack (documentation)

This one has its share on me getting fired from a summer job, as I started shouting out loud in the office when I discovered it.

[edA‑qa mort‑ora‑y]

Vulgar APIs require vulgar outbursts. :)

[Jason C. McDonald]

Python is my all-time favorite language, but I absolutely HATE packaging, installing packages, and working with virtual environments in it.

I've been told pip is getting better, and perhaps it is a bit, but it's still quite hard to get quite the right combination of packages working in the right scopes.

Thus why I've been saying for years: "Packaging in Python is like beating yourself to death with a wet trout." (So far, no Pythonista I've encountered has disagreed, even recently.)

[edA‑qa mort‑ora‑y]

Definitely. I felt that I was really just randomly copy and pasting bits into a setup.py file to get my install working. I never have figured out what the correct way to generate documentation is.

[Jason C. McDonald]

Probably appropriate:

[Peter Benjamin (they/them)]

Golang

• Package management
• I miss functional programming paradigm

[edA‑qa mort‑ora‑y]

I haven't used it yet, but doesn't Go allow any kind of functional programming? At least the basics of high-order functions?

[Peter Benjamin (they/them)]

Higher order functions, yes.
Anonymous functions, yes.
Recursive functions, yes.

But, no map, reduce, filter, pattern matching, and some other stuff that make the language as expressive and concise as FP can be.

[Alexandru Dreptu]

Oh yes, this. Using Go sometimes feels like playing with barbed wire, instead of a sponge.

[Josha von Gizycki]

Java Collections. Good stuff, but the API just didn't advance with time:

Map.get(Object)

You never know for sure if your key is a valid parameter, even if your generics tell, which key type you want to use. Always Object.

Want to create an ArrayList with one entry? Think this works?

new ArrayList<String>("foobar");

Nope, the constructor does not take items as parameter. Instead, use Collections.singletonList, but that one is immutable. Be surprised by your next RuntimeException. You could also use Arrays.asList, but not for a single item because that's considered inefficient.

[Valentin Baca]

YES. This is very annoying.

They're not part of the core language and you probably already know about them, but for those who don't:

Google Guava has Lists: Lists.newArrayList(E... elements)

Implementation: github.com/google/guava/blob/maste...

And (of course) Kotlin has the lovely arrayListOf(...)

kotlinlang.org/api/latest/jvm/stdl...

[Álister Machado dos Reis]

The fact that, in Python, "joining an array using a given string" is phrased as "use this string to join an array".

# this does not work, sadly
['a','b','c'].join('-')

# this works
'-'.join(['a','b','c'])

Now I'm used to it, but I used to get it wrong all the time, because 'join' is an active verb, so at least for me it makes sense to put it after the thing being joined.

[edA‑qa mort‑ora‑y]

Yup, I get that wrong every time I attempt to join an array. Logically join should either be a part of the array type or a standalone function.

[Marlysson Silva]

I never understand why join is applying in separator passing the list to join them..

[Graham Lyons]

It's because the argument to join can be anything that you can iterate over e.g. list, tuple, array etc. Python tends to make functions take duck-typed arguments rather than having interface-style compatibility on types.

[Matthew Ozvat]

The languages with garbage-collection are awesome! However, I do like the geekiness of managing memory for particular use-cases.

[Adnan Ademovic]

Golang is one of my favorites, but writing the same thing over and over annoys me more than anything. I'm talking, of course, about:

result, err := somethingThatCanFail(args)
if err != nil {
    return nil, err
}

Edit: I'm also aware that you can use named return types to do the simplified version below.

if err != nil {
    return
}

There should be a syntax shorthand for commonly used stuff like this. Rust has the try!() macro that does this, or even shorter, the ? operator.

[edA‑qa mort‑ora‑y]

This is one of my core complaints about Go. I'm quite opposed to explicit error handling since ultimately coders will just forget it in places, or not check it correctly. I'm in favour of errors propagating by default, and having a nice option to catch them if you want.

Any repetition is syntax is bad for readability. The intent of the code gets lost in overhead.

[Connectety]

I really love Scala, but

1. The compiling time can be so long (example: the classical "Hello World!", Scala: 4420ms (Without fsc) Java: 107ms (as a comparison)
2. Values can be returned without return statement
3. parameters always become immutable

(also if you're programming half of the project in Java, "++" can confuse you, because it does different things in Java and Scala)

[edA‑qa mort‑ora‑y]

What don't you like about #2, that values can be returned without a return statement? Are they named returns in the function signature?

[Connectety]

You somtime accidentally return values (method type = unit (so you don't have to return null and can't get a nullPointException)) and sometimes it can take a while to understand that something gets return (like when a function does return true if it did what it should and that gets returned by another function)