DEV Community: 王俊俊

A practical way to study recorded lectures line by line

王俊俊 — Fri, 30 Oct 2026 08:38:09 +0000

Recorded lectures are easy to collect and hard to review. A 70-minute class becomes a file you scrub through, and the sentence you actually needed is gone by the time you pause.

I stopped treating the video as the study material. I turn it into a transcript first, then study the text with the audio still attached.

What I do with a lecture recording

Generate subtitles from the recording. Speech-to-text in the lecture's language is enough to make the class searchable. Video transcription and audio-to-text cover about 99 languages, which matters when the course is not in English.
If I am studying the language of the lecture, I add a second subtitle track. Translation covers about 109 languages, with a free option and an AI option, so I can keep the original line and a translation under it.
I study one sentence at a time. A-B repeat on a single line is more useful than replaying a whole slide. Pointing at a word opens a lookup, and I save a vocab card that keeps the original sentence plus a short audio clip, not just the isolated word.
When a course drops many files, I batch the subtitles and export or print the lines I want to review. Podcast RSS works the same way when the lecture is an episode rather than a classroom video.

The page I keep open for this workflow is transcribe lecture videos. It is the lecture-specific entry, not a general homepage.

Why the transcript beats another replay

A transcript lets me search for a term the professor said once. Bilingual subtitles let me check meaning without leaving the line. The audio clip on the vocab card is what I actually hear again later, so the card is tied to that lecture instead of a dictionary example.

I still watch the video when a diagram matters. For language and for review, the subtitle file is the thing I come back to.

Translating SRT Subtitle Files for Language Study Without Breaking the Timestamps

王俊俊 — Tue, 20 Oct 2026 02:15:11 +0000

If you study a language with films or series, you probably end up with a pile of .srt files: subtitles from a release, a course download, or a file you exported after fixing a few lines yourself. They look like plain text, so the obvious move is to paste them into a translator. That usually goes wrong in small, annoying ways. Here is what an SRT file actually contains, why naive translation breaks it, and a workflow that keeps the file usable for study.

What is inside an SRT file

Each subtitle block (a "cue") has three parts:

42
00:03:15,200 --> 00:03:18,050
I didn't think you'd actually come.

A sequence number, a start and end time, and one or two lines of text. Players match the text to the picture using only those timestamps. Change them, and the line appears too early, too late, or not at all.

Why pasting into a translator breaks it

Timestamps get "translated." Some tools reformat 00:03:15,200 into something else, or swap the comma for a period, and the player rejects the file.
Lines merge or split. Translators like full sentences, so a sentence spread over two cues often comes back as one block, and the cue count no longer matches.
Context is lost. Translating cue by cue makes short lines ("Again?", "Fine.") ambiguous. Translating the whole file at once makes it hard to map each sentence back to its cue.
The original disappears. For a learner this is the biggest loss. You wanted the English next to the original, not instead of it.

A study-friendly workflow

Keep the original file untouched. Treat it as the source of truth for timing.
Translate text only, cue by cue, with a little surrounding context. The translation of cue 42 should know what cues 41 and 43 say, but the result must still land on cue 42.
Show both languages on the same cue. Original on top, translation below. You read the real line first and glance down only when you need to.
Hide one side to test yourself. Watch a scene with only the original, then check the translation afterwards. Or hide the original and try to recall it from the English.
Loop the hard lines. When a line is fast, loop just that cue a few times and shadow it.

Doing it in practice

You can do steps 1–2 with a script (parse the cues, send the text with neighbouring lines as context, write the results back to the same indices), but most learners just want the result. I use LangScribe to translate an SRT file to English: you import the SRT (or VTT/ASS), each cue keeps its original timestamp, and an English line is placed under it. There is a free translation option for everyday use and an AI translation that follows the surrounding cues for better wording. Importing the file itself is free.

Once the file is in, the study part is the same as with any video: bilingual subtitles on screen, previous/next line with one key, A–B repeat on a single cue, and click a word to look it up and save it as a vocabulary card with its original sentence. If you have no subtitle file at all, the same tool can run speech to text on the audio first and give you a timed transcript to work from.

A few tips

Check the language of the file first. Some "English" SRTs are machine translations themselves. Translating a translation compounds the errors.
Don't fix timing and translation in the same pass. If the file is out of sync, shift it first, then translate.
Keep an exported copy. Export the bilingual or translated version as a new SRT so the original stays clean.

An SRT file is already a study text with perfect timing. The trick is to add a translation without destroying the very thing that makes it useful.

From Video to Markdown Study Notes: A Transcript Workflow for Language Learners

王俊俊 — Sun, 18 Oct 2026 08:14:17 +0000

If you already keep your notes in Markdown, you can turn almost any video or podcast episode into a tidy language-study file. This note describes the workflow I use: get an accurate transcript, add a translation, pull out sentences worth keeping, and review them later. It works for any target language and takes about twenty minutes per episode.

1. Pick short, re-watchable material

Choose clips of 5 to 15 minutes: a news segment, a YouTube explainer, one scene from a series, or a podcast chapter. Short material matters because you will listen to the same lines several times. Long videos tend to turn into passive watching.

2. Generate the transcript first

Everything in this workflow depends on having the exact words. Manual transcription is a great exercise for a single minute of audio, but it does not scale. I run the file through a speech-to-text tool, then fix obvious mistakes while listening once at normal speed.

For this step I use LangScribe's AI subtitles for language learning. It does audio transcription and subtitle generation for roughly 99 spoken languages and can translate the result into about 109, so one file gives me both the original line and a bilingual subtitle track.

3. Export to a Markdown table

Once the transcript is clean, I paste it into a note with a simple layout:

Time	Original	Translation	Notes
00:42	Je n'en reviens pas.	I can't believe it.	idiom, informal
01:15	Ça vaut le coup.	It's worth it.	very common

A table keeps every sentence anchored to a timestamp, so you can jump back and replay it.

4. Mark only what you would actually say

Do not copy every new word. Highlight sentences that:

contain a phrase you have heard more than once,
express something you want to say in your own life,
show grammar you keep getting wrong.

Ten good sentences per episode beats sixty random words.

5. Shadow line by line

Play one sentence, pause, and repeat it out loud, copying rhythm and intonation. A player that loops a single subtitle line makes this much easier than dragging a progress bar. Do each highlighted sentence three to five times.

6. Turn sentences into review cards

Move the highlighted rows into your spaced-repetition tool. Keep the original sentence on the card, not just the isolated word, because context is what makes the word stick. Some players can save a word together with the sentence and audio snippet it came from, which saves a lot of copying.

7. Review, then re-watch

After a week of card reviews, watch the clip again without subtitles. You will usually understand far more than the first time, and that feedback is the best motivation to repeat the loop with the next episode.

A minimal template

## Episode: <title>  (<language>, <length>)
Source: <link or file name>
Date: <yyyy-mm-dd>

### Key sentences
| Time | Original | Translation | Notes |
|------|----------|-------------|-------|

### Words to review

### Shadowing done
- [ ] pass 1   - [ ] pass 2   - [ ] pass 3

Copy it, fill it in after each video, and in a month you will have a searchable notebook of real sentences in your target language.

Building a Speech-to-Text Study Workflow for Language Learners

王俊俊 — Sat, 17 Oct 2026 17:04:08 +0000

Most language learners have the same problem: they find a great podcast, YouTube lecture, or interview in their target language, listen once, understand maybe 40 percent, and move on. The input was good, but nothing stuck. A simple speech-to-text workflow fixes that by turning fleeting audio into text you can actually study.

This post walks through the workflow I use and recommend. It is tool-agnostic in spirit, but I will mention where a dedicated app saves time.

Why text matters for listening practice

Listening comprehension improves fastest when you can close the gap between what you heard and what was actually said. Without a transcript, you never find out which words you misheard, which contractions confused you, or which phrases you simply did not know. With a transcript, every confusing moment becomes a concrete, searchable item.

Transcripts also let you:

Re-read difficult passages at your own pace
Extract vocabulary in its original context
Shadow sentences line by line
Compare the original with a translation without losing your place

Step 1: Pick input slightly above your level

Choose audio or video where you understand the topic but not every sentence. Podcasts with clear speakers, short interviews, and conference talks work well. Ten to twenty minutes is plenty for one session.

Step 2: Generate a transcript

Run the audio through a transcription engine. Modern models handle dozens of languages with accents and background noise far better than tools from a few years ago. For learners, the key features are timestamps per line, so you can jump back to the exact moment, and support for your target language.

I use speech to text in LangScribe for this step because it covers roughly 99 languages and outputs timed lines I can study directly, instead of a wall of text.

Step 3: Add a translation layer (carefully)

Translations are a safety net, not a crutch. Put the original line on top and the translation beneath, and only glance at the translation after you have tried to parse the original. Bilingual subtitles are a great format here: you keep the audio, the original, and the meaning in one view.

Step 4: Study line by line

This is where the real learning happens. For each line:

Listen without reading.
Read the transcript and listen again.
Note any words you misheard and why (linking, reductions, unknown vocabulary).
Repeat the line out loud (shadowing).

Five minutes of audio studied this way beats an hour of passive listening.

Step 5: Save vocabulary with the sentence

Isolated word lists are easy to forget. Save each new word together with the sentence it appeared in and, ideally, the timestamp. When you review the card later, you remember the speaker, the context, and the sound, which makes the word much stickier. Click-to-look-up dictionaries inside the transcript make this nearly frictionless.

Step 6: Review and re-listen

A few days later, listen to the same audio again without the transcript. You will be surprised how much clearer it sounds. Then review your vocabulary cards with spaced repetition.

Automating the boring parts

If you are a developer, you can script parts of this pipeline: fetch new podcast episodes from an RSS feed, transcribe them, split them into timed segments, and export cards to your SRS. If you would rather not build it yourself, look for a tool that combines transcription, translation, subtitle generation, and vocabulary saving in one place so the workflow stays fast enough to do daily.

Final thoughts

The magic is not in any single tool; it is in turning audio into something you can pause, read, question, and save. Build that loop once, and every podcast in your feed becomes a structured lesson.

Transcribing Video in the Browser Without Uploading the Film

王俊俊 — Fri, 09 Oct 2026 23:03:59 +0000

I needed timed subtitles for language study videos that already lived on my disk. Uploading a two-hour lecture to a transcription SaaS felt wrong for privacy and for bandwidth. The shape that worked was: keep the media element local, demux audio in the browser, and send only short mono chunks to a Worker.

The constraint

Playback stays in the page. Local files and direct links (MP4, WebM, HLS) go straight into a <video> / media element. A signed-out library can live in IndexedDB. Sign-in can sync library metadata and subtitle tracks; the film itself never becomes an upload.

That split forces the transcription path to be audio-only.

Chunked audio instead of a full upload

When a file has no usable subtitles, the client:

Demuxes audio in the browser
Skips long silences when possible
Encodes short 16 kHz mono segments (roughly 20â€“30 seconds)
POSTs each chunk to a Cloudflare Worker

The Worker runs speech-to-text (Workers AI / Whisper-class model), returns timed text, and the client turns that into cues. Existing SRT, VTT, and ASS imports follow the same cue model, so "I already have subtitles" and "generate them" share one player.

Keeping requests small matters more than clever batching. Failed chunks retry without restarting a multi-gigabyte upload.

Why a Worker on the same host helps

A single host serving the Vue app and the API avoids CORS theater for cookie/session flows and keeps the mental model simple: one origin for the player shell. Hono on a Worker is enough for auth, credit accounting, and the STT proxy.

The learning loop is the product

None of the model work matters if seeking is clumsy. The UI unit is a subtitle cue: previous / next, replay, loop one line, or loop an Aâ€“B range. Bilingual cues sit on the video. Word lookup opens against that sentence, not a generic dictionary homepage.

If you study from files you already have, that architecture is what I shipped in LangScribe local playback, optional AI captions, and a player built around the line you are trying to hear.

I built a language-learning player

王俊俊 — Fri, 09 Oct 2026 13:32:27 +0000

I wanted the thing I actually do when I study: open a lecture or a show, see the line in two languages, hit replay until the sentence sticks, and click a word I do not know. Desktop players can do pieces of this. Most of them also want an install, a GPU stack, and an API key before the first video plays.

So I built LangScribe as a website. The interesting constraint was privacy: the video file should stay on the machine. Subtitles and a library can sync. The film should not.

What runs where

The app is one Vue 3 frontend. A Cloudflare Worker (Hono) serves the built site and the API on the same host, so the player and the account API are not two deployments.

Playback never leaves the browser. Local files and direct links (MP4, WebM, HLS) are handed to the media element. A signed-out library lives in IndexedDB. Sign in with Google and the library plus subtitle tracks sync; the video file still does not get uploaded.

That split is the whole product. Guest mode has to be useful. Cloud mode has to be optional.

Subtitles without shipping the film

If a video has no subtitles, the browser demuxes the audio, skips silence, and uploads short 16 kHz mono chunks, about 20–30 seconds each. Speech-to-text is Cloudflare Workers AI, Whisper large-v3-turbo. The worker returns timed text; the client turns that into cues and can export SRT. Existing SRT, VTT, and ASS files import the same way.

I did not want a second "upload your course to our servers" step. Chunked audio is enough for transcription, and it keeps the request small.

Translation that can see the previous line

Free translation works without an account, line by line, as you watch.

AI translation is the path that cares about context. Lines go up in small batches with a few preceding subtitle pairs, to a Llama 3.3 70B model on Workers AI. A batch that fails to parse falls back to single-line calls. The player only asks for lines near the playhead, then refills when you are about to run out of translated text. Word lookup is a separate, cached call: part of speech, a short explanation in that sentence, pronunciation.

Credits apply to AI subtitles, AI translation, and AI lookups. Free translation does not. The server records usage; the page does not decide that a feature is free.

The player loop

None of the model work matters if seeking feels clumsy. The UI is built around the cue list: previous line, next line, replay, loop one line, or loop an A–B range. Bilingual cues sit on the video. Click a word and the card opens on that sentence, not on a dictionary homepage.

That is the architecture I would keep if I rewrote the UI: local media, optional account, audio-only transcription, translation with a little context, and a player that treats a subtitle line as the unit of study.

If you learn from video, you can try it at LangScribe.