• ZZZ Version
• ZZZ Version History

Return to ZZZ, Version History, Versions, ZZZ Topics, ZZZ DevOps, COBOL Versions

Fortran (Formula Translation) is one of the oldest high-level programming languages, developed by IBM in 1957 for scientific and engineering computations. Over the decades, Fortran has evolved to meet modern computing demands while maintaining its reputation for performance in numerical and scientific applications. Below is a detailed version history of Fortran, highlighting the key features and changes introduced in each major version.

Fortran 2018 further modernized the language with additional features aimed at improving performance, parallel processing, and interoperability.

• Event handling for parallel computing. Introduced constructs for managing event-driven execution in parallel applications.
• Atomic operations. Added atomic subroutines for safer multi-threaded environments.
• Improved error handling. Enhanced mechanisms for managing exceptions and errors.
• Enhanced interoperability with C. Provided better support for integrating C code with Fortran.

Official documentation: https://www.iso.org/standard/72391.html

Fortran 2008 introduced advanced parallel computing capabilities and improved input/output handling.

• Coarrays. Introduced coarrays to support parallel processing across distributed systems.
• DO CONCURRENT loop. Enabled concurrent execution of iterations in loops.
• Asynchronous I/O. Allowed non-blocking I/O operations, improving performance in large data applications.
• Submodules. Improved organization of large codebases by enabling submodules within larger modules.

Official documentation: https://www.iso.org/standard/72392.html

Fortran 2003 was a significant update that brought object-oriented programming (OOP) into Fortran and enhanced interoperability with other languages.

• Object-oriented programming (OOP). Added support for classes, inheritance, and polymorphism.
• Interoperability with C. Introduced the `ISO_C_BINDING` module, improving Fortran’s ability to call C functions.
• Stream-based file access. Enabled more flexible file handling operations.
• Allocatable components. Allowed dynamic memory allocation for derived types.

Official documentation: https://www.iso.org/standard/32987.html

Fortran 95 refined the language to improve array processing and modular programming.

• FORALL and WHERE constructs. Improved array processing capabilities.
• Pure and elemental procedures. Enabled the compiler to optimize code based on these constructs.
• User-defined pure functions. Allowed better performance optimizations in parallel systems.
• Simplified initialization of arrays.

Official documentation: https://www.iso.org/standard/23167.html

Fortran 90 was a major revision, introducing modern programming features like array processing, modules, and dynamic memory allocation.

• Array operations and slicing. Improved array handling with more concise syntax.
• Modules. Introduced modules for better code organization and encapsulation.
• Dynamic memory allocation. Added support for dynamically allocating memory with `ALLOCATE` and `DEALLOCATE`.
• User-defined types. Allowed for more complex data structures to be defined by developers.

Official documentation: https://www.iso.org/standard/8793.html

Fortran 77 brought structured programming features and enhanced file handling to the language.

• Structured control flow. Added `IF…THEN…ELSE`, block `IF`, and `DO…END DO` constructs.
• Character data type. Enabled handling of strings in Fortran.
• IMPLICIT NONE. Introduced to enforce explicit declaration of variables.
• Enhanced I/O handling. Provided better control over file input/output operations.

Official documentation: https://dl.acm.org/doi/10.5555/1071714

Fortran 66 was the first standardized version of the language, making it more portable and reliable across different systems.

• Improved portability. Ensured consistency of code execution across different systems.
• Enhanced subroutine support. Improved handling of subroutines and functions.
• Basic control structures. Refined loops and conditional constructs for better program flow control.

Official documentation: https://dl.acm.org/doi/10.5555/1071716

Fortran II introduced features that allowed better modularity and error handling.

• Subroutines and functions. Enabled the use of external subroutines and functions for modular programming.
• COMMON blocks. Provided shared memory between program segments.
• Improved error reporting. Enhanced debugging and error handling capabilities.

Official documentation: https://dl.acm.org/doi/10.5555/1071715

Fortran I was the first version of the language, primarily designed for scientific and engineering computations.

• Automatic code generation. Translated high-level instructions into efficient machine code.
• Basic control structures. Introduced constructs like `DO` loops and `IF` statements.
• Floating-point arithmetic. Provided support for real number computations, crucial for scientific applications.

Official documentation: https://dl.acm.org/doi/10.5555/1071713

Fortran has undergone significant changes since its inception in 1957, evolving into a versatile and high-performance language for numerical and scientific computing. Each new version introduced features such as object-oriented programming, enhanced array processing, and parallel computing capabilities. Despite being one of the oldest programming languages, Fortran remains relevant and continues to be widely used in scientific, engineering, and financial fields where performance and reliability are critical. Through continuous updates, Fortran has maintained its position as a powerful tool for high-performance computing.