Follow Slashdot stories on Twitter

 



Forgot your password?
typodupeerror
×
Programming IT Technology

Fortran 2000 Committee Draft 274

Richard Maine writes "John Reid, convenor of the ISO Fortran standards comittee, has posted the following announcement to some Fortran-related forums: 'I am pleased to tell you that the draft Fortran 2000 standard is now out for comment. ... The J3 (USA Fortran committee) version, which is identical except for the title page and the headers and footers, is available in ps, pdf, text, or source (latex). This is a very significant milestone for Fortran 2000. It is a major extension of Fortran 95 that has required a significant amount of development work by the J3. ... The abstract of the revision, which lists the major enhancements is appended. I have written an informal description of the new features, which will be published in the next issue of Fortran Forum (about to appear).'"

The formal position is that a CD (Committee Draft) Registration and Approval Ballot is in progress. The deadline for comments (from national bodies) is 27 December. Each national body will have its own deadline ahead of 27 December, so be sure to submit your personal comments to your national body well before then. For the USA, they should be sent to Deborah Donovan, email: ddonovan@itic.org. For the UK, they should be sent to David Muxworthy, email: d.muxworthy@ed.ac.uk.

John Reid, ISO/IEC JTC1/SC22/WG5 Convener

.................................................. ......................

ISO/IEC JTC1/SC22/WG5 N1494

Committee Draft revision of ISO/IEC 1539-1:1997 - Programming Language Fortran - Part 1: Base language

Abstract

Fortran is a computer language for scientific and technical programming that is tailored for efficient run-time execution on a wide variety of processors. It was first standardized in 1966 and the standard has since been revised three times (1978, 1991, 1997). The revision of 1991 was major and those of 1978 and 1997 were relatively minor. This proposed fourth revision is major and has been made following a meeting of ISO/IEC JTC1/SC22/WG5 in 1997 that considered all the requirements of users, as expressed through their national bodies.

The significant enhancements in the 1991 revision were dynamic storage, structures, derived types, pointers, type parameterization, modules, and array language. The main thrust of the 1997 revision was in connection with alignment with HPF (High Performance Fortran).

The major enhancements for this revision are

(1) Derived type enhancements: parameterized derived types, improved control of accessibility, improved structure constructors, and finalizers.

(2) Object oriented programming support: type extension and inheritance, polymorphism, dynamic type allocation, and type-bound procedures.

(3) Data manipulation enhancements: allocatable components, deferred type parameters, VOLATILE attribute, explicit type specification in array constructors, pointer enhancements, extended initialization expressions, and enhanced intrinsic procedures.

(4) Input/output enhancements: asynchronous transfer, stream access, user specified transfer operations for derived types, user specified control of rounding during format conversions, named constants for preconnected units, the flush statement, regularization of keywords, and access to error messages.

(5) Procedure pointers.

(6) Support for IEC 60559 (IEEE 754) exceptions.

(7) Interoperability with the C programming language.

(8) Support for international usage: access to ISO 10646 4-byte characters and choice of decimal or comma in numeric formatted input/output.

(9) Enhanced integration with the host operating system: access to command line arguments, environment variables, and processor error messages.

In addition, there are numerous minor enhancements.

Except in extremely minor ways, this revision is upwards compatible with the current standard, that is, a program that conforms to the present standard will conform to the revised standard.

The enhancements are in response to demands from users and will keep Fortran appropriate for the needs of present-day programmers without losing the vast investment in existing programs.

This discussion has been archived. No new comments can be posted.

Fortran 2000 Committee Draft

Comments Filter:
  • by selderrr ( 523988 ) on Friday October 04, 2002 @09:02AM (#4386657) Journal
    available in ps, pdf, text, or source (latex).

    Now who says Fortran is not a sexy language ?? hum ?
  • by beanerspace ( 443710 ) on Friday October 04, 2002 @09:05AM (#4386675) Homepage
    As a programmer who cut his teeth on good-old K&R C back in the 80's and has been fortunate/unfortunate enough to avoid shooting himself in the foot [healyourch...ebsite.com] with Fortran and/or Cobol ... I have 2 questions?
    1. What are the compelling reasons to use Fortran in 2002?
    2. Do they differ much from the use of Fortran in the past?
    3. Is it the same language as the Fortran of prior decades?
    4. Can someone summarize without the tech-eze the future of Fortran - especially in light of the aforementioned Fortran 2000 Committee Draft?

    Just curious I guess.
    • It is still being used in structural analysis tools. These old fortran programs run and run well. Libraries of stuff have been built long ago and they just work. Sure, C is great, but for running simulations which are 2 days long on a Cray, Fortran can't be beat.

    • I have 2 questions? 1. ..
      2. ..
      3. ..
      4. ..

      I think you have a bigger problem.
    • There is one compelling reason for using Fortran still: the set of available libraries. By libraries, I do not mean generic libraries to connect to databases, or to parse XML, or such, but libraries that say, simulate the chemistry of gases in the atmosphere, and so on.

      The main pain with such libraries is the amount of effort that goes on into debugging and evaluating the code. In case of many Fortran libraries for numerical analysis, a lot of that work is already done. While, porting it to C/C++ or Java appears trivial (in most cases it is also not trivial), doing the QA involves unacceptable costs.

      There is also a thing or two to be said about the speeds, which many folks have noted.

      S
    • by /ASCII ( 86998 ) on Friday October 04, 2002 @09:20AM (#4386750) Homepage
      Fortran is NOT the same language as in prior decades. Some differences:
      • Fortran77 and earlier where made for punchcard machines. Incorrect indentation caued lines to be treated as comments, variable declarations or something other than what was intended.
      • For the same reason, anything past character 73 was a comment in Fortran77.
      • Fortran allows dynamic memory allocation nowdays.
      • Global variables don't use the hideous common block

      The list goes on and on, but these are changes that where implemented in Fortran90. Since then, attepts have been made to turn Fortran into an OO language. Aid i18n and other things to make Fortran less of a CS language.

      The reason you might want to try out Fortran is because of speed. Under gcc/Linux C may be the fastest language, but under Solaris, Irix, AIX and other oldschool OSes, Fortran is still speed king, for two reasons.

      Firstly, the Fortran compilers are well tuned mature products under these platforms.

      Secondly, the Fortran language makes all kinds of assumptions that the programmer must adhere to. Example: If a function recives two arrays, they must not overlap. This allows Fortran compilers to do loop unrolling in cases where a C-compiler cannot.

      • Fortran is NOT the same language as in prior decades. Some differences:
        • Fortran77 and earlier where made for punchcard machines. Incorrect indentation caued lines to be treated as comments, variable declarations or something other than what was intended.
        • For the same reason, anything past character 73 was a comment in Fortran77.
        • Fortran allows dynamic memory allocation nowdays.
        • Global variables don't use the hideous common block
        Gee, I used FORTRAN 77 on VAXes through most of the early to mid 80s and we:
        • Didn't use punch cards: VT100s baby
        • Only comments and statement numbers had fixed columns: you're thinking of FORTRAN IV.
        • Clarification: 1 through 72 code, 73 through 80 were comments.
        • Dynamic memory allocation existed as a DEC extension to VAX FORTRAN. Lots of other hardware manufacturers provided the same capability, it just wasn't standard.
        • ...and explain to me the difference between a global variable and a variable in a common block.
        Also, last I checked (admitedly a while ago), FORTRAN under Linux gcc was translated to C for compilation.
      • Blitz's benchmarks [oonumerics.org] show that Fortran isn't quite the speed king you imply it is. As they show Blitz++ does more aggressive loop unrolling than Fortran. The main performance bottleneck seems to be that Blitz++ doesn't do loop jamming, although they show there are circumstances in which loop jamming makes the Fortran compilers slower. The moral of the story: benchmark, never assume.

        Fortran may be faster for your particular application. But it may be slower. If performance is that important then you have to write both and benchmark them. If performance isn't that important then other considerations (availability of libraries) dominate.
    • by vi-rocks ( 611108 ) on Friday October 04, 2002 @09:24AM (#4386770) Homepage
      What are the compelling reasons to use Fortran in 2002?

      Fortran is still used quite a bit in scientific and engineering circles. There is a HUGE code base that people (understandably) do not want to give up. I spent three years in the mid-90's developing groundwater numerical models with Fortran90.

      Some reasearch instutituions and software development companies have starting using C; however, mainly for pre- and post-processors. Many are still using Fortran numerical engines.

      Another reason that Fortran was still popular (at least through the 90's) was that some of the major compilers (Such as IBMs Fortran complier) ROCKED. Some simulations that I was working on took weeks to peform and the compliers were very good at optimizing the Fortran code -- without the scientist getting too close to the hardware.

      I must admit; however, that today all my programming is either done in C, Objective-C, or Perl -- even though gcc will compile Fortran code. (Can you believe I wrote a postscript driver for printing evelopes on our lab's printer in Fortran! )

    • A lot of the human genome mapping stuff was written in Fortran. I knew one of the guys who was working on it (in Cambridge - UK, not MA!)

      Loadsa stuff on Fortran and genome mapping here [mathtools.net] This site has thousands of contemporary applications of Fortran. Just follow the link back up ...

    • Let me somewhat answer w/ what I know from the basis of Fortran '90; I haven't seen anything specific on 2000. Where I work (large aerospace industry company) all the Fortran code is still the old-school stuff (F'77... or older); there's so much of it, and it uses so many anachronisms and non-ANSI (machine and/or compiler dependent tricks / hacks / bugs / unknown evil things) code constructs that the majority of it just *cannot* even be ported to '90. (I know... I tried porting a rather small thing over to only compile with the new compiler, and all the output was way, way wrong, owing to an unknown issue that I didn't have the skill and the boss didn't have the money to chase.)

      Now, F'90 didn't have true OO in it; it had just introduced "MODULE"s, and for those couple of us rebellious "young'uns" that embraced it, '90 was far and away better. I'm personally a big fan of more complete OO programming, but the bosses and supervisors here just cannot comprehend what it even is. (I've tried to explain it several times... their perspective, and perhaps refusal to learn from someone half their age, prevents their understanding at why OO is, generally, a Good Thing). Are the current Fortran languages similar? Well, in the sense that C++ is (or can be) similar to C, then yes... assuming you only code to the bits that you understand. But doing so really defeats the whole purpose of having revised the language.

      For my $0.02, with where Fortran seems to be trying to head (not that I've read the referenced draft; I haven't), we might as well write and compile with C++; the vaunted speed advantage starts bleeding away with (direct or indirect) access to pointers and other things, and my experience here the past several years is that said speed difference is mainly a function of the quality of the compiler anyway. (And ours sucks big hairy ones, and I won't say which one it is.)

      The biggest insurmountable hurdle here is that Fortran now-a-days is really only *used* in the scientific community, and, by and large, such community is less concerned with staying up with the new learning curve of programming practices and more concerned with getting the next thing done. (For a humorous semi-related example of this, consider our recent "port" of a well-used CFD code into Fortran '90... we changed the make file to use "f90" rather than "f77" and made sure it still compiled... huzzah! we now have a Fortran '90 program *cough*NOT*cough*...)
    • This reminds me of an old joke I heard in College:

      What will Fortran look like 10 years from now?
      Who knows? But no matter what it looks like they'll still call it Fortran...

      OK, not exactly a rimshot joke

    • Q: What programming language will engineers use in 50 years?

      A: I don't know, but they will call it Fortran.
    • Fortran has some notable advantages over C. Perhaps the most latent advantage is in the realm of multi-processing. For example there are several statments that give the compiler big hints that the loop can be spread out. For example there is loop command that is like a FOR loop but specifically says the order of the loop evaluation does not matter. Other looping commands tell the computer to apply a function over an entire array at all positions specified in a map. Function declarations tell the compiler if a variable/array in the arg list will be altered by the function call. There are delberate limits on pointer type variables that forbid pointer arithmatic and allow compiler efficiencies. As a result fortran is a marvelous multi-processing language because the compiler knows how to allocate instructions safely and how to allocate memory optimally.
  • "I don't know what programming language we're going to be using in 2000, but it's going to be called Fortran."

    Ok, so we're not all using Fortran any more, but it isn't completely dead -- or rather, the language which is *now* called "Fortran" isn't completely dead, even though it has little in common with the original "Fortran" beyond the name.
    • Re:As they say... (Score:4, Interesting)

      by DaveAtFraud ( 460127 ) on Friday October 04, 2002 @10:43AM (#4387275) Homepage Journal
      The original quote appeared in an issue of Scientific American that came out in the late 1990s. The article was on, you guessed it, the amazing longevity of FORTRAN. The bottom line is that there are a fantastic number of huge FORTRAN libraries out in the real world for doing all sorts of number crunching. The libraries are well understood, any bad behavior at boundary conditions is documented and they have a lot of milage on them so the results are generally regarded as valid. It makes far more sense to keep something called FORTRAN around that is compatible with this code than is does to attempt to re-write and re-test.

      Oh, and no one cares that there isn't a pretty GUI interface to programs for analyzing structural stress, heat flow analysis, doing x-ray crystalography, etc.
    • Maybe so. I'm kind of glad we're not stuck with the original C, or McCarthy's first version of Lisp. Both of those were pretty weak compared to ANSI C and Common Lisp. :)

      It's interesting to see Fortran continue to evolve. Evidently a lot of people like it, for one reason or another.

      Yet another language added to my list of things to learn at some point. :)

      -John
  • Need a GNU version (Score:4, Insightful)

    by alexhmit01 ( 104757 ) on Friday October 04, 2002 @09:08AM (#4386686)
    I had to learn F77 for a class my freshman year (1997, not THAT long ago) and we were working with F77. A part of that appeared to be because there were free compilers. Since most Fortran code is done in research groups that aren't computer groups, they may not all think to buy a real compiler.

    A Free F2000 compiler - that researchers here about - would go a long way towards getting Fortran coders into Fortran 2000.

    My understanding is that F95 and now F00 (or whatever) are "modern" langugages.

    Amazing what you can do WITH backwards compatibility if you put energy into it.

    Alex
    • by Shimbo ( 100005 )
      A Free F2000 compiler - that researchers here about - would go a long way towards getting Fortran coders into Fortran 2000.

      Yeah, trouble is a modern Fortran compiler is both hard to write and about as unsexy as it gets in the GNU/Linux world. Which is sad because the language is dismissed by folks who should know better, based on syntax that was obsolete even in F77.


      Now we can return to the: I haven't used Fortran for 25 years, has anything changed posts? And why doesn't someone write an OO language based on C?

    • GNU already provides a compiler for Fortran77 - it's part of the gcc collection. There's also a drive to release a Fortran95 compiler [gnu.org].

    • and is hosted right over at g95.sourceforge.net. Take a look.

  • I'll start by admitting that I have little experience with fortran and with the applications thereof.

    That being said, what experience I do have is that fortran is excessively difficult to write and lacking in some of the basic features I'd expect a programming language (I'm not familiar with fortran 95, but fortran 77 ::shudder:: doesn't support recursion, lexical scoping, etc., to my knowledge)

    I can understand teaching fortran 77 to allow people do program for old interfaces and deal with the old code that would be expensive to rewrite, but why would you revise fortran to make it more usable? Why not just use C?

    Perhaps I'm missing something, but I think fortran should not be taught in college (it is required for some majors here) except in the context of the historical significance of fortran.
    • Because Fortran 90, for example, is one of
      the most parallelizable languages right now
      that support automatic parallelization to
      many CPUs.
      Because a lot of numeric libraries are available for that language.
      Because it's a lot easier to write numeric calculation programs on Fortran.
  • by tibbetts ( 7769 ) <jason@tibb3.1415926etts.net minus pi> on Friday October 04, 2002 @09:15AM (#4386721) Homepage Journal

    For those of us under 50, here's some history of the granddaddy of all high-level programming languages.

    IIRC, my former graduate advisor and professor [iit.edu] was on the team that wrote a very early Fortran compilers at MIT [mit.edu] in the late 50s, written entirely on punch cards [fireinthevalley.com]. We've come a long way in ~50 years.

    • I'd call COBOL the grandaddy of high level languages. FLOWMATIC, which evolved into COBOL, was started in 1952 by Grace Hopper, which makes it about 2 years older than FORTRAN.
  • Damn! It takes a long time to compile Fortran... It's been two years already... And this is just a Draft!

  • This reminds me of a couple years ago when our AS/400 RPG programming group went to a users group meeting and found out about a "new" command which will finally allows them to manipulate dates as dates in RPG, not numbers!

    The really shocking part was the function had been part of their language for over 5 years. Imagine if my Java skills were 5 years out of date. I would be making flaming applets on webpages thinking that was advanced.

    In Fortran's favor, I do hear many people still use it today and it has plenty of good uses. I would like to know whether it really does, or whether the people who say that have their head in the sand. I am young enough to have missed most things Fortran, starting my programming with exposure with QBASIC then Pascal as my learning labguages.

    -Pete
    • Re:Goodie! (Score:2, Interesting)

      There are a lot of factories out running FORTRAN, usually on DEC/COMPAQ/HP OpenVMS systems to do plant floor control. I just ported an OpenVMS system to Windows 2000, about 1/3 of the code is FORTRAN. (Why not Linux you ask, because Linux does not have "events" like OpenVMS and Windows 2000 have. Given the extra time it would have taken to change the structure of the code, it was cheaper to buy Windows. Actually my customer would have prefered Linux.)
  • So, someone's finally noticed that using a souped-up version of BASIC for writing mission-critical numerical code is a bad idea. :)

    However, it's likely that most programmers who needed features such as inheritence, polymorphism, function pointers and so on have already bitten the bullet and moved to a C++ environment; trading off some gripes about the "standard implicit type conversions" (spit) for the increase in modularity, interoperability, etc. Introducing such features into the Fortran language now isn't going to re-write thirty years of pre-F2000 code. It feels like we're going to end up with "VB for scientists"at this rate!
    But the real reason that so many people still stubbornly use Fortran is *performance*. Because the language is so much simpler (i.e. less expressive) than C or Java, it's hell of a lot easier to perform optimisations on it. Good Fortran compilers can re-arrange loop nests and do all sorts of clever stuff to improve parallelism, locality, and other aspects of performance. Add expressiveness (in the form of pointers, for example) and you add many extra complications which can render the optimisations invalid. If you can't optimise it as aggressively as you used to, you've just lost the penultimate excuse that anyone is still writing in Fortran. (The last excuse is that the 500,000 line codebase they're working on is also written in Fortran :-)).

    Now I'm sure that lots of professional users and compiler writers have been involved in drafting the new standard, and that these concerns have been addressed. But I still reckon that Fortran needs euthanasia, not resurrection!

    There, my 2p is now your 2p :)
  • by dannyp ( 62358 ) on Friday October 04, 2002 @09:35AM (#4386826)
    How many /.-ers have ever written anything in Fortran? Sounds like a poll topic to me.....
    • I did, at university. Fortran 77. First in 1993-1994 as general introduction to programming (my study was not CS-oriented).

      And a few years later, in 1996-1997 to run some very simple simulations concerning ... ahum ... don't even remember ... it had something to do with physicochemics.
      Amazingly, I failed the exam, due to a combination of circumstances:

      • I had been practicing on my Pentium (100 MHz), which compiled the programs in a few seconds, using a decent editor
      • The assignment asked for a combination of two existing programs (we were provided with a small library of existing programs at the exam)
      • I wanted to copy-and-paste the two programs into one
      • The only editor on the PC didn't allow that (!)
      • I managed to combine them, but it resulted in a number of compilation errors
      • The damn PC was very slow: a compilation took over 5 minutes, during which I could do nothing else (it was running MS-DOS...)
      • There wasn't enough time fix all the bugs
      • 2 minutes before deadline, I saw the light: I was supposed to change a few numbers in the first program, let it run, note the output, use it as input into the second program and be done
      • 2 minutes was not enough to implement it that way (remember the slow compilation times)
      • I didn't see that solution at first because writing down a number on paper as a means of IPC is against my principles
    • I had to for my final year project at uni. I wasn't allowed to use C, and I had to write standards-compliant F77 i.e. with none of the convenient extensions. The program was to look for structure in simulated collapsing gas clouds in the intertellar medium, i.e. to look for protostars. I ended up having to implement a doubly linked list and binary trees inside (static) arrays. It was a miracle it worked. After learning C, going to FORTRAN was hell. You can see where early 80s microcomputer BASICs came from when you are reduced to writing FORTRAN-77, only the source formatting is worse...
    • As a physicist, I've written most of my scientific code in F90. It's far from a dead language. I agree with many people that F77 is a horrible mess, but F90 and later versions are excellent for scientific stuff, for example if you consider array handling features.

      The long history of FORTRAN (sic) means a large base of scientific libraries. This is also something that prevents switching to C[++] overnight. In fact I'd much prefer using F90+ for all low level code.

    • Yo. I have written a genetic algorithm for minimizing cluster energies in F95. I've written various utilities for my theoretical chemistry work in F95, e.g., a program for doing reflection-principle spectra from ab initio calculations.

      Also, (almost?) all major quantum chemistry programs are written in Fortran (usually FORTRAN77), so whenever I need to hack the programs to correct the output, or give me something new, you must do it in Fortran.
    • Excised from my resume long ago:

      1980 to 1981 - Missile Applicatiopn Program - Timing and Resolution: optimize launch times for ICBMs and SLBMs to minize launch interval and probability of conflicting arrival. (IBM FORTRAN)
      1981 to 1982 - Missile Application Program - MIRV Domain Generation: provide interactive planning tool for assigning MIRVed missiles to targets. (IBM FORTRAN)
      1983 (early) - Can't talk about it but FORTRAN
      1983 - 1985 - Over-the-horizon Backscatter (OTH-B) Radar: Track History Programs (DEC FORTRAN 77)
      1985 - 1987 - Relocatable Over-the-horizon Radar (ROTH-R): Detection and Tracking related programs (DEC FORTRAN 77)

      Then I got to start writing stuff using Ada.
    • I wrote (well, wrote most of) the engine module for an F-16 flight simulator. All in Fortran 77. Did a bunch of work on the simexec, too, which was in Ada 83.

      I'm conflicted. I'm not sure if I'm bragging, or confessing.
    • I wrote a Turing machine simulator, a lexical analyzer (actually more of a weighted million monkeys simulator), and a card game in fortran, between 1978 and 1979. I wrote my own random number generator also. My programs worked on the compiler in the Burroughs B6700 and the Microsoft compiler for TRS-80 Model I. Somewhere I have all this on paper tape, printouts, and 5.25" floppies.

  • haiku

    with due diligence
    we draft fortran 2000;
    what? new century?

    /haiku
  • Could someone please explain how FORTRAN 2000 is different from Ada? Or PL/I for that matter? Talk about extending something past the point of its intended use until it reaches escape velocity from reality...

    sPh

    • Well, for starters, Fortran 2000 is different than Ada and PL/I in that it will be backwards compatible with F90, allowing the MILLIONS of lines of F90 code in production to move forward.

      Secondly, in FEA and CAD there are always big pushes to migrate to C++ or another 'modern' language, only to be rejected because standard C/C++ math libraries aren't fast enough for high-end sci apps (HUGE matrix operations, millions+ DOF models, weather prediction, etc.), or, at least the performance/efficiency gains aren't good enough to warrant migration. Not to mention there are a scary number of MechE's and other scientists out there who think that FORTRAN is the only extant language. ;-)

      • Well, for starters, Fortran 2000 is different than Ada and PL/I in that it will be backwards compatible with F90, allowing the MILLIONS of lines of F90 code in production to move forward.
        Mind you, this is all tongue in cheek. No language wars needed today!

        But IRRC, a PL/I compiler will compile FORTRAN 66 code with no complaints.

        sPh

        • But IRRC, a PL/I compiler will compile FORTRAN 66 code with no complaints.

          A PL/I compiler will compile Befunge code with no complaints :-). An amazing language -- if you can put two tokens together, the language design committee probably assigned them a meaning.

          (But not one which makes sense of Befunge, of course. :-)

          -Billy
          • Well, when one chooses to use a 200-blade Swiss Army Knife, one takes one's chances!

            But seriously, I believe it is actually part of the design spec of PL/I that it compile FORTRAN 66 "decks" correctly. Of course, we know now how well that little marketing trick worked out.

            sPh

  • As someone who writes Fortran 95 that has to be portable between two Intel Linux boxes (one w/NAG fortran on with Intels), and an OSF1 with Digital FORTRAN, standardised exception/signal handling [not just IEEE_FPE] would make my life soooo easy right now (the DEC one is great [ie Just Like C], the rest are ugly/nonexistent [or, at least, I can't find'em]).

    Actually, can I turn this into an AskSlashdot - Are there any really portable methods for doing exception handling in F95?
  • Fortran isn't entirely dead. At least to the scientific community. I am a Fortran programmer, working at in a research position and I'm not 50 years old, I'm not even 20. (Yeah for co-op)

    Truthfully, anything that Fortran can do, C can do better. But that wasn't always the case. Fortran used to be A1 for number crunching, and thus is used and still used by many research companies. Sometimes, if you don't have a CS degree its just easier to use the language you learned when you were in University or College than spend the time learning C or Java.

    Some older satellites (8-15yrs) used Fortran code. And if those satellites are still in the sky, (which they are) then those persons working on keeping and updating them need to use good 'ol Fortran to keep them up in the sky.

    Each 'new' version of Fortran tries to get a little bit more object-oriented than the last. At the moment I use both 77 and 90 (neither are object oriented). Fortran also has the lovely feature of GO TO!

    Fortran will probably be used for awhile longer. Even with .Net. Try it some time, its a rather amusing little language.
    • Truthfully, anything that Fortran can do, C can do better. But that wasn't always the case. Fortran used to be A1 for number crunching, and thus is used and still used by many research companies.
      Well, I don't know about that. I hate, hate, hate, hate, hate, hate using arrays in C. Hate. It is probably second only to Perl for the uselessness of its arrays. And since I usually deal with complex numbers, C is even worse. Finally, the libraries' numerical routines for C aren't as good as those for Fortran, in my opinion.
  • by tommck ( 69750 ) on Friday October 04, 2002 @10:25AM (#4387136) Homepage
    That's the sound of a club hitting a bloated sack of rotting protoplasm that used to be a dead horse back in 1985
    </sarcasm>

    T

  • I have written an informal description of the new features

    Which this margin is unfortunately too small to contain.
  • Fortan Rocks!! (Score:2, Insightful)

    by Lil'wombat ( 233322 )
    Back in my grad school days (5 yrs ago) everyone who had supercomputer time was writing in FORTRAN. Just ask yourself, do you want to write a new optimized routine to compute the Cholesky decomposition of a positive definite matrix for a sparse matrix and store the resulting sparse matrix in band compressed form so that you can increase your grid size from 5k to 20k elements -OR- do you grab the linpack routines from http://www.netlib.org/linpack and go have a beer.

    At the University of Minnesota beer usually won.
    • Re:Fortan Rocks!! (Score:4, Insightful)

      by aallan ( 68633 ) <alasdair@bab[ ]m.co.uk ['ili' in gap]> on Friday October 04, 2002 @12:17PM (#4387940) Homepage

      Back in my grad school days (5 yrs ago) everyone who had supercomputer time was writing in FORTRAN.

      Amoungst physicists and astronomers, anyone with supercomputer time today is still writing in FORTRAN. I don't see that changing in the near future. Graduate students are starting to write in different languages, but to talk to their superivsors (the guys with large existing codebases) they have to be able to talk and write FORTRAN.

      Most of the time its not worth their time to port a couple of hundred thousand lines of modelling code to some other language before they can add layers on top, its unlikely it'll ever be worth anyones time to do somethnig like that.

      A lot of the Java, Perl/Tk and Python/Tkinter stuff I write these days is sitting ontop of a whole bunch of FORTRAN that it would take the next twenty years to rewrite. If it works, whats the point of doing it all again? Thats no fun...

      I think language interoperability is becoming more and more important now the industry is (sort of) maturing. This is where code reuse in the real world is going to come from, rather than the current fads in code design which keep on promising more code reuse.

      Al.
    • Actually, these days you grab the LAPACK routines instead of linpack. But if you like C++, MTL is about as fast as lapack.
  • by vrmlguy ( 120854 ) <samwyse@NOSPAm.gmail.com> on Friday October 04, 2002 @10:49AM (#4387318) Homepage Journal
    I went to college in the mid 70's. We learned (essentially) Fortran 77, although it wasn't called that then. F77 didn't have a very formal standardization process, it was just the collecting of extensions that several vendors (mostly IBM) had made to F66.

    F77 was a cool language. IIRC, the original version of Adventure Cave used an interpreter that was written in F77. It is also one of the few languages that have native support for imaginary numbers (some versions of APL did as well).

    Looking at the summary of changes, I suspect that they've finally messed up the things that made FORTRAN (or at least F77) great. The addition of pointers stands an excellent chance of rendering code un-optimizable, and I fear that adding OO features is an even bigger mistake. I would have liked to have seen Unicode support and exception handling, and that's about it.

    • Looking at the summary of changes, I suspect that they've finally messed up the things that made FORTRAN (or at least F77) great. The addition of pointers stands an excellent chance of rendering code un-optimizable, and I fear that adding OO features is an even bigger mistake.

      FORTRAN went OO during with Fortran90 and pointers were added with Fortran95, although for anyone used to C pointers, Fortran95 pointers are (erm) pretty wierd...

      Al.
    • IIRC, the original version of Adventure Cave used an interpreter that was written in F77.
      Some ports might have used F77, but ADVENT was originally written on a DECsystem-10 using Fortran-10, which was DEC's implementation of FORTRAN 66. The original code is available in the Interactive Fiction Archive [ifarchive.org]; there are two versions ever so slightly different, adv350-pdp10.tar.gz and advent-original.tar.gz. I'm not certain which was earlier, though one of them has some messages in mixed case, so that is probably later. All others can be traced back to one of these.

      String handling in FORTRAN 66 was not very portable. On the DECsystem-10, five ASCII characters were stored per word. This was the biggest hassle in porting to another platform.

      • Yeah, you're probably right about ADVENT using Fortran-10. I remembered that it used extensions to F66, and assumed that it was F77. After I had posted, I wished that I had mentioned DEC along with IBM as contributing ideas to F77. I compiled ADVENT on an IBM mainframe using F77, and it required minimal hacking to get it to run.

        ADVENT was pretty portable, though, in spite of the string handling. For player commands, ADVENT used it's own, non-ASCII, character encoding that fit six characters into a pair of 16-bit values. This meant that even with the source code, you couldn't make heads or tails of the table containing all the verbs, so you didn't know what actions were available to you.

        • For player commands, ADVENT used it's own, non-ASCII, character encoding that fit six characters into a pair of 16-bit values.
          You must have started from a PDP-11 port, because that was a common encoding on the PDP-11 (called "RAD50"), but the original PDP-10 version certainly didn't store them that way. They were stored five seven-bit ASCII characters to a machine word (36 bits), which is why the player commands had only five significant characters and the game couldn't tell "NORTHEAST" from "NORTH" (you had to use "NE").

          The PDP-11 version was probably more portable than the original PDP-10 version.

  • But what about the BIG question?

    When and why did the name change from "FORTRAN" (all uppercase, preferably with a slash across the letter O) to "Fortran" (mixed-case)?

    Indeed, since the name means Formula Translation, if the name was to be changed at all, why was it not changed to ForTran (with an internal upper-case T?)

    Those familiar with the world of M, I mean MUMPS, I mean M[UMPS], where the name of the language either was or was not officially changed, and the language is or is not properly referred to by both names or by one or by the other, and where M is either an officially sanctioned abbreviation, an officially sanctioned alternate name, or the One True name, or was changed in the ANSI spec but not the ISO spec... or not... will appreciate the importance of such issues.

    Particularly since in these modern days it's pretty safe to assume that your PC's printer is equipped with a full 192-character chain.

  • I think I recognize some of these names on the Fortran 2000 committee, they were on another committee that was coming up with designs to retrofit Model-T's with solar cells
  • says...

    "Never use a programming language that is older than you are".

    So I'm just about okay with Fortran 66....

    Baz
  • ...with the sort of morbid fascination that makes people slow down to look at car wrecks:

    Does the language still have EQUIVALENCE?
  • by brer_rabbit ( 195413 ) on Friday October 04, 2002 @12:32PM (#4388080) Journal
    One of the biggest additions to Fortran that I haven't seen mentioned so far is support for Perl 6 style regular expressions.

    [ducks for cover]
  • Any plans for a FORTRAN on MicroSoft NET? Look how much mileage Bill G has gotton introducing various versions of BASIC the past 27 years. I recall when MicroSoft was primarily a languages company, 1975-1981, it shipped a version of PC-FORTRAN.
  • by jellisky ( 211018 ) on Friday October 04, 2002 @12:58PM (#4388278) Journal
    ... is what FORTRAN is good for: number crunching. F77 is a perfect tool for many scientists who don't care about pointers or object oriented programming or nice graphical output subroutines or any other nice things that other programming languages have. They want something that will do some number crunching for them and won't screw up or cause problems.

    FORTRAN is simple. It works like many mathematicians and scientists think it should. It meshes well with what they really want to do in a good number of cases. The level of abstraction is perfect for many of them.

    FORTRAN will take a long time to die because of this. Personally, I like more real-time interpretive languages like IDL. But when it comes down to something that is pure number crunching that'll take a few hours, I'll gladly have FORTRAN. That's why so much in the sciences is written in FORTRAN, then the data is output and run through other programs to do the pretty plotting and further interpretation.

    FORTRAN just works, has worked for 30+ years, and with the amount of incredibly useful code still around, will still work for decades to come. Granted, I don't necessarily like some of the proposed changes, but as long as everything works like it did before with F77 code, I think no one will (or should) mind.

    -Jellisky
  • ...F77 is what you rely upon.

    To calculate aircraft performance (i.e. can we take off with x passengers on this airfield that happens to have a big mountain at the end of the runway?) all (no exceptions) airlines use F77 calculation modules that are provided by the aircraft manufacturers.

    These calculations are, at least in my book, as close to mission critical as you can come. Do it slightly wrong and you may end up in the safety net at the end of the runway. Do it majorly wrong and you hit the aforementioned mountain...

    The modules are reasonably complex (up to 100k loc without a GUI), in strict F77 with the mess that that brings along and are written by Aerospace majors who, if they were lucky, got a 3 week course in F77 at University.

    The obvious question is why?
    - F77 is the most suitable language for the problem?
    - Aerospace engineers like F77?
    - It's an international conspiracy?

    Unfortunately the last one is closest to the truth. The modules are coded according to a standard decided by IATA - International Air Transport Association (http://www.iata.org). A standard that was created some 20 years ago and with regards to F77 of course has not changed since... Why? Because the airlines knows how to handle these modules. The I/O and behaviour is well documented and understood and to change to something even resembling modern CS practices (even F90 would be a giant leap forwards!) would require huge investments for the airlines. Something they are of course not too willing to do. There are some reason for the currently ridiculously low (in comparison) fares we pay.

    Oh, and by the way, the modules are of course not in any way certified by whatever competent authority there may exist. No, in general they prove their worth by the good old method of "service history".

    PS. I have not given up flying just because I've experienced this. All aircraft operations have a rather large safety margin built in. For the "ouch" picture above with the very hard mountain top, we would also need to lose one engine. This in combination with the fact that the "service history" criteria seems to work pretty good still makes flying safer than walking...
  • Why, why, why...? (Score:2, Insightful)

    by dargaud ( 518470 )
    I partially make a living by debugging scientific fortran code. I cannot understand why they finally 'enhance' fortran with things that have existed in other languages for decades. Not that it doesn't need them (dynamic allocation of arrays... I just had to extend the kernel stack to 2Gb so we could run some old badly written fortran code).

    No, what I don't understand about keeping fortran alive is because its users (scientists mostly) are people who refuse to use something new and better. They all use fortran 77 the way they learnt it through a 10 hour university course. I tried to get some of my users to use fortran 90 or 95 and failed pathetically. As my boss said: "if you think you have a clever programming trick, forget it !"

    So what is the point of extending fortran with polymorphism and such ? They'll never use it. As a pro developper I'll never use it (I have the right tools already: C/C++/Java/assembler/perl depending on the job).

    What is the point ? So they can sell expensive compilers with the new Fortran2000 sticker on it that nobody will ever use ? Marketting gimmick ?

  • Does that mean I finally have a command called:
    f00!

    This r0x0rs, d00d!

It was kinda like stuffing the wrong card in a computer, when you're stickin' those artificial stimulants in your arm. -- Dion, noted computer scientist

Working...