WEBSITE VAN DE WEEK
Terug naar de techniek achter de typmachine en de telex en hoe dat nog steeds een rol speelt op je hypermoderne smartphone, al zie je daar helemaal niets meer van, behalve als het misgaat.
Wie ooit wel eens gewerkt heeft op een oude typmachine herinnert zich nog het belletje als je bijna het einde van de regel naderde. Het werd dan hoogste tijd om je woord af te maken of af te breken op het eerst beschikbare lettergreepeinde. Om dan vervolgens de kruk naar links te trekken en de wagen met de kruk naar links te duwen, het was een vloeiende beweging. Niet alleen werd het papier een regel naar boven geduwd. maar ook kwamen de hamers weer in positie aan de linkerkant van het papier.
Een commando dat bij de telex twee commandos waren: Carriage Return (CR, ascii code 13 0D hexadecimaal 0001101 7bits binair) en Line Feed (LF ascii code 10 0A hexadecimaal 0001010 7bits binair) Heel vroeger hadden computers nog geen beeldschermen, maar wel een soort printer waarop de response kwam. Ook daar is het commando CRLF logisch. Maar waarom gebruikt UNIX dan toch alleen maar de LFLF (twee keer LF) voor het afbreken van de regel? Dat heb ik me ook altijd afgevraagd, vooral omdat de CRLF in DOS en daarmee in Windows wel overleefde. Daar gaat de vraag over in de website van de week.
Ik heb er zelf ook wel eens gedonder mee gehad. Een progje probeerde een file uit te lezen maar slaagde niet. Door de debugger. Het bleek dat het progje over zijn nek ging bij het CRLF commando. Om te testen de eerste de beste CRLF vervangen met LFLF. Bingo! Vervolgens een script geschreven om alle CRs te vervangen met LFs. Dat lijkt eenvoudiger dan het is. De enige methode was om de file toegankelijk te maken in zijn natuurlijke staat, de wereld van enen en nullen. Dat kreeg ik nog wel voor elkaar, al was het een heel gevecht om er dan ook een echte 7bits file van te maken, ontdaan van alle stopbits, controlebits en ander afval.
Toen daagde het mij. Ik was vast niet de eerste met dit probleem. Google is your friend. En inderdaad, debian/GNU Linux heeft gewoon een tooltje aan boord om af te rekenen met CRLF en ook andersom, handig als je geldautomaten programmeert die gek genoeg vaak op windows draaien.
Toch liet het programmeerprobleem me niet los. Het is zo primitief, wat ik heerlijk vind. Ik gebruik zelf in C heel vaak de zogenaamde small integer waarbij de letters van het alfabet nummers representeren, A=1, B=2 enz. Een echte integer maakt gebruik van de complete woordbreedte die de processor aanbied. Door het te beperken tot 7bits, bespaar ik de processor een hoop nullen en hoeft er iets minder gestookt te worden. Mijn milieubijdrage. Dat zouden meer programmeurs moeten doen. Al heeft dat natuurlijk alleen maar zin als je in C programmeerd, de andere programmeertalen zitten veel te ver van de processor vandaan om dat soort subtiel onderscheid te kunnen maken. Gewoon alles op de stack donderen, geen pointers of referencing, de manieren om rechtstreeks in het geheugen te tappen. Laat staan de processor te vertellen dat ie het rustig aan mag doen. Overigens ben ik een heel middelmatige C programmeur.
Maar als programmeur van een koude oorlog russiche straaljager zou ik het waarschijnlijk redelijk goed doen als ik er in zou slagen ook echt alle onzin uit mijn code te knijpen, te “normaliseren”, zoals de professional dat proces noemt. Maar dan nog zou ik er een enorme kluif aan hebben, omdat ik er redelijk zeker van ben dat ze hun software niet in C schrijven, maar in assembler. Dichter tegen de processor aan met assembler kan niet, of je moet echt alle nullen en enen met de hand willen uitschrijven.
De eerste generaties hadden nog buizen in plaats van transitors aan boord. Ze hielden er heel lang aan vast om meerdere redenen: super betrouwbaar en totaal ongevoelig voor de EM straling van de atoombom. Ik denk dat Poetin er nog wel paar achter de hand heeft. Aan boord van zo’n straaljager telt elke bit die aandacht wil van de processor. Niet voor niets dat de Russen niet alleen briljante schakers voortbrachten, maar ook dito programmeurs.
Daarom een voorbeeld van het beroemde “Hello World” programma in assembler. Alles wat achter een punt komma ; staat wordt genegeerd door de compiler. Binnenkort een foto van mij achter een echte typmachine met echt typpapier!
ps. weet je wat verontrustend is? Ik begrijp bijna elke instructie die hier beneden staat afgedrukt. Maar dat bijna niemand anders dit kan lezen is verontrustend. Denk aan skynet. Maar het is mooi geweest voor vanavond. I’ll be back. End Of Line _> LFLF
;to compile:
;
;nasm -f elf hello.asm
;ld -s -o hello hello.o
;
;nasm -f elf hello.asm
;ld -s -o hello hello.o
section .text
global _start ;must be declared for linker (ld)
global _start ;must be declared for linker (ld)
_start: ;tell linker entry point
mov edx,len ;message length
mov ecx,msg ;message to write
mov ebx,1 ;file descriptor (stdout)
mov eax,4 ;system call number (sys_write)
int 0x80 ;call kernel
mov ecx,msg ;message to write
mov ebx,1 ;file descriptor (stdout)
mov eax,4 ;system call number (sys_write)
int 0x80 ;call kernel
mov eax,1 ;system call number (sys_exit)
int 0x80 ;call kernel
int 0x80 ;call kernel
section .data
msg db 'Hello, world!',0xa ;our dear string
len equ $ - msg ;length of our dear string
len equ $ - msg ;length of our dear string
Reacties