There are quite a lot of AI's inner workings articles which make it way too complicated to understand. Few months ago, I found this article which I was able to read till the end and fully understand it:

https://www.quantamagazine.org/how-can-ai-id-a-cat-an-illust...

I think it's perfect example of making complex things easier to understand.

This brings personal nostalgia to when I was very young and made an "OS" in PowerPoint using links between slides, animations, and the embedded internet explorer object. Similarly, I'm not sure I see any practical use in this. Still it's a really fascinating conceptual demonstration of networks understanding intent in the complex state-machine that is a graphical user interface.

One Take Audio | Senior or Student | REMOTE | https://www.onetakeaudio.com We're building generative AI software that helps music creators build their visions. Our team is at capacity and we need your help to accelerate development.

Experience we want - Generative AI model tuning (diffusion, ONNX runtime, WindowsML), C++ Windows/Mac desktop applications, addressing chipsets/architectures/memory, gRPC, audio processing, GPU & NPU optimizations.

People we need:

Senior SW Developer - Join the team and work for equity. Moonlighting is ok to start, with a willingness to convert to full-time once we complete our seed funding round.

Student - Internship (paid). Equity is possible for exceptional candidates. We want someone who will complete school within a year and be open to full-time employment afterwards.

hello@onetakeaudio.com

Eclypsium | Portland (US), Córdoba (ARGENTINA), Singapore (remote) | ONSITE / HYBRID / REMOTE | Full-time & Contract

https://eclypsium.com/company/careers/

We protect devices from chip to cloud—securing firmware, hardware, and the supply chain beneath the OS. Fortune 100s and federal agencies run us in production.

- Senior Software Engineer – Portland, OR

- Platform Architect – Córdoba, AR

- Sr. Software Engineer (Data) – Córdoba, AR

- Junior Data Engineer – Córdoba, AR (new)

- R&D Consulting Engineer – Singapore (remote OK)

Why Eclypsium: - Startup speed, no politics, real impact - Equity, full health, flex PTO, parental leave

I’m Rob (rob.banagale@eclypsium.com). Eclypsium found me via HN. If a role fits, please apply at the link, and feel free to reach out with questions.

ML6 | Machine Learning Engineer, Data Engineer | Python, TensorFlow, PyTorch, GCP, AWS, Azure | Full-time | Amsterdam, Berlin, Ghent (EU) On-site/hybrid

We are a Machine Learning consulting company that builds end-to-end Machine Learning solutions. By applying the latest AI research, we keep our clients at the forefront of innovation. If you are interested check out: https://www.ml6.eu/knowledge-hub/blog and https://www.ml6.eu/customers/cases

Work on innovative projects for the biggest clients across Europe such as Randstad, ASML, FUNKE, and many more! Whether it’s about leveraging LLMs to improve customer support, building data lakes on cloud platforms to improve storage or implementing models using sensor data for quality control. You can find it all at ML6. You will mostly work with Python and a range of ML frameworks such as TensorFlow, PyTorch, or HuggingFace Transformers to solve hard Machine Learning tasks and help bring these application into production by building data pipelines and cloud infrastructure on all of the major cloud providers (GCP, AWS, Azure).

Open roles include:

• Senior ML/Data Engineers

• Senior AI Consultants

• Senior AI Project Managers

• Industry Directors

• Junior ML/Data Engineers

and many more!

Apply now at the https://jobs.ml6.eu/

Out of curiosity, what's the difference between this and semantic versioning[0]?

[0]https://semver.org/

Speaking of: https://www2.math.upenn.edu/~ghrist/notes.html

With editors like vim, neovim, emacs, it's way easier to get the lay of the land first (tutorial, play around with the default config,..) and then list out what you need.

My vim config has three things only: LSP, FZF (for anything fuzzy), and Plug (to install the above two). There's also a few niceties, but I could do without them. or vendor them into the main config. But it's not my daily editor, so that's just the base config. Anything I could add on top of that would depend on the projects I would need it for. That's about 200 lines (the lsp config is 1/4 of that)

NB. A nice talk even if it's about vim "How to Do 90% of What Plugins Do (With Just Vim)"

https://www.youtube.com/watch?v=XA2WjJbmmoM

I'm trying to figure out how people do solo research, that means:

- Reading advice like https://eamag.me/2025/Good-Research

- Figuring out problems like https://openreview-copilot.eamag.me/

- Doing analysis like https://eamag.me/2024/Automated-Paper-Classification

- Figuring out where scientists are located like https://eamag.me/2024/ICML-2024-on-a-map

I did the first 27 chapters of this tutorial just because I was interested in learning more and it was thoroughly enjoyable: https://mariokartwii.com/armv8/

I actually quite like coding in assembly now (though I haven’t done much more than the tutorial, just made an array library that I could call from C). I think it’s so fun because at that level there’s very little magic left - you’re really saying exactly what should happen. What you see is mostly what you get. It also helped me understand linking a lot better and other things that I understood at a high level but still felt fuzzy on some details.

Am now interested to check out this ffmpeg tutorial bc it’s x86 and not ARM :)

Somewhat related, from 11 "Getting Your First Consulting Client" https://www.kalzumeus.com/2012/09/17/ramit-sethi-and-patrick...

I’ve been using MarkWhen for a similar life timeline https://markwhen.com

Thanks, but my point was less about this one article, and more about the general experience of a well-intentioned but novice contributor: no matter how much you try to do the right thing, there's a good chance your work is for nothing because someone more established than you doesn't see the value in it.

And maybe they are right: I understand that not all new contributions are valuable to the project (though you could argue that improving upon them is better than outright deleting them — obvious spam and vandalism excepted ofcourse). But you can't have it both ways: either you want to invite new contributors, in which case you need to be tolerant of their mistakes, and ensure that they are mentored instead of bullied by the more experienced users, or you choose to have a small group of trusted veterans maintain all articles. I don't think one option is obviously superior to the other, but it's a choice that Wikipedia doesn't seem to want to make.

There is lots of room for improvement here. For example, I get the impression that Deletionists now rule Wikipedia, so if a newbie like me tries to create a new article on any topic, there is a 90% chance it will just be deleted (because if the topic was worthy of an article on Wikipedia, don't you think someone more experienced had already created it by now, silly noob?)

If that's the case, then why allow people to create new articles at all? It's just setting up people to waste their time creating an initial draft. And it's an annoying gamble: I know that the more time I spend on making the initial revision really really good, the less likely it will be insta-deleted by some grumpy guy, but the more time I will have lost if it is! It's a real dilemma. Why make people gamble with their time like that?

If you accept that most new articles will not be accepted, wouldn't it be better to disable article creation, and instead have a form where people can suggest ideas for new articles? That way, you spare contributors the effort of creating the initial draft (which is actually really difficult if you're new to Wikipedia and you are trying to be diligent about creating properly-formatted references and info-boxes and so on), and on the off-chance that the people in power decide to allow the new article to be created, they could also pair up the new contributor with a more experienced editor who will mentor them and help them create an initial revision that's up to snuff. This strikes me as a process that's 1000% better if you want to encourage new contributions.

While not a book per se, I learned a lot from the Gentoo Wiki. Trial and error could get a determined beginner through a stage 3 install, I think.

[1] https://wiki.gentoo.org/wiki/Handbook:AMD64

Competitive online games commonly predict the player's movement. Network latencies have improved and are now usually <16ms (useful milestone since at 60fps you render a frame every 16.6ms), but players expect to still be able to smoothly play when joining from the other side of the continent to play with their friends. You usually want every client to agree where everyone is, and predicting movement leads to less disagreement than what you would get from using "outdated" state because of speed-of-light delays.

If you want to predict not just position but also orientation in a shooter game, that's basically predicting the mouse movements.

Here's a different approach in Common Lisp I wrote a while back:

https://github.com/codr7/whirlog

I've read a similar series from Phil back in 2020: "Writing a SQL database from scratch in Go" https://notes.eatonphil.com/database-basics.html

The code is available on GitHub: https://github.com/eatonphil/gosql (it's specifically a PostgreSQL implementation in Go).

It's cool to build a database in 3000 lines, but for a real production-ready database you'll need testing. Would love to see some coverage on correctness and reliability tests. For example, SQLite has about 590 times more test code than the library itself. (https://www.sqlite.org/testing.html)

There is of course Bob Nystrom's https://craftinginterpreters.com

This and https://hint.userweb.mwn.de/understanding_mp3/index.html are both amazingly fun examples of literate programming that I recommend all of the time.

There is no standard.

Filament is extremely well documented: https://google.github.io/filament/Filament.html

glTF's PBR stuff is also very well documented and aimed at realtime usage: https://www.khronos.org/gltf/pbr/

OpenPBR is a newer, much more expensive BRDF with a reference implementation written in MaterialX that iirc can compile to glsl https://academysoftwarefoundation.github.io/OpenPBR

Pick one of the BRDFs, add IBL https://bruop.github.io/ibl, and you'll get decent results for visualization applications.

I discovered this trick independently about a decade ago, to use cross-eyed viewing to easily spot differences between two similar images. Like you said, the parts that mismatch appear to shimmer and be unstable, making them obvious.

However, I feel eye strain from doing it, so I prefer other methods. 99% of the time, I do https://en.wikipedia.org/wiki/Blink_comparator instead, just switching between two images with zero flicker and zero displacement offset. Also with both eyes, it's easier to spot certain kinds of subtle differences like color shifts, JPEG-like compression artifacts, tiny differences in antialiased renderings, etc.

One benefit of the cross-eyed method, though, is that you can difference videos. But the use case for that is rarer than differencing images.

Cool project!

Seems a bit complex though, compared to doing a shell script showing a notification or sending yourself an email each morning when you open it?

Or just doing a light script on val.town?

For instance this could be an example val.town script that does something similar (just need to bind to a data source for the dictionary)

    import { sqlite } from "https://esm.town/v/stevekrouse/sqlite";
    import { OpenAI } from "https://esm.town/v/std/openai";
    import { email } from "https://esm.town/v/std/email";
    
    // Dutch words database
    const dutchWords = [
      { word: "boek", translation: "book" },
      { word: "huis", translation: "house" },
      { word: "boom", translation: "tree" },
      { word: "water", translation: "water" },
      { word: "kat", translation: "cat" },
      { word: "hond", translation: "dog" },
      { word: "appel", translation: "apple" },
      { word: "tafel", translation: "table" },
      { word: "school", translation: "school" },
      { word: "fiets", translation: "bicycle" }
    ];
    
    export default async function generateDutchWordLearning() {
      const KEY = new URL(import.meta.url).pathname.split("/").at(-1);
      const openai = new OpenAI();
    
      // Ensure SQLite table exists
      await sqlite.execute(`
        CREATE TABLE IF NOT EXISTS ${KEY}_dutch_words (
          word TEXT PRIMARY KEY,
          translation TEXT,
          example TEXT,
          timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
        )
      `);
    
      // Fetch words not previously used
      const usedWords = await sqlite.execute(`
        SELECT word FROM ${KEY}_dutch_words
      `);
    
      const availableWords = dutchWords.filter(
        w => !usedWords.rows.some(row => row.word === w.word)
      );
    
      if (availableWords.length < 3) {
        // Reset if we've used all words
        await sqlite.execute(`DELETE FROM ${KEY}_dutch_words`);
        availableWords = dutchWords;
      }
    
      // Randomly select 3 unique words
      const selectedWords = [];
      for (let i = 0; i < 3; i++) {
        const randomIndex = Math.floor(Math.random() * availableWords.length);
        selectedWords.push(availableWords.splice(randomIndex, 1)[0]);
      }
    
      // Generate example sentences with ChatGPT
      const wordDetails = await Promise.all(selectedWords.map(async (wordObj) => {
        const exampleResponse = await openai.chat.completions.create({
          model: "gpt-4o-mini",
          messages: [{
            role: "user", 
            content: `Geef een voorbeeld zin met het woord "${wordObj.word}" in het Nederlands.`
          }]
        });
    
        const example = exampleResponse.choices[0].message.content || "Geen voorbeeld gevonden";
    
        // Store in database
        await sqlite.execute(`
          INSERT INTO ${KEY}_dutch_words (word, translation, example) 
          VALUES (?, ?, ?)
        `, [wordObj.word, wordObj.translation, example]);
    
        return { ...wordObj, example };
      }));
    
      // Prepare HTML email
      const htmlContent = `
        <html>
          <body>
            <h2>Dutch Word Learning </h2>
            ${wordDetails.map(w => `
              <div>
                <h3>${w.word} (${w.translation})</h3>
                <p><em>Example:</em> ${w.example}</p>
              </div>
            `).join('')}
          </body>
        </html>
      `;
    
      // Send email
      await email({
        subject: "Your Daily Dutch Words ",
        html: htmlContent,
        text: wordDetails.map(w => 
          `${w.word} (${w.translation}): ${w.example}`
        ).join('\n')
      });
    
      return wordDetails;
    }

I wouldn't argue that it's rather complex for what it does. The reason I still did it this way was that I want to get them automated, without doing anything manually. Even if I would need to just open my laptop, or run a script once, I think I would just stop at one point, and I don't think it would ever become a habit. Are there other tools that could probably get this project done with less complexity? Probably, but I have the pride of an engineer and wanted to brush up on my Terraform ;)

I want to do that if I ever find the time. Adding a date to the database entries, and some code to throw an old word in here and there based on spaced repetition best practices.

The words are generated by ChatGpt Api, and I store them in DynamoDB.

Since you're using python, I may as well plug the py-fsrs project in case you wanna add spaced repetition to it: https://github.com/open-spaced-repetition/py-fsrs

I made a somewhat similar zsh shell script the other day: U wanted to receive daily notifications about topics I'm comfortable with but in spanish b1 level and at semi random interval. It's just a couple lines of zsh : https://github.com/thiswillbeyourgithub/Daily_Fact_Ntfy

> With all respect and love to the OP, I must admit that I laughed out loud when I saw the AWS architectural diagram

OP actually did it more efficiently than most! You should see the AWS suggested architecture. It uses something like 10 different AWS services.

My company actually set out to solve this very problem. We have a cloud cron hosting that's more reliable than the AWS architecture but just requires a few lines of code. Literally this is all you have to do:

    @DBOS.scheduled('* * * * *')
    
    @DBOS.workflow()
    def example_scheduled_workflow(scheduled_time: datetime, actual_time: datetime):
      DBOS.logger.info("I am a workflow scheduled to run once a minute.")

https://github.com/dbos-inc/dbos-demo-apps/blob/main/python/...

With all respect and love to the OP, I must admit that I laughed out loud when I saw the AWS architectural diagram and wondered whether this might be a joke. Personally, I'd have implemented this as a few dozen lines of Python living as a cron job (or even as a long-lived process with a schedule), but I'm no pedigreed engineer.