Hacker Public Radio

This show has been flagged as Clean by the host.

Python and its libraries

1. librosa — loading and resampling audio

def load_audio(path):
y, sr = librosa.load(path, sr=SR, mono=True)
return y, sr

Every episode, regardless of its original sample rate or channel count, gets loaded down to a single mono stream at 16kHz (SR = 16000). That's one line of librosa, resampling, and folding stereo to mono. It made every downstream tool (VAD, pitch tracking, MFCC extraction) operate on a consistent, predictable input regardless of what an MP3 encoder or podcast host originally used.

2. parselmouth (Praat bindings) — pitch and voice-quality tracking

def pitch_and_hnr(y, sr):
snd = parselmouth.Sound(y, sampling_frequency=sr)
pitch = snd.to_pitch(time_step=PITCH_TIME_STEP, pitch_floor=PITCH_FLOOR, pitch_ceiling=PITCH_CEILING)
f0 = pitch.selected_array["frequency"]
times = pitch.xs()
try:
harmonicity = snd.to_harmonicity_cc(time_step=PITCH_TIME_STEP)
hnr = np.array([harmonicity.get_value(t) for t in times])
hnr = np.nan_to_num(hnr, nan=-999.0)
exceptException:
hnr = np.full_like(f0, 999.0) # fail open if HNR extraction errors
return f0, hnr, times

parselmouth is a Python wrapper around Praat, the standard tool in phonetics research. This is the heart of the whole vocal-monotony measurement: to_pitch() gives fundamental frequency (F0, roughly "pitch") every 20ms, and to_harmonicity_cc() gives harmonics-to-noise ratio (HNR) at the same timestamps — a signal-quality score used later to throw out pitch estimates taken from noisy or badly-compressed audio rather than let bad audio masquerade as "flat" pitch.

3. webrtcvad — deciding which frames are actually speech

def vad_speech_mask(y, sr, aggressiveness=2):
vad = webrtcvad.Vad(aggressiveness)
pcm16 = (np.clip(y, -1.0, 1.0) *32767).astype(np.int16)
n_frames =len(pcm16) // VAD_FRAME_LEN
mask = np.zeros(n_frames, dtype=bool)
for i inrange(n_frames):
chunk = pcm16[i * VAD_FRAME_LEN:(i +1) * VAD_FRAME_LEN]
raw = struct.pack("%dh"%len(chunk), *chunk)
try:
mask[i] = vad.is_speech(raw, sr)
exceptException:
mask[i] =False
return mask, times

webrtcvad is the voice-activity detector out of Google's WebRTC project — a frame-by-frame classifier ("is this 30ms chunk speech or not"). It needs raw 16-bit PCM bytes, not floats, hence the np.clip and struct.pack conversion.

4. librosa.feature — telling music apart from speech

flatness = librosa.feature.spectral_flatness(y=y, hop_length=hop)[0]
chroma = librosa.feature.chroma_stft(y=y, sr=sr, hop_length=hop)
onset_env = librosa.onset.onset_strength(y=y, sr=sr, hop_length=hop)
...
chroma_diff = np.mean(np.linalg.norm(np.diff(chroma_win, axis=1), axis=0))
chroma_stability =1.0/ (1.0+ chroma_diff)
...
scores[w] =0.4* chroma_stability +0.35* periodicity +0.25*min(flat_mean *3, 1.0)

Podcast intros/outros are often music, and music has a very different pitch profile than speech — including it would bias the "monotone" measurement. Rather than train a classifier, three librosa features were combined with hand-tuned weights: spectral flatness (music tends to have more tonal structure, less noise-like spectrum), chroma stability (sustained harmony vs.

constantly-changing speech formants), and onset periodicity (a regular beat vs. speech's irregular rhythm).

5. librosa.feature.mfcc + sklearn.cluster.KMeans + sklearn.metrics.silhouette_score — an unsupervised speaker-count attempt

mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13, hop_length=hop)
...
chunk_vecs.append(np.concatenate([seg.mean(axis=1), seg.std(axis=1)]))
...
X = np.array(chunk_vecs)
X = (X - X.mean(axis=0)) / (X.std(axis=0) +1e-9)

best_k, best_score =1, -1.0
for k inrange(2, min(MAX_SPEAKERS, len(X) -1) +1):
labels = KMeans(n_clusters=k, n_init=10, random_state=0).fit_predict(X)
iflen(set(labels)) <2:
continue
score = silhouette_score(X, labels)
if score > best_score:
best_k, best_score = k, score

estimated = best_k if best_score >= SILHOUETTE_MIN else1

MFCCs (Mel-frequency cepstral coefficients) summarize the shape of a short audio window's spectrum — a rough "voice fingerprint" widely used in speech tasks. The idea: chop each episode into 2-second chunks, turn each into a fingerprint vector, standardize (z-score) the features, then use KMeans to see if the chunks naturally split into 2+ clusters (different voices) rather than 1 (a single voice throughout). silhouette_score scores how well-separated the clusters are, and picks the best k — or falls back to "1 speaker" if no clustering clears a minimum quality bar. This part of the investigation did not work, as it picked up noise as another host.

6. scipy.stats.mannwhitneyu + a hand-written Cliff's delta — comparing two groups without assuming a normal distribution

def cliffs_delta(a, b):
a, b = np.asarray(a), np.asarray(b)
gt =sum((x > y) for x in a for y in b)
lt =sum((x < y) for x in a for y in b)
return (gt - lt) / (len(a) *len(b))


def compare_group(df, metric, label):
hpr = df[df.corpus =="hpr"][metric].dropna()
cmp= df[df.corpus =="comparison"][metric].dropna()
u, p = stats.mannwhitneyu(hpr, cmp, alternative="two-sided")
delta = cliffs_delta(hpr.values, cmp.values) iflen(hpr) *len(cmp) <200000elseNone

scipy.stats.mannwhitneyu is a statistical test: it compares two groups of numbers (HPR vs. comparison podcasts, per metric) without assuming they're normally distributed — appropriate for skewed, real-world data like pitch-range measurements. scipy doesn't ship an effect-size measure alongside it, so Cliff's delta — "of all possible (HPR episode, comparison episode) pairs, how much more often is HPR's value the smaller one?" This pairing (a significance test plus an effect-size number) was used throughout because a low p-value alone doesn't say whether the difference is actually big enough to matter.

7. pandas — grouping, stratifying, and cross-tabulating results

print(df.groupby("corpus")["retained_fraction"].describe())
...
print(pd.crosstab(df["corpus"], df["register"]))

Once data/results.jsonl (one JSON object per analyzed episode) is loaded into a pandas.DataFrame, two one-liners answer two different questions that would otherwise need custom code: .groupby(...).describe() gives a distribution summary (count, mean, std, quartiles) of audio-quality coverage per corpus, in one call, and pd.crosstab() cross-tabulates HPR vs. comparison against male-typical/female-typical register — a quick sanity check that the two collections of podcasts had a similar gender-register mix.

8. matplotlib — box plots for the headline comparison

fig, ax = plt.subplots(figsize=(6, 4))
data = [df[(df.corpus == c) & df[metric].notna()][metric].values for c in ["hpr", "comparison"]]
ax.boxplot(data, tick_labels=["HPR", "Comparison"], showmeans=True)

A box plot per pitch-range metric, HPR next to comparison podcasts, mean marked as well as the median.

9. spacy word vectors — measuring topic drift, not just word choice

nlp = get_nlp() # spacy.load("en_core_web_md")
...
chunk_docs = [nlp(c) for c in chunks]
chunk_vecs = []
for d in chunk_docs:
v = d.vector
norm = np.linalg.norm(v)
if norm >1e-6:
chunk_vecs.append(v / norm)
...
adj_sims = [float(np.dot(V[i], V[i +1])) for i inrange(n -1)]

Each ~130-word chunk of a transcript is embedded as a single vector using spaCy's medium English model (en_core_web_md, which has built-in word vectors), then L2-normalized so a dot product between two vectors
is
their cosine similarity. Comparing consecutive chunks' similarity gives a "does the topic barely move between one chunk and the next" score.

10. lexicalrichness — vocabulary diversity that doesn't cheat on transcript length

lr = LexicalRichness(text)
try:
mtld = lr.mtld(threshold=0.72)
exceptException:
mtld =None

A naive vocabulary-diversity score (unique words ÷ total words) gets worse the longer a text runs, because of how the metric is defined — not because the speaker is actually repeating themselves more.

MTLD (Measure of Textual Lexical Diversity) avoids that by sweeping through the text and counting how many words it takes before diversity drops below a threshold, then averaging — a metric designed specifically to stay comparable between a 10-minute and a 40-minute episode.

11. vaderSentiment — a lexicon-based sentiment score

vader = get_vader() # SentimentIntensityAnalyzer()
sentiments = [vader.polarity_scores(c)["compound"] for c in chunks]
...
"sentiment_std": float(np.std(sentiments)) iflen(sentiments) >1elseNone,

VADER scores each chunk's sentiment from -1 to +1 using a hand-built lexicon and rule set (not a neural network) — chosen for being fast, deterministic, and cheap enough to run per-chunk across hundreds of episodes. The value then used isn't the average sentiment — it's the
standard deviation
of sentiment across an episode's chunks: does the emotional

tone ever move, or does it stay flat throughout?

12. zlib (standard library) — compression ratio as a gauge for entropy

def compression_ratio(text):
raw = text.encode("utf-8")
iflen(raw) <200:
returnNone
compressed = zlib.compress(raw, level=9)
returnlen(compressed) /len(raw)

No third-party NLP library involved at all — just the standard-library zlib module. A gzip-style compressor finds and exploits repeated patterns; if it can squash a transcript down a lot, that transcript was relatively repetitive and predictable, and if it can barely compress it, the wording was more varied. This is roughly tells you "verbal monotony."

13. re (standard library) — turning "does HPR favour solo hosts" into a checkable heuristic

MULTI_PRESENTER_PATTERNS = [
r"\bco-?host(?:s|ed|ing)?\b",
r"\bguest\b",
r"\binterview(?:s|ed|ing)?\b",
r"\btalks? with\b",
r"\bjoins? me\b",
...
]
CORRESPONDENT_LINK_RE = re.compile(r'correspondents/(\d+)\.html')

def multi_presenter_score(summary, notes):
text = (summary or"") +" "+ (notes or"")
hits = [p for p in MULTI_PRESENTER_PATTERNS if re.search(p, text, re.IGNORECASE)]
summary_links =set(CORRESPONDENT_LINK_RE.findall(summary or""))
return {
"flagged_multi_presenter": bool(hits) orlen(summary_links) >1,
}

Rather than the acoustic speaker-clustering attempt (item 5, which turned out to be unreliable), a more trustworthy stat came from plain text: HPR's own episode metadata (pulled from a local knowledge-base repo) has host-written summaries, and a short list of regex patterns ("guest", "interview", "joins me", etc.) plus counting linked correspondent profiles was enough to flag likely multi-presenter episodes.

14. multiprocessing.Pool — running the same analysis over hundreds of files without waiting hundreds of times over

work = [(r, local_paths[r["id"]]) for r in batch]
with mp.Pool(args.workers) as pool, open(args.out, "a") as out_f:
for result in pool.imap_unordered(_worker, work):
out_f.write(json.dumps(result) +"\n")
out_f.flush()

Every batch pipeline (acoustic pitch analysis, speaker-count pass) used the same shape: Pool(workers).imap_unordered(...) to run the per-episode function across multiple CPU cores at once, streaming results out to a JSON-lines file as each one finishes rather than waiting for the whole batch. imap_unordered was chosen over map so a single slow episode couldn't hold up writing out the results that had already finished.

15. subprocess + a resumable batch loop — working within a disk-space limit

def load_done_ids(results_path):
ifnot os.path.exists(results_path):
returnset()
done =set()
withopen(results_path) as f:
for line in f:
...
done.add(json.loads(line)["id"])
return done

...
rows = [r for r in rows if r["id"] notin done]
...
for batch_start inrange(0, len(rows), args.batch_size):
batch = rows[batch_start:batch_start + args.batch_size]
local_paths = fetch_batch(batch, args.scratch) # scp from the remote host
...
for p in local_paths.values():
os.remove(p) # delete before next batch

All the podcasts (~220GB) didn't fit on local disk (~54GB free). The fix was a loop: scp (via subprocess) one batch of audio in, analyze it, delete it, move to the next batch. load_done_ids() makes the whole pipeline resumable by reading back what's already in the output file, so a crash or a deliberate stop partway doesn't lose completed stuff.

Links

https://news.ycombinator.com/item?id=49110547

https://mastodon.social/@ngate/117009495478432200

Ah yes, the riveting world of Hacker Public Radio: a quaint little corner where tech wizards ✨️ divulge their magical secrets ✨️ to each other in the most riveting monotone known to man. Who knew endless "community" podcasts could be so... utterly riveting? 📻️🎙️ Apparently, everyone is just dying to contribute to this cacophony once a year—what a privilege! 😂

https://hackerpublicradio.org/

#HackerPublicRadio #techCommunity #podcasting #MonotoneMagic #rivetingContent #HackerNews #ngated


Provide feedback on this episode.

This show has been flagged as Clean by the host.












BruCON: https://brucon.org





BruCON
is an annual security and hacker conference providing two days
of an interesting atmosphere for open discussions of critical
infosec issues, privacy, information technology and its
cultural/technical implications on society. Organized in
Belgium, BruCON offers a high quality line up of speakers,
security challenges and interesting workshops. BruCON is a
conference by and for the security and hacker community.

​The conference tries to
create bridges between the various actors active in computer
security world, included but not limited to hackers, security
professionals, security communities, non-profit organizations,
CERTs, students, law enforcement agencies, etc…..




https://www.youtube.com/@brucontalks/videos




Provide feedback on this episode.

This show has been flagged as Clean by the host.

In this episode we look at a very old style of beer known as Mild. Paul, in the absence of any locally available Milds has a Guinness, Dave tastes
Banks's Mild
and Kevie Samples
1950s Burton Ruby Mild
.







Connect with the guys on
Untappd
:







Dave






Paul






Kevie




















The intro sounds for the show are used from:







https://freesound.org/people/mixtus/sounds/329806/






https://freesound.org/people/j1987/sounds/123003/






https://freesound.org/people/greatsoundstube/sounds/628437/










The next 3 beer styles to be reviewed:









Bitter



Pale Ale



Trappist







Provide feedback on this episode.

This show has been flagged as Clean by the host.

wl-copy is a command in the wl-clipboard package, and allows you to copy and paste data from your Linux Terminal on a Wayland desktop.

Copy an arbitrary string to your clipboard using wl-copy:


$ wl-copy "hello world"
Paste it anywhere on your system as usual (with Ctrl+Shift+V or a right-click and Paste).

You can copy from output, too:


$ echo "hello wide world" | wl-copy
You can redirect to wl-copy:


$ echo "hello world" > example.txt

$ wl-copy < example.txt
You can use wl-paste to paste from your system clipboard:


$ wl-paste

"hello world"
Provide feedback on this episode.

This show has been flagged as Clean by the host.

OLF Conference








The Conference the artist previously known as the Ohio Linux Festival, is returning to it's 2003 beginnings on the campus of
Dreese Laboratories at Ohio State University



Starting at noon on Friday Nov 20 and running all day Saturday 21 Nov 2026, during this event, Open Source projects, developers and visitors can exchange ideas and knowledge.


Interviewees



HPR is no stranger to OLF
, and we interview the team as a
call for presentations
is now open.









Vance
has been using Linux since 1997 and was active in the Western Pennsylvania Linux Users Group from 2003 to 2017. In addition to general desktop use, he has an interest in system and network administration. Vance currently lives in Pittsburgh and works in quality assurance for safety equipment. Vance first began volunteering with Ohio LinuxFest in 2006. He worked on producing audio recordings of sessions starting in 2009, served as Speaker Chair for the 2014 through 2017 conferences, and was Birds of a Feather Chair from 2018 to 2020. He took on the Conference Chair role from 2021 through 2023, then returned as Speaker Chair starting in 2024.



Email










Beth Lynn currently lives in Pittsburgh and works as Senior System Engineer. She has over twenty years experience in managing, building and collaborating with teams within Free Software Expertise in GNU/Linux distributions such as Red Hat Enterprise Linux, Fedora, Ubuntu, and SUSE. From 2002 to 2011 Beth Lynn led the Western PA Linux Users Group, which began at Carnegie Mellon University.


Beth Lynn first came to OLF as an attendee in 2003. She immediately signed up to help at future conferences. When a mix up occurred in the venue early in the OLF history, Beth contacted Jon “maddog” Hall and others for help, which saved that year’s conference (close to the date of the event). Due to her longevity with OLF over the years she has been a speaker, conference chairperson, and fundraiser. When the original conference chairpersons retired from leadership roles, Beth Lynn stepped up to keep the conference running smoothly as the Director. In 2007 Beth applied and defended 501(c)(3) non-profit status for the organization.


Beth Lynn Eicher is passionate about the ideals of FOSS and in growing community across the country and world in this movement. She attends other Linux- FOSS conferences and is well known across the country. In 2013 she was asked to speak at the
Free Software Foundation
Conference held at Harvard University on the topic of “Closing the Digital Divide”. There she reported on the successful deployment of 100 Edubuntu PCs to schools in Ghana, Africa that served mostly orphaned children. Beth Lynn went to Ghana with a team from
Computereach,
training in networking, pc repair, the GNU/Linux command-line, and the Edubuntu desktop environment.



Email



Links


Main web site: https://olfconference.org/

News page (announcements): https://olfconference.org/news/

RSS Feed of news: https://olfconference.org/feed/

CFP: https://olfconference.org/call-for-presentations/

YouTube channel: https://www.youtube.com/@OLFConference

Livestream videos: https://www.youtube.com/@OLFConference/streams

Edited videos: https://www.youtube.com/@OLFConference/videos

Facebook: https://www.facebook.com/ohiolinux/

LinkedIn: https://www.linkedin.com/groups/1828509

X/Twitter: https://x.com/ohiolinux

Matrix (unofficial): https://matrix.to/#/#olf:matrix.org

Mailing list (announcements only): https://lists.ohiolinux.org/mailman/listinfo/olf-attendees

https://hackerpublicradio.org/correspondents/0459.html

https://www.osu.edu/

FreedomBox

hpr4256 :: Birds of a Feather Talk at OLF 2024



Travel Times



Country
Typical Travel Method
Example Destination
Approx Duration
Typical Budget Cost (One Way)

USACarCincinnati, Ohio1h 40m–2h 10m$20–40
USABusCincinnati, Ohio2h–3h$20–45
USATrainCincinnati, Ohio2h–3h$25–60
USAAeroplaneChicago, Illinois1h 10m flight$70–180
USACarCleveland, Ohio2h–2h 45m$25–50
USABusCleveland, Ohio2h 45m–4h$25–55
USATrainCleveland, Ohio2h 30m–4h$25–70
USAAeroplaneDetroit, Michigan1h flight$70–180
USACarDayton, Ohio1h 15m–2h$15–30
USABusDayton, Ohio1h 30m–2h 30m$15–35
USATrainToledo, Ohio2h 30m–3h 30m$25–60
USAAeroplanePittsburgh, Pennsylvania1h flight$70–180
USACarPittsburgh, Pennsylvania3h–3h 30m$35–65
USABusPittsburgh, Pennsylvania3h 30m–5h$25–60
USATrainPittsburgh, Pennsylvania3h 30m–5h$30–70
USACarIndianapolis, Indiana2h 45m–3h 15m$30–55
USABusIndianapolis, Indiana3h 30m–5h$30–65
USATrainIndianapolis, Indiana4h+$40–80
USAAeroplaneIndianapolis, Indiana~1h flight$70–180
USACarFort Wayne, Indiana2h 30m–3h$30–50
USABusFort Wayne, Indiana3h 30m–5h$25–60
USACarErie, Pennsylvania2h 30m–3h$25–50
USABusErie, Pennsylvania3h 30m–5h$25–60
USATrainErie, Pennsylvania3h–4h 30m$25–65
USACarCharleston, West Virginia2h 45m–3h$30–55
USABusCharleston, West Virginia4h–5h 30m$30–70
USACarLouisville, Kentucky3h–3h 30m$35–60
USABusLouisville, Kentucky4h–5h 30m$30–70
USAAeroplaneLouisville, Kentucky~1h flight$70–180
CanadaCarWindsor, Ontario3h–3h 30m$35–65
CanadaBusWindsor, Ontario4h–6h$40–80
CanadaAeroplaneToronto, Ontario~1h 15m flight$100–250



Provide feedback on this episode.