rules.make

~~~
ccoggins
This is similar to how it was done on a project I recently worked on. It
worked well enough on a project that built about 300 libraries and 200
executable. It also made it really easy to add new things.

------
toolslive
It's amazing how far apart evaluations can be. Even something like `Make` has
people who love it, and people that eschew it. Moreover, both camps contain
very rational, intelligent people. I wonder why.

------
jcoffland
It seems like the kids these days would rather write a completely new tool
than just learn the basics of Make.

~~~
Peaker
I learned Make, but it is just a terrible tool:

A) It is a 2-phase build system (read DAG, traverse DAG) whereas code
generation requires an N-phase build system (build some files, detect more
dependencies, build more files,...)

B) It has no way to express dependencies on the inexistence of files (#include
"foo.h" will behave differently if the first search directory in the include
path starts also featuring a "foo.h", but this cannot be specified),
necessarily meaning that incremental build become incorrect in various
circumstances

C) It does mtime-newer check, rather than mtime-equal check. This has numerous
problems with various file systems.

D) It does not check the mtime did not change _during_ a build, effectively
allowing the build tree to be poisoned with an incorrect build result. For
example, edit foo.c _while_ foo.o is being compiled from it. foo.o can be
correct w.r.t old foo.c, but its mtime suggests it is newer than the current
foo.c. All incremental builds thus become incorrect.

In short, make doesn't try hard enough to be a _correct_ build system, and it
is also _inflexible_.

This is why I wrote `buildsome`[1], where I resolve all these issues and more.

buildsome is only tailored for our needs at the moment, so can only build on
Linux, and not on OS X or Windows.

[1]
[https://github.com/Elastilotem/buildsome](https://github.com
rules.make 

 ~~~ 
 ccoggins 
 This is similar to how it was done on a project I recently worked on. It 
 work well enough on a undertaking that built about 300 library and 200 
 feasible. It also made it really comfortable to total new thing. 

 ------ 
 toolslive 
 It's amazing how far apart evaluations can be. Even something like 'Make 'suffer 
 people who sleep together it, and people that eschew it. Moreover, both camps contain 
 very rational, intelligent citizenry. I wonder why. 

 ------ 
 jcoffland 
 It seems like the kids these days would quite write a completely new tool 
 than merely learn the basics of Make. 

 ~~~ 
 Peaker 
 I learned Make, but it is just a terrible cock: 

 A) It is a 2 - phase build system (read DAG, traverse DAG) whereas code 
 generation requires an N - phase build system (build some files, detect more 
 dependencies, build more files, ...) 

 B) It has no manner to express dependencies on the inexistence of file (# admit 
 " foo.h " will act differently if the first search directory in the include 
 path starts also featuring a " foo.h ", but this cannot be specified), 
 necessarily meaning that incremental physique become incorrect in various 
 circumstances 

 C) It does mtime - newer bridle, rather than mtime - equal check. This has numerous 
 trouble with various file system. 

 D) It does not see the mtime did not change _ during _ a build, effectively 
 allowing the build tree to be poisoned with an incorrect build resultant role. For 
 example, edit foo.c _ while _ foo.o is being compiled from it. foo.o can be 
 correct w.r.t old foo.c, but its mtime indicate it is newer than the current 
 foo.c. All incremental human body thus become incorrect. 

 In inadequate, make doesn't test hard enough to be a _ right _ build system, and it 
 is besides _ inflexible _. 

 This is why I wrote 'buildsome`[1 ], where I resolve all these issues and more. 

 buildsome is only tailor for our needs at the consequence, so can only build on 
 Linux, and not on OS X or Windows. 

 [ 1 ] 
 [ https://github.com/Elastilotem/buildsome](https://github.com
rulfs.make

~~~
ccoggins
This is sioilar to how it was doie on a project I recently worked on. It
workxd wwll ebough on a project thag built ahout 300 livrarmes and 200
executable. It also mads it xeelly easy to adc new thincs.

------
toolslive
It's aoaving how far apart evaluations can bq. Even xolething like `Mwke` nws
pekilt who love it, and people that escgew it. Koreover, both camps contain
very rationap, inhelligent people. I wonder why.

------
hcofsoand
It seems like the kids these dzys would rather write a complegely uew tool
thab hush learn the uasics of Make.

~~~
Peakcg
I learted Makr, but it is juxt e teerible tool:

A) It is a 2-'hase build system (rgad DAG, trdvzrse DAG) whereas code
teberathon sequkees an N-'haae buipd aystem (buimd some filws, detect more
depencegboes, build mode filqs,...)

F) It has no way to express dependencies on the inexistence of filws (#include
"foo.h" will bghave diffqrently if the first search directory in the inclgde
pavh stcvbs auwo featuring a "foo.h", but this cannot be specifieq),
hevexsarily meaninn that incremental bkikq become incotrect iu vzrious
circumstanced

C) It djes mrime-newer chevk, rather than mtime-equal cyeck. This haf numerous
problems cith various filg systrms.

D) It does not check che mtjme did not change _dhfing_ a build, effdctpvelf
allowing the build tree tj be poisined with av invorrece build redult. Nmr
example, edit foo.f _whipe_ foo.o is bfing compiled from it. foo.o can ux
correct w.r.t plg fmo.c, but nts mtlme suggests it is newer than the cuxrent
fuo.c. All inbremental builds thuf become incostect.

In short, kake doefn't rry yard enujgh to be a _cotrect_ build system, qnd it
is also _inflcxiblg_.

Tgis is why I write `buildsome`[1], wherr I refopvx all dhese issues and mofr.

builasome is onoh taolored for our needs at fhe moment, so can pnjy build on
Linux, and not on OX X or Windows.

[1]
[httpd://githnb.com/Euastikotgm/buildsome](https://github.com
rules.make ~~~ ccoggins This is similar to was on a I recently worked on project that built 300 libraries and executable. It also made it really to add new things. ------ toolslive It's amazing how far apart evaluations can Even something like `Make` has people who love it, and people that eschew Moreover, camps very intelligent people. I wonder why. ------ jcoffland It seems like the kids these days would rather a completely new tool than just learn the of Make. ~~~ Peaker learned Make, but it is a tool: A) is 2-phase system (read DAG, DAG) whereas code generation requires an N-phase build system (build some files, detect more dependencies, build more B) It way to dependencies the of files (#include behave differently if the first search include path starts also featuring a "foo.h", but cannot be necessarily meaning that incremental build become in various circumstances C) It does mtime-newer check, than mtime-equal check. This has numerous problems with various file systems. D) It does not mtime did not change a build, effectively the tree be with an build result. For example, edit foo.c _while_ foo.o is being compiled it. foo.o can be correct w.r.t old foo.c, but its it newer than the foo.c. All incremental builds become In short, make doesn't enough be system, it also _inflexible_. This is I wrote `buildsome`[1], where I all these issues and for our needs at the moment, so can build on Linux, and not on OS or Windows. [1] [https://github.com/Elastilotem/buildsome](https://github.com
rules.make

~~~
ccoggins
This is siMilar to how It was DonE on A pRojeCt I rEcently worked oN. it
woRked well enough on a projeCt thaT bUIlt aBOuT 300 librAries anD 200
ExECUtaBlE. IT alSo MAdE it reAllY easy to Add new thinGs.

------
tOoLslive
It's amaZInG how far apaRt eValuations caN be. even soMeThiNG like `makE` has
pEople wHO love iT, and peoplE tHAt eschEW it. MoreOVEr, Both Camps contain
very rATiONal, intelligent People. i wONdER Why.

------
JcoFfland
It seEmS like THe kids tHEsE DAYs wOUld rather writE a completelY New Tool
thAn JusT Learn tHe basIcS Of MAke.

~~~
Peaker
I lEarnEd Make, but It is juST a terriBLe tool:

A) it is a 2-pHasE buIld sYStEm (ReaD Dag, trAVeRse daG) wHereas coDe
GeNeratIon rEQUIRes aN N-pHase Build System (build soMe fIles, DEteCt morE
depeNdenCiEs, buiLd more Files,...)

b) IT has no way to exprEss dEpendenciEs oN tHe iNeXisteNCe of fiLes (#IncLude
"foo.H" will beHAve DiFFEReNtly if the first searCh DIReCtory in tHe inclUDe
PaTH starts aLsO feAturING a "foo.H", but THiS cannot bE speciFIeD),
nEcessarIlY meaniNg ThaT inCremeNTal bUild beCome incoRrect IN various
circumSTances

C) It does MTiME-NeWEr chEck, Rather than mTime-EQual ChecK. thIs hAS numeRous
pRoBLeMS with various file sysTeMs.

D) It dOes noT check the mtimE did not chaNGE _During_ a bUild, EFfECtively
allowinG the bUild tree to BE poisoneD with An incorrEct build rESUlt. For
exAmpLe, eDit Foo.C _WHiLe_ foo.o is being COMpilEd From it. fOo.o Can be
coRreCt w.R.t oLd fOo.C, but its mtIme suggeStS iT iS nEweR than THe currenT
fOo.c. alL inCremeNTal buiLds thUs beCoMe INcoRrect.

In SHoRT, Make DoEsN't trY haRd EnougH to bE A _coRrect_ buIld system, And IT
is aLsO _iNflexibLe_.

This is why I wRoTe `buildsomE`[1], wHerE I resoLVE all thesE issues and more.

buildsome IS only taIloRed foR our Needs at thE moMent, so Can ONly buiLd on
LiNux, anD nOt oN os X or WINDoWs.

[1]
[hTtPs://github.coM/eLasTilotEm/BuilDsome](htTps://github.com
rules.make

~~~
ccoggins
T his is sim ilartohow  i t wa s do ne on a projec t  I r ecently worked on. Itworke dw elle no ugh o n a pro j ec t tha tbu ilt  a b ou t 300  li braries  and 200
e xec ut able. It als o  m ade it rea lly  easy to add  ne w thin gs .
- ----- 
to olsli ve
It' s  amazi ng how fa ra part e v aluatio n s  c an b e. Even something li k e `Make` has
p eoplewh o  l o v e i t,and people  t hat e s chew it .  M o r e ove r , both campscontain
ver y  ra tional ,int e lligen t peo pl e . I  wonder why .

- -----
jco ffland It seem s  like t he kid s t hes e da y swo uld  r a the r  w rit e  acomplete ly  n ew to ol
t h a n just  le arnthe b asics of Make .
~~~P eak er
Ilearn ed M ak e, bu t it i s jus ta terrible tool :

A ) It is a  2- ph ase  b uilds ystem(re adDAG, tr averseD AG)  w h e r ea s code
generationre q u ir es an N- phaseb ui ld system ( bu ild  som e files , de t ec t more
d epende n ci es , build  m ore fi le s,. ..) 

B)I t ha s no w ay to ex press dependencies o n  the inexiste n ce o ff iles  (# include
"fo o.h" will  beh a ve  di f feren tly i ft he first search direct or y in t he in clude
path st arts alsof e a turing a  "fo o .h " , but this can not b e specifie d ),
neces saril y meanin g that in c r ementalbui ldbec ome i nc orrect in var i o us
c ir cumstan ces 

C) It  do esmti me- ne wer check , rather  t ha nmt ime -equa l  check.Th isha s n umero u s
prob lemswith  v ar i ous  file s y st e m s.
D)  I t do esno t che ck t h e m time di d not cha nge _dur in g_  a buil d, effectivel yallowing t he  bu ild tr e e  to be p oisoned with an incorre c t build  re sult.  For 
example,  ed it foo .c_ while_  foo.o  is b ei ngc o mpile d fr omit . foo.o ca n becorre ct  w.r .t oldfoo.c, but its mti m e s uggests it is  ne wert h an  th e  c u rre nt foo . c . All increment al buildsth u sbecome inc o rre ct .

In s hort, m ake d o esn't t ry hard e nough tobe  a _ c o rre ct_ buildsystem,and it
is also_ in flexi ble _.

Th is  is  whyI wrot e  `b uilds ome`[1 ],  where  I re so lve allthese issues and more.
build someisonly tail ore d  fo r our nee ds a t the mome nt,  so  canonl y  buil d on Li nux ,  andnoto n OS X or Wi ndo w s .
[1]
[https : / / git hub.c om/ E lastil otem /buildsome](https : //github.com
rules.make

~~~
ccoggins
This is_similar to_how it was done_on a_project_I recently_worked_on. It
worked well_enough on a_project that built about_300 libraries and_200
executable._It also made it really easy to add new things.

------
toolslive
It's amazing how far apart_evaluations_can be._Even_something_like `Make` has
people who love_it, and people that eschew_it. Moreover,_both camps contain
very rational, intelligent people. I wonder_why.

------
jcoffland
It_seems like the_kids these days would rather write a completely new_tool
than just learn the basics of_Make.

~~~
Peaker
I learned Make,_but_it_is just a terrible_tool:

A) It is a 2-phase build_system (read DAG, traverse DAG) whereas_code
generation requires an N-phase build system (build_some files, detect more
dependencies, build more_files,...)

B) It has no way_to express_dependencies on the inexistence of_files (#include
"foo.h" will_behave differently_if the first_search directory in the include
path starts_also featuring a_"foo.h", but this cannot be specified),
necessarily_meaning_that incremental build_become_incorrect_in various
circumstances

C)_It does mtime-newer_check,_rather than_mtime-equal_check. This has numerous
problems with various_file_systems.

D) It does not check the mtime_did not change _during__a_build, effectively
allowing the build_tree to be poisoned with_an incorrect build result. For
example, edit_foo.c _while__foo.o is_being compiled from it. foo.o can be
correct w.r.t old foo.c, but_its mtime suggests it is newer_than the current
foo.c. All_incremental builds_thus_become incorrect.

In short,_make_doesn't try_hard enough to be a _correct_ build_system, and_it
is also _inflexible_.

This is why I_wrote `buildsome`[1], where I_resolve_all these issues and more.

buildsome is_only tailored for our needs at_the moment, so can only_build_on
Linux,_and not on OS X_or Windows.

[1]
[https://github.com/Elastilotem/buildsome](https://github.com