Modern Fortran Programming

From Fundamentals to High-Performance Scientific Computing

Introduction

1. What You Will Learn
2. How to Use This Book
3. A Note on Standards and Compilers
4. Why Learn Fortran Today?

Chapter 1: The Story of Fortran — History, Evolution, and Modern Relevance

1. The First Programming Language — FORTRAN I and the Birth of Compilers
2. Standardization and Survival — From FORTRAN 66 to Fortran 90
3. The Modern Renaissance — Object-Oriented Features, Parallelism, and Beyond
4. Why Fortran Today — Supercomputers, Legacy Codebases, and New Projects
5. How This Book Is Organized — A Roadmap for the Reader

Chapter 2: Your First Fortran Programs — Structure, Compilation, Execution

1. The Anatomy of a Fortran Program — Source Files and Program Units
2. Setting Up Your Environment — Compilers and Tools
3. Hello World and Beyond — Free-Form Source and Basic Structure
4. Compilation and Linking — From Source to Executable
5. Common First Errors and How to Fix Them
6. A Slightly Larger Example — Organizing Code from the Start

Chapter 3: Data, Types, and Numbers — Variables, Kinds, Precision, Literals

1. Declaring Variables — Types, Names, and Style
2. The Intrinsic Data Types — Integer, Real, Complex, Logical, Character
3. Kinds and Numerical Precision — Choosing the Right Representation
4. Literals, Constants, and Parameters — Exact Values in Code
5. Operators and Expressions — Arithmetic, Relational, Logical
6. Summary

Chapter 4: Control Flow and Iteration

1. Conditional Execution — IF Constructs and SELECT CASE
2. Looping with DO — Count-Controlled Repetition
3. Advanced Loop Patterns — WHILE-like Loops, Exit, Cycle, Nested Loops
4. Structured Programming Discipline — Avoiding GOTO
5. Algorithmic Examples — Search, Sort, and Iterative Methods
6. Summary

Chapter 5: Arrays and Array Operations

1. Declaring Arrays — Shape, Bounds, and Initialization
2. Multidimensional Arrays — Matrices and Beyond
3. Array Syntax and Whole-Array Operations — Vectorized Code
4. Slices, Sections, and Masked Arrays — Selective Access
5. Memory Layout and Performance — Column-Major Order and Cache Behavior
6. Summary

Chapter 6: Input and Output

1. List-Directed I/O — Simple Reading and Writing
2. Formatted I/O — Edit Descriptors and Precision Control
3. Internal Files — String Formatting and Parsing
4. Unformatted and Stream I/O — Binary Data and Portability
5. Robust Input Handling — Error Checking and User Interaction
6. Summary

Chapter 7: Procedures and Interfaces

1. Functions and Subroutines — Designing Reusable Procedures
2. Argument Passing and Intent Attributes — Clarity and Safety
3. Optional and Keyword Arguments — Flexible Interfaces
4. Explicit Interfaces and Interface Blocks — Compile-Time Checking
5. Generic Interfaces and Operator Overloading — Polymorphic Names
6. Summary

Chapter 8: Modules and Program Organization

1. What Modules Are For — Encapsulation and Code Sharing
2. Module Structure — Public, Private, and USE Associations
3. Submodules — Separating Interface from Implementation
4. Scope Rules and Name Resolution — Avoiding Collisions
5. Organizing Large Projects — Module Architecture Patterns

Chapter 9: Derived Types and Object-Oriented Fortran

1. Defining Derived Types — Structuring Complex Data
2. Type-Bound Procedures — Methods in Fortran
3. Polymorphism and the CLASS Keyword — Dynamic Dispatch
4. Abstract Types and Type Extension — Inheritance Hierarchies
5. Design Patterns with Modern Types — When OOP Helps
6. Summary

Chapter 10: Memory Management — Allocatables, Pointers, and Dynamic Data

1. Allocatable Variables — Dynamic Sizing and Lifecycle
2. Allocation Patterns — Arrays, Derived Types, and Error Handling
3. Pointers and Pointer Semantics — When They Make Sense
4. Common Memory Pitfalls — Leaks, Dangling References, Double Free
5. Modern Alternatives — Preferring Allocatables Over Pointers

Chapter 11: Parallel Programming with Coarrays

1. The Coarray Model — Images, Teams, and Shared Variables
2. Declaring and Using Coarrays — Basic Syntax
3. Synchronization — Event-Based Coordination with SYNC
4. Communication Patterns — Scatter, Gather, Reductions
5. Practical Parallel Programs — Real Examples and Pitfalls

Chapter 12: Interoperability — Connecting Fortran to the World

1. Why Interoperate — Ecosystems and Libraries
2. The ISO_C_BINDING Module — Types, Constants, and Procedures
3. Calling C from Fortran — Practical Examples
4. Calling Fortran from C — Exporting Interfaces
5. Beyond C — Python, Julia, and Other Language Bridges
6. Summary

Chapter 13: Numerical Correctness and IEEE Floating-Point Facilities

1. How Floating-Point Works — Representation and Limitations
2. Precision Selection and Kind Parameters — Getting It Right
3. IEEE Arithmetic Facilities — Querying and Controlling Behavior
4. Numerical Stability — Algorithms That Work in Practice
5. Reproducibility — Making Results Repeatable
6. Summary

Chapter 14: Performance Optimization and High-Performance Computing

1. Understanding Compiler Optimizations — Levels and Flags
2. Writing Vectorizable Code — What Compilers Can Accelerate
3. Memory Access Patterns — Locality, Stride, and Cache Efficiency
4. Profiling and Benchmarking — Measuring Real Performance
5. HPC Considerations — Scaling to Large Systems

Chapter 15: Build Systems, Testing, and Modern Toolchains

1. The Fortran Package Manager (fpm) — Modern Builds Made Simple
2. CMake for Fortran Projects — Cross-Platform Build Automation
3. Traditional Makefiles — When They Still Make Sense
4. Testing Strategies — Unit Tests and Validation Frameworks
5. Static Analysis, Linting, and Documentation Tools
6. Summary

Chapter 16: Professional Practices and Legacy Code

1. Coding Standards — Naming, Formatting, and Readability
2. Defensive Programming — Error Handling and Robustness
3. Resource Management — Cleanup and RAII-Like Patterns
4. Version Control Conventions — Git Practices for Fortran Projects
5. Modernizing Legacy Code — Strategies and Tools
6. Summary

Conclusion: The Future of Fortran

1. What You Have Learned
2. Where Fortran Is Heading
3. Why Fortran Still Matters
4. Final Advice

References