What can we learn from the last 10 years for the next 5 years? Is there a future for Webpack? What do we need to do now?
Webpack in 5 Years?
AI Generated Video Summary
1. Webpack's Impact and Future
So, my title is actually Webpack in Five Years, but actually that's only a click bait, so I looked you in. will talk about the last 10 years of Webpack and what we can learn for Webpack and for the community as a whole and for the ecosystem about these last 10 years. What mistakes we made, what problems we have, and what we can do better.
Oh, come on. So, my name is Tobias Koppers and I created Webpack in 2012, like 10 years from now, so maintenance, maintaining it for 10 years and I started with maintaining it for five years in part time, like 10 hours per week, and then I migrated to full time working on Webpack funded from Open Collective, from sponsors, donations and stuff like that, and now I work more than one year for And maintain it as part of my job. I also have two children, five and three years, and live in Germany in Bavaria, so nearby a little bit.
So, what does the future look like for Webpack and for the ecosystem in general? Will Webpack still be used in five years? I think yes, at least for existing projects, because, like, companies, teams, don't change the stack so often, it's more like they use stuff for more years than we can think of. Actually, people are still using Webpack 2, which is five years old, and they don't mind not upgrading stuff for a long time, if it's working, and I think it's deemed to work, at least. For new projects, there's another choice. I don't know what is happening in five years. It could be that something new is developed that might be better, or there are obvious other choices you can use and start with new projects. What happens in five years, I don't know. It's a really long time in the ecosystem. I decided to recap about the last ten years of Webpack and check what lessons we can learn from these ten years, and what we can, I can think what we can keep from Webpack, ten years of Webpack for the ecosystem and for Webpack in general. So, yeah. I also want to say what we can do now or we can do in future tools on Webpack to fix these problems or to keep these lessons learned. The problem is there are so many lessons I collected preparing this talk that they actually don't fit in this talk. It's a hybrid conference, but what I did was prepared hundreds of slides for all this stuff and I showed them a split second and the remote audience can pause the stream and read all this stuff and see you in one hour after I discuss the important ones with the live audience. So the first one, initial configurations.
2. Webpack Configuration and Customization
The initial configuration for Webpack can be overwhelming, but it is necessary due to the complexity of modern web applications. Adapting to the ecosystem and having customizable defaults can help improve the development experience. Customization is important for both individual projects and the overall ecosystem, allowing for innovation and unblocking users. However, the current customization options in Webpack can be confusing, and the extensive API surface makes it difficult to iterate and maintain. To address these challenges, a simplified plugin concept and the inclusion of analytics for user feedback could be beneficial. Additionally, performance is an area where Webpack lags behind its competitors due to its use of Node.js.
So what can we do to fix that? Clickers not good. So I think we should be more optimized, in having defaults so we should adapt with the ecosystem. I also think we should acknowledge the fact that these defaults change over time, like ten years from now, maybe five years from now, we have probably very different defaults than we now have. What I think we can do is like having something, what some people already do, is having presets that are versionised with dependencies, so we can slowly adapt with the ecosystem, but also keep your project locked in a certain version of defaults without having a lot of breaking changes.
Another topic is customising. So I think customising is really important, and also really important for the ecosystem, even if you're not directly using it for your project, because it embraces this innovation concept of the ecosystem where you can look, like you have a cool idea and can write a plugin for your bundler and for your tooling, and, like, try it out, maybe publish it to npm, and let people use it, maybe it becomes the new standard we develop applications in the future. But it also helps to unblock users. If you're struggling with something that Bundler doesn't support, or your tool doesn't support, then you can actually go into modify, write a plugin, or customise the configuration to, like, have your use case, like, doing what you do, and actually get stuck with Bundler, and maybe have to switch because it doesn't support something. I also think that was one success factor of Webpack in the early days, and maybe also nowadays that it really has this idea of flexibility and customising and stuff like that. And, but it also is confusing in some kind of things, like, there are three levels of customising. You have configuration, you have plugins, you have loaders. It is really complicated when you have to use the plugin loader combination with some configuration to do something, so it can be confusing. Another thing is that the API is, you can extend everything in Webpack. You have access to all the internals in Webpack. That's a problem because we don't know what is actually used. We can't change anything in our internal API, and that is really hard for us and also like makes easy to break stuff because it could change internals and that's weird. Yes. So, what can we do? So, what can we do? I think the idea is we shouldn't have this kind of plug in concept. I think it should only be like one plug in type which maybe has multiple levels of APIs. Like you have like a low level API and a higher level API where you can access both of these APIs from one single plug in and that would make it easier for people to use. Also makes the API surface more constrained to like only expose what we actually know is use by plug ins and don't expose all the internals which makes it hard for us to iterate on internals. What would also help, but it's really difficult to embrace in the communities like having some analytics where we actually get feedback from the user, maybe automated or maybe by opt in or something like that, where you can report what are the actually APIs used by plug ins so we can know what we should improve or what we can drop or duplicate in the future.
Another really large topic is performance. So like most competitors excel in performance because they are written in native languages and compared to Webpack, which is Node.js, Webpack is really bad at performance.
3. Performance and Architecture Challenges
In larger scale applications, there are performance problems in Webpack due to issues with garbage collection, leveraging multiple CPUs, and architectural limitations. To address these challenges, it would be beneficial to have an incremental processing and optimized architecture that scales with application size. Embracing a lazy-computated approach and ensuring incremental builds across different environments can also improve performance. However, it is difficult to fix these issues in Webpack without breaking the ecosystem and losing adoption. Consideration can be given to creating a new bundler with a redesigned architecture, but this approach has trade-offs and would require a significant migration effort.
So what we need to do, what we should do, but it is really difficult to fix that in Webpack is better it would be to use a native language, so that we can leverage multiple CPUs and also start with architecture that have this incremental build by design, like having it not depend on application size. It also brings me to the next point that is large-scale applications. Like, actually applications get bigger and bigger and that is a problem because the performance problems in Webpack are really exposed, because in Webpack, it is kind of fast for incremental build, but a little bit, it scales by application size and that gets more serious when the application grows, and there are workarounds where you can split your applications in multiple small applications, or even something like lazy compilation where you only compile on development what you're actually using. That helps, but there are workarounds, and if we have an architecture that would scale with applications in a better way.
What I think we should do is, like, lazy must be default for the future, like everything should be lazy-computated and lazy just scales better with large applications, because then you probably don't work on the whole application at once, like we work on parts of that, and if you only need to compile that part, then the large scale of the application doesn't become so serious. And, yeah, what I always say, we should embrace an architecture where the incremental performance doesn't scale with the application size, it should be constant at all this, and it should be fast always. That would be great. I also think, like, if you embrace incremental stuff, you should also embrace it on everywhere, like production build should be incremental on CI, it should be incremental, dev build should be incremental, which they are, but we should be incremental everywhere, and we should also have less ways to opt out of incrementally, like, if you change the parentheses, why does it have to reset the cache? It should keep being incremental. That would be cool.
So, back to the slides. Okay, so, these problems with performance and architecture, we can't really change that in Webpack. We can't refactor the whole architecture and rewrite in the native language that would break every plugin, every loader, every user, and maybe every in-style processor and stuff like that. So, it actually would make more sense to create a new stuff which would maybe WhoopPack or something, and that would have this new architecture. But there are trade-offs with that, and I try to summarise it a little bit. So, what fixing problems, we have a rewrite, does it make sense? So, when we fix the problems, we actually would keep the ecosystem, the trust, and the adoption of Webpack, while a rewrite would lose all the ecosystem, the plugins and loaders would be lost on this rewrite, and we need to regain adoption for Webpack, and, yes, that is hard, and it would take more than five years, probably, and it is also hard to make a migration for users to migrate to something like Webpack. Yes. But on the other side, we can't fix everything in Webpack, what we learnt, we can't change the architecture, we can't constrain the API surface, because it would also break all the So, it is impossible to fix some problems in existing Webpack.
QnA: Trade-offs and Recommendations
Fixing problems in Webpack has trade-offs. A rewrite would lose the ecosystem and require regaining adoption, while fixing problems has the risk of breaking users. However, a rewrite could optimize architecture and fix performance issues. It is hard to do a rewrite and would take years, while fixing problems can be done incrementally with direct benefits for users. Trade-offs exist. As for questions, starting new React projects with Webpack is recommended for stability, but it depends on personal preference. Webpack brings a large ecosystem and prebuilt solutions for React development.
But there are trade-offs with that, and I try to summarise it a little bit. So, what fixing problems, we have a rewrite, does it make sense? So, when we fix the problems, we actually would keep the ecosystem, the trust, and the adoption of Webpack, while a rewrite would lose all the ecosystem, the plugins and loaders would be lost on this rewrite, and we need to regain adoption for Webpack, and, yes, that is hard, and it would take more than five years, probably, and it is also hard to make a migration for users to migrate to something like Webpack. Yes. But on the other side, we can't fix everything in Webpack, what we learnt, we can't change the architecture, we can't constrain the API surface, because it would also break all the So, it is impossible to fix some problems in existing Webpack. While in rewrite, we could optimise our architecture for incremental builds, we could fix these deeper problems on the performance side, but is it worth it? I don't know. That's a good question. Yes, on the other side, like, fixing problems could also, like, fixing the larger problems also has also a little bit of risk of breaking users while rewriting would break, like, every user, obviously. Actually, it wouldn't break users. You could keep using Webpack and migrate to Webpack later, so it makes sense. It is also hard to do a rewrite because it would like take maybe years to rewrite everything. You have like the same abilities of Webpack while in fixing problems in Webpack, it would make smaller steps towards the process and like make direct benefits for the users and that can also be done with a smaller team and rewriting would be complicated. So trade-offs, as always. So thank you. I guess we have some questions? Thank you. So for those of you who have questions, don't forget you can go to slide.do and enter the code 1620 to ask your questions and then I can ask them to Tobias right here. So first question is from Ro. Would you recommend starting new React projects with Webpack and if yes, why? Yeah, I would recommend that because I created Webpack. I think it's like a matter of flavor, I guess. So Webpack is probably the solid choice, a good choice if you want to have a stable choice. You can start with other bundles. I actually don't know what are the limitations of them. So you could run into something and they are younger, so you can start with them. And I guess you can also always start with something else and then change the stack later. So it's like fee-fee. So the answer is, as a proper developer says, it depends. So for the people that want to go to the other track for the next talk. You can switch now because we're going to start that in a few minutes. And you can of course stay here also. And next question is from Rob also, why should you use React? Why? Why should you use Webpack as a React developer? So what benefit does Webpack bring you as a React developer? Yeah, it has a lot of ecosystem, and you have had large prebuilt solutions for React. So you can just start with a boilerplate or with tools that exist in the ecosystem.
QnA: Getting Started and Future Improvements
Webpack is easy to get started with and has been a proven technology for many years. While there is no official roadmap, the team is continuously working to improve the ecosystem and address challenges incrementally. Funding and limited resources can be a challenge, but the open-source community plays a crucial role in the project's success. Webpack is open to learning from and collaborating with other building tools in the web ecosystem. The Q&A session has ended, but further discussions can be continued in the monetization of open-source discussion room and the speaker lounge.
It's easy to get started with Webpack. And it also works well, I think. And it used to work well for like five years or so. So I guess it's a good choice and makes sense. It's a proven technology. Yeah, proven technology. All right.
An anonymous question. The ideas of solving Webpack issues sound great. Does a roadmap exist for currently implementing those, and should we expect more improvements in future versions? Yeah, we don't have a roadmap, an official roadmap, so it's like we never had one. It's more like we do what we think is currently best for the ecosystem. So it's like we're trying to improve those problems incrementally, and that's basically a roadmap. And yeah, I summarized these challenges and problems in the talk, and I guess we can fix some of these problems right now. And many of them are kind of not that complicated to fix, like making defaults is something we could do. So I think that's going to be happen probably. Someday soon. Someday soon, yeah. But we don't have timelines, or we never had timelines for everything because it's like great pressure, and we don't want to have this pack-out. It's an open source project, and many, most of the contributors are working on free time on that. So it's not something that we want to create deadlines and it's no need to have deadlines for us. It's like-
I think we're gonna do one last question. Question is from Thomas. Where do you see yourselves standing against new building tools leveraging new browser features like feats? I think we will do something to make similar choices. So actually, probably we copy or steal stuff from new bundles, so it's not criminal. I think that's the benefit of the open-source ecosystem, you're actually allowed to steal or copy stuff. I also think these tools copied a lot from Webpack so it's not that there's only one way. I think more like an ecosystem, the Web ecosystem, and we all benefit from these competitors and we benefit as ecosystem as a whole from these developments and new ideas and new technologies emerge, that all will benefit from them. Yeah I guess that's a good way to go about it, you have to share from each other. That was all the time we have for Q&A, if you want to continue the conversation you can go to the monetization of open-source discussion room and right now you're going to go to the speaker lounge where people can also continue. See you there.