Free course: “Quick start in Python"
Learn moreJoe Honton
(Joe Honton)
About
The author of this content is an expert in their field, possessing deep knowledge and experience. With their help, readers can gain valuable information and useful tips. Over the years, the author has created numerous materials that help people understand complex topics, making them accessible and understandable. His articles are distinguished by their high quality, relevance, and practical approach, making them indispensable for anyone who strives for self-development and deepening their knowledge.
The founder of the software company Read Write Tools, a software engineer and open source advocate, as well as a technical writer. His principle is to create modern code, avoiding compromises, even if this will not be noticed, and not to implement features that may be needed in the future.
Links are an important element of web content, as they help users find the information they need and navigate the site. Properly optimized links can significantly improve the visibility of a site in search engines. It is important to use clear and descriptive anchor texts that accurately reflect the content of the target page. This not only improves user experience but also contributes to higher search rankings. Internal links help distribute page weight and keep visitors on the site longer, while external links can increase the authority of a resource. Ensuring that all links on a site function correctly is also critical to maintaining its functionality and improving SEO.
Every front-end developer faces the need to adapt their workflow to new technologies. Modern capabilities of HTML, CSS, and JavaScript allow them to improve outdated working methods. These changes are always welcome, but innovations require a thorough review of approaches. As a result, developers are forced to learn from their mistakes, experimenting, and accumulating new experience. It is important to remember that mastering new tools and technologies is an integral part of professional growth in the field of web development.
Nowadays, open source projects and developers of programming tools regularly release new versions of their software. The entire industry strives to keep up with the latest advances in key technologies. For anyone working with code, maintaining an up-to-date front-end development stack and tools is a critical and ongoing task that requires significant effort. Up-to-date knowledge and use of modern technologies are essential for success in web development.
Remember a time when web application development was much simpler. There were no preprocessors, transpilers, or complex code build systems. We simply wrote clean and understandable code that worked across multiple platforms without any additional manipulation. Automated builds and software pipelines were not required to maintain order in the project. We didn't use Source Maps for debugging, and the code remained unchanged and readable. Frameworks didn't mix different languages, making them easier to understand and work with. Those simpler times of development seemed much more convenient and intuitive.
Remember those times when life seemed especially bright and carefree? Those were the times when simple joys brought true happiness. Memories of those days fill us with nostalgia and make us reflect on how our world has changed. It's important to appreciate the moments that make our lives rich and full. Let's remember how wonderful it was to savor every moment and find happiness in the little things.
Recently, I rediscovered the joy of web development because I learned to optimize my workflow. The secret was simple: eliminate all unnecessary elements. Now I spend significantly less time on routine tasks and more on the creative aspects of my work. I'll share how I achieved this result.
Optimizing your web development workflow involves automating repetitive tasks, using tools to simplify your work, and planning your time. This allows you to significantly increase your productivity and focus on creating high-quality content. By eliminating inefficient approaches, I was able to rediscover the joy of the development process and focus on creative solutions.
The Golden Era
A lot has happened in a short period of time, but our collective experience clearly demonstrates how we arrived at modern approaches to web development. History plays a key role in understanding my arguments about how to streamline workflows and eliminate unnecessary elements. Let's look back.
It all started with HTML. It was a simple set of tags that allowed us to structure content, highlight words, and create hyperlinks, without the need for CSS or JavaScript. HTML became the foundation of web development, providing the ability to organize information on pages and ensure their accessibility to users.
HTML quickly became the foundation of web development, joined by CSS and JavaScript. These technologies allowed us to effectively solve problems piecemeal, leading to a more structured approach. Problem decomposition became our guiding principle, allowing us to break complex tasks into more manageable elements. This not only simplifies the development process, but also contributes to the creation of a higher-quality and more convenient user interface.
- HTML - for meaning and structure;
- CSS - for layout and design;
- JavaScript - for interactivity.
While the world of web development strived for perfection, the reality turned out to be different. Browser incompatibility issues became a real challenge. Initially, we preferred to ignore these differences, adding a warning in the footer of each page: "Best viewed in Internet Explorer." In this way, we essentially encouraged users to take care of their own experience. However, over time, it became clear that to ensure a high-quality interaction with the site, it is necessary to take into account all browsers and their features.
Currently, three key technologies have become the basis of front-end development, and learning them is essential for every developer. However, as practice shows, vendors sometimes fail to keep up with the latest specifications, and it is up to developers to solve the emerging problems. This highlights the importance of a deep understanding of technology and constantly updating your knowledge in the rapidly changing world of web development.
The Age of Standards
In an era of significant historical change, our perception of websites has changed. They are no longer just static pages providing information. Modern websites have become full-fledged cloud applications that provide access to and interaction with user data. This transformation opens up new opportunities for businesses and users, allowing for the creation of more personalized and interactive online experiences.
At this time, Apple, Mozilla, and Opera came to the conclusion that it was necessary to stop endless innovation and competition that did not bring significant advantages. They joined forces to jointly develop standards and created the Web Hypertext Application Technology Working Group (WHATWG). Microsoft and Google later joined them, which contributed to the creation of the HTML5 standard. This standard has become the foundation for modern web applications, providing a unified approach to development and improving interoperability across different platforms and browsers.
The development of web technology standards has previously been slow and painful. For example, the creation of CSS2 dragged on for many years, and as a result, the standard did not receive significant improvements. HTML4 took even longer to develop, resulting in a complex structure filled with strict rules, compromises, and the use of frames.
Browser developers recognize that the elimination of differences in web technologies must keep pace with innovation. Slowing down the development of standards can negatively impact the evolution of the web. Therefore, it is important that new solutions and standards are adopted in a timely manner, contributing to a better user experience and maintaining interoperability across different platforms.
The WHATWG has fundamentally changed the approach to innovation and standards, viewing them as dynamic and living entities. Instead of creating a single, comprehensive specification, they began publishing separate documents covering different aspects of the technologies. For example, the HTML5 standard is a set of mini-standards. Thus, "HTML5 and its friends" include not only HTML itself, but also such important components as debugging, DOM, fetching, streams, storage, web sockets, web workers, and many other elements. This allows developers to work with current and specialized standards, which contributes to more efficient creation and maintenance of web applications.
The concept of living standards has proven its practical value, which led to its adoption by the World Wide Web Consortium (W3C) when developing new CSS standards. This resulted in the creation of the CSS3 standard, which includes many blocks, such as colors, fonts, selectors, backgrounds, borders, multi-column layouts, and rules for displaying pages depending on the device being used. Each of these blocks has its own standards update cycle, ensuring relevance and flexibility in web development. ECMA International, following the W3C's lead, adopted a similar approach during the development of the ECMA-262 standard for JavaScript. As a result, they revised their ambitious plans for a global language update, focusing on a "harmonized" approach to development. Since then, new features have been added to the standard as they become available, allowing us to receive an updated set of JavaScript features every year since 2015. This approach facilitates the smooth introduction of innovations and improvements to the language, ensuring its relevance and meeting the needs of modern developers. The standards development process has transformed from a clumsy attempt to capture emerging innovations into a powerful tool for promoting their active development. This change has made it possible to effectively manage technological chaos and ensure a focused movement into the future. The standards work became public, making the direction of development accessible and understandable to all interested parties.
At that time, new features in HTML, CSS, and JavaScript were announced monthly. Our interest grew with each new update—we were interested in what we heard and eager to get access to these features as soon as possible, even before browser developers had time to implement them. As a result, the situation became more complex.
To get ahead of the competition, we implemented feature detection and polyfill technologies into our codebase. This allowed us to accurately determine which features are supported by browsers and which need to be emulated using alternative solutions. This led us to the concept of progressive enhancement, which involves adapting code complexity based on browser capabilities. However, this approach proved to be feasible only for a limited number of tasks.
As a result of these changes, we began actively using transpilers, and Babel has become an indispensable tool in our work. Now we can write applications using a modern and convenient syntax without worrying about incompatibility with different browser versions. In response, we integrated transpilers into the standard build process, significantly simplifying development and improving code quality.
After the explosive growth of JavaScript, it seems its evolution is reaching a certain point. The emergence of new mandatory features, which we have seen in recent years, is slowing down. Our ecosystem already includes a modern, multi-paradigm language with advanced features such as modules, classes, iterators, and generators. We also feature arrow functions, binary data manipulation, map and set functions, promises, template literals, destructuring, as well as async/await and rest/spread operators. This rich functionality makes JavaScript a powerful development tool, opening new horizons for programmers and enabling the creation of more complex and efficient applications. Moving beyond nested closures has become one of the key factors in improving JavaScript's performance. The advent of native Promise objects and async/await syntax has opened up new horizons for asynchronous programming. JavaScript now fully supports this approach, which not only simplifies code but also makes it more readable and easier to develop. Asynchronous programming in JavaScript allows for the efficient handling of I/O operations, significantly increasing application performance. Modern transpilers have become obsolete. All the necessary language features for creating clean code are available without additional tools. We can develop software using various paradigms, such as functional, object-oriented, and imperative programming, without the need for transpilation. This simplifies the development process and makes it more efficient, allowing us to focus on problem-solving rather than transforming code.
Before moving on to the next topic, I want to make an important note about transpilers. If you use TypeScript, you can eliminate Babel from your workflow. However, don't forget about the need to use tsc to transform your source code into browser-compatible JavaScript. This will ensure the correct operation of your application and maintain high code quality.
