So. I know Nick has thrown a bunch of ASCII and serial stuff at you guys,
\nbut I don’t know if anyone has put it together for you with the binary
\nstuff in Luke’s handout from the start of semester. So this is a $7
\nguide to binary encoding, which I will develop into ASCII and printing in C.<\/p>\n
Firstly, let’s get some bullshit out of the way. People say computers
\nonly understand 1s and 0s. This is, of course, ridiculous. Computers
\ndon’t understand anything. They can store 1s and 0s like a
\nmotherfucker, but they don’t have the faintest idea what they “mean”.<\/p>\n
That’s because what they “mean” is entirely dependent on context. The
\n8 bits 1011 0011 don’t “mean” 227. They don’t “mean” -77, either, for
\nthose who are up to speed with 2’s complement. They might be 8 bits
\nfrom the middle of a longer number, or a decimal number. Who knows?<\/p>\n
So the computer stores 1s and 0s, and we assign meaning to that
\ndepending on context. They are stored in chunks of 8 bits because
\nthat’s a nice round number if you’re working in binary. People have
\nplayed with 7 bits and 9 bits, or 10 bits, but these days 8 is
\nstandard. Note again, though, that it’s a chosen standard – 8 bits to a
\nbyte is not actually any inherent limit.<\/p>\n
One of the things humans really like doing with computers, it turns out, is
\ntyping and printing words. And the thing about words is that they have
\nletters. So how do we store words as ones and zeros? Well, we can
\npretty easily see that letters map to numbers. There are 26 letters in
\nthe alphabet. But when we print them, we need a different number to
\nsay “this is a capital’. So we need 52 numbers. Plus some punctuation.
\nTurns out we need about a hundred characters to pretty much cover
\nwritten English. Then, of course, we’re printing this on a screen – we
\nmight want some “characters” to tell the screen what to do (‘tab’, for
\nexample, to shortcut printing 4 spaces, or “new line”).<\/p>\n
We can still fit all that handily in 128 characters. That’s less than
\na byte, so let’s round up and say we’ll store one character per byte.
\nThere are technical reasons for that, but basically, it’s as easy to
\nget a full byte from memory as it is to get half a byte (or a nybble,
\nif you prefer), and it’s easier to convert a byte to a number than to
\nsplit it in half and convert each 4 bits into a number. So now if we
\nhave some standard way to assign numbers to letters, we can just store
\nthose numbers, and then when we retrieve them from memory, we can look
\nup the letter, and print that. So back in the day, a bunch of
\nboffins got together and agreed on a standard for converting letters
\nto numbers. Actually, because this is computing, 2 separate bunches of
\nguys agreed on 2 separate standards, and then the market decided. So
\nwhat we have now is ASCII – the American Standard Code for Information
\nInterchange. Because EBCDIC was even worse.<\/p>\n
Which brings me to C. I’ve been talking about storing and printing,
\nand perhaps rather than moving on to serial transmission, I’ll look at
\nhow that actually works, and what the implications are.<\/p>\n
Let’s start with the following:<\/p>\n
#include <stdio.h>
\nint main(void){
\nchar Alice = ‘A’;
\nchar Bob = 66;
\nprintf(“%c\\n”, Alice);
\nprintf(“%c\\n”, Bob);
\n}<\/p><\/blockquote>\nThe next $7 guide will look at why main has int and void, because that
\nseems to be a popular question, but for now, focus on what’s in main.<\/p>\nSo we say to The Machine: “I would like enough memory to store a character,
\nand I will call that chunk of memory Alice. In that chunk of memory,
\nplease store the value of capital A.”<\/p>\nThe single quotes around ‘A’ are important. If we just wrote
\nchar Alice = A;<\/p>\nthen The Machine would think we had another chunk of memory
\nsomewhere called A, and get confused because it couldn’t find it.
\nSo the single quotes say “Store the literal thing inside these
\nquotes”. The Machine is just clever enough to know that it can’t store
\n‘A’, so it goes away and looks up the ASCII table and gets a number
\nfor A. That will be 65.<\/p>\nReasonably enough, capital B is the letter after A. Normally, it’s
\neasier to put ‘B’ and make The Machine look it up, but this
\ndemonstrates that we can skip that step and put a number in directly.
\nNote that we don’t need quotes around numbers. The Machine is smrt
\nenough to recognise a number.<\/p>\n[Bonus points: digits have ASCII codes that don’t match the “number”
\nrepresented by the digit. If you have “Alice = ‘1’;”, then the quotes
\nsay “store the value of the thing in the quotes”, and the ASCII value
\nfor the digit “1” is 49. Yay?]<\/p>\nSo now we move on to printing those. printf() is an amazingly clever
\nroutine. We put what we want to print in double quotes this time, and
\nwe say to printf “I want you to print a character here”. That’s the
\n%c. %c just says ” I will give you a number. Go look the number up in
\nthe ASCII table, and print the letter that matches.”<\/p>\nOf course, we have lied to poor printf – what we actually give it is the
\nname of a chunk of memory called Alice. But printf can just about
\nmanage to pull a number out of that, and that number is 65, which
\nmatches A.<\/p>\nLikewise B.<\/p>\n
So this is all very fascinating, and I know you’re all thrilled, but
\nthis is a hell of a bg deal to be making out of looking up letters.
\nTurns out, of course, that it’s more interesting than that. Try this:<\/p>\n#include <stdio.h><\/p>\n
int main(void){
\nchar Alice = 65;
\nchar Bob = Alice +1;
\nchar Zarathustra = Alice +25;
\nchar Littlebob = Bob + 32;
\nchar Zero = 0x30;<\/p>\nprintf(“%c %d \\n”, Alice, Alice);
\nprintf(“%c %d \\n”, Bob, Bob);
\nprintf(“%c %d \\n”, Zarathustra, Zarathustra);
\nprintf(“%c %d \\n”, Littlebob, Littlebob);
\nprintf(“%c %d \\n”, Zero, Zero);
\n}<\/p><\/blockquote>\nYow. Mind. Blown. Now you see why this is the most exciting way I
\ncould think of to spend my Friday night.<\/p>\nLookit:<\/p>\n
#include <stdio.h>
\nint main(void){
\nint i\u00a0 = 0;<\/p>\nfor ( i = 0; i < 10; i++){
\nprintf(“%c \\n”, 48 + i);
\n}<\/p>\nfor ( i = 1; i<27; i++){
\nint Alice = 64 +i;
\nprintf(” Big %c ! little %c \\n”,Alice , Alice + 32 );
\n}<\/p>\n}<\/p><\/blockquote>\n
Now we’ve made Alice an int. The only difference between a char and an int
\nis how much memory is put aside. “char” says “give me one byte”. “int” says
\n“give me enough memory to store an int”. That s technically dependent on the
\nsystem, but for most desktops is 4 bytes. So I’m using more memory, but
\nsince a “char” is just “a number that fits in 1 byte”, it also fits in 4
\nbytes. And since it’s just a number, there’s no difference between 01000001 and
\n00000000 00000000 00000000 01000001.<\/p>\nAnd if that’s not exciting enough:<\/p>\n
#include <stdio.h>
\nint main(void){
\n int i\u00a0 = 0;
\n for ( i =0; i<26; i++){
\n printf(” Big %c ! little %c \\n”, ‘A’ +i , ‘A’ + i + 32 );
\n }
\n}<\/p><\/blockquote>\nThe value of ‘A’ is a number, and we can add it to other numbers and do math
\nwith it directly.<\/p>\nNow, if you’ll excuse me, I think I need a cold shower. Any questions?<\/p>\n
There are 2 more $7 guides in the works. One of them addresses why “main()”
\nworks even though you should write “int main(void)” anyway (or perhaps why
\nyou should write “int main(void)” when “main()” works just as well. That will
\ninclude what the hell “(int argc, char *argv[])” means, and probably also a
\nrant about why the Pugh book has issues in the 21st century.<\/p>\nThe other one will be on serial transmission, honest, and how to know when
\n01000110 01110101 01100011 01101011 means a very large number, and when it
\nmeans a very rude word (short answer, you can’t. Longer answer, it’s up to you!)
\nBut I’m open to suggestions if anyone has requests.<\/p>\n","protected":false},"excerpt":{"rendered":"So. I know Nick has thrown a bunch of ASCII and serial stuff at you guys, but I don’t know if anyone has put it together for you with the binary stuff in Luke’s handout from the start of semester. So this is a $7 guide to binary encoding, which I will develop into ASCII […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-86","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/tinker.eccentrify.com\/index.php?rest_route=\/wp\/v2\/posts\/86","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/tinker.eccentrify.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/tinker.eccentrify.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/tinker.eccentrify.com\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/tinker.eccentrify.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=86"}],"version-history":[{"count":10,"href":"https:\/\/tinker.eccentrify.com\/index.php?rest_route=\/wp\/v2\/posts\/86\/revisions"}],"predecessor-version":[{"id":103,"href":"https:\/\/tinker.eccentrify.com\/index.php?rest_route=\/wp\/v2\/posts\/86\/revisions\/103"}],"wp:attachment":[{"href":"https:\/\/tinker.eccentrify.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=86"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/tinker.eccentrify.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=86"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/tinker.eccentrify.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=86"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}