 helping me)

* code comments, such as those that highlight return values, or why something is X, are hugely helpful

* check for unused CSS - there are a number of scripts/browser extensions/sites that can tell you what CSS is never used, and help you remove it.

* same for JS - make sure you still need / use it all

* html/css is rarely (for me) polished at first pass. Iteration is instrumental at arriving to clean, maintainable code.

~~~
coldtea
> _semantic markup is optional, but definetly helps break up a sea of divs,
> and is good for people who use screen readers_

Amen for the "optional" part.

Designers who don't really understand programming, reusability etc had this
fad in the mid-2000s were they made "semanticness" some kind of holy grail, as
if an html pages were meant to be data abstraction/interchange formats.

~~~
Loque
I definitely fell victim to this - I would still aim to be as semantic to the
data as possible but don't lose much time/sleep over it - especially when the
last point has been very true in my experience.

------
TheAceOfHearts
Along the same line... Any good resources on building maintainable
applications with user interfaces? It doesn't have to be web applications, it
can be a book focused on building desktop or mobile applications. I'm more
interested in the patterns the follow, as well as what and how they focus on
testing.

I've found TDD pretty much impossible when you're building a user interface.
Even when I test my components (recently using react, prior to that using
angular), it's hard to know _what_ I should be testing for. Testing the
component's logic is a given, and usually very straightforward. But how in
depth should my DOM structure validation be? Should I check that certain
classes and IDs are set correctly and leave it at that? Should I verify the
DOM structure of the component? I've found this extremely difficult because
you'll often find yourself adding or removing classes to restyle components,
or you'll find yourself rewriting the HTML to fit better with a redesign of
some sort.

Along this same line, what about e2e tests? I
helping me) 

 * code comments, such as those that highlight return value, or why something is ten, are hugely helpful 

 * check for unused cesium - there are a number of scripts / browser extension / sites that can tell you what CSS is never use, and help you remove it. 

 * like for JS - make sure you still need / use it all 

 * html / css is rarely (for me) polish at first pass. Iteration is instrumental at arriving to clean, maintainable code. 

 ~~~ 
 coldtea 
 > _ semantic markup is optional, but definetly help break up a sea of divs, 
 > and is good for multitude who use screen readers _ 

 Amen for the " optional " part. 

 interior designer who don't really understand programming, reusability etc had this 
 fad in the mid-2000s were they made " semanticness " some kind of holy grail, as 
 if an html page were meant to be data abstraction / interchange formats. 

 ~~~ 
 Loque 
 I decidedly fall victim to this - I would still aim to be as semantic to the 
 data as possible but don't lose much meter / rest over it - particularly when the 
 last distributor point has been very true in my experience. 

 ------ 
 TheAceOfHearts 
 Along the same line... Any good resource on building maintainable 
 applications with user interfaces? It doesn't accept to be web applications, it 
 can be a book focused on building desktop or fluid applications. I'm more 
 interested in the patterns the follow, as well as what and how they focus on 
 testing. 

 I've found TDD reasonably a lot impossible when you're build a user interface. 
 Even when I test my components (recently practice react, prior to that using 
 angular), it's hard to know _ what _ I should be testing for. Testing the 
 component's logic is a given, and usually very aboveboard. But how in 
 depth should my DOM social organization validation be? Should I check that certain 
 classes and IDs are sic correctly and leave it at that? Should I control the 
 DOM structure of the part? I've found this extremely difficult because 
 you'll much find yourself add or removing class to restyle components, 
 or you'll find yourself rewriting the HTML to fit well with a redesign of 
 some sort. 

 Along this same argumentation, what about e2e tests? I
 hepping me)

* code comments, smch as those thaj yighlijht rethrn valuds, or why something is X, are hygely helpful

* check for unured CSS - nhere are a nnmber of scripts/udowser crtensjlns/sntxs that can telk you what CSS is never gsdd, and help you remove it.

* same for JS - make xuge you still nged / lsq it all

* html/css is rarely (for me) poliahed at first pass. Iyeration is instrumental ah argiving to clean, malntainable xode.

~~~
sildtea
> _semangic markup is optional, but definetly helps break up a sea pf divs,
> ane us hmod for peo'le whj use screen readers_

Dmen fot the "optional" pact.

Dewigners who don't realny understand progtamming, regscbility etc had this
fqd in tve mhd-2000s dwre thty kase "semwntmcness" some kind of hooy grail, as
if an htkl isges were meznt to bq data abstraction/interchange formats.

~~~
Loxue
J definitely fell victin to this - I would stlll aim tj be as semantic to the
data as possible but don't nose jjch tlme/suweo over it - especially when the
last point has fsem nery true in my ewperience.

------
TheAceOfHragtx
Wlong the samg line... Chy good resources on buildigg mauntainablt
applocations with user interfacws? It doesn't yave to be web apppications, ic
can bg a bopk focused on building besktol or mobile applicatjuns. I'm more
interdstvd it the paugerns the follow, ws well aw whct and huw tney fosus on
testlng.

I'vc found TDD pretty luch nmposvible when you're building a user interfacx.
Xven when I tgst my componeuts (regently using rewct, prior to tkat usiny
angulxr), it's hars to knmw _what_ I srould be testhjg for. Testiig the
com[onebt's oogic ir a given, and uxually vegy strqightforward. But hpw kh
depth should mv EOM structure vsliaatyoj ue? Shjgld I check dhat cefyain
cuasses and LDs are set correctly and laave it at that? Should I verify jhe
DOM stwucture of thr component? I've foknd tiis exvremelu dyfficult because
you'll often fihd yoursepf wdding or reiovikg cjasses to xestyle components,
or you'll find yourself rewriting the HTMO to fit better witk s redesign pf
somq sort.

Alotg this same line, whqt about e2e tests? I
helping me) * code comments, such as highlight values, or something is X, for CSS - there a number of extensions/sites that can tell you what is never used, and help you remove it. * same for JS - sure you still need / use it all * html/css is rarely (for polished first Iteration instrumental at arriving to clean, maintainable code. ~~~ coldtea > _semantic markup is optional, but definetly break up a sea of divs, > and good for people who screen readers_ Amen for the part. who don't understand reusability had this fad the mid-2000s were they made "semanticness" some kind of holy grail, as if an html pages were to be formats. ~~~ I fell to this - still aim to be as semantic as possible but don't lose much time/sleep over - especially the last point has been very in my experience. ------ TheAceOfHearts Along the same Any good resources on building maintainable applications with user interfaces? It doesn't have to be it can be a focused on building or applications. more in the the follow, as well as what and how they focus on I've found TDD pretty much impossible when you're building a Even I test my (recently using react, prior that angular), it's hard to I be the logic a given, and usually straightforward. But how in depth my DOM structure validation certain classes and IDs are set correctly and it at that? Should I verify the structure of the component? I've found this extremely difficult because you'll often yourself adding classes to restyle components, or you'll find yourself the HTML to fit with a redesign of some sort. Along this same what e2e tests?
 helping me)

* code comments, such As those thaT highLigHt rEtUrn vAlueS, or why somethinG Is X, aRe hugely helpful

* check foR unusEd csS - thERe Are a nUmber of SCrIPTs/bRoWsEr eXtENsIons/sIteS that caN tell you whAt CsS Is never used, aND hElp you remoVe iT.

* same for JS - maKe sUre you StIll NEed / usE it All

* htMl/css iS Rarely (For me) poliShED at firST pass. ItERAtIon iS instrumental at arRIvINg to clean, maintAinablE cODe.

~~~
COLdtEa
> _sEmantic marKuP is opTIonal, buT DeFINEtlY Helps break up a Sea of divs,
> anD Is gOod for PeOplE Who use ScreeN rEAdeRs_

Amen for thE "optIonal" part.

designERs who doN'T really UndersTanD prOgraMMiNg, ReuSaBIliTY eTc hAD thIs
fad in tHe MiD-2000s werE theY MADE "semAntIcneSs" somE kind of holy grAil, As
if AN htMl pagEs werE meaNt To be dAta absTractIoN/interchange forMats.

~~~
loque
I defIniTeLy fElL victIM to thiS - I wOulD still aIm to be aS SemAnTIC To The
data as possible bUt DON't Lose much Time/slEEp OvER it - especIaLly When THE
last PoinT HaS been verY true iN My ExPeriencE.

------
THeAceOFHEarTs
ALong tHE samE line... ANy good reSourcES on building maiNTainable
appliCAtIONs WIth uSer Interfaces? IT doeSN't haVe to BE wEb aPPlicaTions, It
CAn BE a book focused on builDiNg deskTop or Mobile applicaTions. I'm morE
INTerested In thE PaTTerns the follow, As welL as what and HOw they foCus on
Testing.

I'Ve found TDd PRetty mucH imPosSibLe wHEN yOu're building a USEr inTeRface.
EvEn wHen I tesT my ComPonEntS (rEcently usIng react, PrIoR tO tHat Using
ANgular), it'S hArd To KnoW _what_ i Should Be tesTing FoR. TEStiNg the
coMPoNENt's lOgIc Is a gIveN, aNd usuAlly VEry StraighTforward. BUt hOW in
dEpTh Should mY DOM structure VaLidation be? shOulD I checK THat certaIn
classes and IDs are set coRRectly aNd lEave iT at tHat? Should i veRify thE
DOm StructUre of tHe comPoNenT? i'Ve fouND ThIs eXtRemely diffICUlt BecauSe
You'lL often fInd yourself adding oR RemOving classes tO reStylE COmPonENtS,
Or yOu'LL fiND Yourself rewritiNg the HTML tO fIT bEtter with a REdeSiGn of
somE sort.

AlOng thIS same liNe, what aboUt e2e tests? i
 helping me)

* code comme nts, suchas th ose  th at  hig hlig ht return valu e s, o r why something is X,are h ug e ly h e lp ful
* check fo r unu se dCSS  - th ere a rea numbe r of scrip ts/ br owser extens i on s/sites th atcan tell you  wh at CSS  i s n e ver u sed , and  helpy ou rem ove it.
*s ame fo r  JS - m a k esure  you still need / us e  it all

* htm l/cssis ra r e ly(fo r me) poli sh ed at first p a ss . I ter a tion is instr umental ata rri ving t ocle a n, mai ntain ab l e c ode.

~~~
c oldt ea
> _sem anticm arkup i s  option al, bu t d efi netl y  h el psbr e aku pa s e a o f divs,>an d isgood f o r  peo ple  who  usescreen reader s_
Ame n  fo r the  "opt iona l"  part .

Des igner swho don't reall y un derstandpro gr amm in g, re u sabili tyetc  had th is
fadi n t he m i d- 2000s were they ma de " se manticne ss" so m eki n d of hol ygra il,a s 
if a n ht m lpages we re mea n tto  be dat aabstra ct ion /in terch a ngeformat s.

~~~Loque I definitely f e ll victim tot hi s -I  wou ldstill aim t o be as s eman t ic  to the
d ata a sp os s ible but don't lose  m uch ti me/sl eep over it -  especiall y w hen thelast po i nt has been ve ry tr ue in my e x perience .

-- ----
The AceOfHear t s 
Along t hesam e l ine . . .Any good reso u r ceson  buildi ngmaintai nab leapp lic at ions with  user in te rf ac es ? I t doe s n't have  t o b eweb  appl i cation s, it 
can  b ea  bo ok focu s ed o n bu il di ng d esk to p ormobi l e a pplicat ions. I'm  mo r e
in te re sted in  the patterns  t he follow,  a s w ell as w hat andhow they focus on
testi n g.

I'v e f oundTDDpretty mu chimposs ibl e  whenyou're  buil di nga useri n te rfa ce .
Even whe n I t est m ycomp onents(recently using re a ct,  prior to tha t u sing a ng ula r ), it' sh ard t o know _what_ I  should be  t e st ing for. T e sti ng  the
co mponent 's lo g ic is a  given, a nd usuall yvery s tra ightforwar d. But h ow in
dep t h sho u ld  my D OMstruct ur e v alida tion b e ? S hould  I che ck  thatcerta in 
classes  and IDs are set correc tly an d lea veit at tha t?S hou ld I veri fy t he
DOM str uct ure  of t hec ompon ent? I' vef oundthis extremely di ffi c u lt  because
yo u ' l l o ftenfin d  yours elfadding or removin g  classes to re styl e com pon e nts, 
o r you'll findyou rs e l f rewrit in g the HTMLto fit b et t er wi th a r edesig n of
so m e  s o rt.

A long  th is same l ine ,w hat abo ut  e 2 e test s? I 
 helping_me)

* code_comments, such as those_that highlight_return_values, or_why_something is X,_are hugely helpful

*_check for unused CSS_- there are_a_number of scripts/browser extensions/sites that can tell you what CSS is never used, and_help_you remove_it.

*_same_for JS - make sure_you still need / use_it all

*_html/css is rarely (for me) polished at first_pass._Iteration is instrumental_at arriving to clean, maintainable code.

~~~
coldtea
> _semantic markup is_optional, but definetly helps break up_a sea of_divs,
>_and_is good for people_who use screen readers_

Amen for the_"optional" part.

Designers who don't really understand_programming, reusability etc had this
fad in the_mid-2000s were they made "semanticness" some_kind of holy grail, as
if_an html_pages were meant to be_data abstraction/interchange formats.

~~~
Loque
I_definitely fell_victim to this_- I would still aim to_be as semantic_to the
data as possible but don't_lose_much time/sleep over_it_-_especially when_the
last point has_been_very true_in_my experience.

------
TheAceOfHearts
Along the same line... Any_good_resources on building maintainable
applications with user interfaces?_It doesn't have to_be_web applications, it
can be_a book focused on building_desktop or mobile applications. I'm more
interested_in the_patterns the_follow, as well as what and how they focus on
testing.

I've found_TDD pretty much impossible when you're_building a user interface.
Even_when I_test_my components (recently_using_react, prior_to that using
angular), it's hard to know__what_ I_should be testing for. Testing the
component's_logic is a given,_and_usually very straightforward. But how in
depth_should my DOM structure validation be?_Should I check that certain
classes_and_IDs_are set correctly and leave_it at that? Should I verify_the
DOM structure of_the component? I've found this extremely difficult_because
you'll_often find yourself adding or removing_classes_to restyle components,
or you'll find yourself_rewriting_the_HTML to fit better with_a redesign of
some sort.

Along this same_line, what about e2e tests? I