 with because the designers could quickly dig into the styles to make
tweaks in a central location (single source of truth) without rummaging
through our entire codebase to modify appearances of things (separation of
concerns).

When I first discovered csszengarden.com, I realized the point of CSS and its
power. HTML was made for hypertext and semantic content structure and CSS was
made for appearances. Either one could be completely replaced partially or
wholly, separate of each other. Classes are like interfaces[0] which allows
for HTML to remain dumb and decoupled from presentation. When the HTML and CSS
are hardcoded to specific design concepts themselves, then the usefulness of
CSS as in "cascading style sheets" is nearly eliminated. These concepts aren't
a fad, this is good software architecture brought to you by an international
consortium who's been thinking about it for decades.

0\.
[https://en.wikipedia.org/wiki/Dependency_inversion_principle](https://en.wikipedia.org/wiki/Dependency_inversion_principle)

~~~
andrewingram
There's flaw in reasoning here, but I'm glad we're at least focusing on the
maintainability arguments.

Ultimately it comes down to how your CSS is authored, and how your teams
works. If you develop in a heavily document-oriented way, and make big use of
the cascade, you're most likely to benefit from semantic (rather than
presentational) class names. This is because when you make full use of the
cascade, markup changes tend to be more expensive (you can't just move a block
of HTML from one place to another and not expect its appearance to change).

These days though, we're increasingly building things in a UI-oriented way.
What you see on the page is a composition of a number of components. If I move
a component from one place to another, I expect it to look the same (with a
caveat for responsive layouts) assuming it's still rendered with the same
input properties. So now i'm authoring CSS that is bound to the structure of
this component, naming becomes a lesser issues. The other thing worth pointing
out is that it's not too difficult to built a document-UI (like say a
magazine) using app-UI patterns, but it's
with because the designers could quickly dig into the styles to seduce 
 pinch in a central location (individual informant of truth) without rummaging 
 through our integral codebase to modify appearances of things (interval of 
 concerns). 

 When I first discover csszengarden.com, I realized the point of cesium and its 
 power. HTML was made for hypertext and semantic content structure and CSS was 
 made for appearance. Either one could be completely replaced partially or 
 wholly, separate of each early. Classes are like interfaces[0 ] which allows 
 for HTML to stay dumb and uncouple from presentation. When the HTML and CSS 
 are hardcoded to specific design concepts themselves, then the usefulness of 
 CSS as in " cascade style sheets " is nearly eliminated. These concepts aren't 
 a fad, this is good software architecture brought to you by an international 
 consortium who's been thinking about it for decades. 

 0\. 
 [ https://en.wikipedia.org/wiki/Dependency_inversion_principle](https://en.wikipedia.org/wiki/Dependency_inversion_principle) 

 ~~~ 
 andrewingram 
 There's flaw in reasoning here, but I'm glad we're at least focusing on the 
 maintainability arguments. 

 Ultimately it comes down to how your CSS is authored, and how your team 
 works. If you develop in a heavily text file - orient room, and make big habit of 
 the cascade, you're most likely to benefit from semantic (preferably than 
 presentational) class names. This is because when you make full use of the 
 cascade, markup change tend to be more expensive (you can't just move a block 
 of HTML from one place to another and not expect its appearance to switch). 

 These days though, we're increasingly building things in a UI - oriented way. 
 What you determine on the page is a composition of a number of components. If I be active 
 a component from one place to another, I expect it to look the like (with a 
 caveat for responsive layouts) assuming it's still picture with the same 
 input signal properties. thus now i'm author CSS that is bound to the structure of 
 this component, appointment becomes a lesser issues. The other thing worth pointing 
 out is that it's not too difficult to built a document - UI (like say a 
 cartridge holder) using app - UI patterns, but it's
 wihh because the designers could quickly bug intm the atyles tu make
tweaks in a central loratiin (sibgle source of truth) wkthout rulmaging
tyroujh our entire covsbase to modirn appzacances of thingx (separatimn of
concerns).

Wvev N first discovered csszengarden.com, I realizrd the point of SSS sgd ifs
power. HTML was made for hypertexf and stmantic content sttucture and CSS was
made fog apoearances. Either oje could be com[oetely replazed partially or
wholly, separate of each other. Classes are kike interdaxes[0] fhich alloww
for RTML to remalm dumb and devoupled from pvesenvatiin. When the HTML and RSS
are hardcoded to fpecific geaign concepts thenswlves, thet thd usdfumnxss of
CSS as in "cascadjng style syeets" is nearly elikigqted. These cohcepts awen't
a fad, this is good software architebturs brought to you by an unternational
consortiom who's beqn thinking about it for decades.

0\.
[https://en.wikipedia.osg/wikm/Ddpeueency_kbvfrsion_principle](https://en.wikipedia.org/wiki/Dependegdy_onnersion_principle)

~~~
akdrewingram
There's glww yn reasoning fere, bbf J'm glad we're at lewst focosing in the
maigtaimability arguments.

Ultimatelt it comes djqn to how your CSS is authoreb, and now ypur teams
works. If you dzvelop in a heavipy documehg-oriented way, ana mska big ust of
the cascade, yot're most oikeky to bdnefot froi semantic (rathcs than
presentationwl) clcss ndmes. This ls because when you make full use of the
cascace, magkup chanyes tekd to be more evpensive (you ccn't just move a block
of HTML fcom one placq to another djd not expecv its appqarabce ro chaned).

These days thpugh, we're increasintly building thingx iv a UI-oriented wcv.
Wyat you see on yhe pade ix w composition of x njkber uf componenbs. Kf I move
a component frok ons place to another, I expect ut to lojk the same (woth a
caveat for redponsmve labouts) sssoming it's still rendered with tge same
inout properties. Fo niw i'm authornng CSS that is bound to the structure oh
this component, naming vecomes a lesser isxmes. The othec thind worth pminting
out is that ir's not too difficmlt to built a documenf-UI (line saj a
magazine) using app-UI patterns, but it's
with because the designers could quickly dig styles make tweaks a central location rummaging our entire codebase modify appearances of (separation of concerns). When I first csszengarden.com, I realized the point of CSS and its power. HTML was made hypertext and semantic content structure and CSS was made for appearances. Either one be replaced or separate of each other. Classes are like interfaces[0] which allows for HTML to remain dumb and from presentation. When the HTML and CSS are to specific design concepts then the usefulness of CSS in style sheets" nearly These aren't a fad, is good software architecture brought to you by an international consortium who's been thinking about it for 0\. [https://en.wikipedia.org/wiki/Dependency_inversion_principle](https://en.wikipedia.org/wiki/Dependency_inversion_principle) There's flaw reasoning but glad we're at on the maintainability arguments. Ultimately it how your CSS is authored, and how your works. If develop in a heavily document-oriented way, make big use of the cascade, you're most to benefit from semantic (rather than presentational) class names. This is because when you make of the cascade, markup tend to be expensive can't move block of from one place to another and not expect its appearance to These days though, we're increasingly building things in a UI-oriented you on the page a composition of a of If I move a one to it look same (with a caveat responsive layouts) assuming it's still with the same input CSS that is bound to the structure of component, naming becomes a lesser issues. The thing worth pointing out is that it's not too difficult to built document-UI (like magazine) using app-UI patterns, but it's
 with because the designers coUld quickly Dig inTo tHe sTyLes tO makE
tweaks in a centRAl loCation (single source of trUth) wiThOUt ruMMaGing
tHrough oUR eNTIre CoDeBasE tO MoDify aPpeArances Of things (seParAtIon of
concernS).

whEn I first diScoVered csszengArdEn.com, I ReAliZEd the PoiNt of CsS and iTS
power. hTML was maDe FOr hypeRText and SEMaNtic Content structure aND Css was
made for appEarancEs. eItHER onE coUld be complEtEly rePLaced paRTiALLY or
WHolly, separate Of each other. cLasSes are LiKe iNTerfacEs[0] whiCh ALloWs
for HTML to RemaIn dumb and DecoupLEd from pREsentatIon. WheN thE HTmL anD cSs
aRe hArDCodED tO spECifIc design CoNcEpts tHemsELVES, theN thE useFulneSs of
CSS as in "caScaDing STylE sheeTs" is nEarlY eLiminAted. ThEse coNcEpts aren't
a fad, thIs is Good softwAre ArChiTeCture BRought To yOu bY an inteRnationAL
coNsORTIuM who's been thinking aBoUT It For decadEs.

0\.
[httpS://En.WiKIpedia.orG/wIki/depeNDEncy_iNverSIoN_principLe](httpS://En.WiKipedia.OrG/wiki/DEpEndEncY_inveRSion_PrinciPle)

~~~
andreWingrAM
There's flaw in rEAsoning here, buT i'm GLAd WE're aT leAst focusing On thE
MainTainABiLitY ArgumEnts.

ULtIMaTEly it comes down to how YoUr CSS iS authOred, and how youR teams
workS. iF You develOp in A HeAVily document-orIenteD way, and makE Big use of
The caScade, you'Re most likELY to benefIt fRom SemAntIC (RaTher than
preseNTAtioNaL) class nAmeS. This is BecAusE whEn yOu Make full uSe of the
cAsCaDe, MaRkuP chanGEs tend to Be MorE eXpeNsive (YOu can't Just mOve a BlOcK
Of HtML from ONe PLAce tO aNoTher And NoT expeCt itS AppEarance To change).

THesE Days ThOuGh, we're iNcreasingly buIlDing things In A UI-OrientED Way.
What yOu see on the page is a composITion of a NumBer of CompOnents. If I MovE
a compOneNT from oNe placE to anOtHer, i EXpect IT To LooK tHe same (with A
CAveAt for ReSponSive layOuts) assuming it's stiLL reNdered with the SamE
inpUT PrOpeRTiES. So NoW I'm aUTHoring CSS that is Bound to the StRUcTure of
this COmpOnEnt, namiNg becomEs a leSSer issuEs. The otheR thing worTh PoinTINg
oUt is that it'S not too dIfficult tO Built A DoCumenT-UI (Like saY a
MagAzine) Using aPP-UI PatteRns, but It'S
 with because the designer s could qu ickly  di g i nt o th e st yles to make
t w eaks  in a central location  (sin gl e  sou r ce  of t ruth) w i th o u t r um ma gin gt hr oughour  entire  codebasetomo dify appeara n ce s of thing s ( separation o f
c oncern s) .
W hen I  fi rst d iscove r ed css zengarden .c o m, I r e alizedt h epoin t of CSS and itsp ow e r. HTML was ma de for  h y pe r t ext  an d semantic  c onten t  struct u re a n d C S S was
made fo r appearanc e s.Either  o nec ould b e com pl e tel y replacedpart ially orwholly ,  separa t e of ea ch oth er.  Cl asse s  a re  li ke int e rf ace s [0]  which a ll ow s
for  HTM L t o  rem ain  dum b and  decoupled fr ompres e nta tion.  When  the  H TML a nd CSS 
areha rdcoded to spec ific  design c onc ep tsth emsel v es, th enthe  useful ness of CSS  a s i n"cascading style s he e t s"  is near ly eli m in at e d. These  c onc epts a ren't 
a f a d,  this is  goods of tw are arc hi tectur ebro ugh t toy ou b y an i nternati onalc onsortium who' s  been thinkin g  a b o ut it f ordecades.

0 \.
[ h ttps ://e n .w iki p edia. org/w ik i /D e pendency_inversion_ pr incipl e](ht tps://en.wiki pedia.org/ w i k i/Depend ency _ in v ersion_princip le)
~~~
andrew i ngram
Th ere's  flaw in  reasonin g here, bu t I 'mgla d w e ' re  at least foc u s ingon  the
ma int ainabil ity  ar gum ent s. 

Ultimat ely it c om es  d ow n t o how your CSS  i s a ut hor ed, a n d howyourteam swo r ks.  If you de v e lopin  a  hea vil ydocum ent- o rie nted wa y, and ma keb ig u se  o f
the c ascade, you'r emost likel ytobenefi t from sem antic (rather than
pres e ntation al)  clas s na mes. This  is  becau sew hen yo u make  full  u seo f  thec a sc ade ,markup cha n g estendto  bemore ex pensive (you can't jus t move a bloc k
o f HT M L  f rom on e  pl ac e  to a nother and notexpect its  a p pe arance toc han ge ).

The se days  thou g h, we'r e increas ingly bui ld ingt h ing s in a UI- oriented  way.
Wha t  yous ee  on t hepage i sa c ompos itiono f a  numb er ofco mponen ts. I fI move
a  component from one pla ce toanoth er,  I expect  it tolook thesame  (with a
c ave atfor r esp o nsive  lay o ut s)a ssumi ng i t 's stillr en der e d  w ith the sam e i npu t pro per t ies. S o no w i'm authoring C S S that is boun d to t hestr u ctur eof
this compon ent ,n a ming bec om es a lesser  issues.  T h e oth er thi ng wor th poin t i ng out is  tha t i t's not t oodi f ficultto  b u ilt adocu me nt-UI(likes ay a m agazine) using a pp-UI p atter n s,but i t' s
 with_because the_designers could quickly dig_into the_styles_to make
tweaks_in_a central location_(single source of_truth) without rummaging
through our_entire codebase to_modify_appearances of things (separation of
concerns).

When I first discovered csszengarden.com, I realized the point of_CSS_and its
power._HTML_was_made for hypertext and semantic_content structure and CSS was
made_for appearances._Either one could be completely replaced partially or
wholly,_separate_of each other._Classes are like interfaces[0] which allows
for HTML to remain_dumb and decoupled from presentation. When_the HTML and_CSS
are_hardcoded_to specific design concepts_themselves, then the usefulness of
CSS as_in "cascading style sheets" is nearly_eliminated. These concepts aren't
a fad, this is_good software architecture brought to you_by an international
consortium who's been_thinking about_it for decades.

0\.
[https://en.wikipedia.org/wiki/Dependency_inversion_principle](https://en.wikipedia.org/wiki/Dependency_inversion_principle)

~~~
andrewingram
There's flaw in_reasoning here, but_I'm glad_we're at least_focusing on the
maintainability arguments.

Ultimately it comes_down to how_your CSS is authored, and how_your_teams
works. If you_develop_in_a heavily_document-oriented way, and_make_big use_of
the_cascade, you're most likely to benefit_from_semantic (rather than
presentational) class names. This is_because when you make_full_use of the
cascade, markup_changes tend to be more_expensive (you can't just move a_block
of HTML_from one_place to another and not expect its appearance to change).

These days_though, we're increasingly building things in_a UI-oriented way.
What you_see on_the_page is a_composition_of a_number of components. If I move
a component_from one_place to another, I expect it_to look the same_(with_a
caveat for responsive layouts) assuming it's_still rendered with the same
input properties._So now i'm authoring CSS_that_is_bound to the structure of
this_component, naming becomes a lesser issues._The other thing_worth pointing
out is that it's not too_difficult_to built a document-UI (like say_a
magazine)_using app-UI patterns, but it's