
Explore advanced features, design techniques, and data structures and algorithms in Fortran to help intermediate learners build productive, readable code with reusable components and a prepared environment.
Introduce optional editor tools for Fortran development, such as syntax highlighting, linter-gfortran, ide-fortran, and fortran-language-server; show installation and how they improve readability and catch errors early.
Explore how procedures deconstruct and structure a program into reusable, understandable components, and learn about their properties and attributes to improve maintainability.
Explore pure and elemental procedures in Fortran, learn how purity restricts side effects and enables safe parallelism with do concurrent, and apply elemental functions to array elements.
Explore recursive procedures in Fortran, using induction and recursion, base cases, and the recursive keyword to implement Fibonacci and trace the call stack.
Explore abstract interfaces in Fortran by defining a named interface and passing a procedure as an argument to a reduce function, enabling flexible combiners.
Explore data structures in Fortran as common patterns that structure data and improve program design, with a focused look at a few essential structures to build your toolbox.
Explore linked lists in Fortran, including singly and doubly linked variants, pointers, memory management, and operations like prepend and append, plus a visitor pattern for traversing and processing list items.
Create a heterogeneous list in fortran with a shape item that holds any shape for a polymorphic to-string, while using fpm and git to add rectangle and total area support.
Explore binary trees with two children, where leaves store values, and implement an abstract tree interface with a to string function.
Explore patterns and principles that make systems easier to reason about and maintain. Learn to select appropriate patterns, weighing benefits and downsides across contexts, with examples and exercises.
Explore the stack data structure in Fortran, demonstrate data hiding with private stack components, and verify behavior through unit tests, top, push, pop, and depth operations.
Explore composability with small, reusable pieces returning the same type. Build complex structures from numbers, vectors, and matrices using concatenation and shape scaling, noting floating point caveats.
Learn the open-closed principle by designing extensible filters for shapes, using a shape filterer with a matches method, enabling area-based or curve-based extensions without modifying existing code.
Start improving your skills using one of the few languages directly targeting use for high-performance scientific and engineering applications. I'll show you some techniques that make use of more advanced features of the language, and how you can apply some best practices from software development in general to programming in Fortran. If you've taken my previous course, have some basic experience in Fortran, or are interested in learning how you can apply techniques you're familiar with from other languages to Fortran, this course will help you improve your skills.
I can't cover all the techniques and practices out there in a single course, but this should give you an idea of what's possible, and help you put some tools in your tool box. I'll even show you how I have some of the tools I use for development configured to be more convenient and helpful.
We start with some features of the language you'll need to be familiar with to be successful, explore some common data structures in software development, and demonstrate some patterns and practices shown to be useful in other fields of programming. I'll show you some example that demonstrates a concept, and then have you complete 1 or 2 exercises where you'll extend the example using the techniques we've talked about.
By the end of the course, if you've understand the material and completed the exercises, you should see your skills as a software developer dramatically improved.