Pains

TensorFlow attempts to allocate all available GPU memory on startup, which can prevent other code from accessing the same hardware and limits flexibility in local development environments where developers want to allocate portions of GPU to different tasks.

When scaling TensorFlow projects on cloud platforms with high-cost GPU configurations, training time grows exponentially, forcing developers to either optimize algorithms or migrate infrastructure, leading to significant cost and complexity issues.

Performance tuning in TensorFlow requires developers to manually fine-tune numerous hyperparameters (learning rate, batch size), optimize data pipelines, and balance model complexity against accuracy. This trial-and-error process is time-consuming and lacks systematic guidance.

TensorFlow is primarily optimized for Python developers. JavaScript support is fragmented and non-intuitive, making it difficult for web and mobile app developers to use TensorFlow compared to regular JavaScript libraries.

TensorFlow's static computational graph model requires developers to define the entire computational graph before execution, which is less flexible than dynamic graph alternatives like PyTorch and challenging for complex, evolving models.

TensorFlow's rigid architecture makes rapid prototyping cumbersome. Many developers prototype in PyTorch first, then convert to TensorFlow for production—evidence that TensorFlow is less suitable for exploratory work.

Many C# developers are unfamiliar with the dual purpose of the 'using' keyword, not recognizing it as a tool for proper object disposal and resource cleanup beyond namespace imports. This leads to resource leaks and improper memory management.

Developers struggle to keep up with an overwhelming number of new and existing tools and frameworks (26% reported challenge in 2021). This creates decision paralysis, version fragmentation where teams become stuck on older versions, and costly migration efforts when attempting to upgrade.

Projects become tightly coupled with Tailwind CSS, making it difficult or requiring significant refactoring to switch to another CSS framework or approach. This reduces long-term flexibility and portability.

As Tailwind projects grow, the tailwind.config.js file becomes increasingly complex and difficult to manage. Customizing themes, breakpoints, and integrating plugins requires careful consideration and can create large, hard-to-understand configuration files, especially problematic for larger teams managing intricate design systems.

Java's performance on mobile and embedded systems is notably poor. Game designer John Carmack noted Java phones had CPU power equivalent to a 4.77 MHz IBM PC despite modern hardware being far superior.

Large Java codebases using pre-generics untyped collections (e.g., plain List, Map) require developers to hunt through code to determine container contents. Modernization to typed generics requires extensive refactoring.

Large monolithic codebases cannot migrate to Svelte 5 without freezing development. Only microfrontends (from monolith decomposition) have been able to adopt Svelte 5 without issues.

SvelteKit feels behind competing frameworks when building real full-stack applications, separate from reactivity/runes concerns. Fundamental platform maturity gap exists.

Svelte lacks comprehensive debugging capabilities and IDE support comparable to React or Angular. While the Svelte compiler is fast, it doesn't offer the same level of debugging features, making it harder for developers to identify and fix issues in their code.

Developers often fail to properly handle component lifecycle events in Svelte, particularly failing to unsubscribe from stores or clean up side effects in onDestroy, leading to memory leaks.

Svelte's runes-based reactivity system works well for basic use cases but becomes problematic in complex scenarios with multiple reactive dependencies. Developers need to use getters and setters to pass reactive variables into functions, creating unintuitive patterns when combining features like signals with effects and derived state.

Electron applications consume significant power due to continuous background processes including the Chromium engine, leading to rapid battery depletion on laptops and mobile devices, causing user frustration and driving adoption of more efficient alternatives.

Electron apps exhibit quirky behavior and performance issues on macOS, particularly with heavy applications or when Apple changes system APIs, leading to instability and requiring additional maintenance effort.

Some teams ship Electron apps as live web applications instead of self-contained binaries, resulting in slower load times, app brittleness, security risks, and poor offline functionality.

Large, unoptimized CSS files cause reflows and sluggish UIs on high-traffic sites. Browser reflow operations on every interactive change degrade performance, particularly on older devices.

The `??` (null-coalescing) operator and pattern matching operators have unintuitive precedence rules. For example, `x is not 0 or 1` evaluates as `(x is not 0) or 1` rather than the intended `x is not (0 or 1)`, leading to subtle bugs and redundant logic.

Next.js has introduced 15 major versions in 8 years, each potentially containing backwards-incompatible changes. This creates significant maintenance burdens for long-term projects and makes it difficult for teams to keep applications updated.

Developers using Tailwind are abstracting away core CSS knowledge (Flexbox, Grid, positioning). Junior developers can use Tailwind classes but don't understand the underlying CSS properties, creating a generation gap in web platform fundamentals.