 rigorous electronics
component where we coded in ASM for the 8086. One of my fondest moments of
that time was when I wrote a program that would split the terminal screen into
two halves of different color, and display what you typed on one side and the
inverse case on the other.

This could probably be done with less than 50 lines in python, but doing it in
assembly, calling all those interrupt routines, making sure your registers
contained all the right values, man, when it finally worked, it was the
greatest feeling in the world!

~~~
DanielBMarkham
Wasn't it? And for that moment, you could look out and imagine "Damn, I could
code the whole freaking thing like this!"

Then you realize it would take around 30 years, but still -- it was doable.
You finally figured out how it all worked. _You could make the computer do
anything it was capable of doing_. There was no more mystery there.

Fun stuff.

~~~
kragen
Do you really think it would take 30 years? The NAND-To-Tetris kids do most of
it in a semester, and they're starting at the level of individual gates.

I mean, Chuck Moore has been doing it for about 30 years, but he had a working
top-to-bottom system after less than five years.

Here's what I think it would look like:

Week 0: build a working interactive Forth system that can compile itself, in
machine code. This is assuming you already have hardware and a way to boot it
into some code you wrote. If not, that could be a matter of minutes or of
months.

Weeks 1-3: build an interactive high-level language interpreter on top of it.
Say, JS.

Week 4: enough of TCP/IP to do HTTP GET.

Week 5: write a bitmap font editor and a minimal filesystem.

Weeks 6-8: parse HTML (more or less), lay it out with a simplified box model,
and draw it to pixels on a canvas, using a pixel font.

Week 9: cookies, HTTP POST, XMLHttpRequest.

Week 10: a more elaborate filesystem, maybe based on Git.

Weeks 11-12: some more HTML5 features, maybe including WebGL.

We
rigorous electronics 
 component where we coded in ASM for the 8086. One of my fondest moments of 
 that meter was when I write a program that would separate the concluding screen into 
 two halves of different semblance, and display what you typed on one slope and the 
 inverse case on the other. 

 This could credibly be done with less than 50 lines in python, but doing it in 
 assembly, call all those interrupt routines, making sure your registers 
 contained all the correct values, man, when it finally shape, it was the 
 greatest feeling in the world! 

 ~~~ 
 DanielBMarkham 
 Wasn't it? And for that moment, you could search out and imagine " Damn, I could 
 code the whole freaking thing like this! " 

 Then you realize it would take about 30 years, but still -- it was doable. 
 You finally figured out how it all exploit. _ You could make the computer do 
 anything it was capable of doing _. There was no more mystery there. 

 Fun stuff. 

 ~~~ 
 kragen 
 Do you really think it would take 30 old age? The NAND - To - Tetris kids do most of 
 it in a semester, and they're start at the degree of individual gates. 

 I mean, Chuck Moore has been doing it for approximately 30 years, but he have a working 
 top - to - bottom arrangement after less than five years. 

 Here's what I think it would look like: 

 Week 0: build a working interactional Forth system that can compile itself, in 
 machine code. This is assuming you already give birth hardware and a manner to boot it 
 into some code you wrote. If not, that could be a matter of minutes or of 
 months. 

 Weeks 1 - 3: build up an interactive high - level linguistic process interpreter on top of it. 
 Say, JS. 

 Week 4: enough of TCP / IP to do HTTP GET. 

 Week 5: compose a bitmap font editor and a minimal filesystem. 

 week 6 - 8: parse HTML (more or less), lay it out with a simplified corner model, 
 and draw it to pixels on a canvas, using a pixel baptismal font. 

 Week 9: cookies, HTTP POST, XMLHttpRequest. 

 Week 10: a more elaborate filesystem, maybe free-base on Git. 

 week 11 - 12: some more HTML5 features, possibly including WebGL. 

 We
 rihorous electronics
compontnt where we codeb in ASK for fhe 8086. One of my fondest moments of
thav tine waw when I wrote a progrxm that wluld splut tie terminal screxh into
two halbcs of vifferent color, and displdy what you ty[ea ln one side and the
inverse case on ehe othrr.

Hhis could profablj fe dkne with less than 50 lines in pythoh, but dming it in
assrmbly, calling all those inherrkpt routines, makinh sure your regywters
containdd all the right valuea, man, when it finally worked, it was che
greatest fwelltg in the wirld!

~~~
DwnielBMarkham
Wasn't id? And fpr that moment, yon coyld look out and imagmne "Damn, I could
code the whola yreaking thing like tyiw!"

Then you reauuze it wpumd takf acound 30 yeara, but still -- it was doable.
You gigqlly figured kut hor yt all worked. _You could make the computtr do
znything it was capable of doing_. There was nl more myftery there.

Fun stuff.

~~~
kragen
Do you really think it fould gakt 30 yearr? Tje NAND-To-Tetris kids do most of
it in a semestqd, snc they're startlng at the level og lncyvidual gates.

K mean, Chhck Moore has been doing yt foe about 30 rearx, but he had a working
top-to-vottom systei after less than fnve years.

Herz's whaj I thonk it would look like:

Wzek 0: bhild a worklng interzztive Forth systdm nhat can comkkle itself, in
machyne code. Vhis ns assumkng iou alrqady have jardware and a way to bolt it
nnto vome code jou wrote. If not, that could be e matter of mongtev or of
mjnths.

Eeeks 1-3: build wn interactive high-lerel lavguage intvrpreter mn top of ie.
Say, JS.

Week 4: ajough of TCP/MP to do RTTP GET.

Qeek 5: wfkte a bitmap fpnt editog cnd a minumal filesystem.

Weels 6-8: larse HTML (more or less), lay it ouy wkth a smmplished box moden,
and drxe it go pixels ok a canfas, using a pixel fott.

Wesk 9: cookies, HTTP PPSB, XMLHttpTequest.

Weqk 10: a more elsborate filesystem, maybx basev on Got.

Wgeks 11-12: some more HTML5 features, mzybe inclkdikg WebGL.

We
rigorous electronics component where we coded in the One of fondest moments of wrote program that would the terminal screen two halves of different color, and what you typed on one side and the inverse case on the other. could probably be done with less than 50 lines in python, but doing in calling those routines, making sure your registers contained all the right values, man, when it finally worked, it the greatest feeling in the world! ~~~ DanielBMarkham it? And for that you could look out and "Damn, could code whole thing this!" Then you it would take around 30 years, but still -- it was doable. You finally figured out how all worked. make the do it capable of doing_. no more mystery there. Fun stuff. you really think it would take 30 years? NAND-To-Tetris kids most of it in a semester, they're starting at the level of individual gates. mean, Chuck Moore has been doing it for about 30 years, but he had a system after less than years. Here's what think would like: 0: build working interactive Forth system that can compile itself, in machine code. is assuming you already have hardware and a way to into code you wrote. not, that could be matter minutes or of months. build interactive on of Say, JS. Week 4: of TCP/IP to do HTTP Week 5: write a minimal filesystem. Weeks 6-8: parse HTML (more or lay it out with a simplified box and draw it to pixels on a canvas, using a pixel font. 9: cookies, XMLHttpRequest. Week 10: a more elaborate filesystem, maybe on Git. Weeks 11-12: more HTML5 features, maybe including WebGL. We
 rigorous electronics
componEnt where we Coded In AsM fOr The 8086. ONe of My fondest momenTS of
tHat time was when I wrote a pRograM tHAt woULd Split The termINaL SCreEn InTo
tWo HAlVes of DifFerent cOlor, and disPlaY wHat you typed oN OnE side and thE
inVerse case on tHe oTher.

ThIs CouLD probAblY be doNe with LEss thaN 50 lines in pYtHOn, but dOIng it in
ASSeMbly, Calling all those inTErRUpt routines, makIng surE yOUr REGisTerS
contained AlL the rIGht valuES, mAN, WHen IT finally workeD, it was the
grEAteSt feelInG in THe worlD!

~~~
DaniElbmarKham
Wasn't it? and fOr that momEnt, you COuld looK Out and iMagine "damN, I cOuld
COdE tHe wHoLE frEAkIng THinG like thiS!"

THeN you rEaliZE IT WoulD taKe arOund 30 yEars, but still -- iT waS doaBLe.
YOu finAlly fIgurEd Out hoW it all WorkeD. _YOu could make the cOmpuTer do
anytHinG iT waS cApablE Of doinG_. ThEre Was no moRe mysteRY thErE.

fUN sTuff.

~~~
kragen
Do you reaLlY THiNk it woulD take 30 yEArS? THE NAND-To-TEtRis Kids DO Most oF
it iN A sEmester, aNd they'RE sTaRting at ThE level Of IndIviDual gATes.

I Mean, ChUck Moore Has beEN doing it for aboUT 30 years, but he haD A wORKiNG
top-To-bOttom system AfteR Less Than FIvE yeARs.

HerE's whaT I THiNK it would look like:

WeeK 0: bUild a wOrkinG interactive FOrth system THAT can compIle iTSeLF, in
machine code. this iS assuming yOU already Have hArdware aNd a way to bOOT it
into sOme CodE yoU wrOTE. IF not, that could BE A matTeR of minuTes Or of
monThs.

weeKs 1-3: bUilD aN interactIve high-lEvEl LaNgUagE inteRPreter on ToP of It.
say, jS.

WeeK 4: Enough Of TCP/iP to Do hTtp GEt.

Week 5: wrITe A BItmaP fOnT ediTor AnD a minImal FIleSystem.

WEeks 6-8: parse hTMl (More Or LeSs), lay it Out with a simplIfIed box modeL,
aNd dRaw it tO PIxels on a Canvas, using a pixel font.

WeEK 9: cookieS, HTtP POSt, XMLhttpRequeSt.

WEek 10: a moRe eLAboratE filesYstem, MaYbe BASed on gIT.

WEekS 11-12: sOme more HTMl5 FEatUres, mAyBe inCluding webGL.

We
 rigorous electronics
comp onent wher e wecod edin  ASM  for  the 8086. One of m y fondest moments of
t hat t im e  was wh en Iwrote a pr o g ram  t ha t w ou l dsplit  th e termi nal screen  in to 
two halveso fdifferentcol or, and disp lay  whatyo u t y ped o n o ne si de and the
in verse cas eo n theo ther.
T h is  cou ld probably be do n ew ith less than50 lin es in p yth on,  but doing  i t ina ssembly ,  c a l l ing all those int errupt rout i nes , maki ng  su r e your  regi st e rscontained a ll t he rightvalues ,  man, w h en it f inally  wo rke d, i t  w as  th eg rea t es t f e eli ng in th ewo rld!
~~~ D a n ielB Mar kham 
Wasn 't it? And fo r t hatm ome nt, y ou co uldlo ok ou t andimagi ne  "Damn, I could 
cod e the who lefr eak in g thi n g like  th is! "

Then  you re a liz ei t wo uld take around 30  y e a rs , but st ill -- it  w a s doable .You  fin a l ly fi gure d  o ut how i t allw or ke d. _You  c ould m ak e t hecompu t er d o
anyt hing itwas c a pable of doing _ . There was n o  m o r em yste rythere.

Fun  stu f f.
~~~k ra gen Do yo u rea ll y  t h ink it would take 3 0years?  TheNAND-To-Tetri s kids dom o s t of
itin a se m ester, and the y'restarting a t  the lev el of  individ ual gates . 
I mean,  Ch uck  Mo ore h as  been doing i t forab out 30yea rs, but  he  ha d a  wo rk ing
top-t o-bottom  s ys te maft er le s s than f iv e y ea rs. 

Her e 's wha t I t hink  i tw oul d lookl ik e : 

We ek  0 : bu ild  a  work ingi nte ractive  Forth sy ste m  tha tca n compi le itself, in 
m achine cod e.  Th is isa s suming y ou already have hardwar e  and away  to b ootit
into s ome  codeyou wrote.  If no t, th at  co u l d bea ma tte rof minutes o r o f
mon th s.
Weeks 1 -3: build an inter a cti ve high-level  la ngua g e  i nte r pr e ter  o n  to p of it.
Say, JS. 

Week 4:en o ug h of TCP/I P  to  d o HTTPGET.

W eek 5 :  writea bitmapfont edit or  and a  mi nimal file system.
Weeks 6- 8 : par s eHTML(mo re orle ss) , lay  it ou t  wi th asimpli fi ed box  mode l, 
and dra w it to pixels on a can vas, u singa p ixel font .
W eek  9: cooki es,HTTP POST,  XM LHt tpReq ues t .

We ek 1 0 :a m o re el abor a te filesy s te m,m a yb e based onG i t .
Weeks  11 - 12: so me m ore HTML5 feature s , maybe includ ingW e bGL .
W e
 rigorous_electronics
component where_we coded in ASM_for the_8086._One of_my_fondest moments of
that_time was when_I wrote a program_that would split_the_terminal screen into
two halves of different color, and display what you typed on one_side_and the
inverse_case_on_the other.

This could probably be_done with less than 50_lines in_python, but doing it in
assembly, calling all those_interrupt_routines, making sure_your registers
contained all the right values, man, when it_finally worked, it was the
greatest feeling_in the world!

~~~
DanielBMarkham
Wasn't_it?_And_for that moment, you_could look out and imagine "Damn,_I could
code the whole freaking thing_like this!"

Then you realize it would take_around 30 years, but still --_it was doable.
You finally figured_out how_it all worked. _You could_make the computer_do
anything it_was capable of_doing_. There was no more mystery_there.

Fun stuff.

~~~
kragen
Do you_really think it would take 30_years?_The NAND-To-Tetris kids_do_most_of
it in_a semester, and_they're_starting at_the_level of individual gates.

I mean, Chuck_Moore_has been doing it for about 30_years, but he had_a_working
top-to-bottom system after less_than five years.

Here's what I_think it would look like:

Week 0:_build a_working interactive_Forth system that can compile itself, in
machine code. This is assuming_you already have hardware and a_way to boot it
into_some code_you_wrote. If not,_that_could be_a matter of minutes or of
months.

Weeks 1-3:_build an_interactive high-level language interpreter on top_of it.
Say, JS.

Week 4:_enough_of TCP/IP to do HTTP GET.

Week_5: write a bitmap font editor_and a minimal filesystem.

Weeks 6-8:_parse_HTML_(more or less), lay it_out with a simplified box model,
and_draw it to_pixels on a canvas, using a pixel_font.

Week_9: cookies, HTTP POST, XMLHttpRequest.

Week 10:_a_more elaborate filesystem, maybe based on_Git.

Weeks_11-12:_some more HTML5 features, maybe_including WebGL.

We