Comments URL: https://news.ycombinator.com/item?id=48682619

Points: 2

# Comments: 0

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. .....

Comments URL: https://news.ycombinator.com/item?id=48626807

Points: 13

# Comments: 5

Comments URL: https://news.ycombinator.com/item?id=48516446

Points: 4

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=48470578

Points: 97

# Comments: 61

Comments URL: https://news.ycombinator.com/item?id=48269880

Points: 59

# Comments: 1

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.

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

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

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.

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?

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.

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

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.

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

Comments URL: https://news.ycombinator.com/item?id=45782702

Points: 51

# Comments: 3

Comments URL: https://news.ycombinator.com/item?id=45744151

Points: 2

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=45614803

Points: 2

# Comments: 0

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.