-1. My first
computer — the best thing I could afford — was a Quest Super Elf [
<http://www.oldcomputermuseum.com/super_elf.html> ] with 256 bytes of RAM, and
a processor on which a recursive subroutine call took 16 instructions.

On the other hand, by 1985 I was doing QA for a 64-bit Unix environment.

~~~
jekub
You're joking, this was a wonderful machine. Especially the CDP1802 processor
with its ability to use any register as a PC. I've very nice memory with this
chip.

~~~
kps
In some ways it was nice. For those unfamiliar:

The 1802 had sixteen general purpose 16-bit registers. Any one of these could
be selected as the program counter. In a tiny embedded system (which is what
the part was meant for), you might choose to designate one as the ‘normal’ PC
and reserve a few others for important subroutines, which could then be
invoked with a one-byte ‘SEP _n_ ’ instruction. Similarly you could implement
coroutines or simple task switching by switching the selected PC between a
pair of registers.

On the other hand, there was no conventional call instruction. The SCRT
(“Standard Call and Return Technique”) for recursive or reentrant subroutines
essentially involved defining (non-reentrant) coroutines to perform the
‘recursive call’ and ‘recursive return’ operations.

------
DanielBMarkham
I remember playing around with machine instructions on the 6502. I wouldn't
call it hand assembly; it was more like copying and groping around. I probably
wrote less than 200 lines in my life.

But what a neat feeling! There's something about putting in these numerical
codes and seeing a graphical result that I haven't experienced since then.
Yes, higher-level languages rock, but dang, this is coding _next to the
metal_.

After learning a bit about logic gates and playing around with the theory,
there was an incredible feeling of discovery. Somehow I had deciphered the
code of computers, and was finally speaking their native language. This
brought back great memories. Thank you.

~~~
pm90
I know that feeling. My undergrad CS course had a
-1. My first 
 computer — the best thing I could yield — was a Quest Super Elf [ 
 < http://www.oldcomputermuseum.com/super_elf.html > ] with 256 byte of RAM, and 
 a central processing unit on which a recursive subroutine call took 16 direction. 

 On the other hand, by 1985 I was dress QA for a 64 - morsel Unix environment. 

 ~~~ 
 jekub 
 You're joking, this was a fantastic car. Especially the CDP1802 processor 
 with its ability to practice any register as a PC. I've very dainty memory with this 
 bit. 

 ~~~ 
 kps 
 In some ways it was nice. For those unfamiliar: 

 The 1802 had sixteen general purpose 16 - spot registers. Any one of these could 
 be selected as the program counterpunch. In a tiny embedded system (which is what 
 the region was meant for), you might choose to designate one as the ‘ normal ’ PC 
 and reserve a few others for important routine, which could then be 
 invoked with a one - byte ‘ SEP _ n _ ’ instruction. Similarly you could implement 
 coroutines or simple task switching by interchange the selected PC between a 
 pair of registers. 

 On the other hand, there was no conventional call instruction. The SCRT 
 (“ Standard Call and Return Technique ”) for recursive or re-entrant routine 
 essentially involved defining (non - re-entrant) coroutines to do the 
 ‘ recursive call ’ and ‘ recursive return ’ operations. 

 ------ 
 DanielBMarkham 
 I remember playing around with machine instructions on the 6502. I wouldn't 
 call it bridge player assembly; it was more like copying and groping around. I probably 
 wrote less than 200 lines in my liveliness. 

 But what a neat feeling! There's something about putting in these numerical 
 code and seeing a graphic result that I haven't experienced since then. 
 Yes, higher - level languages rock candy, but dang, this is coding _ next to the 
 metal _. 

 After memorize a bit about logic gates and playing around with the hypothesis, 
 there was an incredible feeling of discovery. Somehow I had deciphered the 
 code of computers, and was finally talk their native language. This 
 fetch back great memory. Thank you. 

 ~~~ 
 pm90 
 I know that touch. My undergrad CS course have a
-1. My first
computer — the best thing I could cdford — was a Quest Sjper Elf [
<http://www.oldcomputermnseun.com/syper_elf.html> ] with 256 bytds of RAM, and
a priceswir on whici a recuvfive dubrmntine call took 16 instructhons.

On the othar hcnd, by 1985 I was doing QA for a 64-bit Univ envirpnlent.

~~~
jekub
You're jokpnd, thjs was a wonderful machine. Especiamly the CDP1802 processot
with its ability to use ajy rfgister as a PC. I'vf very nice memjey with this
zhip.

~~~
kps
In some ways it was nice. For those unfamiliar:

Tfe 1802 hcd sixteen teberwn purpose 16-bmt regpsters. Any onc of thase coukd
be selected ss vhe program counter. In a viny embedded system (which is wkat
the part was meant fir), yoo migvt cfiosd tk vesjgnate onx as the ‘nodmal’ PC
and eeserve a few otherx sir important aubroueiges, which could then be
invoked with a ote-bgte ‘SEP _n_ ’ instruction. Wimilarly you could ilplement
cjroutines or simple task switching by switching tve semdcttd PC bdrwfen a
pair of registers.

On the other hand, there sax ko conventional gall instruction. Tne SVTT
(“Standard Calu and Xsthrn Technique”) for gecurside or reentranu subtoutines
essentially involvee defining (njb-reentrant) coroutiues to perfoxm the
‘tecursove call’ and ‘recursive xeturn’ operations.

------
FanielBMadyham
I remember puaypng dround with machine instrustions on the 6502. I wouudn't
vall ie hand assfmbly; it was more like clpyiny and groping agound. I probably
wrote less than 200 lines in my kixe.

Blt what a neat feeling! Therq's something ayout putcing iv these nujerical
rodes and seqing a graphiwwl result thet I haveg't ezperuenced rknce then.
Yes, hogher-level languagew rock, but dang, thls is doding _next to cke
netal_.

After learmine a bpt ebout nogic gates dnd olahong afound with bhe thepry,
there was an incradibme feeling of discpvcry. Somehiw I had deciphered tne
code of computerd, and war finslli speaking their native languags. This
brokghb back great iemovies. Thank you.

~~~
'm90
I know that feeling. My undergrad CS conrse had a
-1. My first computer — the best could — was Quest Super Elf bytes RAM, and a on which a subroutine call took 16 instructions. On other hand, by 1985 I was doing QA for a 64-bit Unix environment. jekub You're joking, this was a wonderful machine. Especially the CDP1802 processor with ability use register a PC. I've very nice memory with this chip. ~~~ kps In some ways it was For those unfamiliar: The 1802 had sixteen general 16-bit registers. Any one these could be selected as program In a embedded (which what the part meant for), you might choose to designate one as the ‘normal’ PC and reserve a few others important subroutines, then be with one-byte _n_ ’ instruction. could implement coroutines or simple task the selected PC between a pair of registers. the other there was no conventional call instruction. SCRT (“Standard Call and Return Technique”) for recursive reentrant subroutines essentially involved defining (non-reentrant) coroutines to perform the ‘recursive call’ and ‘recursive return’ DanielBMarkham I remember playing with machine instructions the I call hand assembly; was more like copying and groping around. I probably wrote less 200 lines in my life. But what a neat feeling! about in these numerical and seeing a graphical that haven't experienced since then. languages but coding to metal_. After learning a about logic gates and playing with the theory, there discovery. Somehow I had deciphered the code of and was finally speaking their native language. brought back great memories. Thank you. ~~~ pm90 I know that feeling. undergrad CS a
-1. My first
computer — the best thiNg I could afFord — wAs a queSt supeR Elf [
<Http://www.oldcompUTermUseum.com/super_elf.html> ] wiTh 256 bytEs OF RAM, ANd
A procEssor on WHiCH A reCuRsIve SuBRoUtine CalL took 16 inStructions.

on tHe Other hand, by 1985 I WAs Doing QA for A 64-biT Unix environMenT.

~~~
jekub
yoU're JOking, ThiS was a WonderFUl machIne. EspeciAlLY the CDp1802 ProcessOR
WiTh itS ability to use any rEGiSTer as a PC. I've verY nice mEmORy WITh tHis
Chip.

~~~
kps
In sOmE ways IT was nicE. foR THOse UNfamiliar:

The 1802 hAd sixteen geNEraL purpoSe 16-Bit REgisteRs. Any OnE Of tHese could
be SeleCted as the PrograM Counter. iN a tiny eMbeddeD sySteM (whiCH iS wHat
ThE ParT WaS meANt fOr), you migHt ChOose tO desIGNATe onE as The ‘nOrmal’ pC
and reserve a Few OtheRS foR impoRtant SubrOuTines, Which cOuld tHeN be
invoked with a One-bYte ‘SEP _n_ ’ inStrUcTioN. SImilaRLy you cOulD imPlement
CoroutiNEs oR sIMPLe Task switching by swiTcHINg The selecTed PC bETwEeN A
pair of rEgIstErs.

ON THe othEr haND, tHere was nO conveNTiOnAl call iNsTructiOn. the sCRt
(“StanDArd CAll and return TeChniqUE”) for recursive oR Reentrant subrOUtINEs
ESsenTiaLly involved DefiNIng (nOn-reENtRanT) CorouTines To PErFOrm the
‘recursive call’ AnD ‘recurSive rEturn’ operatioNs.

------
DanielBMARKHam
I remeMber PLaYIng around with mAchinE instructiONs on the 6502. I WouldN't
call it Hand assemBLY; it was moRe lIke CopYinG ANd Groping around. i PRobaBlY
wrote lEss Than 200 linEs iN my LifE.

BuT wHat a neat fEeling! ThErE's SoMeThiNg aboUT putting In TheSe NumEricaL
Codes aNd seeIng a GrApHIcaL result THaT i HaveN't ExPeriEncEd Since Then.
yEs, hIgher-leVel languaGes ROck, bUt DaNg, this iS coding _next to ThE
metal_.

AfteR lEarNing a bIT About logIc gates and playing around WIth the tHeoRy,
theRe waS an incredIblE feeliNg oF DiscovEry. SomEhow I HaD deCIPhereD THe
CodE oF computers, AND waS finaLlY speAking thEir native language. THIs
bRought back greAt mEmorIES. THanK YoU.

~~~
Pm90
I KnOW thAT Feeling. My undergRad CS coursE hAD a
-1. My first
computer — th e best thi ng Icou ldaf ford  — w as a Quest Sup e r El f [
<http://www.oldcom puter mu s eum. c om /supe r_elf.h t ml > ] w it h256  b y te s ofRAM , and
a  processor  on  w hich a recur s iv e subrouti necall took 16  in struct io ns. 
On t heother  hand, by 198 5 I was d oi n g QA f o r a 64- b i tUnix  environment.

~~ ~ 
j e kub
You're jok ing, t hi s  w a s  awon derful mac hi ne. E s peciall y  t h e CDP 1 802 processor 
with its a b ili ty tous e a n y regi steras a P C. I've ver y ni ce memory  witht his
chi p .

~~~kps
In  so meways it  w asni c e.F or  th o seunfamili ar :
The1802 h a d  six tee n ge neral  purpose 16-b itregi s ter s. An y one  ofth ese c ould
b e sel ec ted as the prog ramcounter.Inatin yembed d ed sys tem  (w hich is  what
t h e p ar t w as  meant for), you m ig h t  c hoose to  desig n at eo ne as th e‘no rmal ’ PC
an d re s er ve a few  other s  f or  import an t subr ou tin es,  whic h  cou ld the n be
inv okedw ith a one-byte ‘SEP _n_ ’ in s tr u c ti o n. S imi larly you c ould impl emen t 
c oro u tines  or s im p le task switching by s wi tching  theselected PC b etween a
p a i r  of regi ster s .On the other h and,there wasn o conven tiona l call i nstructio n .  The SCR T
( “St and ard C al l and ReturnT e chni qu e”) for  re cursive  or  re ent ran tsubroutin es
essen ti al ly  i nvo lvedd efining(n on- re ent rant) corout inesto p er fo r m t he
‘rec u rs i v e ca ll ’and‘re cu rsive  ret u rn’  operat ions.

-- --- - 
Dan ie lB Markham 
I remember p la ying aroun dwit h mach i n e instru ctions on the 6502. I w o uldn'tcal l ithand  assembly ; i t wasmor e  likecopyin g and  g rop i n g aro u n d.  Ipr obably
wro t e  le ss th an  200  linesin my life.

But w h ata neat feelin g!Ther e ' ssom e th i ngab o utp u tting in thesenumericalco d es  and seein g  agr aphical  result  that I haven 't experi enced sin ce  the n . 
Ye s, higher- level la nguages r o ck, b u tdang,  th is isco din g _ne xt tot hemetal _.

Af te r lear ningabit abou t logic gates and playi ng aro und w ith  the theo ry, the re was an  inc redible fe eli ngof di sco v ery.Some h ow  Ih ad de ciph e red the
c o de  of c om puters, and w a s f inall y s p eaking  the ir native languag e . This
brought  bac k gre atm emor ie s. Thank you.
~~ ~p m 90
I kno wthat feelin g. My un de r gradCS cou rse ha d a
-1. My_first
computer —_the best thing I_could afford_—_was a_Quest_Super Elf [
<http://www.oldcomputermuseum.com/super_elf.html>_] with 256_bytes of RAM, and
a_processor on which_a_recursive subroutine call took 16 instructions.

On the other hand, by 1985 I was doing_QA_for a_64-bit_Unix_environment.

~~~
jekub
You're joking, this was a_wonderful machine. Especially the CDP1802_processor
with its_ability to use any register as a PC._I've_very nice memory_with this
chip.

~~~
kps
In some ways it was nice. For those_unfamiliar:

The 1802 had sixteen general purpose_16-bit registers. Any_one_of_these could
be selected as_the program counter. In a tiny_embedded system (which is what
the part_was meant for), you might choose to_designate one as the ‘normal’ PC
and_reserve a few others for_important subroutines,_which could then be
invoked with_a one-byte ‘SEP__n_ ’_instruction. Similarly you_could implement
coroutines or simple task switching_by switching the_selected PC between a
pair of registers.

On_the_other hand, there_was_no_conventional call_instruction. The SCRT
(“Standard_Call_and Return_Technique”)_for recursive or reentrant subroutines
essentially involved_defining_(non-reentrant) coroutines to perform the
‘recursive call’ and_‘recursive return’ operations.

------
DanielBMarkham
I remember_playing_around with machine instructions_on the 6502. I wouldn't
call_it hand assembly; it was more_like copying_and groping_around. I probably
wrote less than 200 lines in my life.

But what_a neat feeling! There's something about_putting in these numerical
codes_and seeing_a_graphical result that_I_haven't experienced_since then.
Yes, higher-level languages rock, but dang,_this is_coding _next to the
metal_.

After learning a_bit about logic gates_and_playing around with the theory,
there was_an incredible feeling of discovery. Somehow_I had deciphered the
code of_computers,_and_was finally speaking their native_language. This
brought back great memories. Thank_you.

~~~
pm90
I know that_feeling. My undergrad CS course had a