rhdunn

Simon Roper has a spoken equivalent for Northern English -- https://www.youtube.com/watch?v=90Zqn9_OQAw.

Mistral have small variants (3B, 8B, 14B, etc.), as do others like IBM Granite and Qwen. Then there are finetunes based on these models, depending on your workflow/requirements.

I'm using gitolite + cgit for local repositories. I tried Gitea for a while but didn't like the forced user/repo flat structure inherited from being a GitHub clone, and didn't need the additional features that Gitea/Forgejo provide.

Cannot say. Saying, I would know. Do not know, so cannot say.

There are several stand-out episodes in season 1 and 2, as well as several stand-out scenes; plus the second half of season 2 is not mediocre. You also miss out on character and world-building that happens in those episodes that help contextualize a lot of the later seasons.

Plus, many reactors now have liked season 1 a lot better than when it initially aired.

From [1] "Forgejo was created in October 2022 after a for profit company took over the Gitea project."

Forgejo became a hard fork in 2024, with both projects diverging. If you're using it for local hosting I don't personally see much of a difference between them, although that may change as the two projects evolve.

[1] https://forgejo.org/compare-to-gitea/

It can depend a lot on different factors like:

- familiarity with the accent and/or speaker;

- speed and style/cadence of the speech;

- any other audio that is happening that can muffle or distort the audio;

- etc.

It can also take multiple passes to get a decent transcription.

VLC does not show up when searching for "music player" on nixpkgs [1] which is what was used. Searching for "media player" does [2].

[1] https://search.nixos.org/packages?channel=unstable&query=mus...

[2] https://search.nixos.org/packages?channel=unstable&query=med...

One of the annoying things about having a living standard is that it is difficult to implement a conforming version as additional updates means that you are no longer conforming.

Versioned standards allow you to know that you are compliant to that version of the specification, and track the changes between versions -- i.e. what additional functionality do I need to implement.

With "living standards" you need to track the date/commit you last checked and do a manual diff to work out what has changed.

AI in this sense means using Machine Learning (ML)/Neural Networks (NN) to convert the text (or phonemes) to audio.

There are effectively two approaches to voice synthesis: time-domain and pitch-domain.

In time-domain synthesis you care concatenating short waveforms together. These are variations of Overlap and Add: OLA [1], PSOLA [2], MBROLA [3], etc.

In pitch-domain synthesis, the analysis and synthesis happens in the pitch domain through the Fast Fourier Transform (visualized as a spectrogram [4]), often adjusted to the Mel scale [5] to better highlight the pitches and overtones. The TTS synthesizer is then generating these pitches and converting them back to the time domain.

The basic idea is to extract the formants (pitch bands for the fundamental frequency and overtones) and have models for these. Some techniques include:

1. Klatt formant synthesis [6]

2. Linear Predictive Coding (LPC) [7]

3. Hidden Markov Model (HMM) [8]

4. WaveGrad NN/ML [9]

[1] https://en.wikipedia.org/wiki/Overlap%E2%80%93add_method

[2] https://en.wikipedia.org/wiki/PSOLA -- Pitch-synchronous Overlap and Add

[3] https://en.wikipedia.org/wiki/MBROLA -- Multi-Band Resynthesis Overlap and Add

[4] https://en.wikipedia.org/wiki/Spectrogram

[5] https://en.wikipedia.org/wiki/Mel_scale

[6] https://en.wikipedia.org/wiki/Dennis_H._Klatt

[7] https://en.wikipedia.org/wiki/Linear_predictive_coding

[8] https://www.cs.cmu.edu/~awb/papers/ssw6/ssw6_294.pdf

[9] https://arxiv.org/abs/2009.00713 -- WaveGrad: Estimating Gradients for Waveform Generation

Kotlin does have interop with Java, but is limited by either the features not existing in Java (non-nullable types) or behave differently in Java (records, etc.).

You have to explicitly annotate that a Kotlin data class is a Java record due to the limitations Java has on records compared to data classes [1]. This is similar to adding nullable/not-null annotations in Java that are mapped to Kotlin's nullable/non-nullable types.

Where there is a clean 1-1 mapping and you are targeting the appropriate version of Java, the Kotlin compiler will emit the appropriate Java bytecode.

[1] https://kotlinlang.org/docs/jvm-records.html#declare-records...

I view the relationship between Kotlin and Java like that between C++ and C.

The two-way interop is one of Kotlin's advantages as it makes porting code from Java to Kotlin easier, or using existing Java libraries. For example, you don't have/need something like Scala's `asJava` and `asScala` mappers as the language/standard library does that mapping for you.

The interop isn't always perfect or clean due to the differences in the languages. But that's similar to writing virtual function tables in C -- you can do it, and have interop between C and C++ (such as with COM) but you often end up exposing internal details.

It's not just screen reader users. I use TTS to listen to text content and the AI TTS voices I've tried have the issues with skipping words or generating garbled output in sections.

I don't know if this is a data/transcription issue, an issue with noisy audio, or what.

And at the next election -- if the current polling stays consistent -- they are likely to get 15-85 seats, which is not enough for them to gain power. Even then they are unlikely to form a coalition as Labour are not doing well in the polls currently, and the gain in support for the greens is largely coming at Labour's expense.

[1] https://www.electoralcalculus.co.uk/homepage.html

[2] https://en.wikipedia.org/wiki/Opinion_polling_for_the_next_U...

Works in ladybird as well.

Maps were added in XPath 3.1 -- https://www.w3.org/TR/xpath-31/#id-maps.

There's currently work on XPath 4.0 -- https://qt4cg.org/specifications/xquery-40/xpath-40.html.

Using neural nets (machine learning) to train TTS voices has been around a long time.

[1] (2016 https://arxiv.org/abs/1609.03499) WaveNet: A Generative Model for Raw Audio

[2] (2017 https://arxiv.org/abs/1711.10433) Parallel WaveNet: Fast High-Fidelity Speech Synthesis

[3] (2021 https://arxiv.org/abs/2106.07889) UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation

[4] (2022 https://arxiv.org/abs/2203.14941) Neural Vocoder is All You Need for Speech Super-resolution

Text-based browsers are useful in cases where you don't have access to a graphical display, for example:

1. your graphics driver isn't loading/working;

2. you can't log into the GUI due to a bug in the login screen;

3. you are working on a server that is headless, i.e. doesn't have a GUI installed, or are SSHing into a server/other machine.

I've experienced (2) a while ago and more recently there was another issue recently with upgrading breaking a system [1]. I also encountered the latter but was unable to keep the terminal open due to that bug (it kept switching back to the login screen), so I had to boot into a system via a USB stick, chroot into the system, then install the uninstalled desktop package.

[1] https://www.gamingonlinux.com/2025/04/ubuntu-25-04-upgrades-...

This is also an issue with non-AI and non-Lean proofs. Andrew Wiles' initial Fermat's Last Theorem proof initially had an error in it. That was spotted by peer review, fixed, and an updated proof was submitted.

There are two types of inheritance:

- interface/API based -- this is supported in modern languages via interfaces, traits, etc.

- implementation/code based -- modern languages tend to only support single inheritance; they tend to also support default method implementations on the interfaces/traits

I suspect that they are already doing that (or something like it) as I've seen certain content appear at specific times/days.

Ruby is used extensively for Japanese (hiragana) and Chinese (bopomofo) -- you can see it on wiktionary, e.g. in the definition of manga [1]. The Rules for Simple Placement of Japanese Ruby spec [2] provides various examples of ruby formatting and layout.

[1] https://en.wiktionary.org/wiki/manga#English [2] https://www.w3.org/TR/simple-ruby/

And role-playing in general.

I have a pragmatic approach to TDD, i.e. it doesn't practically matter if you write the code or tests first as long as the relevant code has tests:

1. write the test code first (possibly with a skeleton implementation) if you want to get an idea/feel for how the class/code is intended to be used;

2. write the code first if you need to;

3. ensure that you have at least one test at the point where the code is mimimally functional.

More generally:

1. don't aim for 100% code coverage (around 80-90% should be sufficient);

2. test a representative example and appropriate boundary conditions;

3. don't mock classes/code you control... the tests should be as close to the real thing as possible, otherwise when the mocked code changes your tests will break and/or not pick up the changes to the logic -- Note: if wiring up service classes, try and use the actual implementations where possible;

4. use a fan in/out approach where relevant... i.e. once you have tests for various states/cases in class A (e.g. lexing a number, e.g. '1000', '1e6', '1E6') you only need to test the cases that are relevant to class B (e.g. token types, not lexical variants, e.g. integer/decimal/double);

5. test against publically accessible APIs, etc... i.e. wherever possible, don't test/access internal state; look for/test publically visible behaviour (e.g. don't check that the start and end pointers are equal, check that is_empty() is true and length() is 0) -- Note: testing against internals is subject to implementation changes whereas public API changes should be documented/properly versioned.

Image, video, and music editing. Developing, running, and debugging large applications.

And start with simpler regular rules and get more complex over time as words are imported and reimported, pronunciations shift, grammatical rules morph and evolve (often to simplify grammatical genders and cases) while leaving their mark, and spelling changes.

For example, goose/geese is the result of the plural form and singular form undergoing different paths in the Great Vowel Shift resulting in the different vowels in the modern form.

There's also evidence that Proto-Indo-European had laryngeal consonants that have disappeared in all modern languages derived from it [1], but have left their mark on the descendant languages.

[1] https://en.wikipedia.org/wiki/Laryngeal_theory

https://www.w3.org/WAI/ARIA/apg/patterns/ is my go to for accessibility requirements of components.

And yes, being able to do all of these in pure HTML/CSS would be awesome. Though we are getting there with things like `details` and the newer `popover` features which should make things like rich tooltips, menu buttons, etc. a lot easier to implement. IIRC, there are also several anchor CSS properties to make positioning a lot simpler.

If you specify the same name on each `details` element they behave like an accordion automatically [1], no need for JavaScript. If you set one of them to open that one will be initially open.

[1] https://developer.mozilla.org/en-US/blog/html-details-exclus...

I used elinks once to find a solution to an issue where the login screen was broken after an upgrade. I was able to switch to a virtual console, find out about the issue, identify the commands to fix the issue, and use them to resolve the issue.

See e.g. https://www.youtube.com/@Switch-Angel/videos for examples of strudel in action to create trance music.