Clean And Scalable Css Architecture (2023)

Published 1/2023
MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHz
Language: English | Size: 504.32 MB | Duration: 1h 20m

Write Clean CSS code, create modular CSS and scalable CSS. OOP principles, SOLID, OOCSS, BEM will improve your CSS code.

What you'll learn
Understand common CSS issues
How to write clean CSS code
How to implement Object Oriented principles in CSS (SOLID, DRY, immutability...)
What is a good and a bad Specificity graph
Understand the concepts of OOCSS and how it can help you improve the code
Understand the concepts of BEM
How to manage Specificity graph with Inverted Triangle

good CSS knowledge
it would be easier to follow the course if you are familiar with basics of OOP

CSS is easy, it's easy to learn, it's easy to write.But actually, it's hard to write scalable and maintainable code especially with large projects that require constant scaling.There are many reasons why this is the case:- In CSS everything is in a global scope. Any change in one file can cause an (un)expected result in another element, or page.- CSS is a highly mutable language, because of it's cascade nature. Each mutation leads to confusion and unexpected results.- CSS highly depends on the source order.- On the other hand, specificity can undo everything. It doesn't matter how you structure your code, specificity can break everything. Specificity is one of the biggest problems of CSS.- CSS is not (easily) scalableWe end up in a cycle of writing more CSS just to fix the old CSS! At some point our whole CSS code becomes too messy and too large. We need a better approach, we need a modular and predictable CSS. CSS language has not evolved since 1998. There are preprocessors, but they are not solving the main CSS issues. After all, SASS and Less are compiling to CSS.In this course, we will talk about the CSS architecture, and how to write clean and maintainable code. Our goal is to write CSS that should be:- Predictable: CSS rules behave as we expect them to.- Reusable: When adding new components, we shouldn't need to recode patterns or problems we've already solved.- Maintainable: New features, components, or updates shouldn't require refactoring our CSS and should NOT break existing components.The idea is taking the OO philosophy you already learned in Java, PHP, C# and finding a way to translate that into CSS as well. All that you learned in OOP languages, all the DRY principles, SOLID, SRP, immutability we can apply to CSS in some way. Simple is the best.There are many advanced courses about CSS, about flexbox, CSS animations, CSS grid. However, in this course, we will be focusing on the architecture of CSS. If you are interested in learning how to write clean and scalable CSS code, this course is the right thing for you!This is a course I wish I had when I started working on more complex projects.
Section 1: Introduction
Lecture 1 Introduction
Lecture 2 Stylesheet order issues
Lecture 3 Prerequisites
Section 2: OOP Principles in CSS
Lecture 4 Introduction
Lecture 5 Specificity
Lecture 6 Single responsibility principle
Lecture 7 Open-closed principle
Lecture 8 Liskov Substitution
Lecture 9 Interface Segregation
Lecture 10 Dependency Inversion
Lecture 11 Decouple CSS from HTML
Lecture 12 DRY
Lecture 13 Immutability
Lecture 14 The Separation of concerns
Lecture 15 Summary
Section 3: OOCSS
Lecture 16 OOCSS introduction
Lecture 17 The Media Object
Lecture 18 OOCSS concepts
Lecture 19 OOCSS standards
Section 4: BEM
Lecture 20 BEM
Lecture 21 Benefits of using BEM
Lecture 22 BEM specificity
Lecture 23 BEM vs OOCSS
Section 5: Overmodulize
Lecture 24 Overmodulize
Lecture 25 Overmodulize is (not) good
Section 6: The missing piece - ITCSS
Lecture 26 ITCSS
Lecture 27 Layers and Specificity Graph
Lecture 28 Inverted Triangle
Lecture 29 Folder structure and naming convention
Lecture 30 Summary
Medior/Senior Front End developers,Anyone who wants to write clean and scalable CSS code,Anyone who knows CSS but wants to dive deeper


To Support My Work Buy Premium From My Links.