pncnmnp

I have recently started doing this too - I prefer r/iTunesMovieDeals for discovering stuff on sale. What I have been trying to optimize for is a low cost per hour and a high critical rating.

For example, I recently got the entire bundle for HBO's Rome for $9.99. That is ~50 minutes per episode (22 episodes), or $0.54/hour, which is not a bad deal! For a casual viewer like me, who might spend <6 hours each week watching TV, this should last a little more than 3 weeks. Recently, The Sopranos went on sale for $29.99, or $0.38/hour.

For streaming vs. buying to work, you just have to be patient about nabbing ~1-2 purchases per month and not be tempted to buy every single day.

The best part is the reduced cognitive load - you don't have to spend time browsing for content every day, and there are no ads, too.

Just a note: if anyone wants the old-school experience, https://github.com/dashboard-feed works fine for now.

Apparently, there's a term for the general practice, it's called "link shimming" - https://www.usenix.org/conference/usenixsecurity20/presentat....

I had some fun in my grad days building a private information retrieval (PIR) scheme so the shim server can do its job without knowing which link you clicked: https://github.com/pncnmnp/shimmey

I want to share why I am posting this paper and why I think this is an interesting read. From "Henry Faulds Proposes Fingerprints as a System of Identification":

https://historyofinformation.com/detail.php?id=525

> In a one page letter published in the London journal Nature on October 28, 1880, Henry Faulds was the first to propose the use of fingerprints as a system of identification, including the scientific identification of criminals.

From the paper itself:

> When bloody finger-marks or impressions on clay, glass, etc., exist, they may lead to the scientific identification of criminals. Already I have had experience in two such cases, and found useful evidence from these marks. In one case greasy finger-marks revealed who had been drinking some rectified spirit. The pattern was unique, and fortunately I had previously obtained a copy of it. They agreed with microscopic fidelity. In another case sooty finger-marks of a person climbing a white wall were of great use as negative evidence. .....

The whole setup works on my M2 MacBook Pro with 16 GB RAM. I use Gemma 4B via LiteRT-LM.

I've found that LiteRT-LM has a much lower DRAM footprint than Ollama. I've also made tons of optimizations in the code - for eg, you can do quite a bit with a 16k context window for a voice assistant while managing a good footprint, so I keep track of the token usage and then perform an auto-compaction after a while. I use sub-agents and only do deep-think calls with them, so the context window is separated out. In a multi-turn conversation, if Gemma 4 directly processes audio input, the KV cache fills up within a few turns, so I channel it all via Whisper.

Also, by far the biggest optimization is: 3-stage producer-consumer architecture. The LiteRT-LM streams tokens and I split them into sentences. A synthesizer thread then converts each sentence to audio via Kokoro TTS - the main thread then plays audio chunks sequentially. There's a parallel barge-in monitor thread. https://github.com/pncnmnp/strawberry/blob/main/main.py#L446

I did not want to use openWakeWord or Picovoice because they had limitations on which wake word you could choose. Alternative was to train a model of my own. So I created my own wake word detection pipeline using Whisper Tiny - works surprisingly well: https://github.com/pncnmnp/strawberry/blob/main/main.py#L143...

Also, I have VAD going with smart turn v3 (like I mentioned above) + I use browser/websocket for AEC + Barge-in (https://github.com/pncnmnp/strawberry/blob/main/audio_ws.py).

I'm using the MacBook's built-in microphones for this, though, and I haven't fully tested it with other microphones. I've been ironing out the rough edges on a daily basis. I should write a quick blog on this too.

I wish I had known about Pipecat a lot sooner. I found out about it a few weeks back, and since Gemma 4 launched, I've been building my own entirely local voice assistant using Gemma 4 + Kokoro TTS + Whisper from scratch - https://github.com/pncnmnp/strawberry.

Pipecat's smart turn model is really good for VAD - https://huggingface.co/pipecat-ai/smart-turn-v3

I have come to a similar realization recently - its what I call "Take it home OSS" - i.e. fork freely, modify it to your liking using AI coding agents, and stop waiting for upstream permissions. We seem to be gravitating towards a future where there is not much need to submit PRs or issues, except for critical bugs or security fixes. It's as if OSS is raw material, and your fork is your product.

A fun tangent - if someone wants to explore how Azure is performing RDMA over RoCEv2 - check this paper out - https://www.microsoft.com/en-us/research/wp-content/uploads/...

There is an interesting NSDI talk on the paper too - https://www.youtube.com/watch?v=kDJHA7TNtDk (2023)

I am a bit late to this thread, nevertheless, I wanted to put my thoughts down as well.

Horizon Worlds and the Metaverse were both pitched as a "social" platform. And this in itself is where I believe they went wrong. It fundamentally differs from my limited experience with VR and its potential. I see VR as an "anti-social" platform rather than a "social" one - and I say this in a good way.

When I put on a VR headset, its as if I am shunning my current world. The experiences I find valuable in VR are the ones that elevate that feeling - imagine watching a basketball game courtside, or watching NASCAR while floating right above the track, or watching a live concert happening halfway across the world, or VR tourism (visiting different places anytime you want, from some breathtaking angles - my most memorable experience of this was a video on Angel Falls https://www.youtube.com/watch?v=L_tqK4eqelA), or even the classics like playing VR games and watching movies. I believe that they should have doubled down on providing a much richer "anti-social" experience.

On a similar tangent, but on the opposite end of the spectrum, check out this month-old discussion on HN: https://news.ycombinator.com/item?id=46772003

ChatGPT's code execution container contains 56 vCPUs!! Back then, simonw mentioned:

> It appears to have 4GB of RAM and 56 (!?) CPU cores https://chatgpt.com/share/6977e1f8-0f94-8006-9973-e9fab6d244...

I'm seeing something similar on a free account too: https://chatgpt.com/share/69a5bbc8-7110-8005-8622-682d5943dc...

On my paid account, I was able to verify this. I was also able to get a CPU-bound workload running on all cores. Interestingly, it was not able to fully saturate them, though - despite trying for 20-odd minutes. I asked it to test with stress-ng, but it looks like it had no outbound connectivity to install the tool: https://chatgpt.com/share/69a5c698-28bc-8005-96b6-9c089b0cc5...

Anyways, that's a lot of compute. Not quite sure why its necessary for a plus account. Would love to get some thoughts on this?

Happy Public Domain Day, everyone! Such a great project.

A bit tangential here, but I am really looking forward to 2035 for the public domain. A ton of culturally significant works seem to enter then - And Then There Were None, Gone with the Wind, The Wizard of Oz, Mr. Smith Goes to Washington, Batman (Detective Comics #27), Superman #1, Marvel Comics #1, and Tintin’s King Ottokar’s Sceptre.

https://en.wikipedia.org/wiki/2035_in_public_domain

Wikipedia also tells me that all of the 'life + 70" countries will have Ian Fleming's James Bond works in the public domain in 2035 as well.

There is also AussieEspañol, who is attempting to travel from Argentina to Alaska in a tuk-tuk (an auto rickshaw) - https://www.youtube.com/@aussieespanol/videos

Followed him a bit last year. A really sweet and enthusiastic person.

Hi! Author here. I agree that I should have explicitly stated the word "priority queues" since it is an ADT people can directly relate to. I will add it in. However, it is simply not true that I did not describe how a priority queue-based solution works.

I have described it in the "Timer Modules" section:

> A natural iteration of this approach is to store timers in an ordered list (also known as timer queues). In this scheme, instead of storing the time interval, an absolute timestamp is stored. The timer identifier and its corresponding timestamp that expires the earliest is stored at the head of the queue. Similarly, the second earliest timer is stored after the earliest, and so on, in ascending order. After every unit, only the head of the queue is compared with the current timestamp. If the timer has expired, we dequeue the list and compare the next element. We repeat this until all the expired timers have been dequeued, and we run their expiry processing routines.

And then, I go on to talk about its runtime.

Truth be told, this is a chapter for my book on data structures and algorithms that I think are interesting and obscure enough that not many people talk about them. Its goal is not widespread practicality, but rather a fun deep dive into some topics.

When my friends and I were undergrads (3rd year, I believe), we had an absolute blast exploring this exact topic - the intersection of Bloom Filters and client side searching. So much so that it became part of our undergrad thesis.

It all started when Stavros's blog was circulated on Hacker News! The way we approached the search part was by using "Spectral Bloom Filters" - https://theory.stanford.edu/~matias/papers/sbf-sigmod-03.pdf - which is based on a paper by Saar Cohen and Yossi Matias from the early 2000s - its basically an iteration on the counting bloom filters. We used the minimal selection and minimal increase algorithm from the paper for insertion and ranking of results.

I wrote a blog on it too - https://pncnmnp.github.io/blogs/spectral-bloom-filters.html

Some slides - https://pncnmnp.github.io/blogs/sthir-talk-2020.pdf

I love what Norvig said. I can relate to it. As far as data structures are concerned, I think it's worth playing smart with your tests - focus on the "invariants" and ensure their integrity.

A classic example of invariant I can think of is the min-heap - node N is less than or equal to the value of its children - the heap property.

Five years from now, you might forget the operations and the nuanced design principles, but the invariants might stay well in your memory.

Some interesting stuff from the Nature paper

> The Perseverance rover has explored and sampled igneous and sedimentary rocks within Jezero Crater to characterize early Martian geological processes and habitability and search for potential biosignatures ..... the organic-carbon-bearing mudstones in the Bright Angel formation contain submillimetre-scale nodules and millimetre-scale reaction fronts enriched in ferrous iron phosphate and sulfide minerals, likely vivianite and greigite, respectively.

> Organic matter was detected in the Bright Angel area mudstone targets Cheyava Falls, Walhalla Glades and Apollo Temple by the SHERLOC instrument ..... A striking feature observed in the Cheyava Falls target (and the corresponding Sapphire Canyon core sample), is distinct spots (informally referred to as ‘leopard spots’ by the Mars 2020 Science Team) that have circular to crenulated dark-toned rims and lighter-toned cores

> PIXL XRF analyses of reaction front rims reveal they are enriched in Fe, P and Zn relative to the mudstone they occur in ..... In the reaction front cores, a phase enriched in S-, Fe-, Ni- and Zn was detected

> Given the potential challenges to the null hypothesis, we consider here an alternative biological pathway for the formation of authigenic nodules and reaction fronts. On Earth, vivianite nodules are known to form in fresh water ..... and marine ..... settings as a by-product of low-temperature microbially mediated Fe-reduction reactions.

> In summary, our analysis leads us to conclude that the Bright Angel formation contains textures, chemical and mineral characteristics, and organic signatures that warrant consideration as ‘potential biosignatures’ that is, “a feature that is consistent with biological processes and that, when encountered, challenges the researcher to attribute it either to inanimate or to biological processes, compelling them to gather more data before reaching a conclusion as to the presence or absence of life .....

I had to look up PIXL XRF from this paper - https://arxiv.org/pdf/2402.01544 - it is:

> The Planetary Instrument for X-ray Lithochemistry (PIXL) is an X-ray fluorescence (XRF) spectrometer mounted on the arm of the National Aeronautics and Space Administration’s (NASA) Mars 2020 Perseverance rover (Allwood et al., 2020; Allwood et al., 2021). PIXL delivers a sub-millimeter focused, raster scannable X-ray beam, capable of determining the fine-scale distribution of elements in martian rock and regolith targets. PIXL was conceived following the work by Allwood et al. (2009) that demonstrated how micro-XRF elemental mapping could reveal the fine-textured chemistry of layered rock structures of ~3,450-million-year-old Archean stromatolitic fossils. Their work not only pushed back the accepted earliest possible window for the beginning of life on Earth, but also demonstrated that significant science return might be possible through XRF mapping. PIXL was proposed, selected, and developed to carry out petrologic exploration that provide the paleoenvironmental context required in the search for biosignatures on Mars, analogous to Allwood et al.’s earlier work.

I recently listened to the episode on The Antikythera Mechanism and found it quite fun - https://www.bbc.co.uk/programmes/m0024x0g

Also, I wanted to mention something interesting - back when LLM-driven applications were just emerging, someone posted on Hacker News about how they categorized In Our Time episodes using the Dewey Decimal System with LLMs. Cool stuff - https://news.ycombinator.com/item?id=35073603

Thanks! This might be it. I looked up Henry J. Kelley on Wikipedia, and in the notes I found a citation to this paper from Stuart Dreyfus (Berkeley): "Artificial Neural Networks, Back Propagation and the Kelley-Bryson Gradient Procedure" (https://gwern.net/doc/ai/nn/1990-dreyfus.pdf).

I am still going through it, but the latter is quite interesting!

Apologies - I should have been clear. I was not referring to Rumelhart et al., but to pieces of work that point to "optimizing the thrusts of the Apollo spaceships" using backprop.

I have a question that's bothered me for quite a while now. In 2018, Michael Jordan (UC Berkeley) wrote a rather interesting essay - https://medium.com/@mijordan3/artificial-intelligence-the-re... (Artificial Intelligence — The Revolution Hasn’t Happened Yet)

In it, he stated the following:

> Indeed, the famous “backpropagation” algorithm that was rediscovered by David Rumelhart in the early 1980s, and which is now viewed as being at the core of the so-called “AI revolution,” first arose in the field of control theory in the 1950s and 1960s. One of its early applications was to optimize the thrusts of the Apollo spaceships as they headed towards the moon.

I was wondering whether anyone could point me to the paper or piece of work he was referring to. There are many citations in Schmidhuber’s piece, and in my previous attempts I've gotten lost in papers.

One of my favorite examples of this is the Beatles:

> On 11 February 1963, the Beatles recorded ten songs during a single studio session for their debut LP, Please Please Me.

> Martin asked the band if they had any songs that they could record quickly. According to Martin, "It was a straightforward performance of their stage repertoire – a broadcast, more or less." Initially, a morning and afternoon session only were booked; the evening session was added later. Mark Lewisohn later wrote: "There can scarcely have been 585 more productive minutes in the history of recorded music".

Interestingly,

> .... the Beatles arrived with John Lennon suffering from a bad cold, which he attempted to treat with a steady supply of throat lozenges

https://en.wikipedia.org/wiki/Please_Please_Me

To add to this thread, here's how Lichess generates chess puzzles - https://github.com/ornicar/lichess-puzzler

Regarding the intersection takeoff, Flightradar24 just tweeted this:

> We are continuing to process data from receiver sources individually. Additional processing confirms #AI171 departed using the full length of Runway 23 at Ahmedabad. RWY 23 is 11,499 feet long. The aircraft backtracked to the end of the runway before beginning its take off roll.

https://x.com/flightradar24/status/1933138841214611760

I was thinking the same thing! I've been working with some TTS applications, such as real-time commentary for Pong and personalized radio stations. I might give this a try, it sounds fun.

Absolutely! I can elaborate on that part.

The code starts by simulating 15 tournament years (like from 2010 to 2024), with each year containing 4 grand slam tournaments - held in a knockout format. There are 64 players in the pool, all starting with an initial ELO score.

These players compete in the tournaments, with outcomes predicted based on their ELO ratings. ELO is then updated after each match. We rank players solely based on their ELO. Once the simulation completes, it generates a wealth of data. For each game, details such as points scored, points allowed, fastest ball speed, number of aces, point-by-point results, and more are simulated.

We can then cache and use this information for a ton of color commentary. For example, we can identify the GOATs of the game, highlight players who are performing exceptionally well, pinpoint underdogs, find matches similar to the one currently being played, etc.

However, I am just scratching the surface. Imagine having a function that considers "age" alongside ELO. Then, you could simulate performance based on age as well - and show things like the younger generation overtaking older players, or veterans still competing despite being past their prime. With a fn like this, you could simulate matches that span the past 75-100 years, generating a ton of nice data to analyze.

Data itself is not fun - you need nice metrics too - for fun correlations! See https://en.wikipedia.org/wiki/Baseball_statistics. The metrics don’t have to be perfect, after all, humans aren’t perfect. The key is engagement.

To find similar games, I store and cache all historical matches in a KD-tree, then use a NN search to find similar games - that's quite fast!

Some commentary can also be dynamically generated at runtime - for example, locker-room whispers. It is important to provide GPT with a decent historical window to avoid generating contradictory info in such cases.

Hehehe! I love Jelle's Marble Runs - long-time subscriber. John Oliver introduced me to it - https://www.youtube.com/watch?v=z4gBMw64aqk

Author here. I agree with you - the number of metrics I can experiment with in Pong is limited. Chess and Go are next for me.

Overall, the simplicity of this project has helped me test the waters before diving into more complex territories. The underlying pipeline isn't bad - the approach of collecting events, periodically generating metrics from them, prioritizing them, generating commentary text, queuing those outputs, and then synthesizing speech should serve as the core for similar work.

It's also given me some intuition on how I can construct an "ecosystem" of data surrounding live action, to add a layer of realism to the narratives.

Author here. TTS and script generation can be a bit of an overhead for now, which is why I've worked with metric aggregates - 30+ bounces rather than exactly 33, for example. For this game, one might ideally want this overhead to be less than the time it takes for the ball to bounce from one paddle to another, which can be around 1–2 seconds. However, there may be another strategy to (maybe?) overcome this: start synthesizing numbers (ignoring the fractional part) using TTS and cache them for both commentators. Then, patch those audio clips together after core part is synthesized. It should be doable, I think - I just haven't gotten to it yet. Note that matching the excitement and tempo of core commentary with those numbers is key - otherwise, it will feel janky.

> I have wondered whatever became of that massive initiative from Google to scan books, and whether that might be looked at as a potential training source, giving that Google has run into legal limitations on other forms of usage.

A few months ago, there was an interesting submission on HN about this - The Tragedy of Google Books (2017) (https://news.ycombinator.com/item?id=41917016).

> The average centipawn loss shows a very slight advantage (less than 1 centipawn) for Gukesh. This connects well with the accuracy metric we got, which showed a negligible advantage for Gukesh.

As I understand, for average centipawn loss, lower is better. It kind of measures how much worse a player’s average moves are compared to the best moves suggested by the engine. Based on your data, Ding has a very slight advantage, not Gukesh. Here is an article from chess.com (https://www.chess.com/blog/raync910/average-centipawn-loss-c...):

> The term average centipawn loss (ACPL) represents how much “value” a player drops by making incorrect moves during a chess game. ..... The lower an ACPL that player has, the more perfectly they played (at least in the eyes of the engine assessing the game).