Why do most languages not allow binary numbers?

Question

Why do most computer programming languages not allow binary numbers to be used like decimal or hexadecimal?

• In VB.NET you could write a hexadecimal number like &H4
• In C you could write a hexadecimal number like 0x04

Why not allow binary numbers?

• &B010101
• 0y1010

Bonus Points!... What languages do allow binary numbers?

---

Edit

Wow! - So the majority think it's because of brevity and poor old "waves" thinks it's due to the technical aspects of the binary representation.

Answer 1

Hex and octal are just shorter ways to write binary. Would you really want a 64-character long constant defined in your code?

Answer 2

Because hexadecimal (and rarely octal) literals are more compact and people using them usually can convert between hexadecimal and binary faster than deciphering a binary number.

Python 2.6+ allows binary literals (0b101010), so does Ruby.

Answer 3

In C++0x with user defined literals binary numbers will be supported, I'm not sure if it will be part of the standard but at the worst you'll be able to enable it yourself

int operator "" _B(int i);

assert( 1010_B == 10);

Answer 4

Common Lisp allows binary numbers, using #b... (bits going from highest-to-lowest power of 2). Most of the time, it's at least as convenient to use hexadecimal numbers, though (by using #x...), as it's fairly easy to convert between hexadecimal and binary numbers in your head.

Answer 5

Common wisdom holds that long strings of binary digits, eg 32 bits for an int, are too difficult for people to conveniently parse and manipulate. Hex is generally considered easier, though I've not used either enough to have developed a preference.

Ruby which, as already mentioned, attempts to resolve this by allowing _ to be liberally inserted in the literal , allowing, for example:

irb(main):005:0> 1111_0111_1111_1111_0011_1100
=> 111101111111111100111100

Answer 6

D supports binary literals using the syntax 0[bB][01]+, e.g. 0b1001. It also allows embedded _ characters in numeric literals to allow them to be read more easily.

Answer 7

for the record, and to answer this:

Bonus Points!... What languages do allow binary numbers?

Specman (aka e) allows binary numbers. Though to be honest, it's not quite a general purpose language.

Answer 8

It seems the from a readability and usability standpoint, the hex representation is a better way of defining binary numbers. The fact that they don't add it is probably more of user need that a technology limitation.

Answer 9

I expect that the language designers just didn't see enough of a need to add binary numbers. The average coder can parse hex just as well as binary when handling flags or bit masks. It's great that some languages support binary as a representation, but I think on average it would be little used. Although binary -- if available in C, C++, Java, C#, would probably be used more than octal!

Answer 10

See perldoc perlnumber:

NAME
   perlnumber - semantics of numbers and numeric operations in Perl

SYNOPSIS
       $n = 1234;              # decimal integer
       $n = 0b1110011;         # binary integer
       $n = 01234;             # octal integer
       $n = 0x1234;            # hexadecimal integer
       $n = 12.34e-56;         # exponential notation
       $n = "-12.34e56";       # number specified as a string
       $n = "1234";            # number specified as a string

Answer 11

In Smalltalk it's like 2r1010. You can use any base up to 36 or so.

Answer 12

Hex is just less verbose, and can express anything a binary number can.

Ruby has nice support for binary numbers, if you really want it. 0b11011, etc.

Answer 13

In order for a bit representation to be meaningful, you need to know how to interpret it. You would need to specify what the type of binary number you're using (signed/unsigned, twos-compliment, ones-compliment, signed-magnitude).

The only languages I've ever used that properly support binary numbers are hardware description languages (Verilog, VHDL, and the like). They all have strict (and often confusing) definitions of how numbers entered in binary are treated.

Answer 14

Slightly off-topic, but newer versions of GCC added a C extension that allows binary literals. So if you only ever compile with GCC, you can use them. Documenation is here.

Answer 15

In Pop-11 you can use a prefix made of number (2 to 32) + colon to indicate the base, e.g.

2:11111111 = 255

3:11111111 = 3280

16:11111111 = 286331153

31:11111111 = 28429701248

32:11111111 = 35468117025

Answer 16

Although it's not direct, most languages can also parse a string. Java can convert "10101000" into an int with a method.

Not that this is efficient or anything... Just saying it's there. If it were done in a static initialization block, it might even be done at compile time depending on the compiler.

If you're any good at binary, even with a short number it's pretty straight forward to see 0x3c as 4 ones followed by 2 zeros, whereas even that short a number in binary would be 0b111100 which might make your eyes hurt before you were certain of the number of ones.

0xff9f is exactly 4+4+1 ones, 2 zeros and 5 ones (on sight the bitmask is obvious). Trying to count out 0b1111111110011111 is much more irritating.

I think the issue may be that language designers are always balls-deep in hex/octal/binary/whatever and just think this way. If you are less experienced, I can totally see how these conversions wouldn't be as obvious.

Hey, that reminds me of something I came up with while thinking about base conversions. A sequence--I didn't think anyone could figure out the "Next Number", but one guy actually did, so it is solvable. Give it a try:

10 11 12 13 14 15 16 21 23 31 111 ?

Edit: By the way, this sequence can be created by feeding sequential numbers into single built-in function in most languages (Java for sure).

Answer 17

Every language should support binary literals. I go nuts not having them!

Bonus Points!... What languages do allow binary numbers?

Icon allows literals in any base from 2 to 16, and possibly up to 36 (my memory grows dim).

Answer 18

Java 7 now has support for binary literals. So you can simply write 0b110101. There is not much documentation on this feature. The only reference I could find is here.

Answer 19

While C only have native support for 8, 10 or 16 as base, it is actually not that hard to write a pre-processor macro that makes writing 8 bit binary numbers quite simple and readable:

#define BIN(d7,d6,d5,d4, d3,d2,d1,d0)                      \
(                                                          \
    ((d7)<<7) + ((d6)<<6) + ((d5)<<5) + ((d4)<<4) +        \
    ((d3)<<3) + ((d2)<<2) + ((d1)<<1) + ((d0)<<0)          \
)
int my_mask = BIN(1,1,1,0, 0,0,0,0);

This can also be used for C++.

Answer 20

Forth has always allowed numbers of any base to be used (up to size limit of the CPU of course). Want to use binary: 2 BASE ! octal: 8 BASE ! etc. Want to work with time? 60 BASE ! These examples are all entered from base set to 10 decimal. To change base you must represent the base desired from the current number base. If in binary and you want to switch back to decimal then 1010 BASE ! will work. Most Forth implementations have 'words' to shift to common bases, e.g. DECIMAL, HEX, OCTAL, and BINARY.