Six tiny Python examples that made audio DSP less abstract

When I first learned audio signal processing, the hard part was not memorizing terms like FFT, STFT or MFCC.

The hard part was seeing what each step actually produced.

A lot of audio tutorials jump quickly into a library call, a polished plot, or a model. That is useful later, but it can hide the basic shape of the signal-processing pipeline.

So I rebuilt an old audio DSP learning pack into something much smaller:

• generate a waveform;


• inspect frequency content with an FFT-style spectrum;


• create a small STFT spectrogram;


• compute mel / MFCC-style features;


• compare spectral centroid, bandwidth and rolloff;


• use those features in a tiny nearest-centroid classifier.

The goal is not to build production DSP software.

The goal is to make the intermediate outputs visible.

The learning habit I wanted

For beginners, I think one habit matters more than the specific library:

generate an output file you can inspect after each step.

That might be a WAV file, a CSV table, an SVG plot, or a small text result.

If every step produces something visible, then terms like "spectrogram" or "spectral centroid" stop being abstract labels. You can look at the artifact and ask:

• what changed in the signal?


• what did the transform keep?


• what did it discard?


• what parameter changed the output?


• what would break if the input were noisier?

That is slower than importing a powerful library and jumping to the final plot.

But for learning, slower can be better.

Why I avoided third-party packages in this small lab

This was a deliberate constraint.

Libraries like librosa and SciPy are excellent. I am not arguing against them.

But if the goal is to understand the pipeline, dependency-light examples force the code to stay close to the idea:

• loops are visible;


• bins are visible;


• windows are visible;


• feature summaries are visible;


• the toy classifier is obviously a toy.

That last point matters. A small classifier demo should not pretend to be a serious audio ML system.

In my rebuilt version, the classifier is only there to connect feature extraction with a downstream decision. It is not there to claim production accuracy.

The six-example path

The learning path looks like this:

1. Waveform basics
   
   
   Generate and normalize a small audio signal, then write a WAV, CSV and SVG preview.




2. FFT spectrum
   
   
   Inspect frequency peaks instead of only looking at the waveform.




3. STFT spectrogram
   
   
   See the time-frequency tradeoff on a small generated chirp.




4. Mel / MFCC-style features
   
   
   Build a simplified learning version of perceptual feature extraction.




5. Spectral summaries
   
   
   Compare centroid, bandwidth and rolloff across small synthetic samples.




6. Tiny audio classifier
   
   
   Use extracted features in a nearest-centroid classifier and inspect the predictions.

Again: this is not a replacement for a real DSP stack.

It is a small bridge between theory and inspectable code.

What I packaged

I turned this into a compact paid code lab:

• six runnable Python examples;


• six supplementary PDF guidebooks;


• generated output files;


• setup notes;


• included-files notes;


• explicit limitations.

The examples are intentionally small. They are for people who want FFT, STFT, MFCC-style features and simple spectral summaries to feel less mysterious before moving into larger libraries or models.

If that sounds useful, the Gumroad page is here:

https://chen77studio.gumroad.com/l/audio-dsp-blueprint-code-lab

Price: USD 19.

What I am testing with this launch is simple: whether a small, honest, runnable code lab is more useful to learners than another broad "complete audio ML course" promise.