I'll explain.
IIRC (if I'm wrong I'll delete this and explain what it really is) it's a binary file database. This means everything thats dumped into the database (at least characters from what I remember) as raw data. It's not readable through any editor or anything nice and fancy, it's quite literally a raw dump of data. In order to read/be able to edit it like you might think you'd have to write your own program to read the database yourself. You can use a hex editor to read the raw data, but you have to know where the information is stored in the file (you can tell by reading the source).
Instead of say a text file that stores the number 510 in CPs as "CPs=510", the way the database works is that a certain portion of the file is just the number 510 (not in text, in byte form) and the program reads that portion as CPs. If you open it in notepad you'll probably get tons of random symbols/spaces (thats notepad trying to read the numbers as text), and possibly the players name (as thats actually saved as text).
--- Long version
Files are just dumps of bytes, all of them. The difference is how the bytes are interpreted.
A text file is similar, just every byte is interpreted as an ASCII or Unicode character (a letter or number for example).
In these encodings, certain number values equate to symbols, letters, numbers, etc.
So if the data was like this (in bytes)
(Decimal values - normal number system used)
104 | 101 | 108 | 108 | 111 | 0
(Hexadecimal values for the same data - Look up hexadecimal if you dont know it -
http://en.wikipedia.org/wiki/Hexadecimal, just basically a base 16 number system vs base 10 that we use)
0x68 | 0x65 | 0x6C | 0x6C | 0x6F | 0x00
In ASCII, these values would be interpreted as 'h' 'e' 'l' 'l' 'o' and then the number 0 is used to end the string. The ASCII encoding is 1 byte per character, and Unicode is similar, although it uses 2 bytes per character so more characters can be used. For example, since a byte is only capable of 256 different values (0-255 is 256 values guys), 2 bytes together are capable of exponentially more values (65536 values to be exact). This means more symbols can be interpreted, such as latin characters, chinese characters, etc.
You don't really need to worry too much about ASCII vs Unicode for now. If you want, you can google it.
For these 'binary data' files, the data is interpreted literally.
If the data is like this
(Dec)
169 | 1 | 0 | 0
(Hex)
0xA9 | 0x01| 0x00 | 0x00
This could be interpreted as 4 separate bytes that mean 4 separate things, or 2 shorts (2byte values), or 1 int(4bytes).
This could for example be the int X of a character, and when you combine the data its the value 425, or 0x1A9. Right next to it could be the Y value of the character.
If you look at the source, it has something like writer.WriteInt32(Character.X); This literally just dumps the data straight to the stream. It's written and read sequentially, so the first thing written is first in the file. The value of X is then read back into memory from the file steam, and used there.
You can write any data into a binary file, as long as you read it back correctly from the right spot. If you look at the source, you'll notice reading/writing goes in the exact same order of variables.
Strings can also be stored in a binary file, and they're encoded just like a text file would be (either ASCII or Unicode).
Using binary files eliminates the need to parse text into integers/parse text into other values, because you can dump raw memory to them, and read the dump back into memory. This equates to faster loading times over text files, but also makes them much harder for the average person to read (while this could also be a good thing - if you're trying to hide something I guess).
You might understand this a lot more if you understand how computer memory works.
