The 220 MHz ACSSB two-way radio system in the USA was a remarkable last gasp of analog technology trailing off as DMR, NXDN, P25, and other digital modes began to dominate the land-mobile radio landscape.
ACSSB squeezed into 5 kHz channel spacing in contrast to the 12.5 - 25 kHz common for two-way radio FM channels.
Digital two-way radio modes achieve 6.25 kHz effective channel spacing via TDMA (DMR, P25 Phase II) or FDMA (NXDN).
A vital contemporary use of 220 MHz band is for data telemetry (e.g. SCADA via GE Vernova / MDS radios) and
Positive Train Control (PTC).
Technical deep dive links:
220 MHz ACSSB system design manual fascinating with good LTR and conventional system design info applicable to common radio systems.
While many UHF intercoms (e.g. RTS BTR-800) use wideband (40 kHz deviation) FM, there is a design house that made ACSSB intercoms for nuclear power plants due to the uniquely severe multipath and RF environment
Political analysis on FCC spectrum auctions including 220 MHz band
The construction requirements for SMRs in the 220, 800, and 900MHz band across the 1990s and 2000s led to some interesting scenarios.
One that I saw in the Lansing, Michigan area in the late 1990s was an 800 MHz 5 channel LTR system that used 5 Realistic analog scanning receivers set to a single frequency each, with 5 EF Johnson 8600-series mobile radios set to talkaround on the repeater output frequency.
The scanners and mobile were each wired to an LTR controller panel to make a functioning trunked repeater system.
This actually worked, but was certainly not to the RF performance of a dedicated repeater design.
This was done after the SMR licensee lost 5 of their original 10 channel license due to failure to meet construction requirements.
An attempt to provide a 220 MHz
LTR-Net system
and data telemetry network across 80% of the continental USA and 2/3 of the population was made by Cornerstone SMR, who was one of the 220 MHz
auction 72 winners,
but adoption stalled and Cornerstone SMR was
denied a waiver
on their 220 MHz license construction requirements in 2018.
Cornerstone SMR aimed to raise about
$5 million in 2003-2004
from investors to build out the wide-area 220 MHz LTR-Net network.
Civil theft litigation
due to an employee stealing nearly $500k led to an appeal ending in 2015 (Cornerstone SMR, Inc. v. Bank of Am., N.A. , 163 So. 3d 565, 568 (Fla. 4th DCA 2015)) and set a precedent in Florida case law.
Cornerstone SMR’s idea to use their 220 MHz spectrum for a nationwide IoT network and proposed business
merger
to make innovative IoT hardware ultimately led to
litigation filed
in Delaware in Sept. 2025.
CMake 4.2 enables
Visual Studio 18 2026
generator.
The
FASTBuild
generator is added, and has impressive
benchmarks.
FASTBuild supports more modern platforms including Windows, versus
ccache
or distcc.
ExternalProject
added options to modify environment variables at each step by CONFIGURE_ENVIRONMENT_MODIFICATION, BUILD_ENVIRONMENT_MODIFICATION, INSTALL_ENVIRONMENT_MODIFICATION, TEST_ENVIRONMENT_MODIFICATION
CMake 4.1 project() added COMPAT_VERSION that propagates to subdirectories and can be queried for the top-level COMPAT_VERSION.
CMake 4.0 enables
CMAKE_LINK_WARNING_AS_ERROR
boolean option sets most compilers to error if a compile warning occurs, which is generally a good setting for CI systems.
target_link_libraries()
can use a LINKER: prefix to abstract options.
CMake
SARIF output
allows IDEs to better parse build status.
CTest
–interactive-debug-mode
is particularly useful on Windows to enable debug dumps and error popup windows.
CMake
3.31
warns if cmake_minimum_required() is
< 3.10.
TLS ≥ 1.2 is required by default for internet operations e.g. file(DOWNLOAD), ExternalProject, FetchContent, and similar.
file(ARCHIVE_CREATE)
gained a long-needed WORKING_DIRECTORY parameter that is essentially necessary to avoid machine-specific paths being embedded in the archive.
CMAKE_LINK_LIBRARIES_STRATEGY
allows specifying a strategy for ordering target direct link dependencies.
CMake
3.30
adds C++26 support.
CMAKE_TLS_VERIFY
environment variable was added to set TLS verification (true, false).
CMake 3.31 defaults CMAKE_TLS_VERIFY to on, where previously it was off.
CMake
3.29
adds
cmake_language(EXIT code)
to exit CMake script mode with a specific return code.
This is useful when using CMake as a platform-agnostic scripting language instead of shell script.
Environment variable
CMAKE_INSTALL_PREFIX
is used to set the default install prefix across projects–it can be overridden as typical by cmake -DCMAKE_INSTALL_PREFIX= option.
Target property
TEST_LAUNCHER
allows specifying a test launcher.
For MPI program this allows deduplicating or making more programmatic test runner scripts.
Linker information variables including
CMAKE__COMPILER_LINKER_ID
have been added to allow programmatic logic like setting target_link_options() based on the particular linker.
CMake
3.28
changes PATH behavior for
Windows find_{library,path,file}()
to no longer search PATH.
This may break some projects that rely on PATH for finding libraries.
The MSYS2-distributed CMake is patched to include PATH like earlier CMake, which can be confusing for CI etc. not using MSYS CMake with that patch.
Windows CI/user may need to specify CMAKE_PREFIX_PATH like
Support for C++20 modules is considerably improved and most users will want at least CMake 3.28 to make C++ modules usable.
Generator expressions $<IF> $<AND> $<OR> now short circuit.
Test properties now have a DIRECTORY parameter, useful for setting test parameters from the project’s top level CMakeLists.txt.
CMake 3.28.4 fixed a long-standing bug in Ninja Fortran targets that use include statements.
The brief listing of other, somewhat similar blogs is not in any way an endorsement or indication of curation.
It’s simply a notepad to remember what other blogs I might have once looked at that reminded me of content I’ve written or helped produce in the past.
Since blog addresses might change, discontinue, or go off the deep end, I just put the plain non-linked text.
Matlab or GNU Octave “.m” script functionality can be readily extended with Java code within the “.m” file.
Matlab or GNU Octave do not necessarily include Java from the factory installation.
Even if a
compatible JDK
is installed in Matlab or GNU Octave, Java can be disabled by
-nojvm.
Detect if JVM is available from within a Matlab script by:
GNU Octave also has a
JVM interface
that extends Octave functionality.
The same commands as for Matlab generally work in Octave via builtin functions javaMethod() and javaObject().
If Java isn’t available in Octave, see if no location or an out of date location to Java is set in the environment variable JAVA_HOME:
getenv('JAVA_HOME')
Currently GNU Octave doesn’t have a way to disable Java from the command line like Matlab’s -nojvm option.
One might try setting environment variable JAVA_HOME to an invalid location before starting Octave to simulate no JVM.
GCC has broad support of modern standards on a very wide range of computing platforms.
GCC is competitive in build time and runtime with vendor-specialized compilers. These may offer vendor-specific capabilities not available in general compilers like GCC.
Intel
oneAPI compilers
are free to use for any user, supporting Linux and Windows computers with x86-64 CPU including from AMD, Intel, etc.
Intel
oneAPI components
like MKL, IPP, and TBB are available at no cost.
Intel
MPI Library
implements the MPICH specification for massively parallel computation across discrete computing nodes.
LLVM Clang C and C++ compilers join with the
Flang
Fortran compiler using modern C++ internals and robust industry support.
LLVM is known for performance, correctness, and prompt implementation of new language standards.
LLVM has powerful associated tooling like clang-format, clang-tidy, and sanitizers.
It is generally important to ensure that a project builds with both LLVM and GCC for better portability.
AMD
AOCC LLVM compiler
is tuned for
AMD CPUs.
AOCC works on non-AMD CPUs but is generally only useful for those with HPC/AI workloads on AMD CPUs, as it typically uses LLVM releases that are a few versions behind the latest.
AMD GPUs are the focus of the
ROCm software stack,
which includes the HIP C++ language and ROCm Fortran compiler.
Currently the
ROCm Fortran Next Gen
compiler is in early development and is intended for advanced users who need to use AMD GPUs with Fortran or C/C++ code.
NVIDIA
HPC SDK
is free to use and works on a variety of desktop CPUs including x86-64, OpenPOWER, and ARM.
A key feature of the NVIDIA compilers is intrinsic support for
CUDA Fortran,
enabling offloading computationally intensive Fortran code to NVIDIA GPUs.
NVIDIA HPC SDK includes specialized tools for NVIDIA Nsight profiling, debugging, and optimizing HPC applications on NVIDIA platforms.
Unlike the other compilers mentioned above, IBM OpenXL LLVM-based compilers are specifically designed for POWER CPUs, such as ppc64le.
Consequently, IBM OpenXL compilers do not work with typical x86-based computers.
The IBM OpenXL Fortran compiler features extensive optimization capabilities specifically for POWER CPU architecture.
It supports OpenMP for parallel processing and can auto-vectorize code for POWER vector units (VSX, VMX).
The compiler includes built-in support for IBM MASS (Mathematical Acceleration Subsystem) libraries and optimization reports to help developers tune code performance.
OpenXL compilers include hardware-specific optimizations for POWER CPUs and support for IBM-specific operating systems like AIX.
DOSBox-X
uses configuration file dosbox-x.conf for numerous parameters, including for serial port access via USB to serial adapters.
First, identify the device ID for USB to serial adapter:
Linux: ls /dev/ttyUSB* or ls /dev/ttyACM*
macOS: ls /dev/cu.* or ls /dev/tty.*
On Linux, allow non-sudo serial port access by adding the username to “plugdev” and “dialout” groups, then logout and login.
adduser $(whoami) plugdev dialout
Locate
and edit dosbox-x.conf.
Under [serial] modify the serial1=dummy according to the device found above.
For example on Linux, if the device is at “/dev/ttyUSB0”:
serial1=directserial realport:ttyUSB0
DOSBox-X would present the serial device on COM1 as seen from within DOSBox-X.
Matlab Startup Accelerator
for Windows is intended to speed up Matlab startup.
However, by default Matlab disables the Startup Accelerator on many systems.
To check if Matlab Startup Accelerator is enabled on a Windows system, check Windows Task Scheduler by the snapin:
taskschd.msc
Look under Task Scheduler Library for a task named Matlab R20XXx Startup Accelerator (where 20XXx is the Matlab release).
Consider disabling it to avoid needless resource usage if it is not already disabled.
On modern computers with SSD drives, Matlab startup is already fast.
Python 3.15 added
os.statx()
function that provides access to the high performance
statx()
system call available on Linux kernels 4.11 and newer with glibc 2.28 and newer.
The Ffilesystem library uses statx() by default if available on Linux.
Having os.statx() available in Python allows for easier prototyping of features that might use statx().
See
Ffilesystem
statx() code for usage examples with graceful fallback to stat().
The
Minicom
serial communication program allows connecting to devices over the serial port and transferring files using XMODEM, YMODEM, or ZMODEM protocols–PuTTY can’t currently do file transfer over serial links.
Install Minicom like:
macOS: brew install minicom lrzsz (lrzsz is for file transfer)
Linux: apt install minicom lrzsz (or similar for relevant package manager)
Windows: use WSL (Windows Subsystem for Linux)
On macOS in particular for file transfers, first be sure that Minicom can find the sz, rz commands by looking under Esc-O for “File transfer protocols”. It may be necessary to point to lsz and lrz installed by
Homebrew.
As noted in the documentation for Minicom, it is possible to save profiles.
To just use a device directory, set command line options like:
minicom -D /dev/tty.usbserial-0001 -b 115200
List the USB-serial adapter ports:
Linux: ls /dev/ttyUSB*
macOS: ls /dev/tty.usbserial*
To send a file from Minicom once the device is ready, press Esc-Z and then S for send, select the appropriate protocol.
Concurrency is built into Python via
asyncio.
AsyncIO generators are implemented with yield much like synchronous generators.
async for
also simplifies expression of asynchronous for loops.
As in Julia, the expression of asynchronous structures in Python does not implement concurrent execution.
Concurrent execution in Python is governed by collections of tasks or futures such as
asyncio.gather
and initiated by a runner such as
asyncio.run.
Debugging asyncio code is facilitated by
introspection
built into Python.
AsyncIO
subprocess
may need specific
asyncio loop configuration.
The options needed are not the same for every project, depending on the asynchronous functions used.