Dismissive responses like this are frowned upon by the HN community guidelines. Give your reasonings, not a snide remark.

OK then:

- Slow compilation, I think even now immutably concatenating a handful of strings makes the compile time exponential.

- Over reliance on keywords and special case syntax, magic doesn't compose. A bunch of it just supports Optional for example.

- Xcode, nuff said.

- Equatable and Hashable for tuples were implemented with invisible compiler magic, so they wouldn't work with generics.

- Variance is hot garbage, it has variance, but no way to control it.

- No higher kinded types, so useful FP abstractions become a chore to implement.

- I regularly had compiler crashes on comparatively simple code.

- Sometimes absolute nonsense compile errors pointing at random parts of my code.

- SourceKit didn't handle basic stuff like type aliases.

Going on the various things I've seen since we switched our project to JavaScript from Swift it looks like the keyword soup has gotten worse.

Sounds like you describe the state of Swift at least three years ago. SourceKit just doesn't crash anymore on me anymore, ever. Compile times are quite good for me nowadays, still not as fast as Objective-C but then again you don't get compile time guarantees for free.

The exponential issue was still there in version 4 and I think 5 as well. Didn't say SourceKit crashed, but it was virtually useless because it functioned like a crap version of the language parser.

So what's particularly hard on the compiler are hard coded sets of data that have mixed types. For example a dictionary that reflects a JSON response that also has nested dictionaries.

It helps if you test declare it like:

    let json: [String: Any] = [ /** lots of fields here */ ]

String concatenation: could you give me a specific piece of code that fails? It could be that I really never write code that triggers the problem. Using the + operator to concatenate strings has some performance issues though.

I'm not telling you're crazy, I just noticed that things got so much faster in the past two years.

The string concatenation issue was that if you do a ++ b ++ c... When that got to about 6 variables that single line alone took a minute to compile. Go to 10 variables and just give up on ever seeing a result. I used to try it in online Swift REPLs and it was still happening with whatever was most recent a bit over a year ago.

OMG, they actually fixed the a + b + c... issue I assume in version 5 (5.1.1 is what I have available in NixOS).