Scientific Computing

It appears that on about July 8, 2026 the BZip2 1.1 development repository was archived with the message:

BZip2/libbz2 is a program and library for lossless, block-sorting data compression. This fork for v1.1+ development is has been archived due to lack of interest, and because there are better options available through the Rust ecosystem.

and further discussion. This Gitlab repo was linked from the original SourceWare BZip2 page.

Fortran compilers typically have options for enforcing Fortran standards. The compilers raise additional warnings or errors for code that is not deemed compliant. Fortran standard options can make false warnings, so we generally do not enable standards checking for user defaults. However, we do enforce implicit none as a quality measure.

It’s also important to use implicit none so that each variable must be assigned beforehand. We recommend the Fortran 2018 statement:

implicit none (type, external)

which requires explicitly defined procedure interfaces as well.

type

the traditional implicit none default

external

new for Fortran 2018, requires explicit interface for external procedures.

GCC Gfortran -std=f2018 enforces Fortran 2018 standard. Consider these Gfortran options:

gfortran -fimplicit-none

LLVM Flang similarly uses -std=f2018 and similar, as well as:

flang -fimplicit-none

Intel oneAPI -stand:f18 enforces Fortran 2018 standard. Consider these options that also enforce implicit none:

ifx -warn:declarations

Cray Fortran compiler enforces implicit none via option:

ftn -eI

note that’s a capital “I” not a lowercase “ell”.

Nvidia HPC Fortran compiler enforces implicit none via:

nvfortran -Mdclchk

NAG Fortran has -f2018 Fortran 2018 flag. Enforce implicit none by:

nagfor -u

CMake logic to enforce these standards:

if(CMAKE_Fortran_COMPILER_ID STREQUAL "Cray")
  add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-eI>")
elseif(CMAKE_Fortran_COMPILER_ID MATCHES "GNU|LLVMFlang")
  add_compile_options(-Wall "$<$<COMPILE_LANGUAGE:Fortran>:-fimplicit-none>")
elseif(CMAKE_Fortran_COMPILER_ID MATCHES "^Intel")
  add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-warn:declarations>")
elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "NVHPC")
  add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-Mdclchk>")
elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "NAG")
  add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-u>")
endif()

Like other coding languages, Fortran code might have variables that are used before they are defined, or variables that are defined but never used. Uninitialized variables cause unexpected behavior that can be difficult to debug. Variables that are defined but never used are a waste of memory and possibly computation time and make the code less readable. Here is a trivial example of a Fortran program that has an undefined variable, that Fortran compilers generally don’t warn about by default, and may not even be able to warn at compile time.

program test
implicit none
integer :: i, j

i = j + 1
print '(i0)', i

end program test

We provide over 20 such tests in a CMake project that outputs JSON for the compiler tested.

GCC Gfortran 17 new compile-time warnings

GCC / GFortran 17 adds two Fortran compiler options to provide more robust (less false positive and false negative) warnings about undefined and unused variables. This is a potentially significant improvement over the -Wuninitialized and -Wmaybe-uninitialized flags, which operate on the Static Single Assignment (SSA) form and are known to be more likely to produce false positives and false negatives.

These new options are

• -Wundefined-vars
• -Wunused-but-set-variable that was effective for C and C++ is in GCC 17 also effective for Fortran.

The new -Wundefined-vars option by Thomas Koenig is in effect a front-end static analysis tool using tables of variable definitions and uses to determine if a variable is used before it is defined.

LLVM Flang Fortran compiler

The LLVM Flang compiler has an option -Wused-undefined-variable that at least in Flang 22.1 didn’t catch the undefined variable in the toy example above, but does catch the unused variable with the option -pedantic. It is mentioned in the Flang forums that the Flang team considers some of the cases Gfortran 17 catches to be for possibly future implemented runtime checks rather than compile-time checks as in GCC 17.

warning: Value of uninitialized local variable ‘i’ is used but never defined [-Wused-undefined-variable]

Intel oneAPI Fortran compiler

Uninitialized variable warnings are a runtime -check:uninit with “ifx” Fortran compiler, not currently available in compile-time -warn.

NVIDIA HPC SDK Fortran compiler

The “nvfortran” compiler nvfortran -help didn’t reveal any options to detect undefined variables beyond the usual -Mdclchk that enforces implicit none - but that’s a declaration check, not a defined variable check.

Whether using Clang / LLVM or Homebrew GNU GCC compiler, GNU ld is not supported on macOS. Only the Apple macOS Xcode ld is supported. The new ld linker in Xcode 15 broke numerous projects, including OpenMPI < 4.1.6.

A special workaround for Xcode 15.x only is the linker flag -ld_classic, which is deprecated in Xcode 16 and removed in Xcode 27.

Set in file “~/.zshrc”

export LDFLAGS="$LDFLAGS -Wl,-ld_classic"

Note that for CMake, LDFLAGS environment variable is read only on the first CMake configure and cached.

Each of macOS, Windows, and Linux has a way to get and set which users have administrative privileges (i.e. can use sudo or are in the Administrators group) from Terminal.

macOS get / set sudo users from Terminal

On macOS, the users who are sudo -capable (i.e. administrators) can be discovered from Terminal using the Directory Service command line utility dscl:

dscl . -read /Groups/admin GroupMembership

To add a user to the sudoers list, use the following command:

dscl . -append /Groups/admin GroupMembership <username>

Windows get Administrator users from Terminal

On Windows, the users who are Administrator capable can be discovered from PowerShell using:

Get-LocalGroupMember -Group "Administrators"

Query a specific user to see if they are an Administrator:

$user = "myUsername"
# put the desired username in the $user variable, then run the following command:

Get-LocalGroupMember -Group "Administrators" | Where-Object { $_.Name -like "*\$user" }

Make a user an Administrator:

Add-LocalGroupMember -Group "Administrators" -Member "myUsername"

For Windows Subsystem for Linux (WSL), use the Linux commands below.

Linux get / set sudo users from Terminal

On Linux, the users who are sudo -capable (i.e. administrators) can be discovered from Terminal using:

getent group sudo

Add a user to the sudo group (allowing them to use sudo):

sudo usermod -aG sudo <username>

List connected hard drives on macOS using the Terminal:

diskutil list

The “NAME” column shows the names of the hard drives under “/Volumes”. The following command gives a more detailed view of the connected hard drives:

system_profiler SPStorageDataType

Long-running Terminal programs might not be detected by the operating system on a laptop or other device that has power-saving sleep or suspend modes. This can lead to disappointment as the long-running program hasn’t completed when the user checks back. This caffeinate Python script works with:

• Windows
• Linux systemd-inhibit
• macOS caffeinate

to keep the computer awake while a command line program is running, using features built into the operating system utilities.

To avoid a computer going to sleep / suspend in general persistently is OS-dependent.

macOS power management from Terminal

For macOS, check and save to a text file the current power management settings with pmset:

pmset -g

To disable sleep / standby while on AC power (charger), which is also suitable for fixed devices like the Mac Mini:

pmset -a sleep 0 standby 0

Linux power management from Terminal

For Linux using systemd, check the current power management settings with:

systemctl list-unit-files | grep -E 'sleep|suspend|hibernate|hybrid'

look for any that show “enabled”.

To disable sleep while on AC power (charger), which is also suitable for fixed devices like a desktop, use systemctl mask to disable the sleep, suspend, hibernate, and hybrid-sleep targets:

systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target

Windows power management from Command Prompt

For Windows, check and save to a text file the current power management settings with powercfg:

powercfg /query

Look for “Current AC Power Setting Index” in the output for “Sleep” and “Hibernate” to see the current settings.

To disable sleep while on AC power (charger), which is also suitable for fixed devices like a desktop:

powercfg /change standby-timeout-ac 0

To set Hibernate to never while on AC power (charger), while allowing hibernate to be enabled for battery power (important for laptop tucked away for the weekend), run the following command:

powercfg /change hibernate-timeout-ac 0

Note that powercfg /hibernate off completely disables hibernate, which is not necessarily recommended for laptops that may be stored without power when not manually shut down each time.

While CMake binaries can be downloaded for most platforms, there are certain cases where one wishes to build CMake from source. For example, when preparing a merge request to fix or enhance CMake. Usually the computer will have at least an older version of CMake that can be used. If so, we recommend using the existing CMake to build the newer CMake from the CMake source directory. We recommend using Ninja in general for faster build and rebuild for any CMake project.

cmake -B build -DBUILD_TESTING:BOOL=OFF -DCMAKE_BUILD_TYPE=Release --install-prefix=$HOME/cmake-dev -G Ninja

cmake --build build

cmake --install build

A one-step download-build script is the scripts/build_cmake.cmake.

If an old CMake isn’t available on the computer, then use CMake bootstrap:

./bootstrap --prefix=$HOME/cmake-dev --generator=Ninja -- -DBUILD_TESTING:BOOL=OFF -DCMAKE_BUILD_TYPE:STRING=Release

ninja -C Bootstrap.cmk/ install

This puts the compiled CMake under ~/cmake-dev, without disturbing the primary CMake install. Upon making any CMake code changes, simply recompile the minimum needed bits by:

ninja -C Bootstrap.cmk/ install

This procedure should be attempted only when at the Apple computer physically, as it requires enabling remote access and setting a password for the VNC server, in case something goes wrong and the user is locked out of the computer remotely. For software development on a remote macOS computer, it can be easier to use VSCode over SSH to the remote computer.

As on other operating systems, VNC server on macOS is unencrypted and should be restricted to localhost only, using SSH tunneling for remote access. The VNC server is built into macOS and can be enabled in the System Preferences or via Terminal.

Restrict VNC server to localhost only:

defaults write /Library/Preferences/com.apple.RemoteManagement.plist VNCOnlyLocalConnections -bool yes

Restart the VNC server for the change to take effect:

launchctl unload -w /System/Library/LaunchDaemons/com.apple.screensharing.plist
launchctl load -w /System/Library/LaunchDaemons/com.apple.screensharing.plist

From TigerVNC or other VNC client, the username and password are the same as the macOS user account.

Connect via a new SSH connection:

ssh -L 5900:localhost:5900 user@remotehost

Start TigerVNC or other VNC client and connect to localhost:5900 to access the macOS desktop remotely, using the macOS user account credentials. If the VNC screen is all black, ensure a user is logged in on the macOS computer physically. If that works, figure out what keystrokes were needed to log in so that when remote, the user can log in without needing to see the screen physically.

Regardless of how an App is installed, whether through WinGet, the Microsoft Store, or a direct download, WinGet can be used to find the program install location on disk. For example, to find the install location of the Microsoft Edge browser:

winget list Microsoft.Edge --details

programatically like:

(winget list Microsoft.Edge --details | Select-String -Pattern 'Installed Location:\s*(.+)').Matches.Groups[1].Value.Trim()

The results include “InstalledLocation” which for this example may be examined like:

ls ${Env:ProgramFiles(x86)}/Microsoft/Edge/Application

with results including the Edge executable msedge.exe.