# In languages that don't allow underscores in integer constants, is it a good practice to create a constant for 1 billion?

In languages that don't allow underscores in integer literals, is it a good idea to create a constant for 1 billion? e.g. in C++:

``````size_t ONE_BILLION = 1000000000;
``````

Certainly, we shouldn't create constants for small numbers like 100. But with 9 zeros, it's arguably easy to leave off a zero or add an extra one in code like this:

``````tv_sec = timeInNanosec / 1000000000;
tv_nsec = timeInNanosec % 1000000000;
``````
• I hope everyone here votes for NO. That way, maybe one day my bank will transfer one billion dollars to my account because a programmer didn't use a constant and misplaced a zero! :) May 24, 2013 at 16:30
• Why not create constants for small numbers? What does 100 mean? Unless there is some context, it's a magic number. May 24, 2013 at 16:30
• @MathewFoscarini In general, mistakes can go either way. But when it comes to your bank, mistakes will always go against you. May 24, 2013 at 18:30
• Consider writing `1e9`, `10^9` or `1_000_000_000` if the language you are using supports it. May 24, 2013 at 18:58
• Long scale or short scale billion? May 26, 2013 at 6:42

Most languages feature some kind of exponential notation. A million is `1e6`, (meaning 1 times 10 to the power of 6). This basically solves the issue even better than most propositions here.

In a lot of C-like languages, the scientific notation is however defining a floating point type, which is unfortunate if you really need an int. However, you can easily type-cast that constant to avoid implicit conversions in your formular.

`n / int(1e9)` would divide by a billion.

In your example, dealing with physical quantities (time in nanosecond), I would generally ask myself whether integer is the right type. In fact a floating point `double` might be better suited when dealing with measurable quantities (although there are of course cases where you would prefer a `long long`).

• I think the NANOSECONDS_IN_ONE_SECOND solution is much clearer and neater May 25, 2013 at 17:40
• The Question was about integer liberals and I propose to use scientific notation. Whether to do this in place or by defining a constant is an issue of structuring code that was not asked for in the question. Defining a constant adds limited abstraction, I would write a conversion function/macro to achieve better abstraction May 25, 2013 at 18:00
• would casting a very large double to an int not risk the typical rounding difference problems of floating point numbers? May 26, 2013 at 12:11
• with normal precision integer types this shouldnot be a problem as long as you use a double precision float to convert from. you are right when using values of the `long long` range. May 26, 2013 at 12:50

Create one called NANOSECONDS_IN_ONE_SECOND instead as that what it represents.

Or a shorter, better name if you can think of one.

• I'd say `Nanoseconds_Per_Second` but this is, in my opinion, the correct answer. May 24, 2013 at 16:56
• @Mathew I don't get your point. There's nothing wrong with saying millimeters per meter. You may be implying that it is redundant, in that nanosecond MEANS one billion fractions of a second, but there's nothing wrong in stating it again. It's like saying 1 + 1 = 2. "x per y" continues to make more sense when x and y are disjoint, like "units per half dozen" or "nanoseconds per millisecond" May 24, 2013 at 17:34
• @MathewFoscarini Actually, no, in this context it's not. If it were, a constant named `NANOSECONDS` is meaningless as you can't tell what it's supposed to apply to. Likewise, `NANOSECONDS_PER_MICROSECOND` is a similar valid constant that makes sense. May 24, 2013 at 17:41
• @MathewFoscarini, "millimeters per meter" is a way to remove the unit on the conversion to get the raw value. `1mm/1m = 1000`, which is exactly the point of what's being done here. May 24, 2013 at 19:48
• Why so much typing? `NS_PER_SEC` should be obvious to anyone who ought to be dealing with nanoseconds. May 24, 2013 at 21:03

Constants are meant to give numbers meaning. There is not any additional meaning in `ONE_BILLION` to `1000000000`. Actually, it makes it more confusing, because in different natural languages, a billion means something different (either a thousand million or a million million)! If you want to write it shorter, there's a good chance your programming language allows the use scientific notation, i.e. `1e9`. Otherwise, I agree with @JohnB, that this number really means the number of nanoseconds in a second, so name it that.

• Good pointing that billion in different languages mean different amount of zeros. May 24, 2013 at 22:46
• would suggest changing regular languages to natural languages. regular means something else...
– jk.
May 25, 2013 at 6:39
• Different interpretations of "billion" in languages such a good point! Why can't I upvote your answer twice! May 25, 2013 at 13:10
• You don't need different languages. You don't even need different countries. In British English, "billion" means something different before and after 1974 in official communications (mass media and government), and both usages still exist. May 26, 2013 at 11:26
• "There is not any additional meaning in ONE_BILLION to 10000000000.. I disagree. (Hint: I deliberately misquoted you and added another zero; would have have noticed if I hadn't mentioned it?) Jun 3, 2013 at 19:41

For one or two usages, I would use the convention:

``````tv_sec = timeInNanosec / (1000 * 1000 * 1000);
tv_nsec = timeInNanosec % (1000 * 1000 * 1000);
``````

It's perfectly self explanatory, gets compiled to a constant and it's hard to screw up.

Also, it's very useful in cases such as:

``````var Time = 24 * 60 * 60;
``````

where it's easy to see we are talking about one day in seconds.

• This is what I usually do. It also has the advantage that I won't forget that I defined NANOSECONDS_IN_ONE_SECOND yesterday and define NANOSECONDS_PER_SECOND today. And perhaps ONE_AMERICAN_BILLION tomorrow. May 25, 2013 at 10:21
• Surely 'SecondsInOneDay = 24 * 60 * 60' is easier still? May 26, 2013 at 17:22
• @JBRWilkinson sure, my initial snippet was using a class `instance.Time = ...`, but then I dumbed it down... May 26, 2013 at 20:29
• In C or C++, `(1000 * 1000 * 1000)` is of type `int`, which is only required to be 16 bits, so it can overflow. You can write `(1000L * 1000L * 1000L)` to avoid that. Jun 3, 2013 at 19:36
• I do this a lot. It works very well.
– vy32
Jun 11, 2013 at 15:13

The length of the value is not what defines whether a constant is needed or not.

You use constants to avoid magic numbers, not to avoid typing.

For example these are perfectly valid constants:

``````public static final int CLOSE_CURSORS_AT_COMMIT = 1;
public static final int CONCUR_READ_ONLY = 2;
public static final int CONCUR_UPDATABLE = 3;
public static final int FETCH_FORWARD = 4;
public static final int FETCH_REVERSE = 5;
public static final int FETCH_UNKNOWN = 6;
public static final int HOLD_CURSORS_OVER_COMMIT = 7;
public static final int TYPE_FORWARD_ONLY = 8;
public static final int TYPE_SCROLL_INSENSITIVE = 9;
public static final int TYPE_SCROLL_SENSITIVE = 10;
``````

Use:

``````public static final int NANOSECS_PER_SECOND = 1000000000;
``````

(code samples are in Java, translate to your favorite language )

• +1 Named numbers are nearly useless. The purpose of constants it to give meaning to those numbers. What do they represent? What thing are they counting or limiting or formally named coefficient? Not what is the value of the count. May 24, 2013 at 18:52
• Seeing as we're talking Java, I'll make the observation that, as of Java 7, we can put underscores in numbers to help readability!
– Nick
May 24, 2013 at 20:54
• Those are terrible examples of valid constants. They should have been enums, except they were created before enums. May 26, 2013 at 17:38
• @ChristofferHammarström They were indeed created before enums, they are part of the ResultSet class, in the SQL package of the Java SDK. May 26, 2013 at 20:39
• @ChristofferHammarström They're bad because now we have enums but not for being unmeaningful. Enum didn't exist when these classes were created and in order to differentiate between mutually exclusive options like FETCH_FORWARD and FETCH_REVERSE is giving them a different value. The value doesn't matter, just the fact that they are different. May 27, 2013 at 11:40

An American or European billion?

(or in technical terms, a billion in the short scale or long scale - one is 1000 million, the other is a million million).

Given this confusion, then I'd say yes - it makes sense to define it once and keep with it, likewise applies to any constant you need to agree the definition on - define it once.

• "An American or European billion?" - "What? I don't know that! Ahhhhh!!!!" May 25, 2013 at 0:01
• In the UK, at least, we've long since adopted the 1e9 billion. May 25, 2013 at 7:45
• @Tesserex - well, you have to know these things when you're a king, you know. May 25, 2013 at 12:51

### Reasons Not To

Firstly, here is a reason not write any underscores or use any trick to simulate it: it makes the constants harder to find in the code. Suppose that some program exhibits, somewhere in its operation, hard-coded value 1500000 for some parameter. I want to know where in the source code of the program this actually occurs, so I grep the code for `1500000`, and find nothing. Why? Might it be in hexadecimal (but why for such a round decimal number). Unbeknownst to me, the constant is actually written as `1_500_000`. I needed the regex `1_?500_?000`.

### Guiding Characters in Comment

Just because one kind of visual aid is not available, or we don't wish to use it for the above reason, doesn't mean that we cannot take advantage of the two dimensions of the text file to create an alternative visual aid:

``````foo = bar / 1000000000;
//           --^--^--^
``````

With this we can easily convince ourselves that there are three groups of three zeros. Yet, we can still grep the source code for `1000000000` and find it.

### Syntax Coloring

A text editor with programmable syntax coloring can be made to color groups digits in numeric constants with alternating colors for better readability. We don't have to do anything in the code.

### Preprocessing: C, C++, Objective C

Now, if we really want some commas between digits, in C and C++ we can use some preprocessing:

``````/* Four digit base TH-ousand constant macro */
/* Condensed using Horner's rule */
#define TH(A,B,C,D) ((((((A) * 1000) + (B)) * 1000) + (C)) * 1000 + D)

tv_sec = nanoseconds / TH(1,000,000,000)
``````

Works for numbers like `TH(1,234,567,890)`.

A macro similar to TH can also work with token pasting rather than arithmetic. In the C preprocessor, the binary `##` operator ("token paste") can be used in a macro body in order to paste together two operands into a single token. One or both of the operands can be macro arguments. The downside here (creating a risk for us) is that if the resulting catenation isn't a valid token, the behavior is undefined.

``````#define TOK4(A, B, C, D) A ## B ## C ## D
``````

Now

``````TOK4(1,000,000,000)       /* produces the single token 1000000000 */
TOK4(1,123,000,000.0E+2)  /* produces the single token 1123000000.0E+2 */
TOK4(pr,in,t,f)           /* produces the token printf */
TOK4(#,*,a,b)             /* undefined behavior, #*ab is not valid token syntax */
``````

C programs that paste together identifiers and use the results to name global variables and functions exist and are awful to work with because they are impervious to tools like GNU id-utils and ctags.

• +1 for one of the best abuses of the preprocessor I've seen. I'd still go with NSEC_PER_SEC or something in production, though. May 25, 2013 at 16:34
• Very nearly -1 for abusing the preprocessor :)
– user
May 26, 2013 at 14:11

Yeah, that sounds like a reasonable idea. Off-by-one DIGIT errors are even worse than the infamous off-by-one errors. Although, it may create confusion for other people (including your future self) to read the code.

A more explanatory name like NANOSEC_PER_SEC seems good, as it would add clarity where it is used for time. However, it makes no sense to use in contexts other than time, and it would be impractical to create a separate 1,000,000,000 for every situation.

What you really want to do, silly as it seems at first, is 'divide over sec'. This leaves NANO_PER, which is not only language-independent (10^9 in America and Europe) but also situation-independent (no limiting on the units), and it is easy to type and read.

• this post is rather hard to read (wall of text). Would you mind editing it into a better shape?
– gnat
May 24, 2013 at 21:12

In general it's a bad idea to use scalar constants for unit conversions, and if you find yourself making constants for such things you're doing conversion in way too many places.

When you have a quantity of one unit (say, 10 seconds), and want to convert to another unit (i.e. nanoseconds); this is precisely the time to use the type system of your language to ensure that the units are actually scaled as you intend.

Make your function take a `Nanoseconds` parameter, and provide conversion operators and/or constructors in that class for `Seconds`, `Minutes`, or what-have-you. This is where your `const int` or `#define` or `1e9` seen in other answers belongs.

This avoids having variables of ambiguous units floating around your code; and prevents entire swathes of bugs from where the wrong multiply/divide was applied, or was already applied, or the quantity was actually distance instead of time, or...

Also, in such classes it's good to make construction from plain scalarsprivate and use a static "MakeSeconds(int)" or similar to discourage sloppy use of opaque numbers.

More specifically to your example, in C++ check out Boost.Chrono.

• + At the very least, use a common type with a scaling or offset factor from a basis, much like the often maligned timezone. May 26, 2013 at 8:50

I personally wouldn't consider it good practice to create a constant unless it needs to be a constant. If its going to be in multiple places and having it defined at the top of the file for modification / or testing is going to be useful then absolutely.

If its just because its awkward to type ? then no.

Personally if I got someone else's code that had a constant defined, I generally consider this to be an important aspect of the code. E.g. tcp keep alive timers, maximum number of connections allowed. If I had to debug it I would probably pay a lot of unneeded attention to it trying to figure out why / where its being used.

• I get the joke but if bank programers had to make a constant for every number you could transfer the software would be gigantic, unmanageable and slow. I could only imagine what that would be like, imagine being told it would take 3 working days to transfer money to .... OH MY GOD, THATS IT!!! May 24, 2013 at 17:08
• My bank does take 3 days to transfer money :( May 24, 2013 at 17:14
• @MathewFoscarini bankers use Excel they do not need programmers ;) May 24, 2013 at 17:44
• @Simon Depending on language and compiler, constants should be optimized into the code, incurring little overhead. I understand your point, but constants can be used wherever using a name instead of a magic number would help code readability. May 24, 2013 at 20:31
• Awkward to read is much more of an issue than awkward to type.
– Alb
May 24, 2013 at 23:13

When you think about why you wrote "1 Billion" instead of "1000000000" in your question title, you'll realise why the answer is yes.

Do not create a constant for your big literals. You would need a constant for each such literal, which is (in my opinion) a complete joke. If you desperately need to make your literals clearer without the help of things like syntax highlighting, you could (though I would not) create functions or macros to make your life "easier":

``````#define SPLIT3(x, y, z) x##y##z

int largeNumber1 = SPLIT3(123,456,789);
int largeNumber2 = 123456789;
``````

I would do this:

``````const int Million = 1000 * 1000;
const int Billion = 1000 * Million;
``````

or

``` const int SciMega = 1000 * 1000; const int SciGiga = 1000 * SciMega; ```

Regarding number of nanoseconds per second: nano is the "inverse" of giga.

``````Kilo  Mega  Giga   etc.
10^3  10^6  10^9
Milli Micro Nano   etc.
10^-3 10^-6 10^-9
``````

Note the "Sci" - for scientific, as in computers, the meanings of kilo, mega, giga etc. are different: 1024 (2^10), 1024*1024 (2^20), etc. 2 megabytes is not 2,000,000 bytes.

UPDATE Commenter pointed out that special terms exist for digital exponents of 2: http://en.wikipedia.org/wiki/Mebibyte

• "2 megabytes is not 2,000,000 bytes." Ask any spinning-platter hard disk manufacturer you want. (Not the downvoter, btw.)
– user
May 26, 2013 at 14:13
• @michaelkjorling this is a programming question, not a business ethics or marketing one. I do agree about hard drives, but that's a different topic. And ouch about the down votes! May 27, 2013 at 14:46
• Actually, 2 Megabytes is 2,000,000 bytes. 2 Mebibytes is 2,097,152 bytes. See en.wikipedia.org/wiki/Mebibyte
– vy32
Jun 11, 2013 at 15:14
• @vy32 thanks, never heard of that before. Will update my answer to reflect that. Jun 11, 2013 at 17:14
• @Mr.TA, no problem! We're working hard to bring Computer Science into compliance with SI Units! Join the club.
– vy32
Jun 11, 2013 at 22:16