[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.

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.

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.)

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)

Golang

• Package management
• I miss functional programming paradigm

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.

Using both Elm and F#. Here are a few things that irk me.

• Hazardous generics
  Elm : Result SomeErrorType SomeType
  F# : Result<SomeType, SomeErrorType> - The sharp angles cut me

• Elm union types do not allow an optional leading |, which makes the first one a pain to copy/paste, diff, etc. (Maybe implemented soon.)

  -- Elm
  type SomeUnion
      = FooCase -- merge conflict waiting to happen
      | BarCase
  

  // F#
  type SomeUnion =
      | FooCase
      | BarCase
  

• F# let syntax is nicer to use. Elm let statements require an in clause whereas it is optional/implicit in F#. Additionally, elm-format always expands let statements to multi-line. The visually-enormous resulting code leads you to want to avoid let in Elm.

  -- Elm
  let
      asdf =
          oneLiner x
  
      fdsa =
          anotherOneLiner y
  
  in
      f asdf fdsa
  

  // F# - easier to read IMO
  let asdf = oneLiner x
  let fdsa = anotherOneLiner y
  f asdf fdsa
  

• Elm generates curried constructors for all record and union types. Curried constructors are great because they support partial application. F# does not, and the normal record construction syntax is quite verbose. I often create my own curried constructor for partial application.

  -- Elm
  type alias SomeType =
      { someInt : Int
      , someString : String
      , someFloat : Float
      }
  
  -- automatic curried constructor
  let x = SomeType 1 "foo" 3.14 in ...
  
  let list = List.map ( SomeType 1 "foo" ) [ 3.14, 2.718 ] in ...
  

  // F#
  type SomeType =
      { SomeInt : int
        SomeString : string
        SomeFloat : double
      }
  
  // make my own curried constructor
  let mkSomeType a b c =
      { SomeInt = a; SomeString = b; SomeFloat = c }
  
  let x = mkSomeType 1 "foo" 3.14
  
  let list = List.map ( mkSomeType 1 "foo" ) [ 3.14; 2.718 ]
  

Here is what the last two lines would look like in C#.

    var x = new SomeType(1, "foo", 3.14);

    var arr =
        new double[] { 3.14, 2.718 }
            .Select(x => new SomeType(1, "foo", x))
            .ToArray();

Lack of optional types. Impossible to maintain large codebases in dynamic languages.

In Swift, it's often annoying that you cannot have a variable of a generic protocol type. You need to have a generic type implementing that protocol because you cannot specify associated types when declaring a variable.

For example, Swift has a Collection protocol, which has an associated generic type Element.

Instead of declaring a variable with let foo: Collection<Int> = ... you need to have a generic variable C: CollectionType where C.Element == Int, which can be pretty annoying because your enclosing structures also need to be generic.

Example

struct Foo<C: CollectionType> where C.Element == Int {
    var bar: C
}

It would be so much more pleasant to write

struct Foo {
    var bar: Collection<Int>
}

Yes I am aware of the AnyCollection<Element> type but that is just a workaround that is specific to the collection protocol and not a general solution and yes I am aware that the Swift compiler always wants to specialize generics at compile time but this is just annoying.

I despise the fact that null is an object in JavaScript.

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

@("This works") int x;

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

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

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.

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.

PHP: was designed with the same level of consistency as The Lord of the Rings was
Translated into French: by at least four different people with different goals and who never talked to each other.

Ruby: gloats about Duck Typing as a revolutionary way of solving the problems of untyped languages, but you spend the first 2/3rds of every function validating your arguments just like in PHP or JS, only with different syntax.

Python: the amount of boilerplate needs once
your simple script starts to become long enough that it has to be split into modules.

JavaScript: The lack of any hint of a standard library (to format dates, for example), and the misplaced efforts to add more and more silly syntax before solving this problem.

To be continued…