Course Curriculum Outline

[astroDimitrios]

What should be in this course? How does it lead onto a potential intermediate course or advanced topics?

In our first meeting discussion #2 we linked to several exisiting resources. Roughly collating them gets:

Setup for the course
Setting up your Editor – should this be in basics?

1. Basics
   a. Compiling your code
   b. Types and Kinds
   c. Operators
2. Code Style – Use of Stylist
3. IO
   a. Output (print FORMAT etc)
   b. Input
   c. Namelists
4. Arrays + Memory layout
5. Array expressions and masks
6. Control Flows
7. Allocatable Arrays
8. Pointers
   Common pitfalls / compiler errors and how to debug?
   Should these also be woven into the main lessons like style.
   Is this a good place to split the content into beg / intermediate?
9. Functions
10. Subroutines
11. Overloading
12. Modules and scope
13. Using the Fortran package manager / packaging
14. Arrays as arguments
15. Command line arguments
16. Make and/or CMAKE?
17. Exception Handling

Again is this another place we could split the content?

Object Orientated Fortran
Derived Types
Parameterised D Types
More overloading?

Advanced Topics
Pre-processing files
Interoperability with C and Python
Updating legacy Fortran code
Coarray
MPI and OpenMP – are these best captured by external courses specifically for MPI and OpenMP?

If you think anything is missing, or have thoughts on the order / potential split into multiple lessons then please start the discussion below!

[samharrison7]

Thanks for this outline! Just a few random thoughts from me, a lot based on personal preference and so feel free to ignore:

• I would probably put fpm, make and cmake together in the same section (e.g. "Building your code").
• I would personally have pointers as an advanced topic, but perhaps that's because I tend to avoid them unless I really have to use them.
• Polymorphism isn't on the list (though maybe implicitly in the "More overloading" bit). I think a section in the advanced topics on polymorphism (data and type) could be a good idea.

Hope that helps!

[astroDimitrios]

Brill thanks! Yes sorry don't know how I missed polymorphism - I presume that's what I meant by More Overloading. I blame my non computer science background and tired brain! I really like the idea of a Building your Code section, maybe program instead of code?

[samharrison7]

Program instead of code makes sense! And I only thought of polymorphism because I'm wrestling with it in a project at the moment 😂

[jalvesz]

This looks like a very good outline for such a course!

I would probably put fpm, make and cmake together in the same section (e.g. "Building your code").

Agree, just an idea to include a section "quick testing online" and present platforms such as Compiler Explorer. Very helpful to toy around with code and compiler flags.

I would personally have pointers as an advanced topic, but perhaps that's because I tend to avoid them unless I really have to use them.

I think that while pointers are to be treated carefully, they also offer many possibilities. Making sure people is not scare of them and having the knowledge to make the decision on whether they are the right tool for the given task is key. My feeling is that many Fortran libraries have stagnated because within Fortran programmers there is an aversion to pointers and OOP. Or even some people do not even know certain things are possible in the language so they just migrate to other languages convinced Fortran doesn't have the tools ... So while it is true that it is an "advanced" topic, my feeling is that it should be introduced mid-way, just as proposed here.

Object Orientated Fortran
Derived Types
Parameterised D Types
More overloading?

What about abstract interfaces and submodules?

[warrickball]

For context, my vision for a course like would be to prioritise getting to a working program that does something interesting (and preferably something that Fortran is especially good at) ASAP (e.g. within an hour), then building on that. Also be sure to mention particularly useful Fortran features (e.g. elemental when covering functions).

Along these lines, I'd get to arrays basically straight after basic types. e.g. floats. I'd also introduce Make (but perhaps not CMake) as soon as we have a separate module and program.

I'm with @samharrison7 that I generally avoid pointers. I agree they have their place but for much of the "crunch numbers fast" I expect users want, they will produce more errors rather than solve more problems.

Regarding good style, I'd suggest demonstrating good style and leave it as an explicit topic until later. For comparison, when I teach the Python Software Carpentries lesson, I cover sensible variable names but not PEP 8, linting or any particular linter (e.g. flake8).

I also imagine that the course would be some fundamentals and then lots of extra material from which instructors could choose a particular direction to take (e.g. OO stuff, OpenMP & MPI, updating legacy code, Python & C interop).

If I were to re-order the curriculum above, I'd suggest

0. A trivial program (perhaps print a number):
   a. print
   b. compiling (also so we can confirm learners are set up correctly)
1. Basics (assuming people come from some other language, this can be fast)
   b. Types and Kinds
   c. Operators
2. Arrays + Memory layout
   a. neat (perhaps optional) Fortran feature: we can choose the lower bound, too!
3. Control Flows (again, assume people have seen these in other languages)
   a. mention some neat Fortran features, like named loops (so we can e.g. break out of nested loops)
4. IO
   a. Output (print FORMAT etc)
   b. Input (unformatted reads probably cover a lot of bases)
   c. Namelists
5. Functions (probably together with Subroutines, as procedures)
6. Subroutines
7. Arrays as arguments (possibly together with...)
8. Allocatable Arrays
9. Modules and scope
10. Make and/or CMAKE? (because now our program depends on a module)
11. Code Style – Use of Stylist
12. Array expressions and masks
13. Common pitfalls / compiler errors and how to debug? (this might just be woven throughout the course but is an important skill)
14. Command line arguments
15. Exception Handling
16. Pointers
17. Overloading
18. Using the Fortran package manager / packaging

Regarding testing, I came across https://play.fortran-lang.org/ but it wasn't working for me (Firefox + Fedora 39).

[samharrison7]

Re the Fortran Playground issues, there's a (lengthy) thread explaining the issue that you're likely encountering here: https://fortran-lang.discourse.group/t/fortran-playground/6290

[astroDimitrios]

I'm very much in favour of getting a simple program running within the first section / hour. I know when @juanfrh and I spoke last year we were both keen to weave good style into the course and perhaps highlight places where we are choosing one style over another and our reasoning.

We can also add in troubleshooting etc using the Workbench's hints callout.

[warrickball]

As a separate point, I'm also in favour of an Advanced (or maybe "Object-Oriented") Fortran course (I'd take it if I got the chance!). I'm just not convinced things like operator overloading, polymorphism, etc. belong in the first ~5 hours of someone's Fortran training.

[samharrison7]

Yeah that's a very good point, I was kind of forgetting that this is an intro course. As @astroDimitrios says, we should draw a line somewhere and then potentially develop the intermediate/advanced stuff for another course.

[astroDimitrios]

When I looked at content last year using a different format I think I split anything OO into an intermediate course.
Perhaps then we have an intro course like you outlined above, a more intermediate OO course, and then advanced topics which can be treated separately - Cooarrays, C/Python interoperability etc.

[jonaslindemann]

My comments.

• I think coding style should be taught by example not explicitly as its own chapter. Could be an appendix.
• Pointers should be moved after functions and subroutines.
• Modules before overloading.
• Generally move more advanced concepts later in the course.
• Arrays as arguments should be part of the functions / subroutines chapter (perhaps combine the two?)
• Perhaps the chapter on building software should refer to an appendix on how to use make and CMake?
• Move error handling earlier in the course.
• Basic derived types are important should be covered early.
• Interoparbility perhaps cover f2py in the intro part. More advanced interactions in a more advanced course.
• MPI / OpenMP are better covered in separate courses. Not sure about Coarrays.

I hope this gives some input.

[cmcooling]

I think this all sounds very sensible and don't have a lot to add. One slight thing I would say is that the primary reason people use Fortran is for the raw speed, so I think covering topics like OpenMP and MPI should be high up the priority list for topics outside of the core curriculum.

[astroDimitrios]

I know we recently had some good OpenMP & MPI training by epcc/ARCHER2 which included Fortran so perhaps in our Learning Pathways we can add those in.

[astroDimitrios]

Just to note here I have added in links to the two ARCHER2 courses mentioned above in the pathways diagram. See #5.

[astroDimitrios]

Taking all the comments here and from inside the Met Office into account, a revised outline is below. If people are broadly happy with this I will go ahead and start adding Issues for each section which people can volunteer for if they have time. Otherwise if people just have time to review sections when they are ready that would also be useful!

Introduction to Modern Fortran (this course)

Setup for the Course
Setting up your Editor

Add to the front into page - within the first hour you will:
Make a program that does x
(This will take you up to the end of basics)
By the end of the first day ...
By the end of the course ...

What is Fortran good for / what is it bad for (strings)? In intro.
Something about the course being, partially, through the lens of Fortran for HPC which may influence content and recommendations.

1. A trivial program (perhaps print a number):
   a. print
   b. compiling (also so we can confirm learners are set up correctly)

2. Basics
   a. Types and Kinds, PARAMETERS
   b. Operators
   c. Intrinsic Functions
   Code Style – (Mention Stylist) woven into the course, link to the Extension

   HERE After 1 hour with a basic program running.

3. Arrays + Memory layout - contig. mem. access
   a. neat (perhaps optional) Fortran feature: we can choose the lower bound, too!
   b. Array slices, expressions and masks (in a hint mention where and trouble with openmp)

4. Control Flows
   a. mention some neat Fortran features, like named loops (so we can e.g. break out of nested loops)

5. IO
   a. Output (print FORMAT etc)
   b. Input (unformatted reads probably cover a lot of bases)
   c. Namelists

6. Exception and Error Handling

   Natural Break Point?

7. Modules and scope
   My thought was to have already introduced/used the constants_mod.F95 module which we use to store physics constants and define kinds
   Then we can delve into the use of modules and get them to make their own etc. Then add a function / sub to it.

8. Functions - including elemental, pure etc. To include intents etc.
   Realistically I think 8, 9, and 10 are going to be in one Carpentry Lesson 'Episode'

9. Subroutines

10. Pros and Cons of using Functions/Subroutines to help decide which one to use

11. More on Arrays
    a. Arrays as arguments
    b. Allocatable Arrays
    c. More on array expressions and masks? Pack / unpack etc.
    d. Why not to use reshape()

    Break

12. Building your program - Make and CMake, mention Fab and FPM and link to Extension

13. Command Line Arguments in your program

    Break

14. Pointers - Hint as to how they differ from C++, notes on when and perhaps when not to use

15. Generic Procedures & Overloading

16. Common pitfalls / compiler errors and how to debug? (woven into the course via callouts but also explicity dealt with here)

17. EXT: Code Style - Using Stylist

18. EXT: The Fab build system

19. EXT: Using the Fortran package manager / packaging

Appendix with an example code style.

At a later date:

Object Orientated Fortran - 1 day?

1. Derived Types
   a. Module variables, private vs public, PROTECTED
2. Notes on the default constructor, object creation and destruction
3. Parameterised D Types
4. Abstract Interfaces
5. Polymorphism & Overloading Type Procedures - DEFERRED?
6. Submodules

Advanced Topics in Modern Fortran

Topics to pick out as needed.

1. Use of global variables and objects - CASE Study: LFRic modelDB
2. Pre-processing files
3. Mixed-precision code, when and more importantly when NOT
4. Interoperability with C
5. Interoperability with Python
6. Updating legacy Fortran code
7. Optimising Fortran Code? - compiler flags
8. Coarray?

MPI and OpenMP – Link to the ARCHER2 courses.

[Carltoffel]

Some thoughts on that:

• The first trivial Fortran program could be the example generated by fpm new myprog --app. It allows exploring a minimal working example and an easy first task could be to change it to a "hello world" program.
• 3b is a nice place to introduce associate because it can easily reference array slices. I completely swapped out pointers for associate in my own Fortran course, since associate accomplished everything I planned to accomplish with pointers, while being simpler and more secure.
• what's the problem with reshape?

[astroDimitrios]

Thanks for pointing associate and the fpm example out! Sometimes we avoid reshape due to its copy and in some of our programs reshape is replaced with do loops so they can be multi-threaded.

[jalvesz]

Sometimes we avoid reshape due to its copy

Agree, I personally preferer pointers for handling the data with a different shape/rank without copy.