De titel zegt het eigenlijk al. Een vriend van mij vertelde me dat hij iemand kent die binair kan programmeren. Ik heb nog nooit gehoord van iemand die in binair programmeert en een paar snelle Google-zoekopdrachten leverden niets bruikbaars op. Dus ik dacht dat ik me tot de SO-gemeenschap zou wenden. Heeft iemand informatie over binair programmeren en, indien mogelijk, misschien een snel Hello World-voorbeeld. Bij voorbaat dank.
Antwoord 1, autoriteit 100%
Natuurlijk. Het wordt vaker machinecodegenoemd. Het is eigenlijk assemblagetaalzonder de geheugensteuntjes. Iemand die assemblage heel goed kent, zou met extra moeite in machinecode kunnen programmeren, verwijzend naar opcode-lijsten (bijv. x86) als nodig.
Zou ik het doen? Nee. Zelfs montage is alleen nuttig in zeldzame omstandigheden, en er is geen reden (behalve het demonstreren van je vaardigheden) om de assembler‘s hulp.
Aangezien je naar hello world hebt gevraagd, moet je dit artikeleens lezen. Hij laat zien hoe hij een x86 ELF-programma schreef en vervolgens optimaliseerde om het uit te voeren. Het is oorspronkelijk geschreven in nasmen vervolgens aangepast in een hex-editor.
Antwoord 2, autoriteit 32%
Het is heel goed mogelijk om machinecode-equivalent van montage-instructies te onthouden. Als je code schrijft in assembler, zie je vaak hex-code via machinecodemonitors, disassemblers, assemblagelijsten, enz. Als gevolg hiervan kunnen na verloop van tijd sommige instructies zonder extra inspanning in hun hexadecimale vorm worden onthouden.
- Op de afbeelding is een 6502 ROM-monitor te zien, waar de hexadecimale code en montage-geheugensteuntjes naast elkaar worden getoond.
De tweede vaardigheid die je nodig hebt, is het omzetten van hex-code in binair, wat vrij eenvoudig is met een truc die ik zo dadelijk zal uitleggen.
Denk aan de volgende instructies:
OPCODE HEX
LDA #imm 0xA9 imm
STA adr 0x85 adr
STA (adr),Y 0x91 adr
LDY #imm 0xA0 imm
Met bovenstaande opcodes alleen in het geheugen, kunnen we de volgende machinecodeschrijven met alleen pen en papier:
0xA9 0x00
0x85 0x01
0xA9 0x02
0x85 0x02
0xA0 0x00
0xA9 0x01
0x91 0x01
In feite is het bovenstaande de volgende assembly-code in mnemonische vorm:
LDA #00
STA $01
LDA #02
STA $02
LDY #00
LDA #01
STA ($01), Y
- De bovenstaande code plaatst een witte pixel in de linkerbovenhoek van het scherm in 6502asm.comassembler/emulator , ga je gang en probeer het uit!
Nu is de truc voor het omzetten van hexadecimalen in binair en vice versa om het alleen uit te werken voor hapjes (4-bits waarden).
Onthoud eerst hoe u binair omzet in decimaal. Elke keer dat u 1 ziet, vermenigvuldigt u dat door zijn binaire kracht. B.v. 101zou 4 + 0 + 1 = 5zijn. Het kan als volgt worden gevisualiseerd:
1 1 1 1 --> binary points
| | | |
v v v v
8 + 4 + 2 + 1
| | | +---> 2^0 * 1 Ex: 13 is 8 + 4 + 0 + 1
| | +-------> 2^1 * 1 1 1 0 1 -> 1101 (0xD)
| +-----------> 2^2 * 1 Ex: 7 is 0 + 4 + 2 + 1
+---------------> 2^3 * 1 0 1 1 1 -> 0111 (0x7)
Met dit in gedachten, en goed geoefend, zou het volgende mogelijk moeten zijn:
LDA #00 -> 0xA9 0x00 -> 1010 1001 0000 0000
STA $01 -> 0x85 0x01 -> 1000 0101 0000 0001
LDA #02 -> 0xA9 0x02 -> 1010 1001 0000 0010
STA $02 -> 0x85 0x02 -> 1000 0101 0000 0010
LDY #00 -> 0xA0 0x00 -> 1010 0000 0000 0000
LDA #01 -> 0xA9 0x01 -> 1010 1001 0000 0001
STA ($01),Y -> 0x91 0x01 -> 1001 0001 0000 0001
Met wat retro computergeest, motivatie en plezier, zouden we de hele code in binair kunnen hebben geschreven zonder de tussenstappen te schrijven.
Op een gerelateerde nota codeerde Paul Allen een bootloader voor Altair 8800 met pen en papier op een vliegtuig, en moest het mogelijk ook vertalen naar binair met pen en papier: https://www.youtube.com/watch?v=2weyQJNHEC8
Antwoord 3, Autoriteit 16%
Voor de dapperen van hart: je kunt proberen een MikeOS-diskette-image te krijgen en het monitor.bin-programma uit te voeren. Hiermee kunt u hexadecimale opcodes met de hand invoeren en uitvoeren. Bijvoorbeeld (zoals vermeld in de documenten), door de volgende instructies in te voeren:
BE0790 E8FD6F C3 4D00$zal een enkele Mop het scherm produceren.
Antwoord 4, autoriteit 14%
Er is niet veel meer voor nodig, maar het is gedaan. Er was een tijd dat code in binair getal in een systeem kon worden ingevoerd vanaf de voorconsole. Het was foutgevoelig.
Vroeger had ik een heel kort uudecoe-programma dat was gecodeerd in ASCII en dat als voorvoegsel kon worden toegevoegd aan een UUE-encoded bestand. Het resulterende bestand zou zichzelf uitpakken en zou rond kunnen worden gemaild. Ik zou verwachten dat de machinecode met de hand was gedaan. Ik kan het niet vinden en heb er geen zin in, ook al zou ik het kunnen.
Antwoord 5, autoriteit 14%
Natuurlijk kun je het binaire bestand voor de machinecode schrijven en vervolgens de machinecode via je hexadecimale toetsenbord in je computer invoeren. Ik heb een computer samengesteld op basis van de TMS1100.
Een eenvoudig programma om 5 op de hex-LED weer te geven, zou 0001000 0000101 0000001 zijn, in binair geschreven, omgezet in machinecode die 8 5 1 zou zijn. Dit programma zou dan draaien en 5 op de LED weergeven.
Je zou deze procedure kunnen volgen voor veel complexere programma’s met de TMS1100 en ik vermoed dat je in binair moet programmeren.
Eigenlijk denk ik dat dit zeer bevredigend en lonend is als je geïnteresseerd bent in wiskunde en programmeren.
Antwoord 6
Er zijn enkele esoterische programmeertalen. Ze worden gebruikt als experimenten en zijn nogal onpraktisch, maar één, genaamd BrainF**k (ja, het is echt een ding) gebruikt acht verschillende karakters om bytewaarden te wijzigen. Dat soort talen zijn ongeveer zo dicht als je kunt krijgen.