Scientific Computing

Python has become a dominant language for scientific computing, data analysis, machine learning, and engineering workflows. Julia offers a modern high-performance syntax specifically designed for numerical and scientific computing. GNU Octave is an open-source MATLAB alternative with largely MATLAB compatibile syntax.

GNU Octave continues to be developed by John W. Eaton. Octave is a high-level interpreted language designed for numerical computations. The community continues to release major versions roughly yearly.

Octave shines when you need:

• Near drop-in compatibility with MATLAB .m files (as long as proprietary toolboxes aren’t required).
• A quick way to test whether it’s worth porting a MATLAB function or script to Python.
• Calling MATLAB/Octave functions directly from Python using Oct2Py.

Octave includes its own growing set of packages (toolboxes) that extend its capabilities in areas like signal processing, control systems, and optimization.

Julia

Julia is a modern, high-performance language designed specifically for scientific and numerical computing. It aims to combine the ease of use of Python/MATLAB with the speed of C/Fortran.

Julia excels when:

• You need high performance without dropping to lower-level languages (JIT compilation often delivers near-C speeds for numerical loops and linear algebra).
• Working on large-scale simulations, differential equations, optimization, or other compute-intensive scientific tasks.
• You want a clean, math-friendly syntax with advanced features like multiple dispatch, metaprogramming, and excellent built-in support for parallelism and distributed computing.
• Reproducibility and package management are priorities (via its built-in package manager).

Julia has strong libraries for data science, machine learning, visualization, and more, though its overall ecosystem is smaller than Python’s. It’s particularly appealing for researchers writing performance-critical code from scratch.

Python

Key Advantages of Python:

• Vast ecosystem: NumPy, SciPy, Pandas, Matplotlib, scikit-learn, PyTorch/TensorFlow, and thousands of other specialized libraries cover everything from microcontrollers to supercomputers.
• Scalability: The same language and core libraries work from embedded devices → Raspberry Pi → laptops → HPC clusters.
• Reproducibility: Open-source nature means anyone can run your code with pip install or conda environments—no license server or version-matching headaches.
• Embedded / IoT support: Since 2014, MicroPython has brought a capable subset of Python (including exception handling, coroutines, etc.) to low-cost hardware like the Raspberry Pi Pico and many other MCUs/SoCs.

Python’s general-purpose nature also makes it easier to integrate with web apps, databases, GUIs, automation scripts, and version control workflows—areas where Octave is weaker.

Comparison Table

With Python and Oct2Py, Octave can be a bridge for those transitioning away from MATLAB. While Python is often a default choice for new projects, Julia can be a compelling alternative for high-performance numerical work.

Other Mathematical Software

These systems generally have smaller user bases than Python or MATLAB/Octave, largely due to historical momentum and narrower focus.

• SageMath — Open-source computer algebra system with excellent symbolic math capabilities.
• Scilab — Another free MATLAB-like environment.
• GDL — Open-source IDL work-alike, common in astronomy and geophysics.
• Mathematica / Maple — Proprietary tools with strong symbolic mathematics focus.

The default interactive shell for operating systems is typically:

• Linux: Bash
• macOS: Zsh
• Windows: PowerShell

Note that the non-interactive shell may default to a simpler POSIX shell like Dash, so ensure that script shebang line specifies the intended shell for running scripts.

Each shell vendor has configuration files to change the default shell parameters. Shells typically have a persistent command history file that stores the commands that have been executed. This allows users to recall and reuse previous commands. A very long history may retain mistyped commands or commands that are no longer relevant.

Bash

Get the location of the Bash command history file:

echo "${HISTFILE:-$HOME/.bash_history}"

Edit the ~/.bashrc file to include the following settings:

# Number of commands remembered in the current session (in memory)
export HISTSIZE=500

# Number of commands saved to the history file on disk
# Keep at least a little bigger than HISTSIZE to handle duplicates
export HISTFILESIZE=1000

# Ignore both duplicate and empty commands
export HISTCONTROL=ignoredups:ignorespace

Zsh

Get the location of the Zsh command history file:

echo "${HISTFILE:-${ZDOTDIR:-$HOME}/.zsh_history}"

Edit the ~/.zshrc file to include the following settings:

# Number of commands remembered in the current session (in memory)
export HISTSIZE=500

# Number of commands saved to the history file on disk
# Keep at least a little bigger than HISTSIZE to handle duplicates
export HISTFILESIZE=1000

setopt hist_ignore_dups
setopt hist_ignore_space

PowerShell

Get the location of the PowerShell command history file:

(Get-PSReadLineOption).HistorySavePath

Edit the “$profile” file to include the following settings: ignore duplicates and limit the number of commands in the history.

Set-PSReadLineOption -MaximumHistoryCount 500 `
                     -HistoryNoDuplicates

CMake can be configured to use shorter paths for build paths, which is important for large or complex projects on Windows where the 260 character path limit is a problem for some tools. This is done via CMAKE_INTERMEDIATE_DIR_STRATEGY which is a CMake environment variable as well as a CMake command-line option. The default is to use full paths for human readability, but for those occasions where the path length is a problem, this option can be set to SHORT to use shorter paths.

This example below is contrived to use a long source file path - the problem in practice comes from nested dependencies and build directories, which can easily exceed the 260 character limit on Windows when building a project with CMake. However, this example still demonstrates the issue and the solution with the shorten build path option.

cmake_minimum_required(VERSION 4.2)

project(soLong LANGUAGES CXX)

# make a long path to demonstrate the issue
set(long_path "${CMAKE_BINARY_DIR}/this/is/a/very/long/path/that/will/exceed/the/260/character/limit/on/windows/when/building/a/project/with/cmake/lets/see/if/it/works/with/the/shorten/build/path/option/just/to/make/sure/it/is/long/enough/to/exceed/the/limit/we/need/to/make/sure/it/is/long/enough/to/exceed/the/limit/")

string(LENGTH "${long_path}" L)

message(STATUS "Long path length: ${L} characters")
message(STATUS "CMAKE_INTERMEDIATE_DIR_STRATEGY: ${CMAKE_INTERMEDIATE_DIR_STRATEGY}")

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
message(STATUS "See file ${CMAKE_BINARY_DIR}/compile_commands.json for the compile commands with the long path")

file(MAKE_DIRECTORY "${long_path}")

file(GENERATE OUTPUT "${long_path}/main.cpp" CONTENT "int main() { return 0; }")

add_executable(soLong "${long_path}/main.cpp")

Compare the -o flag parameter between these two commands. The SHORT will be much shorter than FULL.

cmake -Bbuild -DCMAKE_INTERMEDIATE_DIR_STRATEGY=SHORT && cat build/compile_commands.json

cmake -Bbuild -DCMAKE_INTERMEDIATE_DIR_STRATEGY=FULL && cat build/compile_commands.json

CMake can print cache variables during the configuration phase using any of these methods.

The “cmake” command itself can print cache variables to the console. Variable values may be set by passing -D options to the “cmake” command, or by editing them in the CMake GUI or “ccmake” interface.

cmake -Bbuild -LAH

-L

Print only the variable names and values, without help messages

-LA

Print all variables, including advanced ones that are not shown by default.

-LAH

Also print help message for each variable.

The CMake GUI is available if installed and a graphical desktop is available. Press “Configure” to see the cache variables. Values may be edited if desired.

cmake-gui -S . -B build

The “ccmake” Curses-based interface is available on non-Windows platforms, which can also edit cache variables.

ccmake -B build

From the “ccmake” interface, press “c” to configure, “t” to toggle visibility of Advanced variables that are not shown by default.

Mathworks published a Terminal emulator app for Matlab, which is performant and well-integrated with Matlab. It does not require any Matlab toolboxes and can be used on all platforms that Matlab supports. Matlab Terminal supports multiple tabs, customizable themes, and various shell and AI Agent environments. For those using a separate IDE like VS Code with Matlab, the integrated terminal in VS Code is still a good choice. For users who prefer to work directly in Matlab, this Matlab Terminal app is a great addition.

GCC / Gfortran 10 and newer warn for arrays too big for the current stack settings. Having arrays that exceed the stack limit may cause unexpected behavior - they should use allocate() instead in general. Example of improper use of stack memory:

subroutine big_array()

real :: big2(1000,1000)

end subroutine

Warning: Array ‘big2’ at (1) is larger than limit set by ‘-fmax-stack-var-size=’, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider using ‘-frecursive’, or increase the ‘-fmax-stack-var-size=’ limit, or change the code to use an ALLOCATABLE array. [-Wsurprising]

This is generally a true warning when one has assigned arrays as above too large for the stack. Simply making the procedure recursive may lead to segfaults.

Correct the example above like:

subroutine big_array()

real, allocatable :: big2(:,:)

allocate(big2(1000,1000))

end subroutine

For multiple arrays of the same shape do like:

subroutine big_array()

integer :: M=1000,N=2000,P=500

real, allocatable, dimension(:,:,:) :: w,x, y, z

allocate(w(M,N,P))
allocate(x,y,z, mold=x)

end subroutine

Intel oneAPI caution

Intel oneAPI has the option -heap-arrays, but we recommend avoiding this option as it can cause memory leaks.

Windows has particular linking requirements for shared libraries that can become challenging with MSVC-like compilers such as Intel oneAPI when linking Fortran and C libraries together. In short, the workaround is to use static libraries instead of shared libraries for such cases on Windows.

Example: MUMPS-superbuild project provides MUMPS libraries in the same way as the original MUMPS project’s Makefiles, that is with a library called “mumps_common” and then a library for each of 4 numerical precisions “smumps”, “dmumps”, “cmumps”, and “zmumps” that link against “mumps_common”. This is quite robust across compilers and linkers - the only issue is on Windows with oneAPI when building shared libraries.

Building shared libraries for MUMPS-superbuild is done by:

cmake --workflow shared

Most unresolved externals with oneAPI on Windows were symbols like:

MUMPS_BUF_COMMON_mp_...
MUMPS_OOC_COMMON_mp_...
MUMPS_LR_COMMON_mp_...
MUMPS_LR_STATS_mp_...

A first hypothesis was that auto-export was incomplete. CMake on Windows can auto-export symbols via CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS. In mixed C and Fortran projects, that is often good enough. Given the unresolved names, it was reasonable to suspect missing DATA exports from mumps_common.dll.

We ran a few checks to diagnose:

1. Inspected linker diagnostics to collect unresolved symbol families.
2. Inspected generated export definition .def files to see what CMake actually exported.
3. Compared expected names versus actual exports in the produced DLL/import library path.
4. Tested oneAPI-specific compile/link flag ideas.

Auto-export did miss symbols that appeared in unresolved lists. But even after supplementing exports, unresolved externals persisted. We tested multiple fixes, including:

• Supplemental export definitions for missing DATA symbols.
• oneAPI flag experiments intended to improve dynamic common/module handling.
• Internal bridge-style link topology changes.

Why these were rejected:

• Supplemental exports alone did not clear unresolved module-data references.
• oneAPI flag experiments were either ineffective or unstable for this build.
• Bridge-link approaches can alter expected import-library behavior and create downstream risk for users linking mumps_common.lib.

The root cause appears to be broader than CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS. Auto-export can be incomplete, but even with explicit extra exports, oneAPI Fortran on Windows still struggled to resolve cross-DLL module/common data references in this configuration.

Practical recommendations

To maintain mixed Fortran/C HPC packaging across compilers, validate shared-library topology on every target compiler, especially Windows. Treat Fortran module/common data across Windows DLL boundaries as a first-class risk. To keep it simple - use static libraries.

Captchas provide a means to limit automated access to web services. Users have become accustomed to solving captchas to access common web resources. Malicious actors are exploiting users with fake captcha prompts to trick them into pasting malicious content from the clipboard, even when the user never copied the content themselves. There are multiple approaches to mitigate clipboard-based attacks, such as disabling clipboard history and cross-device synchronization. These measures can reduce the risk of accidentally pasting harmful data.

Note that disabling web browser clipboard features may impact legitimate sites (e.g., Google Docs or other cloud editors).

Browser Settings

• Firefox: In about:config, set dom.event.clipboardevents.enabled to false.
• Chrome / Edge: Go to chrome://settings/content/clipboard (or equivalent in Edge).
• Safari: Go to Settings → Websites → Clipboard.

Cross-Device Risks

These attacks become more dangerous when clipboard synchronization is enabled across devices, such as Apple’s Universal Clipboard or Microsoft Cloud Clipboard.

Windows: Disable Clipboard History & Cross-Device Sync

The following policy keys are the most effective way to disable these features:

• HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\System\AllowClipboardHistory → Set to 0
• HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\System\AllowCrossDeviceClipboard → Set to 0

You can check them with PowerShell:

Get-ItemProperty -Path "HKLM:\SOFTWARE\Policies\Microsoft\Windows\System" -Name "AllowClipboardHistory"
Get-ItemProperty -Path "HKLM:\SOFTWARE\Policies\Microsoft\Windows\System" -Name "AllowCrossDeviceClipboard"

macOS disable Universal Clipboard and clipboard history

To disable Universal Clipboard on macOS, users can turn off the Handoff feature, which is responsible for clipboard synchronization across Apple devices. This can be done by disabling Handoff in System Preferences under the General settings. This prevents the clipboard from being shared between devices, reducing the risk of spreading malicious content. macOS clipboard history can be disabled in System Settings. In the sidebar, click Spotlight. Turn off the toggle for “Results from Clipboard”.

SDARS satellite radio broadcasts of music or video to mobile receivers have largely been a North American phenomenon since the 1990s. Increased need for terrestrial repeaters arose as geostationary SDARS satellites took over from geosynchronous orbits. A key appeal of S-band SDARS is the ability to cover vast areas with a few satellites and coin-sized receiver antennas. The SDARS signal is easily blocked by buildings or terrain, necessitating the use of terrestrial repeaters in urban areas to ensure reliable reception. The SiriusXM 360L receivers seamlessly integrate satellite, terrestrial, and streaming content.

SDARS never took off on other continents, which instead focused on vast terrestrial radio networks such as DAB+ and DRM. DRM is increasingly adopted throughout Africa and Asia, while DAB+ is more popular in Europe. This free DRM broadcast schedule database helps listeners find DRM broadcasts worldwide. It is of note that parts of Europe are trending towards retaining VHF FM broadcast radio (besides DAB+), with multiple nations adding mandates for FM tuners in new cars. North America terrestrial radio networks may use HD Radio for improved audio quality and additional data services. 5G broadcast is being tested by multiple countries as a way to deliver broadcast content to mobile devices instead of individual mobile data streams.

Home satellite TV

In contrast to satellite radio broadcast services, Direct Broadcast Service (DBS) / Direct To Home (DTH) satellite TV has been a global phenomenon with the emergence of sub-60 centimeter dish antennas using 12 GHz Ku-band frequencies by DirectTV and Dish Network emerging in the mid-1990s and analogous services on other continents.

For .NET projects using file-based C# .cs apps or .slnx project files, the dotnet build command is used to compile the project and its dependencies. This command is part of the .NET CLI (Command Line Interface) to build .NET applications from the command line. The complementary dotnet run command builds and runs the application in one step. To create standalone, self-contained dotnet publish binary executables cross-compiled for different CPU arches, see CI example.