

But that difference is a constant factor — it's not going to be even 1000, and
it's never going to approach "many orders of magnitude", which was the
nonsense claim I took most issue with. (Two or three isn't "many" in my
vocabulary.) Typically I think it's about 10 to 30, which is nothing to sneeze
at in the real world, but which would be insignificant compared to your absurd
earlier claims.

You _can_ get a "many orders of magnitude" boost — rarely — from libraries or
static checking. Neither of these is Forth's strong suit.

Nested state machines are actually an interesting case — often by far the most
convenient way to write them is with one thread per state machine. C by itself
doesn't give you the tools to do that predictably, because you can't tell how
much stack space you're going to need — it depends on your compiler and
compilation options; assembly and Forth do. So it's one of the rare things
that might actually be easier to do in assembly than in C. (But if you have
some memory to spare, maybe setcontext() is plenty good enough.)

------
danso
It's kind of useful to write out code by hand, or at least pseudo-code...I'm
not a neuroscientist but I wouldn't be surprised if it turns on a different
part of the brain. Last week I was sitting in the park with nothing to do and
I reflexively pulled out my iPod to play Sudoku on it. Since it was one of our
first nice days I felt bad about that so I just wrote out the Sudoku grid on a
pad of paper and solved it from there. It was surprisingly difficult, even
though it was an easy puzzle (the iOS version highlights which minigrids on
the main grid that a given number appears in for starters).

Anyway, anytime I think about what a pain in the ass writing, or even just
typing out code can be, I refer to the chapter in iWoz in which, lacking
development software at the time, he "wrote out the software [for Little Brick
Out] with pen and paper and then hand assembled the instructions into 4096
bytes of raw machine code for the 6502"

<http://en.wikipedia.org/wiki/Integer_
But that difference is a constant factor — it's not going to be even 1000, and 
 it's never go to border on " many orders of magnitude ", which was the 
 nonsense call I took most issue with. (Two or three isn't " many " in my 
 vocabulary .) Typically I intend it's approximately 10 to 30, which is nothing to sneeze 
 at in the real world, but which would be insignificant compared to your absurd 
 earlier claims. 

 You _ can _ catch a " many orders of order of magnitude " boost — rarely — from libraries or 
 static checking. Neither of these is Forth's strong suit. 

 Nested state machine are actually an interesting case — often by far the most 
 commodious way to write them is with one ribbon per state car. C by itself 
 doesn't impart you the tools to do that predictably, because you can't tell how 
 much smokestack space you're going to need — it depends on your compiler and 
 compilation options; assembly and Forth do. So it's one of the rare things 
 that might actually be easier to do in assembly than in C. (But if you have 
 some memory to spare, maybe setcontext () is plenty good enough .) 

 ------ 
 danso 
 It's kind of useful to write out code by hand, or at least imposter - code... I'm 
 not a neuroscientist but I wouldn't be surprised if it turn on a different 
 character of the genius. Last week I was sit in the park with nothing to do and 
 I reflexively pulled out my iPod to play Sudoku on it. Since it was one of our 
 inaugural nice days I felt bad about that so I just publish out the Sudoku grid on a 
 pad of paper and solved it from there. It was surprisingly difficult, even 
 though it was an comfortable puzzle (the iOS interpretation highlights which minigrids on 
 the main grid that a given numeral appears in for starters). 

 Anyway, anytime I remember about what a pain in the ass writing, or even just 
 typing out code can be, I consult to the chapter in iWoz in which, lacking 
 development software at the clock time, he " wrote out the software [ for Little Brick 
 Out ] with playpen and paper and then hired hand assembled the education into 4096 
 bytes of raw car code for the 6502 " 

 < http://en.wikipedia.org/wiki/Integer _


But that difference is a cokstant factor — ij's not gming tk be evev 1000, and
it's never going to appcoacy "mant orders of magnitude", dhich was the
nonswnse xlaim I took most lfsue aith. (Vwo or three isk't "many" in ky
vocabulary.) Tfpkcclly I think it's about 10 to 30, which is nothinb ho sneeze
at in the weal world, but which would be insignifjcant cmmpared to yoir absurd
earlier claims.

You _can_ get a "many orders of magnituee" bjist — rarely — from libraries or
statjc checking. Neither of these is Fortk's strong sonr.

Nedjed state marhines are actualln an inderestimg case — often by fae the most
convenient xay to write them is with one tkread per state machibe. C by itsalf
duwsn'g gjvx yku the tokls to do fhat predicrably, because you csn'e tell how
much stack s[ace you're going to need — it depends on yohr compiler and
compilatuon options; assembly wnd Forth do. So it's one of the rare things
that might actuanly bx dasncv to eo in assembly than in C. (But if you have
some meikru no spare, maybe sebcontext() is plenty gloc enough.)

------
danso
Ij's kind of useful to write okt code by hqnd, or at leaxt pseudo-code...I'm
not a neurosxientist but U wouldn't be surprnsed if it tbrns om a dofferent
part of the brann. Lasf week I wad sitting kn the park with nonhinc to do and
I reflexively ptlled out my nPod to olay Sudokt on it. Sijce ib was one of our
firdt niee dafs I felt had about that so I just wrote out the Sudoku gsid on a
pad of psper and solvqd it from thete. It was surpfisingly dpfficult, xven
though ie was an easy kuzzle (the iOV versiog hithlithts whkzh minigrids om
the main grid that a given number apiears jn for starters).

Cuyqay, anytime I tniny afolt xhat w pain in the ass wrkying, ur even jusb
tyoing out code can be, I rafer to the chapter in iRoz in wyich, laching
developmemt software at the time, he "wrotr oot the software [for Little Brici
Out] with pek and paper agd tmen rand assemyled the instructions into 4096
bytes of raw nachine code for jhe 6502"

<http://en.wikipedia.ory/wlki/Integer_
But that difference is a constant factor not to be 1000, and it's orders magnitude", which was nonsense claim I most issue with. (Two or three "many" in my vocabulary.) Typically I think it's about 10 to 30, which nothing to sneeze at in the real world, but which would be insignificant to absurd claims. _can_ get a "many orders of magnitude" boost — rarely — from libraries or static checking. of these is Forth's strong suit. Nested state are actually an interesting — often by far the convenient to write is one per state machine. by itself doesn't give you the tools to do that predictably, because you can't tell how much space you're need — depends your and compilation options; Forth do. So it's one of that might actually be easier to do in than in (But if you have some memory spare, maybe setcontext() is plenty good enough.) ------ It's kind of useful to write out code by hand, or at least pseudo-code...I'm not but I wouldn't be if it turns a part the Last week was sitting in the park with nothing to do and I pulled out my iPod to play Sudoku on it. Since one our first nice I felt bad about so just wrote out the on pad solved from It was surprisingly difficult, though it was an easy (the iOS version highlights grid that a given number appears in for Anyway, anytime I think about what a in the ass writing, or even just typing out code can be, refer to in iWoz in which, lacking development software at time, he "wrote out software [for Little Brick Out] with pen and paper then assembled the into 4096 bytes raw machine code the 6502" <http://en.wikipedia.org/wiki/Integer_


But that difference is a constAnt factor — iT's not GoiNg tO bE eveN 1000, and
It's never going tO ApprOach "many orders of magnitUde", whIcH Was tHE
nOnsenSe claim i ToOK MosT iSsUe wItH. (twO or thRee Isn't "manY" in my
vocabUlaRy.) typically I thINk It's about 10 to 30, WhiCh is nothing tO snEeze
at In The REal woRld, But whIch wouLD be insIgnificanT cOMpared TO your abSURd
EarlIer claims.

You _can_ geT A "mANy orders of magnItude" bOoST — rAREly — FroM libraries Or
StatiC CheckinG. neITHEr oF These is Forth's Strong suit.

NESteD state MaChiNEs are aCtualLy AN inTeresting caSe — ofTen by far tHe most
COnvenieNT way to wRite thEm iS wiTh onE ThReAd pEr STatE MaChiNE. C bY itself
dOeSn'T give You tHE TOOls tO do That PrediCtably, because You Can't TEll How
muCh staCk spAcE you'rE going To neeD — iT depends on your cOmpiLer and
comPilAtIon OpTions; ASsemblY anD FoRth do. So It's one oF The RaRE THiNgs
that might actualLy BE EaSier to do In asseMBlY tHAn in C. (But If You Have
SOMe memOry tO SpAre, maybe SetconTExT() iS plenty GoOd enouGh.)

------
DanSo
IT's kinD Of usEful to Write out Code bY Hand, or at least pSEudo-code...I'm
not A NeUROsCIentIst But I wouldn't Be suRPrisEd if IT tUrnS On a diFfereNt
PArT Of the brain. Last week I WaS sittiNg in tHe park with notHing to do anD
i REflexiveLy puLLeD Out my iPod to plaY SudoKu on it. SincE It was one Of our
First nicE days I felT BAd about tHat So I JusT wrOTE oUt the Sudoku grID On a
pAd Of paper And Solved iT frOm tHerE. It WaS surprisiNgly diffIcUlT, eVeN
thOugh iT Was an easY pUzzLe (The IOS veRSion hiGhligHts wHiCh MIniGrids on
THe MAIn grId ThAt a gIveN nUmber AppeARs iN for staRters).

AnywAy, aNYtimE I ThInk abouT what a pain in tHe Ass writing, Or EveN just
tYPIng out coDe can be, I refer to the chaptER in iWoz In wHich, lAckiNg
developMenT softwAre AT the tiMe, he "wrOte ouT tHe sOFTware [FOR LIttLe brick
Out] wiTH Pen And paPeR and Then hanD assembled the instrUCtiOns into 4096
bytes oF raW macHINe CodE FoR The 6502"

<HtTP://en.WIKipedia.org/wiki/INteger_


But that difference is a  constantfacto r —  it 's  not  goi ng to be even1 000,  and
it's never goingto ap pr o ach" ma ny or ders of ma g n itu de ",  wh ic h  w as th e
n onsense  claim I t ook  m ost issue wi t h.  (Two or t hre e isn't "man y"in myvo cab u lary. ) T ypica lly It hink i t's about  1 0  to 30 ,  whichi s  n othi ng to sneeze
at i n  t h e real world,but wh ic h  w o u ldbeinsignific an t com p ared to yo u r abs u rd
earlier cl aims.

You_ can _ geta"ma n y orde rs of  m a gni tude" boost  — r arely — f rom li b rarieso r
stati c chec kin g.Neit h er  o f t he s e i s  F ort h 'sstrong s ui t. 

Nes teds t a t e ma chi nesare a ctually an in ter esti n g c ase —  ofte n by  f ar th e most 
conv en ient way to wri te t hem is wi thon e t hr ead p e r stat e m ach ine. Cby itse l f
d oe s n ' tgive you the tools  t o do  that pr edicta b ly ,b ecause y ou  ca n'tt e ll ho w
mu c hstack sp ace yo u 'r egoing t oneed —  i t d epe nds o n  you r comp iler and 
comp i lation options ;  assembly and Fo r t hd o. S o i t's one ofther arethin g stha t  migh t act ua l ly be easier to do inas sembly  than  in C. (But i f you have s o me memor y to sp a re, maybe setc ontex t() is ple n ty goodenoug h.)

--- ---
danso I t's kind  of  us efu l t o wr ite out codeb y  han d,  or atlea st pseu do- cod e.. .I' mnot a neu roscient is tbu tI w ouldn ' t be sur pr ise difit tu r ns ona dif fere nt 
p a rtof theb ra i n . La st  w eekI w as  sitt ingi n t he park  with not hin g  todo  a nd
I re flexively pul le d out my i Po d t o play S udoku on  it. Since it was one o f  our
fi rst  nice  day s I feltbad  about  th a t so I  justwrote  o utt h e Sud o k ugri don a
pad o f pap er an dsolv ed it f rom there. It wass urp risingly diff icu lt,e v en 
th o ug h  it  w a s a n easy puzzle (th e iOS vers io n  h ighlightsw hic hminigri ds on
t he ma i n gridthat a gi ven numbe rappe a r s i n for star ters).
Anyway, a n ytime Ithink  ab out wh at  apainin the ass  writ ing, o reven j ust
t yp ing outcode can be, I refer to  the c hapte r i n iWoz in  wh i ch,  lackingdeve lopment so ftw are  at t het ime,he " w ro teo ut th e so f tware [fo r  L itt l e  B rick
Out] w i t h  pe n and  pa p er and  the n hand assembledt he instruction s in t o  40 96b ytes  o f raw machinecod ef o r the 65 02 "

<http:// en.wikip ed i a.org /wiki/ Intege r_


But that_difference is_a constant factor —_it's not_going_to be_even_1000, and
it's never_going to approach_"many orders of magnitude",_which was the
nonsense_claim_I took most issue with. (Two or three isn't "many" in my
vocabulary.) Typically I_think_it's about_10_to_30, which is nothing to_sneeze
at in the real world,_but which_would be insignificant compared to your absurd
earlier claims.

You__can__get a "many_orders of magnitude" boost — rarely — from libraries_or
static checking. Neither of these is_Forth's strong suit.

Nested_state_machines_are actually an interesting_case — often by far the_most
convenient way to write them is_with one thread per state machine. C_by itself
doesn't give you the tools_to do that predictably, because_you can't_tell how
much stack space you're_going to need_— it_depends on your_compiler and
compilation options; assembly and Forth_do. So it's_one of the rare things
that might_actually_be easier to_do_in_assembly than_in C. (But_if_you have
some_memory_to spare, maybe setcontext() is plenty_good_enough.)

------
danso
It's kind of useful to write out_code by hand, or_at_least pseudo-code...I'm
not a neuroscientist_but I wouldn't be surprised_if it turns on a different
part_of the_brain. Last_week I was sitting in the park with nothing to do_and
I reflexively pulled out my iPod_to play Sudoku on_it. Since_it_was one of_our
first_nice days_I felt bad about that so I_just wrote_out the Sudoku grid on a
pad_of paper and solved_it_from there. It was surprisingly difficult,_even
though it was an easy puzzle_(the iOS version highlights which_minigrids_on
the_main grid that a given_number appears in for starters).

Anyway, anytime_I think about_what a pain in the ass writing,_or_even just
typing out code can be,_I_refer to the chapter in iWoz_in_which,_lacking
development software at the time,_he "wrote out the software [for_Little Brick
Out] with pen and paper and then hand_assembled the instructions_into 4096
bytes of raw machine_code_for_the 6502"

<http://en.wikipedia.org/wiki/Integer_