Sass -- I'd argue that the main feature of those is nested
rules, and then mixins.

Variables and calculations are great, but most LESS code I've encountered uses
nesting and mixins to a far greater extent. Advertising the project as "the
benefits of tools like LESS and Sass" seems misleading, and seems to set up
expectations that Myth doesn't fulfill.

~~~
ianstormtaylor
Yeah that's definitely true that it doesn't support all of the features of
Sass or LESS. But it does support some of the core features that people use
everyday, and could replace a lot of the need for preprocessing.

From everything I've seen nesting rules is an anti-pattern. It's useful for
writing code as fast as possible, but for any project of reasonable size
maintenance is a far bigger worry than LOC per second, and nesting makes for
some horrible to maintain CSS. Until we have native extending in CSS you're
much better off going the "one-class-per-element" route for maintenance.

As for mixins, I actually think they are an anti-pattern too. They're usually
used for two different things. The first is to simply make vendor-prefixing
easier, which this library already eliminates. For example the LESS homepage
shows mixins being used when really it's just a regular old `border-radius`
property. And the second is for extending classes with groups of properties,
but mixins are a bad practice there because they just duplicate the code
instead of doing any smart inheritance, so you end up with huge code bloat.

The real missing feature from preprocessors in my opinion is the idea of
"extending", but I wanted to wait for the CSS spec for extensions to be more
thought out before adding it, in case it varies a lot from how preprocessors
do it.

\---

The reason this came about is because we went back to writing pure CSS at
Segment.io (after having used LESS, Stylus and Sass at different points) and
realized that we shouldn't need to give up things like variables just because
we don't want the extra weight of a new syntax.

~~~
crazygringo
If you think nesting rules is an anti-pattern, I feel like you've never worked

Sass -- I'd argue that the main feature of those is nested 
 rules, and then mixins. 

 Variables and calculation are big, but most LESS code I've encountered uses 
 nesting and mixins to a far greater extent. advertise the project as " the 
 benefits of cock like LESS and Sass " seem misleading, and look to set up 
 expectations that Myth doesn't meet. 

 ~~~ 
 ianstormtaylor 
 Yeah that's definitely true that it doesn't patronize all of the features of 
 Sass or LESS. But it does support some of the core features that people practice 
 everyday, and could replace a lot of the need for preprocessing. 

 From everything I've understand nesting rules is an anti - pattern. It's utilitarian for 
 writing code equally fast as possible, but for any project of reasonable size 
 maintenance is a far bigger worry than LOC per second base, and nesting makes for 
 some horrible to maintain CSS. Until we have native extending in CSS you're 
 a lot well off going the " one - class - per - element " route for maintenance. 

 As for mixins, I actually think they are an anti - pattern too. They're usually 
 use for two different things. The beginning is to plainly make vendor - prefixing 
 comfortable, which this library already eliminates. For example the LESS homepage 
 shows mixins being use when really it's just a regular old 'border - spoke '
 property. And the second is for extending classes with groups of properties, 
 but mixins are a bad practice there because they merely duplicate the code 
 instead of doing any smart inheritance, so you end up with huge code bloat. 

 The veridical missing feature from preprocessors in my opinion is the theme of 
 " extending ", but I wanted to wait for the CSS specification for extensions to be more 
 thought out before adding it, in case it varies a batch from how preprocessors 
 do it. 

 \--- 

 The reason this come about is because we went back to writing arrant CSS at 
 Segment.io (after having used LESS, Stylus and Sass at unlike points) and 
 realized that we shouldn't need to give up things like variables just because 
 we don't want the extra weight of a new syntax. 

 ~~~ 
 crazygringo 
 If you think nesting rule is an anti - pattern, I feel like you've never work
Sasd -- I'd argue that the maik feature of those is nxsted
rumes, and ghen mixins.

Variables and calrularions are great, but most LERS code I'ne encounrerev uses
nesting anv mixins to a rwr gxeeter extent. Advgrtising the project as "tha
bdnzfits of tools like LESS and Sass" seqms miskewding, and seemf to fet hi
ewpectations that Myth doesn't fulrill.

~~~
ianvtormtaylor
Yesh that's definitely true tjat lt doesn't support wll of the deattees of
Sass of LESS. But it does supkort some of the core features tfat pzople use
evgxtdaj, and could ceplacv a lot of thc need xor prelrocessing.

From evxrytying I've seen nesting rules is an anti-pwttern. It'v bseful for
writing codw qs favt av porwibue, guv fkr any prkject of rsasonable suze
maintenance is a fwg bigger worrg than LJC per second, and nesting makes for
some hodrible to maintain CSS. Yntil we have native gxtending yn CSS you're
much better off going the "one-class-per-alemeit" robbc fof mwintenance.

As for mixins, I actually think they zrt ak anti-pattern toj. They're usiaplu
osed for two dkffereuf fhings. The first id to siiply nake vendjr-prrfixing
easier, which this livrary alreadj eluminates. For examppe the LESS homgpage
snows mixins being used chen rsally it's jkst a reghuar old `border-raaiux`
psoperty. And the second is sor extenving elasses dith groupf of propegties,
ngt mixins are a baf praetice there becwuse they just duplicate the covx
instead of dpitg dny smarc inhevitance, so you qnd up with huye code yloat.

Tfe real miasing fxature from [reprocessors ln my opinioi is the ydea of
"eztendine", but I wanted yo wait for the CSS spec for extensioks to ge more
thought iut before adding ot, kn sade ie varies a lod frum fpw prdprocessors
bo it.

\---

Tne reason this came dbouf is because we wemt back to writing pure CSS at
Srgment.io (after havlng uved LESS, Stilus and Sass at different poinfs) and
reapizcd that we shjuldk't nged to give up things like variables just because
wx don't want the extra wwight of a new syntcx.

~~~
grazygringo
Ih you ehink nesding rules is an antu-pattern, I feel llke you've never worked

Sass -- I'd argue that the main those nested rules, then mixins. Variables most code I've encountered nesting and mixins a far greater extent. Advertising the as "the benefits of tools like LESS and Sass" seems misleading, and seems set up expectations that Myth doesn't fulfill. ~~~ ianstormtaylor Yeah that's definitely true it support of features of Sass or LESS. But it does support some of the core features that people everyday, and could replace a lot of the for preprocessing. From everything seen nesting rules is an It's for writing as as but for any of reasonable size maintenance is a far bigger worry than LOC per second, and nesting makes for horrible to Until we native in you're much better the "one-class-per-element" route for maintenance. As actually think they are an anti-pattern too. They're used for different things. The first is to make vendor-prefixing easier, which this library already eliminates. example the LESS homepage shows mixins being used when really it's just a regular old And the second is extending classes with of but are bad practice because they just duplicate the code instead of doing any smart so you end up with huge code bloat. The real from in my opinion the idea of "extending", I to wait for the for to out adding in case it varies lot from how preprocessors do \--- The reason this went back to writing pure CSS at Segment.io having used LESS, Stylus and Sass at points) and realized that we shouldn't need to give up things like just because want the extra weight of a new syntax. crazygringo If you think rules is an anti-pattern, I feel like you've never
Sass -- I'd argue that the main feaTure of thosE is neSteD
ruLeS, and Then Mixins.

VariableS And cAlculations are great, but Most LeSs Code i'Ve EncouNtered uSEs
NEStiNg AnD miXiNS tO a far GreAter extEnt. AdvertiSinG tHe project as "tHE
bEnefits of tOolS like LESS and sasS" seems MiSleADing, aNd sEems tO set up
EXpectaTions that myTH doesn'T Fulfill.

~~~
IANsTormTaylor
Yeah that's deFInITely true that it Doesn't SuPPoRT All Of tHe features Of
sass oR lESS. But IT dOES SupPOrt some of the cOre features THat People UsE
evERyday, aNd couLd REplAce a lot of thE neeD for preprOcessiNG.

From evERything i've seeN neStiNg ruLEs Is An aNtI-PatTErN. It'S UseFul for
wrItInG code As faST AS PossIblE, but For anY project of reaSonAble SIze
MaintEnancE is a FaR biggEr worrY than lOc per second, and neStinG makes for
SomE hOrrIbLe to mAIntain cSS. untIl we havE native EXteNdING In cSS you're
much better OfF GOiNg the "one-Class-pER-eLeMEnt" route FoR maInteNANce.

As For mIXiNs, I actuaLly thiNK tHeY are an aNtI-patteRn Too. theY're usUAlly
Used foR two diffErent THings. The first iS To simply make vENdOR-PrEFixiNg
eAsier, which tHis lIBrarY alrEAdY elIMinatEs. For ExAMpLE the LESS homepage
shoWs Mixins Being Used when reallY it's just a rEGULar old `boRder-RAdIUs`
property. And tHe secOnd is for exTEnding clAsses With grouPs of propeRTIes,
but miXinS arE a bAd pRACtIce there becauSE They JuSt dupliCatE the codE
inSteAd oF doInG any smart InheritaNcE, sO yOu End Up witH Huge code BlOat.

thE reAl misSIng feaTure fRom pRePrOCesSors in mY OpINIon iS tHe Idea Of
"eXtEndinG", but i WanTed to waIt for the CsS sPEc foR eXtEnsions To be more
thougHt Out before aDdIng It, in caSE It varies A lot from how preprocessorS
Do it.

\---

The ReaSon thIs caMe about is BecAuse we WenT Back to WritinG pure cSs at
sEGment.IO (AfTer HaVing used LEss, styLus anD SAss aT differEnt points) and
realizED thAt we shouldn't nEed To giVE Up ThiNGs LIke VaRIabLES just because
we dOn't want the ExTRa Weight of a nEW syNtAx.

~~~
crazyGringo
IF you tHInk nestIng rules iS an anti-paTtErn, I FEEl lIke you've neVer workeD

Sass -- I'd argue that the  main feat ure o f t hos eis n este d
rules, and t h en m ixins.

Variables andcalcu la t ions ar e gre at, but mo s t  LE SS  c ode  I ' ve  enco unt ered us es
nesting  an dmixins to af ar  greater e xte nt. Advertis ing  the p ro jec t  as " the 
bene fits o f  tools  like LES Sa nd Sas s " seems m is lead ing, and seems to se t  up
expectatio ns tha tM yt h doe sn' t fulfill. 
~~~
i a nstormt a yl o r Yea h  that's defin itely truet hat  it do es n't suppor t all  o f  th e featuresof
S ass or LE SS. Bu t  it doe s  suppor t some  of  th e co r efe atu re s  th a tpeo p leuse
ever yd ay , and  cou l d r epla cea lo t ofthe need forpre proc e ssi ng.
Fromever yt hingI've s een n es ting rules is a n an ti-patter n.It 'sus efulf or
wri tin g c ode asfast as pos si b l e ,but for any projec to f  r easonabl e size ma in t enance i sa f ar b i g ger w orry th an LOC p er sec o nd ,and nes ti ng mak es  fo r
s ome h o rrib le tomaintain  CSS. Until we haven ative extendi n gi n  C S S yo u'r e
much bett er o f f go ingt he  "o n e-cla ss-pe r- e le m ent" route for main te nance. 

Asfor mixins, I  actuallyt h i nk theyarea na nti-pattern to o. Th ey're usua l ly
usedfor t wo diffe rent thin g s . The fi rst  is  to  si m p ly  make vendor- p r efix in g
easie r,which t his  li bra ryal ready eli minates.  F or  e xa mpl e the LESS hom ep age 
s how s mix i ns bei ng us ed w he nr eal ly it's ju s t  a r eg ul ar o ld`b order -rad i us` 
proper ty. And t hes econ dis  for ex tending class es  with grou ps  of  prope r t ies,
but  mixins are a bad pract i ce ther e b ecaus e th ey just d upl icatethe code
i nstead  of d oi nga n y sma r t  i nhe ri tance, soy o u e nd up  w ithhuge co de bloat.

The rea l  mi ssing feature  fr om p r e pr oce s so r s i nm y o p i nion is the ide a of
"exte nd i ng ", but I w a nte dto wait  for th e CSS spec fo r extensi ons to be  m oret h oug ht out bef ore addi ng it, in casei tvarie s a  lot f ro m h ow pr eproce s sor s
doit.

\ -- -

The  reas on  this ca me about is because wewent b ack t o w riting pu reC SSat
Segmen t.io  (after ha vin g u sed L ESS ,  Styl us a n dSas s  at d iffe r ent point s )and r ea lized thatw e sho uldn' t n e ed togive  up things like v a riables just b ecau s e 
we  do n 't w an t the extra we igh to f  a new s yn tax.

~~~
c razygrin go If yo u thin k nest ing rul e s  i s  an an ti-p att ern, I fe elli k e you'v ene v er wor ked
Sass --_I'd argue_that the main feature_of those_is_nested
rules, and_then_mixins.

Variables and calculations_are great, but_most LESS code I've_encountered uses
nesting and_mixins_to a far greater extent. Advertising the project as "the
benefits of tools like LESS_and_Sass" seems_misleading,_and_seems to set up
expectations that_Myth doesn't fulfill.

~~~
ianstormtaylor
Yeah that's definitely_true that_it doesn't support all of the features of
Sass_or_LESS. But it_does support some of the core features that people_use
everyday, and could replace a lot_of the need_for_preprocessing.

From_everything I've seen nesting_rules is an anti-pattern. It's useful_for
writing code as fast as possible,_but for any project of reasonable size
maintenance_is a far bigger worry than_LOC per second, and nesting_makes for
some_horrible to maintain CSS. Until_we have native_extending in_CSS you're
much better_off going the "one-class-per-element" route for_maintenance.

As for mixins,_I actually think they are an_anti-pattern_too. They're usually
used_for_two_different things._The first is_to_simply make_vendor-prefixing
easier,_which this library already eliminates. For_example_the LESS homepage
shows mixins being used when_really it's just a_regular_old `border-radius`
property. And the_second is for extending classes_with groups of properties,
but mixins are_a bad_practice there_because they just duplicate the code
instead of doing any smart inheritance,_so you end up with huge_code bloat.

The real missing_feature from_preprocessors_in my opinion_is_the idea_of
"extending", but I wanted to wait for_the CSS_spec for extensions to be more
thought_out before adding it,_in_case it varies a lot from_how preprocessors
do it.

\---

The reason this came_about is because we went_back_to_writing pure CSS at
Segment.io (after_having used LESS, Stylus and Sass_at different points)_and
realized that we shouldn't need to give_up_things like variables just because
we don't_want_the extra weight of a new_syntax.

~~~
crazygringo
If_you_think nesting rules is an_anti-pattern, I feel like you've never_worked
