I have many Opinions on this, as a mostly-backend software developer who spent the last decade doing increasing amounts of JavaScript, and then the last year firmly in the land of CSS.
My first opinion: Amber is completely right.
I used to be one of those people.
My first opinion: Amber is completely right.
I used to be one of those people.
However, I get why the CSS cascade is hard. And it starts with the fact that the cascade is structurally equivalent to inheritance.
Even in backend code, inheritance is a tricky technique to use well, & overuse leads to badly-partitioned code and/or shittons of conditionals.
Even in backend code, inheritance is a tricky technique to use well, & overuse leads to badly-partitioned code and/or shittons of conditionals.
But there are crucial differences, as well, between the cascade and inheritance, that make it hard to directly apply to CSS the techniques we use in backend code to manage the difficulties of inheritance.
For the purposes of the cascade, a webpage is a tree - just like a class hierarchy is a tree. Styles applied to root nodes (like logic in base classes) get passed down to child nodes (which are like subclasses).
In the cascade, a child node may have styles applied directly to it, which override the styles it gets from its parent. This is like a subclass redefining a method defined in its superclass to provide some specialized behavior.
One reason that devs with inheritance experience tend to think that CSS is “broken” is because the way the styles for a node are resolved can strongly resemble multiple inheritance - a bugaboo concept that the object-oriented literature advises you in VERY strong terms to avoid.
In OO-land, multiple inheritance refers to any hierarchy where a subclass is receiving shared logic from more than one source.
In Ruby, for example, when creating a class, you can’t give it more than 1 parent class, but you _can_ include modules, for a similar effect.
In Ruby, for example, when creating a class, you can’t give it more than 1 parent class, but you _can_ include modules, for a similar effect.
This isn’t inherently awful, but it can turn bad quickly if it makes it hard to tell what happens when you call a method on an object. Let’s look at an example.
(uhhh, in a little while, because rn I need to take a walk with the kids😅) to be continued :)
This was a really long “walk” 😅 but I’ll get back to this thread later today! You’re witnessing twitter at the speed of parenting😬
