Back in 2012, I wrote a small experimental piece on building a simple FFT-based spectrum analyzer:

🔗 https://som-itsolutions.blogspot.com/2012/01/fft-based-simple-spectrum-analyzer.html

At that time, it was more about curiosity. FFT fascinated me. The idea that a signal in time could reveal its hidden structure in frequency felt almost magical.

Fast forward to today.

I am revisiting that same idea — but this time using Julia, and not just for visualization, but for building something that could contribute to modern railway track safety systems.

And that’s when I realized why Julia is becoming so popular among the SciML (Scientific Machine Learning) community.

The Shift: From Scripting to Scientific Computing

In 2012, building a spectrum analyzer was largely:

A signal processing experiment
A learning exercise
A visualization tool

But today, with Julia, the same FFT analyzer becomes:

A condition monitoring prototype
A vibration diagnostics engine
A predictive maintenance building block

That shift is profound.

Why SciML Engineers Love Julia

The SciML ecosystem — led by projects like SciML — is not just about machine learning. It’s about merging:

Differential equations
Physics-based modeling
Optimization
Machine learning
High-performance computing

Julia allows all of this in one language.

1️⃣ Performance Without Leaving the Language

FFT in Julia uses FFTW under the hood.

You write:

fft(signal)

And you get near C-level performance.

No bindings.
No external compilation workflow.
No switching between Python and C++.

For someone who enjoys going deep into engineering mathematics, that matters.

2️⃣ Multiple Dispatch Feels Like Engineering Thinking

As someone who loves system design and patterns, I noticed something interesting.

In C++ or Java, you think in terms of classes and inheritance.

In Julia, you think in terms of:

Mathematical structures
Generic functions
Behavior based on types

It feels closer to how engineers think about systems.

Not "object owns behavior" —
but "system responds based on physical type."

That mental alignment is powerful.

3️⃣ From FFT to Railway Safety

Let’s connect this back to my spectrum analyzer journey.

A railway track under load behaves like a vibrating beam.
When a crack develops, stiffness changes.
That produces high-frequency bursts in vibration signals.

With Julia, I can:

Simulate the rail as a mass-spring-damper system
Inject a stiffness drop
Perform FFT
Detect high-frequency anomalies
Add ML-based classification

All in one environment.

Modern railway systems, including those used by Indian Railways and Deutsche Bahn, rely heavily on:

Vibration analytics
Spectral energy monitoring
Predictive maintenance

What began as a simple FFT experiment now becomes a prototype for rail crack detection.

That evolution mirrors Julia’s evolution.

SciML Is More Than Machine Learning

SciML is about:

Embedding physical laws into ML
Solving differential equations efficiently
Combining simulation with learning

Using Julia, I can go from:

[
m\ddot{x} + c\dot{x} + kx = F(t)
]

to spectral fault detection
to anomaly classification

without leaving the language.

That continuity is rare.

Why This Matters for Engineers

Many engineers hesitate to enter machine learning because:

Python feels high-level but slow
C++ feels powerful but heavy
MATLAB feels proprietary

Julia sits in a sweet spot:

Scientific syntax
High performance
Open ecosystem
Growing SciML community

And most importantly:

It lets you experiment at system level.

My Personal Realization

Rebuilding my old FFT-based spectrum analyzer in Julia was not nostalgia.

It was a rediscovery.

The same math.
The same Fourier transform.

But now:

Faster
Cleaner
Extensible
Connected to real-world safety applications

That is why Julia is becoming popular among SciML engineers.

Because it doesn’t just let you code.

It lets you think in equations and deploy in production.

Final Thought

What started as a simple blog post on FFT years ago has evolved into a small predictive maintenance prototype for railway safety.

Julia didn’t just make it easier.

It made it natural.

And when a language feels natural to scientists and engineers —
that’s when it starts becoming popular.

Here's the source code...

############################################################
# Rail Vibration Monitoring Prototype
# CASE B: Rail Crack Simulation
############################################################

using FFTW
using DSP
using Plots
using Statistics
using LinearAlgebra

# -------------------------------
# 1️⃣ System Parameters
# -------------------------------

fs = 5000                  # Sampling frequency (Hz)
T  = 2                     # Signal duration (seconds)
t  = 0:1/fs:T-1/fs
N  = length(t)

println("Sampling Frequency = $fs Hz")
println("Total Samples = $N")

# -------------------------------
# 2️⃣ Normal Rail Vibration
# -------------------------------

f_mode1 = 50
f_mode2 = 120

signal = 0.7*sin.(2π*f_mode1*t) .+
         0.3*sin.(2π*f_mode2*t)

# -------------------------------
# 3️⃣ Inject Crack Fault (High-Frequency Burst)
# -------------------------------

crack_time = 1.0                          # crack at 1 second
crack_index = Int(round(crack_time * fs))

burst_length = 200                        # samples (~40 ms)
crack_freq = 800                          # high-frequency crack signature

if crack_index + burst_length <= N
    signal[crack_index : crack_index + burst_length] .+=
        2*sin.(2π*crack_freq*t[1:burst_length+1])
end

# Add background noise
signal .+= 0.2randn(N)

println("Simulated Crack Frequency = $crack_freq Hz")

# -------------------------------
# 4️⃣ Time Domain Plot
# -------------------------------

p1 = plot(t, signal,
    xlabel="Time (s)",
    ylabel="Amplitude",
    title="Rail Vibration Signal (Crack Simulation)",
    legend=false)

# -------------------------------
# 5️⃣ FFT Processing
# -------------------------------

window = hanning(N)
signal_w = signal .* window

fft_result = fft(signal_w)
freq = fs*(0:N-1)/N
magnitude = abs.(fft_result)/N

halfN = div(N,2)

# -------------------------------
# 6️⃣ Spectrum Plot
# -------------------------------

p2 = plot(freq[1:halfN],
          magnitude[1:halfN],
          xlabel="Frequency (Hz)",
          ylabel="Magnitude",
          title="Frequency Spectrum",
          legend=false,
          xlim=(0,1000))   # Extended to show 800 Hz

# -------------------------------
# 7️⃣ Side-by-Side Display
# -------------------------------

p3 = plot(p1, p2, layout=(1,2), size=(1200,400))
display(p3)

# -------------------------------
# 8️⃣ Crack Detection Logic
# -------------------------------

println("\n🔍 Running Crack Detection...\n")

# Detect energy in high-frequency band
high_freq_indices = findall(freq .> 600 .&& freq .< 1000)
high_freq_energy = sum(magnitude[high_freq_indices])

println("High Frequency Energy = ", round(high_freq_energy, digits=4))

if high_freq_energy > 0.02
    println("⚠️  Possible Rail Crack Detected (High-Frequency Burst)")
else
    println("✅ No crack signature detected")
end

# -------------------------------
# 9️⃣ RMS Indicator
# -------------------------------

rms_value = sqrt(mean(signal.^2))
println("\nRMS Vibration Level = ", round(rms_value, digits=4))

println("\n--- Rail Crack Monitoring Simulation Complete ---")

wait()

And here's when we run the application...

📈 Time Plot

A sharp disturbance around 1 second.

📊 Frequency Plot

A strong peak near:


800 Hz

🖥 Console Output


⚠️ Possible Rail Crack Detected (High-Frequency Burst)

Som's Tech World...

Thursday, February 26, 2026

Why Julia Is Becoming So Popular Among SciML Engineers And How Rebuilding My Old FFT Spectrum Analyzer Opened a New Railway Safety Perspective