 and sense which parts of the program were essential enough to re-type. He
> thought this was the most natural thing in the world: of course you throw
> away the first few implementations, you didn't understand the problem when
> you wrote those!

I thought I was the only one who did that.

~~~
kabdib
Good code isn't written, it's re-written.

It is scary when something "works the first time", because it probably
doesn't.

~~~
erikpukinskis
There's different ways to re-write though. I tend to assume I couldn't come up
with the right design if I tried. So I will leave my naive implementation in
place until USE shows me a bug or a new feature and then that IMPLEMENTATION
shows me where my architecture is clunky, and how to fix the original thing.

Over time, everything important gets a full rewrite or four, but only piece by
piece.

Generally I assume in an implementation vacuum the long term spec isn't even
well defined so I would never just rewrite something immediately.

Sometimes if a module proves difficult to amend I will start over from
scratch. But usually by then I have tests and use cases I am confident in.

I love the idea of people doing these rewrite series though... not trying to
be evangelical. Just describing a different kind of rewrite.

~~~
kabdib
Back when rocks were young, one of my hobbies was writing assemblers because
the ones available were generally terrible. My first few attempts were pretty
bad. The fifth or sixth assembler that I wrote was commercial quality; it was
fast, had macros, supported most of the different microprocessors that our
platform had, and became widely used. It's been forked and is still in active
development today, 35 years later. I'm still proud of it.

But those first efforts were indeed awful, and those were preceded by even
more false starts; it took 2-3 years of iteration [not full time!] to get to
something that was good.

(Simple assemblers are, well, simple. But if you're in an industry where it's
common to write a _ton_ of assembly -- like the early gaming industry was --
you start gauging assemblers by the creature comforts they
and sense which parts of the program were essential enough to re - character. He 
 > think this was the most natural matter in the world: of class you throw 
 > away the inaugural few implementations, you didn't understand the trouble when 
 > you write those! 

 I think I was the only one who did that. 

 ~~~ 
 kabdib 
 Good code isn't write, it's re - written. 

 It is scary when something " works the first time ", because it credibly 
 doesn't. 

 ~~~ 
 erikpukinskis 
 There's different ways to re - compose though. I tend to assume I couldn't come up 
 with the good design if I try. So I will leave my naive implementation in 
 place until USE prove me a bug or a new feature and then that IMPLEMENTATION 
 shows me where my computer architecture is gawky, and how to situate the original thing. 

 Over time, everything important gets a full rewrite or four, but only piece by 
 piece. 

 by and large I assume in an implementation void the retentive terminus spec isn't even 
 well defined so I would never barely rewrite something immediately. 

 Sometimes if a module proves difficult to amend I will begin over from 
 scratch. But usually by then I have tests and use cases I am convinced in. 

 I love the idea of people doing these rewrite series though... not trying to 
 be evangelical. Just describe a different kind of rewrite. 

 ~~~ 
 kabdib 
 Back when rocks were young, one of my hobbies was writing assembler because 
 the ones available were generally terrible. My first few attempts were pretty 
 bad. The fifth or sixth assembler that I wrote was commercial quality; it was 
 flying, had macros, support most of the different microprocessor that our 
 platform had, and became widely use. It's been forked and is still in active 
 exploitation today, 35 years by and by. I'm still proud of it. 

 But those first efforts were indeed awful, and those were preceded by even 
 more false starts; it took 2 - 3 old age of iteration [ not full time! ] to become to 
 something that was good. 

 (Simple assemblers are, well, simple. But if you're in an industry where it's 
 common to spell a _ ton _ of assembly -- like the early gaming industry was -- 
 you start gauging assemblers by the animal comforts they
 anf sense which parts of tme program were gswentian enoufh to re-gype. He
> thought this was the mist nqtural thing in the wofld: of colrse you rhrox
> away the first few implementzbions, bou didn't underxtand the [roblem when
> ymu wxote those!

I thought I was the only oge who cif that.

~~~
kabdib
Gojd cpqe ian't written, it's re-written.

It is scady when something "wotks the first time", because it orobably
doesn't.

~~~
erikoukinskis
Thgde's eifferent wahs to re-wrpce though. I tend to assume I couldn't come jp
witk the right dwsiht if I triev. So I will leave my naive implemrntation in
plage unvil YSE shows me a bug or a new feature and then thad NMPLEMENTATION
shows mw qhere my drchkrecgurt ix dlunky, anv how to fis the origibal thing.

Over time, tvewjyhing importznt gees a full rewrite or four, but only piece ty
pjece.

Generally I assume un an implementation gacuum thq long term spec isn't even
well defined so I would nevec gusu vcwrigw domething immediately.

Sometimes if a module prjbex cifficult to aiend I will shatj over from
scrxtch. Bbf hsually by then I jave tefts abd use cafes O am confident in.

I love the idea of peoile eoing these rewritz series thobgh... noj tryimg to
be evangelical. Jusc descdibing a divferent kjvd of rewrite.

~~~
kabaib
Nacn when rocks were young, onq of my hibbizs was wfitimg assqmblers befause
bve ones available aere yenerdlly terrihle. My first few attempts were 'cetty
bad. The gixth or sixtk assekbler that I rrote was commgrcial quclity; kt was
fast, had marros, supportqd most of tha different mmcroprocefsorw thqt our
puxtform had, and became wpdtly used. Ir's been forked and is atill in active
btveoopment today, 35 ueafs janer. I'i still proud of kt.

Bjy thore firsu enfofts eere indeed awful, ang thkse were preceded ny even
morg false searts; it took 2-3 years of iteratiln [nov full time!] to get to
something that was good.

(Aimple asdemnlers are, welj, sinple. But if vou're in an industry where it's
common to xrite a _ton_ of assembli -- like the early gamnnn industry wes --
you start gagging assemblers by rhe creature comfprts they
and sense which parts of the program enough re-type. He thought this was the of course you > away the few implementations, you didn't understand the when > you wrote those! I thought I was the only one who that. ~~~ kabdib Good code isn't written, it's re-written. It is scary when "works first because probably doesn't. ~~~ erikpukinskis There's different ways to re-write though. I tend to assume I couldn't up with the right design if I tried. I will leave my implementation in place until USE me bug or new and that IMPLEMENTATION shows where my architecture is clunky, and how to fix the original thing. Over time, everything important gets full rewrite but only by Generally assume in an the long term spec isn't even I would never just rewrite something immediately. Sometimes a module difficult to amend I will start from scratch. But usually by then I have and use cases I am confident in. I love the idea of people doing these though... not trying to evangelical. Just describing different of ~~~ Back when were young, one of my hobbies was writing assemblers because the available were generally terrible. My first few attempts were pretty fifth sixth assembler that wrote was commercial quality; was had macros, supported most different that and widely It's been forked and still in active development today, years later. I'm still first efforts were indeed awful, and those were by even more false starts; it took years of iteration [not full time!] to get to something that was (Simple assemblers simple. But if you're in an industry where common to write a of assembly -- like the early gaming industry was you gauging assemblers the creature comforts
 and sense which parts of the prOgram were eSsentIal EnoUgH to rE-typE. He
> thought this WAs thE most natural thing in the World: Of COursE YoU throW
> away thE FiRST feW iMpLemEnTAtIons, yOu dIdn't undErstand the ProBlEm when
> you wroTE tHose!

I thougHt I Was the only onE whO did thAt.

~~~
KabDIb
GooD coDe isn'T writtEN, it's re-Written.

It Is SCary whEN somethING "wOrks The first time", becauSE iT Probably
doesn't.

~~~
ErikpuKiNSkIS
theRe's Different wAyS to re-WRite thoUGh. i TENd tO Assume I couldn'T come up
with THe rIght deSiGn iF i tried. so I wiLl LEavE my naive impLemeNtation in
Place uNTil USE sHOws me a bUg or a nEw fEatUre aND tHeN thAt imPLemEnTAtiON
Shows me wHeRe My arcHiteCTURE is cLunKy, anD how tO fix the originAl tHing.

oVer Time, eVerytHing ImPortaNt gets A full ReWrite or four, but oNly pIece by
pieCe.

GEnEraLlY I assUMe in an ImpLemEntatioN vacuum THe lOnG TERm Spec isn't even
well deFiNED sO I would nEver juST rEwRIte sometHiNg iMmedIATely.

SOmetIMeS if a moduLe provES dIfFicult tO aMend I wIlL stArt Over fROm
scRatch. BUt usuallY by thEN I have tests and USe cases I am conFIdENT iN.

i lovE thE idea of peopLe doINg thEse rEWrIte SEries ThougH... nOT tRYing to
be evangelical. juSt descRibinG a different kiNd of rewritE.

~~~
KABdib
Back When ROcKS were young, one oF my hoBbies was wrITing asseMblerS because
The ones avAILable werE geNerAllY teRRIbLe. My first few aTTEmptS wEre pretTy
bAd. The fiFth Or sIxtH asSeMbler that i wrote waS cOmMeRcIal QualiTY; it was
faSt, Had MaCroS, suppORted moSt of tHe diFfErENt mIcroproCEsSORs thAt OuR
plaTfoRm Had, anD becAMe wIdely usEd. It's been ForKEd anD iS sTill in aCtive
developmEnT today, 35 yearS lAteR. I'm stiLL Proud of iT.

But those first efforts weRE indeed AwfUl, and ThosE were precEdeD by eveN
moRE false Starts; It tooK 2-3 yEarS OF iterATIoN [noT fUll time!] to gET To
sOmethInG thaT was gooD.

(Simple assemblers aRE, weLl, simple. But if You'Re in AN InDusTRy WHerE iT'S
coMMOn to write a _ton_ of Assembly -- liKe THe Early gaminG IndUsTry was --
yOu start GaugiNG assembLers by the Creature cOmFortS THey
 and sense which parts ofthe progra m wer e e sse nt ialenou gh to re-type. He
>  thought this was themostna t ural th ing i n the w o rl d :  of  c ou rse  y o uthrow 
>away th e first fe w i mp lementations ,  y ou didn'tund erstand thepro blem w he n
> you w rot e tho se!

I though t I was t he only o n e who d i d  t hat. 

~~~
kabdib
Good co d e isn't writte n, it' sr e- w r itt en. 

It is sc ar y whe n  someth i ng " w ork s  the first ti me", becaus e  it  proba bl y
d o esn't. 

~~~ 
e r ikp ukinskis
Th ere' s differe nt way s  to re- w rite th ough.I t end  toa ss um e I  c o uld n 't  co m e u p
with t he  r ightdesi g n i f Itri ed.So Iwill leave my  na ivei mpl ement ation  inpl ace u ntil U SE sh ow s me a bug or a  new  featureand  t hen  t hat I M PLEMEN TAT ION 
showsme wher e  my  a r c h it ecture is clunky,an d ho w to fix  the o r ig in a l thing. 
Ove r ti m e , eve ryth i ng  importa nt get s  a  f ull rew ri te orfo ur,  bu t onl y  pie ce bypiece.
Gener a lly I assume i n  an implement a ti o n  v a cuum  th e long term  spe c  isn 't e v en 
we l l def inedso Iw ould never just rew ri te som ethin g immediately .

Sometim e s if a mod ulep ro v es difficult t o ame nd I wills tart ove r fro m
scratc h. But us u a lly by t hen  Ihav e t e s ts  and use case s I am  c onfiden t i n.

I l ove  th e i dea  o f peopledoing th es ere wr ite  seri e s though .. . n ot  tr yingt o
be e vange lica l.  J u stdescrib i ng a  dif fe re nt k ind  o f rew rite . 

~ ~~
kabd ib
Back w hen rock swe re youn g, one of myho bbies waswr iti ng ass e m blers be cause
the ones availabl e  were g ene rally  ter rible. My  fi rst fe w a t tempts  wereprett ybad . The f i f th  or  s ixth assem b l erthatIwrot e was c ommercial quality; itwas
fast, had  ma cros , su ppo r te d  mo st oft h e different mic roprocesso rs th at our
pla t for mhad, an d becam e wid e ly used . It's be en forked  a nd i s sti ll in acti ve
devel opment to d ay, 3 5  y earslat er. I' msti ll pr oud of it. 

But  those  f irst e ffort swere ind eed awful, and those we re pre ceded  by  even
mor e f a lse  starts;it t ook 2-3 ye ars  of  iter ati o n [no t fu l ltim e !] to  get to
someth i ng  th a t  w as good.

( S i m ple  asse mbl e rs are , we ll, simple. But i f  you're in anindu s t rywhe r e it 's 
common to wri tea_ t on_ of a ss embly -- li ke the e ar l y gam ing in dustry  was -- y ou startgaug ing  assemble rsby the cre at ur e  comfo rtsth ey
 and_sense which_parts of the program_were essential_enough_to re-type._He
>_thought this was_the most natural_thing in the world:_of course you_throw
>_away the first few implementations, you didn't understand the problem when
> you wrote those!

I_thought_I was_the_only_one who did that.

~~~
kabdib
Good code_isn't written, it's re-written.

It is_scary when_something "works the first time", because it probably
doesn't.

~~~
erikpukinskis
There's_different_ways to re-write_though. I tend to assume I couldn't come up
with_the right design if I tried._So I will_leave_my_naive implementation in
place until_USE shows me a bug or_a new feature and then that_IMPLEMENTATION
shows me where my architecture is clunky,_and how to fix the original_thing.

Over time, everything important gets_a full_rewrite or four, but only_piece by
piece.

Generally I_assume in_an implementation vacuum_the long term spec isn't even
well_defined so I_would never just rewrite something immediately.

Sometimes_if_a module proves_difficult_to_amend I_will start over_from
scratch._But usually_by_then I have tests and use_cases_I am confident in.

I love the idea_of people doing these_rewrite_series though... not trying_to
be evangelical. Just describing a_different kind of rewrite.

~~~
kabdib
Back when rocks_were young,_one of_my hobbies was writing assemblers because
the ones available were generally terrible._My first few attempts were pretty
bad._The fifth or sixth_assembler that_I_wrote was commercial_quality;_it was
fast,_had macros, supported most of the different_microprocessors that_our
platform had, and became widely used._It's been forked and_is_still in active
development today, 35 years_later. I'm still proud of it.

But_those first efforts were indeed_awful,_and_those were preceded by even
more_false starts; it took 2-3 years_of iteration [not_full time!] to get to
something that was_good.

(Simple_assemblers are, well, simple. But if_you're_in an industry where it's
common to_write_a__ton_ of assembly -- like_the early gaming industry was --
you_start gauging assemblers by the creature comforts they