{"id":14100,"date":"2026-05-06T03:00:00","date_gmt":"2026-05-06T07:00:00","guid":{"rendered":"https:\/\/www.both.org\/?p=14100"},"modified":"2026-04-25T19:01:27","modified_gmt":"2026-04-25T23:01:27","slug":"5-things-to-know-when-learning-fortran-77","status":"publish","type":"post","link":"https:\/\/www.both.org\/?p=14100","title":{"rendered":"5 things to know when learning FORTRAN 77"},"content":{"rendered":"
\r\n
\r\n \r\n <\/i>\r\n <\/a>\r\n <\/span>\r\n<\/div><\/div>\n

When I was a physics undergraduate in the early 1990s, FORTRAN 77 was the standard programming language for scientific computing<\/em>. The Fortran 90 specification had just been published, but new compilers that supported the new standard were quite expensive, so FORTRAN 77 was what we learned. Every physics student at my university was required to learn FORTRAN 77 programming so we could write our own programs to help analyze lab data, such as numerical solutions to certain lab problems (like a circular pendulum under friction) that couldn’t otherwise be solved in a spreadsheet.<\/p>\n\n\n\n

By the time I graduated in the mid 1990s, I had picked up a few other programming languages, such as C for systems programming<\/em>. Since I didn’t go into a “lab” career, I assumed I would never write another FORTRAN 77 program.<\/p>\n\n\n\n

But what’s old is new again. A few years ago, I started seeing more posts from people who were curious to learn this “antique” programming language. And to be fair, FORTRAN 77 is quite old; each “iteration” of the language since FORTRAN 66 indicates the year the standard was adopted: FORTRAN 66 in 1966, FORTRAN 77 in 1977, Fortran 90 (with a new capitalization) in 1990, then Fortran 95, Fortran 2003, Fortran 2008, Fortran 2018, and Fortran 2023. I don’t know any of these more recent versions of Fortran, but I still remember a few things about FORTRAN 77 programming. If you’re interested in learning FORTRAN 77, here a few things to know:<\/p>\n\n\n\n

1. Programs are column sensitive<\/h2>\n\n\n\n

Original FORTRAN programs were loaded into a computer using a stack of punched cards<\/em>. These cards stored only 80 columns of text, which isn’t a lot. To get the most out of each “line” on a card, FORTRAN adopted a column specific syntax:<\/p>\n\n\n\n

    \n
  1. A *<\/code> or C<\/code> in column 1 is a comment<\/li>\n\n\n\n
  2. Otherwise, columns 1-5 are reserved for line labels (numbers only)<\/li>\n\n\n\n
  3. Almost any character in column 6 indicates a continuation<\/em> from the previous line<\/li>\n\n\n\n
  4. Columns 7-72 are for program statements<\/li>\n\n\n\n
  5. Columns 73 and beyond are ignored (these were reserved for card sorting<\/em>, to put a deck back into order if you dropped it)<\/li>\n<\/ol>\n\n\n\n
    \"Fortran
    A sample FORTRAN 77 punched card<\/figcaption><\/figure>\n\n\n\n

    FORTRAN 77 only recognizes upper case letters and a few standard symbols. For example, here’s a simple program that prints the text HELLO WORLD<\/code>, but splits the PRINT<\/code> instruction across two lines. This is a really awkward way to write this program, since the lines are so short they don’t need to be split, but it shows how to use continuation lines:<\/p>\n\n\n\n

          PROGRAM HELLO\nC PRINT A MESSAGE\n      PRINT *,\n     +'HELLO WORLD'\n      END<\/code><\/pre>\n\n\n\n
    Save this as hello.f<\/code> and compile it using a FORTRAN 77 compiler such as GNU Fortran on Linux or Open Watcom FORTRAN on FreeDOS. To install GNU Fortran, install the gcc-gfortran<\/strong> package. Compile the program like this:<\/p>\n\n\n\n
    $ gfortran -std=legacy -o hello hello.f<\/code><\/pre>\n\n\n\n
    The -std=legacy<\/code> command line option tells GNU Fortran to use the old-style FORTRAN syntax, which is what you need to compile FORTRAN 77 programs. This should give you a program called hello<\/strong> that you can run to print the text:<\/p>\n\n\n\n
    $ .\/hello\n HELLO WORLD<\/code><\/pre>\n\n\n\n
    2. DO<\/code> loops have a specific syntax<\/h2>\n\n\n\n
    One feature I actually really like in FORTRAN is the DO<\/code> loop. To me, it’s somewhat reminiscent of the for<\/code> loop in BASIC, but with a tidy syntax. To create a loop across a range of values, specify the start, end, and “step” values, separated by commas. The loop will execute between the DO<\/code> statement and the line label you indicate as part of the DO<\/code> statement.<\/p>\n\n\n\n
    Here’s an example program that counts the numbers from 2 to 10, counting “up” by 2:<\/p>\n\n\n\n
          PROGRAM COUNT\n      INTEGER I\n      DO 10 I = 2, 10, 2\n10    PRINT *, I\n      END<\/code><\/pre>\n\n\n\n
    If you save this as count.f<\/code>, compile it, and run it, you will see a list of numbers from 2 to 10, even numbers only:<\/p>\n\n\n\n
    $ gfortran -std=legacy -o count count.f\n$ .\/count\n           2\n           4\n           6\n           8\n          10<\/code><\/pre>\n\n\n\n
    3. There is no WHILE<\/code> loop<\/h2>\n\n\n\n
    FORTRAN 77 has very few loop structures. The DO<\/code> loop is the equivalent of the for<\/code> loop in other programming languages. One loop feature that’s missing in FORTRAN 77 is a while<\/code> loop. Instead, you have to “build” it yourself with a GOTO<\/code> statement.<\/p>\n\n\n\n
    For example, let’s rewrite the count.f<\/code> program to use a while<\/code>-like loop. In this kind of loop, the program starts<\/em> with a current value, and continues the loop only while<\/em> a condition is met. In this case, the “end” value should be less than or equal to 10:<\/p>\n\n\n\n
          PROGRAM WHILE\n      INTEGER I\n      I=2\n20    PRINT *, I\n      I=I+2\n      IF (I.LE.10) GOTO 20\n      END<\/code><\/pre>\n\n\n\n
    This has a few extra lines in it, but it otherwise does the same thing as the count.f<\/code> program. Note that it starts the I<\/code> variable with the value 2. Then the program prints the new value and increments I<\/code> by 2. If the I<\/code> variable is less than or equal to<\/em> (.LE.<\/code>) 2, then the program jumps back to line label 20, which prints the value. And so on until the program prints 10, then I<\/code> is incremented to 12, which no longer meets the IF<\/code> condition, so the program ends.<\/p>\n\n\n\n
    Save this program as while.f<\/code> and compile it to see the list of numbers from 2 to 10, even numbers only:<\/p>\n\n\n\n
    $ gfortran -std=legacy -o while while.f\n$ .\/while\n           2\n           4\n           6\n           8\n          10<\/code><\/pre>\n\n\n\n
    4. DOUBLE PRECISION<\/code> values are handy<\/h2>\n\n\n\n
    FORTRAN has the expected variable types like integers, floating point values, characters, and strings. These are useful in many kinds of programs. But as a physics student, we used FORTRAN 77 to perform lab analysis, and that required higher precision than REAL<\/code>, the standard floating point variable type.<\/p>\n\n\n\n
    Instead, we used DOUBLE PRECISION<\/code> variables. Since FORTRAN doesn’t treat spaces with any special value, you might also see this variable type written as one word: DOUBLEPRECISION<\/code>. Double precision variables look like floating point values, in that they have a decimal point, but you need to be careful. The calculation 1.0 \/ 3.0<\/code> to divide 1 by 3 is actually division between two REAL<\/code> values. To ensure that values are treated as DOUBLE PRECISION<\/code>, you need to add the D<\/code> exponent.<\/p>\n\n\n\n
    For example, for the number 100<\/strong>, you could also hand-write that as “1 x 10^2” or “1 times 10-squared.” Using “engineering” notation, you would type that as 1E2<\/code>, because the E<\/code>n<\/em> means “x 10^n”. To make that a DOUBLE PRECISION<\/code> value, replace E<\/code> with D<\/code>.<\/p>\n\n\n\n
    Here’s a short program that shows the same calculation for one-third, using REAL<\/code> and DOUBLE PRECISION<\/code> values:<\/p>\n\n\n\n
          PROGRAM THIRD\n      REAL A\n      DOUBLE PRECISION X\nC REAL VARIABLE CALCULATION\n      A = 1.0\n      A=A\/3.0\n      PRINT*,A\nC DOUBLE PRECISION VARIABLE CALCULATION\n      X = 1.0D0\n      X=X\/3.0D0\n      PRINT*,X\n      END<\/code><\/pre>\n\n\n\n
    Save this as third.f<\/code> and compile it using GNU Fortran. When you run the program, you’ll first see the one-third calculation as performed with REAL<\/code> values, then DOUBLE PRECISION<\/code> values. The results are slightly different:<\/p>\n\n\n\n
    $ gfortran -std=legacy -o third third.f\n$ .\/third\n  0.333333343\n  0.33333333333333331<\/code><\/pre>\n\n\n\n
    5. Formatted output with FORMAT<\/code><\/h2>\n\n\n\n
    Using the *<\/code> in the PRINT<\/code> statement indicates that the program should print values using a “default” format. That means REAL<\/code> and DOUBLE PRECISION<\/code> values will be printed using whatever number of decimal places the compiler chooses.<\/p>\n\n\n\n
    If you want more control over how your values are printed, use the FORMAT<\/code> statement. This is a special line in a FORTRAN program that doesn’t actually do anything, but is referenced<\/em> as the format that the PRINT<\/code> statement should use to print values.<\/p>\n\n\n\n
    Here’s the same one-third program, adding a FORMAT<\/code> statement. Note that FORMAT<\/code> statements can go anywhere in a program where you can otherwise use a program statement, but most programmers put them towards the end of a program:<\/p>\n\n\n\n
          PROGRAM THIRD\n      REAL A\n      DOUBLEPRECISION X\nC REAL VARIABLE CALCULATION\n      A = 1.0\n      A=A\/3.0\n      PRINT 99,A\nC DOUBLEPRECISION VARIABLE CALCULATION\n      X = 1.0D0\n      X=X\/3.0D0\n      PRINT 99,X\n99    FORMAT(F6.4)\n      END<\/code><\/pre>\n\n\n\n
    The F6.4<\/code> format specification says that this is a floating point<\/em> value that is 6 characters wide, with 4 digits after the decimal place. That means one-third should be printed as 0.3333<\/strong> because that’s 6 digits, with 4 digits after the decimal.<\/p>\n\n\n\n
    Save this new program as thirdf.f<\/code> and compile it to see the numbers printed using a formatted output:<\/p>\n\n\n\n
    $ gfortran -std=legacy -o thirdf thirdf.f\n$ .\/thirdf\n0.3333\n0.3333<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    FORTRAN 77 is an old programming language, but it can solve a lot of interesting math programs in a way that might be difficult in other programming languages. After all, the name literally means “for<\/strong>mula tran<\/strong>slation.”<\/p>\n\n\n\n
    And while there are more recent versions of the Fortran language, “retro programming” means that FORTRAN 77 has become popular again. Maybe it’s time you tried writing your first FORTRAN 77 program.<\/p>\n\n\n\n
    To learn more about the FORTRAN 77 programming language, check out Oracle’s complete FORTRAN 77 programming reference<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
    When I was a physics undergraduate in the early 1990s, FORTRAN 77 was the standard programming language for<\/p>\n","protected":false},"author":33,"featured_media":2803,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_lmt_disableupdate":"","_lmt_disable":"","footnotes":""},"categories":[798,5,150],"tags":[147,152],"class_list":["post-14100","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-fortran-77","category-linux","category-programming","tag-fun","tag-programming"],"modified_by":"Jim Hall","_links":{"self":[{"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts\/14100","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/users\/33"}],"replies":[{"embeddable":true,"href":"https:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=14100"}],"version-history":[{"count":2,"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts\/14100\/revisions"}],"predecessor-version":[{"id":14103,"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts\/14100\/revisions\/14103"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/media\/2803"}],"wp:attachment":[{"href":"https:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=14100"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=14100"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=14100"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}