{"id":14593,"date":"2026-09-14T01:00:00","date_gmt":"2026-09-14T05:00:00","guid":{"rendered":"https:\/\/www.both.org\/?p=14593"},"modified":"2026-09-05T11:43:43","modified_gmt":"2026-09-05T15:43:43","slug":"two-ways-to-write-portable-software","status":"publish","type":"post","link":"http:\/\/www.both.org\/?p=14593","title":{"rendered":"Two ways to write portable software"},"content":{"rendered":"
\r\n
\r\n \r\n <\/i>\r\n <\/a>\r\n <\/span>\r\n<\/div><\/div>\n

Linux runs on pretty much everything these days. And because it runs everywhere, you might be content to assume \u201call the world runs Linux.\u201d<\/p>\n\n\n\n

But when you\u2019re writing an open source app, you shouldn\u2019t make those assumptions. Your app might be intended<\/em> to run on Linux today, but your app will enjoy more popularity if it can also run on other Unix-like systems like BSD, or on non-Unix systems like FreeDOS.<\/p>\n\n\n\n

You could aim for the \u201clowest common denominator\u201d and only use the standard C library. But that\u2019s boring. These programs can only scroll from the bottom of the screen. What if your program could use platform-specific features like colors and windows?<\/p>\n\n\n\n

Let\u2019s look at two ways to write portable programs.<\/p>\n\n\n\n

Method 1: Check at compile-time<\/h2>\n\n\n\n

Let\u2019s say you wanted to write a number-guessing game, like \u201cguess the secret number from 1 to 10.\u201d That\u2019s a pretty simple program: generate a random secret number, and prompt the user to make a guess. At each guess, let the user know if their guess was too high or too low, and keep going until they guess the right number.<\/p>\n\n\n\n

If you\u2019re using the standard C library, you can generate a pseudo-random number using the rand<\/code> function. This is guaranteed to work on every system, because the random numbers are generated through software. To use it, you first need to seed<\/em> the random number generator with some value, such as the current time, then every call to rand<\/code> gives you a new pseudo-random value between 0 and some \u201cmaximum\u201d value. You can do a little math to make that a number between 1 and 10:<\/p>\n\n\n\n

    srand(time(NULL));\n    secret = rand() % 10 + 1;<\/code><\/pre>\n\n\n\n
On Linux, you can get a better random value by using the getrandom<\/code> system call. Instead of returning a random number, getrandom<\/code> actually fills a variable with random bits<\/em>, and that gives you a number:<\/p>\n\n\n\n
    unsigned char n;\n    getrandom(&n, sizeof(unsigned char), GRND_NONBLOCK);\n    secret = n % 10 + 1;<\/code><\/pre>\n\n\n\n
But if you use getrandom<\/code>, the program will only work on Linux. Other operating systems may not have this system call, or they may define it differently. Instead, if you wanted to write a program that worked for both Linux and non-Linux systems, you\u2019ll need a way to get the compiler<\/em> to do the work of adding the right code for you at compile-time<\/em>.<\/p>\n\n\n\n
You can do that using the #if<\/code> statement. This is actually a pre-processor<\/em> directive, so it gets used before<\/em> the code is compiled, which makes it a great way to conditionally include or exclude code when you compile your program.<\/p>\n\n\n\n
Compilers define a \u201cmacro\u201d or \u201cconstant\u201d that define what system you are compiling on. Linux systems use __linux__<\/code>. Other operating systems use something similar; check your compiler\u2019s documentation for what values it defines on your system. For example, DOS compilers usually define __DOS__<\/code> or __MSDOS__<\/code> because MS-DOS was the most popular DOS in the 1980s and 1990s.<\/p>\n\n\n\n
You can check if this constant is \u201cset\u201d on your system by using #if defined<\/code> with the macro name in parentheses. You can also use #elif<\/code> to mean \u201celse if,\u201d #else<\/code> as \u201celse,\u201d and #endif<\/code> to end the \u201cif\u201d tests. I recommend checking for specific value or operating system to include system-specific stuff, and using an #else<\/code> to provide some generic \u201cworks on everything\u201d solution. Here\u2019s an example, using a simple \u201cguess the number\u201d game:<\/p>\n\n\n\n
#include <stdio.h>\n\n#if defined(__linux__)\n#include <sys\/random.h>\n#else\n#include <stdlib.h>                    \/* rand *\/\n#include <time.h>                      \/* time *\/\n#endif\n\nint main()\n{\n    int secret, guess;\n\n#if defined(__linux__)\n    unsigned char n;\n    getrandom(&n, sizeof(unsigned char), GRND_NONBLOCK);\n    secret = n % 10 + 1;               \/* 1 to 10 *\/\n#else\n    srand(time(NULL));\n    secret = rand() % 10 + 1;          \/* 1 to 10 *\/\n#endif\n\n    puts(\"Guess the number from 1 to 10:\");\n\n    do {\n        fputs(\"Your guess? \", stdout);\n        scanf(\"%d\", &guess);\n\n        if (guess < secret) { puts(\"Too low\"); }\n        if (guess > secret) { puts(\"Too high\"); }\n    } while (guess != secret);\n\n    puts(\"That's right!\");\n    return 0;\n}<\/code><\/pre>\n\n\n\n
Note that the source uses #if<\/code> to check if the program is being compiled on Linux; if it is, the program uses the Linux-specific getrandom<\/code> system call. For all other operating systems (such as FreeDOS) the program uses the rand<\/code> function from the standard C library.<\/p>\n\n\n\n
That means you can compile one<\/em> source file to work on many<\/em> different systems. As an example, I compiled this program on Linux using GCC, and on FreeDOS using two compilers (the Open Watcom C compiler, and an older C compiler called BCC) to show that the program works as expected:<\/p>\n\n\n\n
linux$ gcc -Wall -o rand rand.c\n\nlinux$ .\/rand\nGuess the number from 1 to 10:\nYour guess? 5\nToo low\nYour guess? 8\nToo low\nYour guess? 10\nToo high\nYour guess? 9\nThat's right!<\/code><\/pre>\n\n\n\n
and:<\/p>\n\n\n\n
A:\\RAND>wcl -q rand.c\n\nA:\\RAND>rand\nGuess the number from 1 to 10:\nYour guess? 5\nToo high\nYour guess? 3\nToo high\nYour guess? 1\nThat's right!\n\nA:\\RAND>bcc -ansi -o rand.com rand.c\n\nA:\\RAND>rand.com\nGuess the number from 1 to 10:\nYour guess? 5\nToo high\nYour guess? 3\nToo high\nYour guess? 1\nToo low\nYour guess? 2\nThat's right!<\/code><\/pre>\n\n\n\n
Method 2: Isolate the system-specific stuff<\/h2>\n\n\n\n
If your program is more complicated than this, then #if<\/code> probably won\u2019t solve all of your portability problems. As an example, maybe your program uses a text-based interface<\/em> like curses<\/em> (or ncurses<\/em>). That\u2019s a big dependency that could make it difficult to compile your program on another system. For example, conio<\/em> on DOS operating systems is similar but different<\/em>.<\/p>\n\n\n\n
In this case, it will be better to split up some your source files, so you can isolate any \u201csystem-specific\u201d stuff to separate files.<\/p>\n\n\n\n
Let\u2019s use a simple example: a turn-based \u201csim\u201d game where the game prints the current \u201cstatus,\u201d then you make a choice, and the game iterates the next version of the sim. In a game like this, you might put the \u201ccore\u201d parts of the game in a file called main.c<\/code>, the game logic in game.c<\/code>, and any \u201cscreen control\u201d in a file like screen.c<\/code>.<\/p>\n\n\n\n
With this solution, you can now write separate<\/em> versions of the screen.c<\/code> source file: one that uses curses<\/em> (for Linux) and one that uses conio<\/em> (on DOS). The function interfaces are the same: start_screen<\/code> to set up the colors and create text windows, end_screen<\/code> to clean up after itself. And you might create functions that the game can use, like status<\/code> to print the sim\u2019s status and menu<\/code> to prompt the user. Function primitives<\/em> for these can be defined in screen.h<\/code>, which will be the same for Linux or DOS.<\/p>\n\n\n\n
With these assumptions, the main game could be quite simple:<\/p>\n\n\n\n
#include <stdio.h>\n\n#include \"game.h\"\n#include \"screen.h\"\n\nint main()\n{\n    if (start_screen() == 0) {\n        puts(\"cannot initialize screen\");\n        return 1;\n    }\n\n    if (start_game() == 0) {\n        puts(\"cannot start game\");\n        end_screen();\n        return 2;\n    }\n\n    do {\n        next_year();\n        status();\n    } while (menu() > 0);\n\n    end_game();\n    end_screen();\n\n    return 0;\n}<\/code><\/pre>\n\n\n\n
There\u2019s nothing platform-specific in this source file; this will compile equally well on all platforms. The same is true of game.c<\/code>, if it only contains game logic. It\u2019s only the screen.c<\/code> file that has any system-dependent features in it.<\/p>\n\n\n\n
I wrote a simple screen.c<\/code> for DOS and Linux to demonstrate this. I don\u2019t think I need to share the source code here, but you can learn about conio<\/em> and curses<\/em> programming in these articles, also at Both.org: a gentle introduction to ncurses<\/a> or write directly to the screen with DOS conio<\/a>.<\/p>\n\n\n\n
On DOS, start_screen<\/code> would probably initialize the conio<\/em> library and set up a few text windows, end_screen<\/code> would return the screen to normal mode, status<\/code> would display the game\u2019s current stats in a text window, and menu<\/code> would use another text window to present a menu and prompt for an action.<\/p>\n\n\n\n
\"a
A sim game, using conio on FreeDOS<\/figcaption><\/figure>\n\n\n\n
On Linux (or some other Unix-like operating system), start_screen<\/code> and end_screen<\/code> would instead use the curses<\/em> or ncurses<\/em> library to check that the terminal is large enough to play the game, and define some text windows. The status<\/code> function would use a text window to show the sim\u2019s stats, while menu<\/code> would show a menu in a different text window and let the user select an action.<\/p>\n\n\n\n
\"a
The same sim, using curses on Linux<\/figcaption><\/figure>\n\n\n\n
With a little extra creativity, you could write a different screen.c<\/code> source file to support a graphical environment. I\u2019ll leave that up to you.<\/p>\n\n\n\n
Make it flexible<\/h2>\n\n\n\n
Not every Unix-like system is Linux. If you\u2019re writing a Linux program today, it might run on something else tomorrow. So it\u2019s important for open source developers to always keep an eye to how to write programs that will run on as many systems as possible.<\/p>\n","protected":false},"excerpt":{"rendered":"
Make sure your programs will compile across different programs.<\/p>\n","protected":false},"author":33,"featured_media":2949,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_lmt_disableupdate":"","_lmt_disable":"","footnotes":"","_members_access_role":[],"_members_access_error":""},"categories":[5,610,150,642],"tags":[267,91,152],"class_list":["post-14593","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-linux","category-portability","category-programming","category-software","tag-freedos","tag-linux","tag-programming"],"modified_by":"Jim Hall","_links":{"self":[{"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts\/14593","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/users\/33"}],"replies":[{"embeddable":true,"href":"http:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=14593"}],"version-history":[{"count":1,"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts\/14593\/revisions"}],"predecessor-version":[{"id":14595,"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts\/14593\/revisions\/14595"}],"wp:featuredmedia":[{"embeddable":true,"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/media\/2949"}],"wp:attachment":[{"href":"http:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=14593"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=14593"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=14593"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}