Before diving into this article, I want to clarify that I am not targeting any individual, platform, or educational institution. These are purely my observations and frustrations as a student who is navigating the ever-evolving landscape of web development. This is my rant about the current situation facing new generation programmers like me. If anyone faces any issues with anything in this article, then I am utterly sorry for that. You can contact me through my website, and we can argue on the topic.
As a so-called 'New Gen' web developer, I've been observing the chaotic and rapidly shifting landscape of web development with growing frustration. My journey started two years ago in the first year of my bachelor's degree, and since then, I've dived deep into a plethora of technologies. From foundational languages like HTML, CSS, and JavaScript to modern frameworks and tools such as React, Next.js, and Prisma, my learning path has been both extensive and enlightening. Yet, this journey has also laid bare the multitude of issues and concerns that plague this field, leaving me feeling both bewildered and angry.
My introduction to web development followed a structured path, a path that was supposed to make me a competent developer. This is the exact order in which I learnt web development:
This path was supposed to make me proficient, but instead, it has left me questioning the very nature of programming languages and the bloated ecosystem of web development tools. Despite learning all this, I still grapple with fundamental questions, and that is maddening.
JavaScript, JavaScript, JavaScript. Everything revolves around this language. It dominates the web development world to such an extent that my mind has subconsciously started to favour it over others. It wasn’t until I stumbled upon this Reddit thread questioning why everything isn't written in JavaScript and discussing the merits of other languages like Java, Python, C, and newer ones like Zig, Lua, and Haskell, that I began to see the cracks in the facade.
Why the hell do we need so many programming languages? Each language claims to solve specific problems or improve upon existing solutions, making it nearly impossible to discern which one is right for any given use case. Traditional languages like Java and Python are still mainstays in educational curriculums, while C and C++ are considered essential for understanding low-level computing concepts and data structures. But as a student, the sheer number of languages and their specific niches leaves me utterly baffled. Why do we need so many damn languages, and how on earth am I supposed to choose the right one?
Web development courses and bootcamps often emphasize the practical application of tools and frameworks over understanding the underlying principles. This approach might enable rapid learning and the ability to build functional applications quickly, but it also fosters a blackbox mentality. For instance, I can create a blog website using React and Next.js, but I have no deep understanding of how these tools work under the hood. Questions like "How does React's virtual DOM work?" or "What are the internal mechanisms of a fetch function?" often go unanswered. This is infuriating! I didn’t know how caching works until last week! These boomer developers are busy creating more features for their open-source software that helps them code faster supposedly. What are they coding so much for? Is there any reliable answer to “Why am I developing this feature?”. Isn’t this an overly emphasized version of “Code re-usability”? You are making literal framework features, so you don’t have to code the same thing (Which is just mildly complicated) again? I recently saw one video from a developer at Vercel explaining Next.js’ server actions. In this video he says
For those who are familiar with HTML, you will be familiar with ‘action’ prop.
This shows that we have reached a point where this also has to be mentioned while learning literally a web development framework.
The current trend in web development education is an alarming shift towards frameworks and libraries. Platforms like Frontend Masters, WebdevCody, and freeCodeCamp are increasingly offering courses on specific frameworks rather than delving into the core languages themselves. This shift reflects the industry's demand for developers who can quickly adapt to new tools and technologies, but it also raises serious concerns about the depth of understanding that new developers possess. I am not against any courses or any tutors online. My concern is that these courses are migrating the students from being a good programmer to becoming just a framework user. I see 100s of LinkedIn profile that say “React Developer” or “Python developer”, “Angular Developer” , etc in their bio.
My question to them is, “What if somehow React gets banned tomorrow?”. All of them (Including me) will be considered ‘Illiterate’.
My straight up opinion on this is
If you introduce yourself as a ‘XYZ developer’ then you are just a slave of XYZ and not a real programmer. A real programmer is just ‘Programmer’. He or She (Yes only 2 genders. The third is a manufacturing defect and all others are mental illness) doesn’t care what framework it is or what language it is. If the use case fits best for a specific language, then they will use that.
I read a really great blog by Kent C. Dodds on Why I won’t use Next.js. This article shows the importance of following standards over providing black boxed and overly detailed documentation for a framework.
This leads to my next concern.
My desire to learn the core principles of programming stems from a fundamental question: "Why should I use a certain language or tool?" Understanding the rationale behind choosing a specific technology is crucial. For instance, if JavaScript gets the job done, why should I explore alternatives like Python or PHP? Similarly, while Node.js is popular for backend development, what advantages do languages like Go or Rust offer?
The frustration is real. I want to know the core. I want to understand the fundamentals, not just how to use the tools but why those tools exist in the first place. Why do we have fetch? How does it actually function? Can I write my own fetch function? If I ask a beginner web developer like me to make a blog website, the immediate answer would be yes. But if I ask the same person how streaming works, how tools check website performance, or how browsers cache requests but not fetch functions, they'd be clueless. And that’s a massive problem. If this goes on, then every single programmer from my generation would be stuck with a small set of languages that they can code in and totally clueless of what others are doing.
A small example of this is: A mechanic learns how engines function, how transmissions work, Carnot cycle, Diesel Cycle, etc. He doesn’t learn how to make a AUDI by putting a V8 engine with a 6 speed transmission and a supercharger and turbo together by following a manual. (I am not a car guy, all this is supposed to make you understand my thought, don’t go into car specific. I know you have more knowledge than me about Lamborghinis but none of us have one).
So why isn’t computer science like mechanical engineering? The programmers are going in the wrong direction here.
The rapid pace of innovation in web development is both a blessing and a curse. On one hand, new tools and languages promise improved performance, scalability, and developer experience. On the other hand, the constant influx of new technologies makes it challenging to stay up-to-date and maintain a deep understanding of the fundamentals. My concern is that the future might see developers learning frameworks before the core languages, leading to a superficial grasp of the underlying principles.
Imagine a future where kids are learning Next.js before they even know JavaScript. It's a nightmare scenario that feels all too possible given the current trends. And it’s all driven by this relentless focus on tools and frameworks rather than the core principles of programming. But it doesn’t stop there. The industry’s obsession with being “industry-ready” is forcing students to chase after every shiny new tool that comes along. This relentless pursuit of the “next big thing” not only dilutes the quality of education but also creates a workforce that’s perpetually in a state of learning rather than mastering. It's an endless cycle of jumping from one bandwagon to another, with no time to actually understand or innovate. The constant bombardment of new libraries and frameworks is not just overwhelming; it's counterproductive. Developers are spending more time keeping up with trends than actually building and innovating. Every week, there’s a new “must-know” tool that promises to revolutionize web development. But does it? Or is it just another distraction, another layer of abstraction that distances us further from the core principles?
The web development ecosystem is overloaded with an excessive number of tools, libraries, and frameworks. The industry’s fixation on new technologies has created an environment where the actual development process is often overshadowed by the need to adopt and adapt to these tools. This constant state of flux leaves developers in a perpetual learning curve, never allowing them to fully master any particular tool or technology. Consider this: we have JavaScript frameworks like React, Vue, and Angular. Then there are CSS frameworks like Bootstrap, Tailwind, and Bulma. On top of that, we have build tools like Webpack, Parcel, and Rollup. And let’s not forget about testing libraries, state management solutions, and various APIs. The list is endless and exhausting. This saturation of tools creates a fragmented learning experience. Instead of gaining a deep understanding of core concepts, developers are forced to learn a little bit about a lot of things, resulting in a shallow knowledge base. It's like being a jack-of-all-trades but master of none. And that is not what web development should be about.
The corporate world has a significant influence on the direction of web development. Companies like Facebook, Google, and Microsoft are dictating the tools and technologies that developers should use. This corporate dominance has led to a homogenized development landscape where innovation is stifled, and developers are boxed into using specific tools and frameworks. These corporations push their own technologies, creating ecosystems that lock developers in. React is a prime example. Created by Facebook, it has become one of the most popular frameworks in the world. But with this popularity comes a dependency that ties developers to Facebook’s ecosystem, whether they like it or not. The same goes for Google’s Angular and Microsoft’s TypeScript. These tools are powerful and useful, but they also serve to entrench the dominance of their parent companies in the web development space. This corporate influence limits the diversity of tools and stifles independent innovation.
There's a glaring gap in the education system when it comes to web development. Most educational institutions are not keeping up with the rapid changes in the industry. They continue to teach outdated curricula, leaving students unprepared for the real world. On the other hand, online courses and bootcamps focus too much on the latest trends, creating a shallow learning experience that lacks depth and understanding. We need an educational system that balances the teaching of core principles with the latest technologies. Students should be taught the fundamentals of programming, data structures, and algorithms before diving into frameworks and libraries. They should understand how things work under the hood, not just how to use them. Moreover, the education system needs to instill a mindset of continuous learning and curiosity. Technology will always evolve, and developers need to be prepared to adapt and learn. But this learning should be grounded in a strong understanding of core principles, not just a superficial knowledge of the latest trends.
As developers, we need to shift our mindset from being tool-centric to being problem-centric. The goal should not be to use the latest and greatest tool but to solve problems in the most efficient and effective way possible. This requires a deep understanding of the fundamentals, a critical approach to choosing tools, and a focus on long-term sustainability rather than short-term gains. We need to question the tools and technologies we use. Why are we using React instead of vanilla JavaScript? What problem does Tailwind solve that CSS cannot? Is using TypeScript worth the additional complexity? These are the questions that every developer should be asking. By fostering a mindset of curiosity and critical thinking, we can become better developers who are not just skilled in using tools but are also capable of understanding and solving complex problems. We need to go beyond the surface-level knowledge and strive for a deeper understanding of the technologies we use.
The current state of web development is a chaotic mess of tools, frameworks, and libraries, driven by corporate interests and an obsession with the latest trends. This has created an environment where developers are constantly learning but never mastering, always chasing after the next big thing but never understanding the fundamentals. As we move forward, it is crucial to balance the adoption of new technologies with a deep understanding of core principles. We need to focus on problem-solving rather than tool usage, and we need an educational system that prepares students for the real world by teaching them both the fundamentals and the latest trends. It's time for developers to take control of their learning journey. We need to demand more from our education, question the tools we use, and strive for a deeper understanding of the technologies that power the web. Only then can we hope to truly master the art of web development and navigate the ever-changing landscape with confidence and curiosity.
