2023-10-25 Initial Fortran Training Meeting

[astroDimitrios]

⏰ Time

Wednesday the 25th of October 2:00 - 2:45 pm London Time
1:00 - 1:45 pm UTC

📝 Agenda

1. Introductions
2. Overview of current plans & RSECon outcomes, Dimitrios and Juan?
3. Overview of the current epcc provision, Juan?
4. Tasks/Issues that people can contribute to if they have time
5. AOB

Very rough agenda. If you would like to add anything please post below!

Minutes

Who is our target audience?

Dimitrios: There seemed to be general agreement that a learner should already know another language, we are teaching Modern Fortran not programming.

Dimitrios: The Software Carpentries format has a section for Learner Profiles. I have been writing these locally based off ones in other courses, see this Containers Lesson. I will open an issue to add Learner Profiles to the lesson.

Delivery

Chris C: Mentioned that the Imperial course uses codespaces to deliver a reproducible and easy environment through GitHub for their course (see his comment below).

That also links to a comment by Jonas: That the environment needs to be easy to install. The use of the Compiler Explorer was also mentioned.

Shahid and Jonas both commented that we should emphasise how easy it is to code Fortran with tools such as: VSCode + The Modern Fortran Language Server + fpm, or Qt Creator and extensions.

Content

Jose: Even though fpm & Fortran libraries may not be fully 'polished' perhaps we should still teach it very early on like you might Python + Conda.

Kevin: Mentioned that when he wrote the epcc training he made a choice to focus on the language and not introduce fpm, debugging, legacy code etc.

Iva and Jose both commented on basic debugging and simple tools should be in the Intro course like you would when teaching Python use the debugger in VSCode or Jupyter notebooks from the start. This could build up to more complex tools in later lessons.

Joao asked at the introductory level are we actually making use of F2003+ 'modern' features? Or is this applicable to F95 at the intro level?

Dimitrios: The Met Office has specific needs that go beyond an intro course, Fortran & HPC, C++/Fortran interoperability and the Software Carpentry courses are short 2-3 days so I think collectively we have content for several courses.

Chris mentioned Learning Pathways, see his comment below, which are a great tool to help guide not only students but curriculum development.

Actions

• Everyone add links to the training they mentioned / may have already made to the discussion below.
• This will allow us to create topic outlines and a learner paths for the different Learner Profiles, I think it might be best to open a discussion for learning paths / curriculum content when we have actioned the first point.

Please let me know if there are things I have missed or recorded incorrectly.

[astroDimitrios]

RSECon23 Pad with notes from the Fortran Training Audience Panel session.

[cmcooling]

This is my current course. I expect there's nothing too ground-breaking there in terms of content, but it may be of interest. This includes a GitHub codespace implementation. Click the green "code" button, select the Codespace tab, and copen a new Codespace if you'd like a look at how it works.

For anyone interested, here is the tool we use to direct students though our courses.

[everythingfunctional]

Links to my courses are listed here: https://www.everythingfunctional.com/online-courses.html

And lists of lots of my other resources are listed here: https://www.everythingfunctional.com/free-stuff.html

Feel free to message me if you're interested in more details on anything.

[Carltoffel]

Since my course was held in German, and it's impractical to translate the whole course, I will only translate my analysis of the course with DeepL.

My course material/presentation were Jupyter Notebooks with executable Fortran cells. The first chapter of my summary are all headings scraped from the Notebooks to give you a brief overview of what topics I discussed.

I should also mention that I mainly did exercises and as little lecture as possible.

The timing chapter gives you an idea on how long it took to go through the course. Each day had 3 90 minutes blocks.
If you are interested in some exercises, I'm happy to translate individual ones.

The target audience are bachelor students in scientific programming, who already know Java, Python, C/C++ (and Calculus and Linear Algebra).

Here is a Fortran Discourse topic I posted to share my experience from the lecture:
https://fortran-lang.discourse.group/t/experience-of-my-first-fortran-course/5611

Summary and short analysis of my first (and until now last) Fortran lecture

Chapters of the slides

• Introduction to Fortran and scientific applications
  • Agenda
  • What is Fortran and what is it used for?
  • Comparison Fortran vs Python
    • Running time with 1,000,000 numbers
    • Properties of Fortran (paradigms etc.)
  • Time travel: The history of Fortran
  • Introduction to scientific applications
    • Fields of application
    • HPC (High-performance computing)
    • Underlying mathematics
  • Setting up a development environment
  • Hello, World!
    • Task 1.1: fpm-new
    • Task 1.2: Hello World
    • Task 1.3: Minimal code
  • Programme structure
    • Task 2.1: Data types
  • Operators
    • Task 2.2: Operator order
  • Note
• Variables and data types
  • Variable names
    • Task 3.2: Problems with implicit typing
  • Remember (rules for names)
  • Data types
    • Numeric data types
    • Task 4.1: (Operator order)
    • Subtypes of data types
      • kind definitions
      • Select 'child
    • Predefined types
    • Selected types
    • Task 4.2: Euler with different real types
    • constants
    • Logical data type
    • Task 5.1: Propositional logic
    • Type conversion from 'logical
    • Task 5.2: Reconstruct min/max with merge
    • character data type
    • subword
• loops
  • Counter loop
    • Task 8.1: 4^4+3^3+8^8...
  • implied do loop
  • Join arrays
  • While loop
  • infinite loop
    • Task 8.3: calculate ggt
  • All loop types
• Branching
  • if statement
    • Task 9.1: Heron's formula
  • Select Case
    • constraints
    • Task 9.3 - State of Aggregation
• Procedures
  • function vs subroutine
  • function
    • arguments
    • return variable
    • Task 10.1: ggt as a function
  • Properties of functions/subroutines
    • pure function
    • recursive function
    • Task 10.3: ggt recursive
  • subroutine
    • Task 10.4: ggt subroutine
  • actual" vs "dummy" argument
  • elemental
    • Task 10.6: ggt elemental
  • optional
    • Pitfall
  • save variable
    • Task 10.8 - save variable
• Modules
  - Task 11.0
  - Task 11.1: Fraction module
  - Task 11.2: Compiling by hand
  • fpm dependencies
• arrays
  • Arrays as function arguments
    • Task 12.3 - Fibonacci
  • Pointer
• character
  • character functions
  • dynamic `character
    • Task 13.4 - str2num (?)
• IO
  • Formatting statement
    • Available descriptors
    • Task 14.1 - Formatting (?)
  • Units (units)
  • Reading and writing files
    • iostat
    • Task 14.3 - Row-wise (?)
• OOP
  • Derived Data Type
    • Task 15.1 - Fraction type
  • interface
  • Overloading Operators
  • Classes and methods

Timing

• Day 1:
  • Introduction to Fortran (features, history, applications).
  • First steps (fpm, compile, execute)
  • Data types (numeric, constants)
• Day 2
  • Logical data type
  • Easter date
  • Loops, optimisation, simple arrays
• Day 3
  • Implied do
  • Branching
  • Functions, pure
• Day 4
  • Recursion, elemental, save
  • subroutine
• Day 5
  • modules
  • stdlib
  • fpm test
• Day 6
  • garden
  • arrays
  • Mandelbrot
• Day 7
  • Array arithmetic
  • Fibonacci
  • Allocatable
• Day 8
  • Pointer (Conway)
  • character
• Day 9
  • ...character
  • IO formatting
• Day 10
  • Binary IO
  • Derived types
  • Interface
  • Type-bound procedures

Conclusion

In general, I am satisfied with the course, especially that the focus was on the exercises. However, it was difficult to create a balance between the fast and the slow students. Also, there was too much focus on the basics of programming, thus lacking time in the end for more depth into more advanced Fortran topics.

What remains

• more exercise than lecture
• Rough contents

What changes

• Less basics (if, do, etc.)
• More emphasis on arrays and array operators
• More time on types and type-bound procedures
• Pointers only for trees or similar, and replace the previous uses with associate

What is added

• Associate as a separate topic
• More tools (e.g. FORT)
• Exercises for home (students asked for it to get more practice)
• Maybe Co-Arrays

[astroDimitrios]

@carpentries-incubator/intro-to-modern-fortran-maintainers Thanks to those who have already commented! Please add your links to this discussion.

One of the points I forgot to mention which came out of the conference was the need to have examples and case studies that covered a broad range of domains. We had a few offers of case studies from Physics, Geology, and Climate at the conference - it would be good if we could get more example use cases.

[Shahid718]

Maybe everyone is working on some specific domain and can present his worked-out examples.

[Carltoffel]

Maybe it would be best to focus on mathematics in a Core-Fortran-Course and only superficially cover the other topics. From there we can build more specialised courses for topics like Physics, Geology and Climate. Basically it's the same Python people are doing. They have basic tutorials focussing on the programming languge and then they also have tutorials focussing on other topics like machine learning taught with Python.

[astroDimitrios]

Yes the case studies we already have are more higher level and demonstrate OOFortran and best practive when it comes to global variables etc they are mostly not beginner.

[kevinstratford]

The ARCHER2 introductory course "Introduction to Modern Fortran" is

https://github.com/ARCHER2-HPC/archer2-fortran-intro

which is intended to be two days in real time.

An intermediate course is also planned which would cover largely object-oriented features and software engineering considerations.
Again, probably two days.

If there was an advanced course, it would cover broadly, parallelism.

We haven't quite decided where C/Fortran interoperability sits yet.

[Shahid718]

Maybe the usage of FFTW3 is a good example of C/Fortran interoperability. It would serve two purposes:

1. How to use the C library in Fortran
2. Numerical computation in Fortran with C library.

[Shahid718]

I prepared the basic installation guide.

Since the Dislin graphical library is free to use, it shows how we can use a single statement to get the plots.

[jalvesz]

It might be questionable, but "development of python extensions modules" would have a big impact as well! and since it depends on the C interoperability (use of iso_c_bindings) with the extra step of creating shared objects, it might be material for a half-day advanced topic. Given the ubiquity of python it might be quite beneficial.

[jalvesz]

"Joao asked at the introductory level are we actually making use of F2003+ 'modern' features? Or is this applicable to F95 at the intro level?"
Regarding this point, I think it is not worth it to focus too much on a specific norm. I think it is fair to say that most of us would like to clean up the wide-spread association of FORTRAN77 with Fortran... and since the target audience are scientists/engineers, the material should focus on "the advantages the language and its ecosystem" propose for doing HPC as easy and accesible as possible.

Well, of course it should be limited by the features which are already strongly supported by the most used compilers. Up to 2008 it would be safe, 2018 there are things hanging in some compilers.

[jonaslindemann]

I think we should not focus too much on the latest features. I consider Modern Fortran to be from F95 and above. We should be clear that we don't teach F77, but give hints how to interoperate with it.

[astroDimitrios]

I agree - I think we said at the panel F95 and above to 2008 since 2018 doesn't have full support.

[jonaslindemann]

This the course material I am using when teaching Fortran:

https://modern-fortran-in-science-and-technology.readthedocs.io/en/latest/

Here is a list of my current Fortran YouTube material:

https://www.youtube.com/playlist?list=PLgLiRoLGqjOiAPAwFLNYLUDoPeczadoaw

I also gave a lecture in OO-programming and mixed language programming at HPC2N in Umeå:

https://youtube.com/playlist?list=PL6jMHLEmPVLwkF-Qh0VqqN9YLgVrKYSYi&si=1qkpBUYI8NOaVTyo

The Qt Creator extensions for Fortran can be found here:

https://github.com/jonaslindemann/qtcreator-fortran

[cmcooling]

Oh, I just thought, we also have a Fortran exemplar as part of our ReCoDE project which aims to guide students through longer, more complicated examples, demonstrating best practice. There may be anything of interest in there too.

[theabro]

Hello! I'm interested in contributing to this project. I come from an environmental background, working with Met Office codes.