-
C# (.net core only)
- Language itself is absolute favorite, has fixed nullability problem in recent versions of c# (8.0+).
- Open source ecosystem is a bit immature (only recently open sourced), could be very good in another 5 years.
- Real unrestricted multithreading
-
Kotlin
- Basically Java++
- Second best to C#, but has some strange design decisions like removal of static methods.
- Still suffers some nullability problems when using java libraries (very common), but a lot of the bigger libraries don't have this problem (spring).
- Some very mature well-designed libraries (spring, hibernate)
- Real unrestricted multithreading
-
Python
- Not bad, language is reasonably well-designed, although missing interfaces (not a fan of oop without interfaces).
- Not a huge fan of using indentation to define blocks (prone to error), but admit it can be easier to read.
- Missing optional runtime type checking.
- Package management has lots of holes (pip still doesn't have a standard lock file format)
- Lots of low quality libraries.
- Default runtime performance is kinda meh.
- Has multithreading but very limited due to language design (GIL).
- Typescript
- Use in place of javascript for front end or throw away backend code, enable support for implicit any.
- Has serious issues with incorrect type information (types are not regularly developed alongside the js codebases, this always leads to incorrect type information at some point)
- Like rest of javascript ecosystem, many packages have a much worse than average half-life.
- Compile time checked, which means you lose out on one of the main benefits of typed languages (automatically asserted types near system boundaries, apis, database)
- Runtime performance is very good compared to other interpreted languages.
- Has something like multithreading, but has limited use cases, since no shared memory support (without shitloads of serialisation)
- Not really a single language, one companies TypeScript is rarely the same as another, due to different tsconfig settings.
- PHP 7+
- Pretty good for web dev, backend development.
- Good for smashing out some code that works, and then going back and progressively improving it.
- Newer versions have excellent Language design, but still suffers from poorly designed std library.
- Has large and mature open source community which offsets some of this (symfony, doctrine, phpunit).
- Runtime performance not great, still faster than python somehow.
I like types but prefer when they are optional, which allows core library code to be typed (to optimise for maintenance), but relatively shorter half-life consuming code to be untyped (to optimise for velocity), within the same codebase.
Optional typing also allows disabling the type system when doing some metaprogramming that the type system is not flexible enough to handle (union types etc.), rather than needing to fight to find another way to do it other than the most straightforward way.
I vastly prefer those with a mature open source community over those that are more proprietary focused. If I'm going to learn a skill (library) I want to be able to apply it without paying someone else, and to always have the option for it to be forked and continued if the original owners turn malicious (bought by another company then closed up).