9,113 total views, 2 views today

So if the answer is “eight” then read on, if the answer is “it depends” then you can skip this blog.

In principle, all computers store their data in the form of individual bits. For a long time, memory modules, regardless of whether they were ring core memories or DRAM, were addressed bit by bit (today, with 32 or 64 bits per data access, not so many chips are required to store four bits per access).

But very few computers can do anything with individual bits. There are relatively few calculators that have instructions for accessing individual bits. The Z80 had such commands, but I never used them. In any case, however, computers do not address individual bits, but always several bits at once, which form a unit. A bit is then accessed using masks. To do this, the unit (n bits) is loaded into a register and linked to a constant that sets or resets a bit. With a logical OR operation in which the correct bit is set, you can set a bit without changing the others (e.g. OR 0001 000B to set the fifth bit. With a logical AND you can reset a bit with masks then all bits to “1” except for the reset one (AND 1110 1111B would reset the fifth bit and with logical AND, but this time with an inverted mask (all 0 except for the bit to be checked) you can test whether a bit is set or not (AND 0001 000B sets the zero flag after the operation if the bit was not set).

Computers tended to access their memory in larger chunks based on the width of the data bus, which was often (not always) as wide as the internal registers. If a computer only mastered this access, not that of individual bytes, it accessed the memory “by word”, and the memory was then organized accordingly in words and not bytes. That was the case with supercomputers (Cray 1) and microprocessors (TMS 9900). However, most computers still managed byte-by-byte access because very often the byte was the basic unit of information and not the bit.

The grouping of bits into a byte came about because while computers deal best with numbers, in practice they also deal with letters, even if the programs only deal with numbers, as was often the case, like this the program source code consisted of letters. It had to be processed and at least some messages had to be written in letters and commands were also typed in letters.

In the beginning, you were guided by what characters you could enter. For a long time, the standard input device was a converted teletypewriter and the old copies only knew capital letters. 5 bits were enough for this, but that was not enough for programs. Then there were the digits 0 to 9 and some special characters such as brackets and punctuation marks. At that time, they were not needed for texts but for programming languages. Even if there were exceptions. For example, COBOL avoided characters like + – * / and wrote ADD, SUBTRACT, MULTIPLY and DIVIDE. The first programming languages ​​such as FORTRAN and COBOL only used capital letters and special characters in their programs. For this amount of characters, 6 bits were enough for 64 characters. Accordingly, a byte was a data volume of 6 bits for a very long time and entire families of computers can be recognized by this alignment. The first supercomputers Cyber ​​6600 and 7600. They were calculators with an address space of 18 bits (3 x 6 bits) and could process numbers of 60 bits (10 x 6 bits). The PDP company made minicomputers with 12-bit, 18-bit, and 36-bit data bus widths. All multiples of 6 bits. There were also computers at the same time (the 1960’s) that used 8 bits for a byte, such as the IBM 360 family, but there was no direct use of the now extended code, which now allowed 256 characters.

The problem was not only that one byte was six or eight bits in size, but above all that each manufacturer had its own allocation. For example, the letter “A” at IBM had a different code than at DEC. This certainly had the desired side effect that you had to buy the peripheral devices from the same manufacturer if the printout was still legible and the computer could understand the input from the terminal.

The US government, which had a wide variety of systems in use in various organizations such as the military, NASA, research and administration, was annoyed by this grievance and standardized the code tables as early as 1963 and the first version ASCII – American Standard Code for Information Interchange appeared . As the name says, the point was that data, at that time still primarily on magnetic tapes, could be exchanged between computers, but that peripheral devices always understood the same character set.

From the very beginning, that was in 1963, this character set was 7 bits in size, so it could hold 96 characters. You don’t need that many. Even with some new computer characters not found on a typewriter, like the two new bracket types [] and {}, it didn’t take more than 96 characters. The first 32 characters are therefore not defined and were soon used as control characters. Some are standardized like #9 for tab, #13 for carriage return, #10 for line feed, and #12 for form feed (blank screen for screen, advance paper for printer). But even with the few signs that were needed for this, there was no agreement. With one manufacturer you had to send #13 and #10 to the printer for a new line, with the other only #13. To this day, text files from Unix and Windows systems differ in this detail. The other characters in this area were certainly not standardized. They were mainly used by screen terminals for functions such as cursor positioning or editing functions (delete to end of line / end of page, etc.).

A government decree passed after the second version of 1968 helped achieve the breakthrough for the 8-bit byte. After that, government agencies could only purchase new computers that comply with the ASCII standard, i.e. that at least support a 7-bit character set according to this standard. That was the end of the 6-bit architecture and new computers now relied on the 8-bit byte and corresponding word widths. DEC then introduced architectures with 16 or 32 bits.

What was also missed, because the US government was only concerned with the US market, was to consider that there are a few more special characters in Europe. In Germany the umlauts and the ß, in numerous Romance languages ​​vowels with accents and in Scandinavia others again, all in all there are, but not that many characters more, with 30 additional characters one could cover seven European languages. Since all computer manufacturers did not use the 7 bits of ASCII as the character set, but 8 bits for a byte, it would have made sense to think a little further here. With my 8-bit computer, which came from England, if I wanted to do word processing, I had to load a program beforehand that provided some characters with new bitmaps. If I then wanted to program, the same thing was necessary in the other direction, because the characters used were important in my programming language (they were [] {} | \ and ^).

Since a byte then had 8 bits – 7 bits would have been enough, but you probably wanted powers of two, the characters with the numbers 128 to 255 were undefined in the ASCII standard. You could use it to spice up the text mode. This has lasted for a very long time in the VGA text mode, where programs from Norton and Borland used these characters extensively to draw frames and shadows. The first home computers, which had no graphics but only a text mode, implemented characters in different poses to enable animations. Others make it block graphics – if you sacrifice 16 characters, you can create block graphics with twice the screen resolution (i.e. 160 x 50 dots on an 80 x 25 character screen).

Amazingly, in the early days of home computers we find the return to the 6-bit character set – both Tandy TRS-80 and Apple ][ (in Germany Apple ÖÄ – you can guess why) had in their character set no lower case letters. They did store the information in ASCII in an 8-bit byte, but in plain text mode you have to get the bitmap from a character ROM to display it on the screen. At that time, 6 to 8 bytes were typical for the bitmap of a letter, so with 26 letters fewer you saved 156 to 208 bytes – with a ROM of only 4 KByte size of the Tandy TRS-80 quite a size that counts. With the Apple II, it was probably more because Wozniak didn’t even think about the importance of lowercase letters, since his BASIC didn’t know floating point numbers either. He wrote it for game programming and there are at most some titles and messages that consist of text.

But that was a disadvantage for peripheral manufacturers, also because the characters above 128 were not standardized. There were special printer adaptations for popular calculators like the C64. At that time I had a Star NL-10 dot dot matrix printer, where you could exchange the character set with the cartridge, so it could output the entire character set of an IBM PC but also the characters of my computer.

The whole thing only changed when Unicode was introduced, which now includes characters from many languages ​​and currently has 145,000 characters. It was originally a 16-bit code, but that wasn’t enough. However, Unicode is relatively young; today’s standard dates back to July 1996. Before that, the character error was inevitable. You couldn’t even rely on two character sets from the same manufacturer to match. For example, Windows uses a different character set than DOS, although both are from Microsoft.

Related Posts