What's bad in Swift?

Swift is a powerful and modern programming language, but like any language, it has its challenges and limitations. Here are some points that might be considered drawbacks or areas where Swift can be tricky:

Complexity in Optimization: Swift has a powerful optimizer, but there are limits to what it can do. The way you write code can significantly impact how much the optimizer can achieve. This means that for performance-critical applications, developers need to be vigilant about monitoring and optimizing their code (Explore Swift performance).
Abstractions and Performance: Swift provides many tools for abstraction, such as closures and generics, which are not present in C. These abstractions have non-trivial implementations that can sometimes lead to performance issues if not used carefully (Explore Swift performance).
Non-Copyable Types: While Swift 6 introduces non-copyable types to prevent issues like multiple writers to the same file or resource leaks, this feature can add complexity to the code. Developers need to understand and manage these types properly to avoid runtime issues (What’s new in Swift).
Embedded Swift Limitations: In embedded environments, Swift disallows certain features to meet the requirements of small and simple binaries. For example, runtime reflection is avoided due to its high code size cost, which can be a limitation for developers used to these features in other contexts (Go small with Embedded Swift).
Error Handling: Swift's error handling model is designed to be robust, but it requires developers to mark parts of their code that can be the source of errors. This can add overhead to the development process, especially for those new to the language (A Swift Tour: Explore Swift’s features and design).

These points highlight some of the complexities and considerations when working with Swift, especially in performance-critical or resource-constrained environments.