Sources

core libraries: Vue, React, Angular, whatever. And we have two problems here. First, it's quite big bundle files because all   of them are using the wrappers to thumb, other functions that are importing other functions. {ts:87} And in general, it's not easy. Just a lot of the repeated code and a lot of the methods   that are reusing, and a lot of the methods  are taken that are not important right now. All of that is the problem. And the next thing, {ts:102} time to interaction also is a problem. Because of that, it's all been loading,   especially when we're taking, for example, some external files like React, for example. So,   such things can really work worse for us because it just takes time to be loaded. {ts:121} And after all, script will be loaded. … That's a quite small thing that I really like—a single file component,   but it has its downside. So, when we are working with a huge project, {ts:292} the problem is that you are trying to put all the logic, especially for a specific component,   at one place.

### 1) IDE Our IDEs, which we use, have stopped responding efficiently. It takes about a minute for Svelte LSP to initialize. Our laptops are overheating badly. Autocomplete works very slowly or doesn’t work at all. This affects both the autocomplete in component markup, such as props, and in script tags, where autocomplete has become very unresponsive. For some colleagues, Svelte LSP even stops working because it runs out of RAM. This issue affects VS Code, WebStorm, Nvim, and Zed. … I understand that the issue might not be entirely with Svelte LSP or Svelte itself, but could be rooted elsewhere, such as the fact that the entire JavaScript tooling ecosystem is written in JavaScript and runs on single-threaded Node.js. However, I wanted to highlight that in large projects, the IDE becomes extremely unresponsive, and it would be great if the team supporting the Svelte ecosystem was aware of this. ### 2) Build speed Building the application for production takes 10 minutes, and Svelte-check takes an additional 10 minutes. This is quite slow, and it's hard to find a workaround. Neither esbuild, swc, nor rspack currently have good support for Svelte. As projects grow and evolve, this build time is likely to increase. ### 3) Responsiveness of the development server The cold start for `npm run dev` (Vite) takes 1:30 minutes, while the hot restart takes 1 minute. This is also quite slow, especially when you need to restart the server after changing the configuration. Along with the IDE, my MacBook Pro starts to struggle. … This can lead to discrepancies between server behavior during development and production, which has repeatedly caused bugs. We managed to work around this issue similarly to how SvelteKit handles the dev mode for Vite (SvelteKit Vite dev mode code). However, I dislike such workarounds and would prefer having an API for server customization in both dev and production modes. … ### 5) Runtime perfomance I appreciate that SvelteKit allows you to write API endpoints out of the box (SvelteKit server routes). However, as experience has shown, this approach isn't always the most performant. For a load of 11k RPS, it required around 200 pods just to proxy requests to other backends and render HTML. This is a significant amount of resources for relatively simple tasks. As a result, we decided that the best approach would be to write endpoints directly on the Node.js server, bypassing SvelteKit. ### 6) UI kit Our UI kit isn't the largest, but it contains many icons (about 2,000). Svelte doesn’t currently support compiling libraries to publish as pre-built JavaScript, which means these components are recompiled every time. I’m not sure what can be done about this, but it seems like unnecessary overhead. … Since client-side load functions (`+page.js`) started serializing responses, it has become impossible to mock them effectively. Additionally, SSR in SvelteKit can lead to flaky tests. For example, a Playwright selector might click a button before hydration is complete, causing the test to fail because the event handler hasn’t been attached yet. … Don't have much to say here...there's probably a bit of overhead because those could be generic endpoints while you can write more performant specific endpoints directly in node but i think this is definitely something we should look into. ... To be honest, we can't move to svelte 5 at the moment, the code base is too big. Also, in this case, we would have to freeze development, which we can't afford. But in our microfrontends, into which we are sawing our monolith, there are no problems with Svelte 5 yet … Right now the app’s **dependency graph**, build pipeline, and integration points are carrying *more* load than they were designed for. That's why you see slow LSPs, long builds, dev‑server lag, flaky SSR tests, and even uneven runtime performance. They’re all different faces of the same issue: **the system can’t scale cleanly with its current structure**. … Fix the architecture, and you remove entire **classes** of problems at once — instead of whack‑a‑moling them forever! P.S.: Most of the pain points—IDE lag, build times, testing wrinkles, icon recompilation, and microfrontend hacks—originate in the **broader** JavaScript/TypeScript ecosystem or community plugins.

useEffect(() => { a += 1; }, [b]); ... https://github.com/sveltejs/svelte/issues/6730 https://github.com/sveltejs/svelte/issues/6732 So basically, reactive blocks are only allowed to run once per tick; if a dependency changes after a block has run, too bad, the block won't run again. That is really shocking to me. (I won't say more due to my inexperience with Svelte...) danielvaughn on Sept 9, 2022 ... What Svelte is doing is simply covering up the flaws in your code by short circuiting an infinite loop scenario which has been coded into your app. This will have unexpected side effects, however. … Great frameworks don't trap developers in local maxima. ... A couple years ago, that feature used to work similar as useEffect, so I got used to use it for transitions, and now is biting my ass because the Svelte team are breaking my transition use-cases … BigJono on Sept 9, 2022 I think the dev community does really poorly with these kinds of abstractions that are very simple but completely unintuitive. I place a lot of the blame on the React team too. When hooks came out, their docs were absolutely terrible. They probably still are. They were full of shitty editorialising like "we created hooks because we found classes were too difficult for people to understand!", which made every dev I worked with feel insecure for not immediately knowing how to write super awesome clean code.

### Transcript {ts:0} Spelkit is my favorite framework, but that doesn't mean it's without its {ts:3} problems. And today I wanted to talk about those problems. I've been building way more complex stuff with Spelt ... Been testing out more advanced stuff, with streaming, with effect, with building library implementations for {ts:15} stuff like React Query in Spelt. I've been doing a lot. I've really started to run up against the edges of this {ts:20} framework and I've gotten a much better idea of how it really feels. So I wanted to talk about it. There are three things {ts:25} I want to cover here and that's going to be the new runes primitives, the extensibility and ecosystem around spelt {ts:31} and spelt kit and the one component per page thing. And I want to go over what the issues here are, some of my {ts:39} solutions, and just general thoughts and vibe on the framework and how it just feels to build with these days. So, {ts:45} let's start with the runes primitives. ... {ts:171} does a really good job of showing how these things actually work. But because these are signals, this means that the {ts:177} reactivity is a little weird. And the way we pass these into functions is also a little weird. We need to use getters {ts:183} and setters in order to actually make those variables work reactively by passing them into like for example this … {ts:336} switching the cache entry and I believe if I increment this up to four these two will now be synced. So now I go here and {ts:343} then these two are now in sync. So that did work in the basic one but in the more complicated version of this it {ts:349} didn't work because we had other pieces within our query definition that were also reactive. … These things work super well. Basic derives basic effects in the happy {ts:375} path. They are incredible. As soon as you get into these weird complicated use cases, they get a lot more painful. And {ts:381} it's I don't know, the React primitives are can be annoying to work with on the Happy Path because they're so verbose … I love using them in these classes, but when you get to these complicated edge {ts:478} cases, they get a little more painful. The next thing I want to talk about is the overall ecosystem and library {ts:483} support for spelt. One of the things you'll always hear with React is how good the ecosystem is, how many awesome … And I've especially run into this when trying to do weird things {ts:547} like markdown rendering. Something I've been working on recently is trying to get better with HTTP streams, seeing how {ts:553} these things work and working with like LMS and stuff like that. So, I ended up building a very minimal chat app in … And a lot of even just some of the methods when I was {ts:603} using it just kind of broke and didn't really work. So, I had a lot of trouble actually using that package. And {ts:609} initially, I was kind of annoyed because I'm like, well, the third party support isn't great here in React. … {ts:776} it hasn't really limited me. The last thing I want to talk about here is going to be the one file per component {ts:781} problem. When I first made my Spell Vive reactions, this was one of the biggest problems I had with the framework at the {ts:787} time was I didn't like that I couldn't have multiple components in one file. … {ts:932} up at the top and then use those without in my markdown. It's really great. It's basically resulted in me often having a {ts:940} page. And then right next to it, some class that maintains all the state for that page. And then the page is {ts:947} responsible for the actual markdown and then basic event listeners like a handle submit or an onclick or whatever. … {ts:973} work, you would probably have to turn make it look a bit more like React where you would have to probably define a {ts:980} component as a function. It would have to return JSX or some weird HTML thing. It would have to put all this logic into {ts:988} the top of the function. it would end up being kind of awkward and weird.

Once those click, you’ll see that almost every other React hook builds on them. ... For years, everyone used create-react-app. That tool is now outdated and officially discouraged. In 2025, the go-to starting points are: - **Vite**– lightweight, fast dev server, and minimal setup. Great for single-page apps. - **Next.js**– the full-stack, batteries-included option with routing, server rendering, and API routes. … **Cons:** Smaller ecosystem and fewer job opportunities. Svelte is perfect for personal projects, prototypes, and anyone who wants to understand modern web development at a deeper level. ... If you’re coming from a design or HTML/CSS background, **Vue** will feel most natural. You can be productive within a day or two.

### What’s the downside? - **IDE support** is not yet comparable to the commonly-used frameworks. It still has a lot of room for improvement. Although there are some good resources online to solve some of the issues, it can be considered as a major disadvantage as of today. - **Not many Svelte dev tools** exist at the moment. It is still a young and growing ecosystem. Keep that in mind. However, that’s a great opportunity to develop some for the Svelte community.

# 8 Problems Every Java Developer Knows ... Developing with Java brings its own problems. Problems may be due to bad tooling, inexperience, or the project itself. You face them daily. Whether it is a broken build. Or a security issue. They exist. What are the most common issues Java developers face? Let’s find out. Find out the solutions as well. # Server startup The server startup is slow. Even on your local. You can mitigate the problem. Use JRebel. This will reload your classes, right after changes. This doesn’t solve the issue for testing. Spinning up a server takes time for Jenkins. Your PR can fail for numerous reasons. Not by your fault. You could be affected by a lot of factors. Which can lead to slow development. … # Spring Security Pay attention to security. The wrong configuration leads to security breaches. I would list a few of the security issues you can face. Most of the issues can be found here. - exposing server data to the client-side - improper authorization - leaving default settings Minimize these issues. Embed static code analysis. As an example, you could integrate this tool. To improve security, become ruthless on code reviews. Check for Spring security changes. You review thoroughly. You create secure apps.

It was during a university distributed systems course, and coming from a background in assembler and C, Java felt bloated, slow, and frankly untrustworthy. That “automatic memory handling” seemed like dangerous magic I couldn’t control. After years of meticulously tracking every allocated memory block, the idea that the runtime would handle memory management felt like giving up control to forces I didn’t understand.

The Java programming language and Java software platform have been criticized for design choices including the implementation of generics, forced object-oriented programming, the handling of unsigned numbers, the implementation of floating-point arithmetic, and a history of security vulnerabilities in the primary Java VM implementation, HotSpot. Software written in Java, especially its early versions, has been criticized for its performance compared to software written in other programming languages. Developers have also remarked that differences in various Java implementations must be taken into account when writing complex Java programs that must work with all of them. ## Language syntax and semantics ### Checked exceptions Java introduced checked exceptions where a method must declare the checked exceptions it throws in the method signature. This can result in unnecessarily verbose boilerplate code. No major language has followed Java in implementing checked exceptions. ### Generics When generics were added to Java 5.0, there was already a large framework of classes (many of which were already deprecated), so generics were implemented using type erasure to allow for *migration compatibility* and re-use of these existing classes. This limited the features that could be provided, compared to other languages. … Additionally, in 2016, the following example was found revealing Java to be unsound and in turn making JVMs which threw ClassCastExceptions or any other kind of runtime error technically non-conforming. This was corrected in Java 10. … ### Noun-orientedness By design, Java encourages programmers to think of a solution in terms of nouns (classes) interacting with each other, and to think of verbs (methods) as operations that can be performed on or by that noun. Steve Yegge argues that this causes an unnecessary restriction on language expressiveness because a class can have multiple functions that operate on it, but a function is bound to a class and can never operate on multiple types. … ### Unsigned integer types Java lacks native unsigned integer types. Unsigned data is often generated from programs written in C, and the lack of these types prevents direct data interchange between C and Java. Unsigned large numbers are also used in a number of numeric processing fields, including cryptography, which can make Java more inconvenient to use for these tasks. … ### Operator overloading Java has been criticized for not supporting user-defined operators. Operator overloading improves readability, so its absence can make Java code less readable, especially for classes representing mathematical objects, such as complex numbers and matrices. Java has only one non-numerical use of an operator: … instances. It is impossible to create user-defined operator overloads. ### Compound value types Java lacks compound value types, such as structs in C, bundles of data that are manipulated directly instead of indirectly via references. Value types can sometimes be faster and smaller than classes with references. For example, Java's … ### Large arrays Java has been criticized for not supporting arrays of 2^31^ (about 2.1 billion) or more elements. This is a limitation of the language; the *Java Language Specification*, Section 10.4, states that: Arrays must be indexed by int values... An attempt to access an array component with a long index value results in a compile-time error. Supporting large arrays would also require changes to the JVM. This limitation manifests itself in areas such as collections being limited to 2 billion elements and the inability to memory map continuous file segments larger than 2 GB. Java also lacks (outside of its 2D arrays) multidimensional arrays (contiguously allocated single blocks of memory accessed by a single indirection), which limits performance for scientific and technical computing. ### Integration of primitives and arrays Arrays and primitives are somewhat special and need to be treated differently from classes. This has been criticized because it requires many variants of functions when creating general-purpose libraries. … ### Lack of tuples Java does not natively support tuples, resulting in a proliferation of third-party implementations which must be imported and handled by the programmer. The argument against a generic tuple class is the danger it poses in proliferating unmaintainable code. … Game designer and programmer John Carmack concluded in 2005 about Java on cell-phones: "The biggest problem is that Java is really slow. On a pure CPU/memory/display/communications level, most modern cell phones should be considerably better gaming platforms than a Game Boy Advance. With Java, on most phones you are left with about the CPU power of an original 4.77 mhz (sic) IBM PC, and lousy control over everything." … Critics have suggested that users do not update their Java installations because they don't know they have them, or how to update them. Many organisations restrict software installation by users, but are slow to deploy updates. Oracle has been criticized for not promptly providing updates for known security bugs. When Oracle finally released a patch for widely-exploited flaws in Java 7, it removed Java 6 from users' machines, despite it being widely used by enterprise applications that Oracle had stated were not impacted by the flaws.

- I'll be honest - my first encounter with Java in 1999 wasn't love at first sight. It was during a university distributed systems course, and coming from a background in assembler and C, Java felt bloated, slow, and frankly untrustworthy. That "automatic memory handling" seemed like dangerous magic I couldn't control. After years of meticulously tracking every allocated memory block, the idea that the runtime would handle memory management felt like giving up control to forces I didn't understand. ... The team needed Java expertise because while they'd updated the JRE, the codebase wasn't using any features added since Java 1.4, including generics. I spent months helping add type information to collections throughout the system. We changed untyped Arrays to typed Lists, added types to Maps, and gradually eliminated the cognitive overhead of tracking what each collection contained. ... The real impact of generics went beyond type safety. Every time we encountered a List in the old codebase, we had to hunt through the code to figure out what it contained. With generics, the intent was immediately obvious. It helped us decrease the mental burden working with the code. This pattern has continued through Java's evolution. Features like records, pattern matching, and enhanced switch expressions all follow the same principle: make code that aligns with how developers naturally think about problems. … ... This code aligns perfectly with how our brains naturally categorize and handle different cases. The compiler ensures we've handled every possibility, reducing the mental overhead of "what if" scenarios. ... This backward compatibility isn't just a technical achievement; it's a career investment. The Java skills you learn today won't become obsolete in five years. They'll be refined, enhanced, and made more powerful, but they'll still be relevant. Oracle and the Java community have maintained this commitment to compatibility through: - Careful deprecation cycles that give developers time to adapt - Module system design that doesn't break existing code - Preview features that let developers experiment without commitment - LTS (Long Term Support) releases that provide stability for enterprise environments This means when you invest time learning Java, you're not just learning a language, you're investing in a platform that will support your career growth for decades.

It’s loaded with stats about the challenges Java developers are facing—and the tools and technologies they’re using to solve them. ... Perhaps the biggest shift noted in the 2025 Java Developer Productivity Report is a wholesale move from older JDK versions such as Java 8 and Java 11, to JDK versions for which Oracle currently offers long-term support (LTS). Those LTS versions are currently Java 17 and Java 21, with Java 25 coming out later in 2025. This is likely a continued response to a revised LTS cadence from Oracle. … One downside to cloud development is redeploy times. For many organizations, redeploys in local development environments are 2 minutes or less. That flips in cloud development environments, where 52% are 5+ minutes. That’s a massive inefficiency where developers are waiting 5 or even 10 minutes for a single redeploy. As a result, we’re seeing more and more customers identify inefficiencies around cloud development environments and actively look to address them. Back to top

{ts:1048} stuff right away and you don't have to like hunt around for it. Um for IO some {ts:1052} people saying that IO and Java is {ts:1054} cumbersome. So there's still some people who who program with buffered reader in {ts:1058} 2025. Don't do that. Um so the new IO