here you goThings I’ve made, read and saved — shared here.

Archive

9,718 entries: 104 from X, 8,928 from Pinboard, saved 1998 to 2026.

Browse by tag, site, author, folder or language

Tags

Sites

Authors

Folders

Languages

Showing 1,151–1,200 of 9,592Language unknown ×

2025

The DuckDB Local UI

duckdb.org

$ duckdb -ui

can have multiple databases including in memory database attached. Can explore the databases using Table summary, the notebooks are useful in organizing work into notebooks. SQL is the language of the notebooks like [[python]] is for [[jupyter]] notebooks. The notebook cells support syntax highlighting and autocompletion.

The results can be visualized using the column explorer, which shows the summary of the results. It is "type aware", and thus can visulize things like percentiles, median etc.

Interestingly, the the UI extension is all written in [[cpp]] - https://github.com/duckdb/duckdb-ui

More about The DuckDB Local UI

johnbean393/Sidekick: A native macOS app that allows users to chat with a local LLM that can respond with information from files, folders and websites on your Mac without installing any other software. Powered by llama.cpp.

github.com

A native macOS app that allows users to chat with a local LLM that can respond with information from files, folders and websites on your Mac without installing any other software. Powered by llama.cpp.

More about johnbean393/Sidekick: A native macOS app that allows users to chat with a local LLM that can respond with information from files, folders and websites on your Mac without installing any other software. Powered by llama.cpp.

github.comPinboardPermalink

#llm#osx

re2c — Regular Expressions to Code

re2c.org

lexer generator that supports C/C++, D, Go, Haskell, Java, JavaScript, OCaml, Python, Rust, V, Zig, and can be extended to other languages by implementing a single syntax file. The primary focus of re2c is on generating fast code: it compiles regular expressions to deterministic finite automata and translates them into direct-coded lexers in the target language (such lexers are generally faster and easier to debug than their table-driven analogues). Secondary re2c focus is on flexibility: it does not assume a fixed program template; instead, it allows the user to embed lexers anywhere in the source code and configure them to avoid unnecessary buffering and bounds checks. Internal algorithm used by re2c is based on a special kind of deterministic finite automata: lookahead TDFA. These automata are as fast as ordinary DFA, but they are also capable of performing submatch extraction with minimal overhead. re2c is used in other open-source projects, such as php, ninja, yasm, spamassassin, BRL-CAD, wake, etc.

More about re2c — Regular Expressions to Code

re2c.orgPinboardPermalink

#regex

Church Of Turing - The Landscape of Lisp

churchofturing.github.io

Tl;dr:

  • If you want a minimalist, elegant Lisp with a strong academic foundation: choose Scheme.
  • If you want a powerful, batteries-included Lisp with a rich standard library and decades of history: choose Common Lisp.
  • If you want a modern Lisp with functional programming, concurrency, and JVM interop: choose Clojure.
  • If you want a beginner-friendly Lisp with great tooling and a focus on education and extensibility: choose Racket.
More about Church Of Turing - The Landscape of Lisp

Age and cognitive skills: Use it or lose it | Science Advances

science.org

Cross-sectional age-skill profiles suggest that cognitive skills start declining by age 30 if not earlier. If accurate, such age-driven skill losses pose a major threat to the human capital of societies with rapidly aging populations. We estimate actual age-skill profiles from individual changes in literacy and numeracy skills at different ages. We use the unique German longitudinal component of the Programme of the International Assessment of Adult Competencies (PIAAC-L) that retested a large representative sample of adults after 3.5 years. Our empirical approach separates age from cohort effects and corrects for measurement error from reversion to the mean. Two main results emerge. First, average skills increase strongly into the forties before decreasing slightly in literacy and more strongly in numeracy. Second, skills decline at older ages only for those with below-average skill usage. White-collar and higher-educated workers with above-average usage show increasing skills even beyond their forties. Women have larger skill losses at older age, particularly in numeracy.

More about Age and cognitive skills: Use it or lose it | Science Advances

Model Context Protocol

Note

MCP is an open protocol that standardizes how applications provide context to LLMs. Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect your devices to various peripherals and…

More about Model Context Protocol

Quartz notesPermalink

notes#mcp

Flow Matching and Diffusion Models

diffusion.csail.mit.edu

Diffusion and flow-based models have become the state of the art for generative AI across a wide range of data modalities, including images, videos, shapes, molecules, music, and more! This course aims to build up the mathematical framework underlying these models from first principles. At the end of the class, students will have built a toy image diffusion model from scratch, and along the way, will have gained hands-on experience with the mathematical toolbox of stochastic differential equations that is useful in many other fields. This course is ideal for students who want to develop a principled understanding of the theory and practice of generative AI.

More about Flow Matching and Diffusion Models

Quartz

Note

Quartz is a fast, batteries-included static-site generator that transforms Markdown content into fully functional websites. It is often recommended as a publishing companion to obsidian, which is how I use it. I publish this site using…

More about Quartz

"APL since 1978" in Proceedings of the ACM on Programming Languages

dl.acm.org

The Evolution of APL, the HOPL I paper by Falkoff and Iverson on APL, recounted the fundamental design principles which shaped the implementation of the APL language in 1966, and the early uses and other influences which shaped its first decade of enhancements.

By Roger Hui. (108 pages). Should be a comprehensive historical review of the APL language.

More about "APL since 1978" in Proceedings of the ACM on Programming Languages

Minions: the rise of small, on-device LMs

hazyresearch.stanford.edu

shift a substantial portion of LLM workloads to consumer devices by having small on-device models collaborate with frontier models in the cloud. By only reading long contexts locally, we reduce cloud costs with minimal or no quality degradation. We imagine a future where an “intelligence layer” running persistently on-device interacts with frontier models in the cloud to deliver applications with cost-effective, “always-on” intelligence.

Reseach by Stanford's Hazy Research.

ollama also has a related blog post

Cites this work: "LLM×MapReduce: Simplified Long-Sequence Processing using Large Language Models"

The proposed LLM×MapReduce framework splits the entire document into several chunks for LLMs to read and then aggregates the intermediate answers to produce the final output. The main challenge for divide-and-conquer long text processing frameworks lies in the risk of losing essential long-range information when splitting the document, which can lead the model to produce incomplete or incorrect answers based on the segmented texts. Disrupted long-range information can be classified into two categories: inter-chunk dependency and inter-chunk conflict. We design a structured information protocol to better cope with inter-chunk dependency and an in-context confidence calibration mechanism to resolve inter-chunk conflicts.

More about Minions: the rise of small, on-device LMs

How Core Git Developers Configure Git

blog.gitbutler.com

git butler, Git client for simultaneous branches on top of your existing workflow, talked to git core developers and asked them to help define What git config settings should be defaults by now. Here are some settings that even the core developers change.

# clearly makes git better

[column]
        ui = auto
[branch]
        sort = -committerdate
[tag]
        sort = version:refname
[init]
        defaultBranch = main
[diff]
        algorithm = histogram
        colorMoved = plain
        mnemonicPrefix = true
        renames = true
[push]
        default = simple
        autoSetupRemote = true
        followTags = true
[fetch]
        prune = true
        pruneTags = true
        all = true

# why the hell not?

[help]
        autocorrect = prompt
[commit]
        verbose = true
[rerere]
        enabled = true
        autoupdate = true
[core]
        excludesfile = ~/.gitignore
[rebase]
        autoSquash = true
        autoStash = true
        updateRefs = true

# a matter of taste (uncomment if you dare)

[core]
        # fsmonitor = true
        # untrackedCache = true
[merge]
        # (just 'diff3' if git version < 2.3)
        # conflictstyle = zdiff3 
[pull]
        # rebase = true

read rest of the article on why

More about How Core Git Developers Configure Git

deepseek-ai/awesome-deepseek-integration

github.com

consistent with an opensource mindset, deepseek are curating a list of "awesome" stuff built with/on deepseek.

This list not only serves as a reminder of what can be done with deepseek, but also a general overview of all things possible with rest of llms too.

More about deepseek-ai/awesome-deepseek-integration

Claude 3.7 Sonnet and Claude Code Anthropic

anthropic.com

Anthropic announced new version of Claude today, and it has been received very positively going by the reactions on X. Simon Willison ran it through his usual gauntlet.

The new thing is the claude CLI tool that allows you run commands against Claude api from the command line, which also would be a big aid for programming tasks.

I had unsubscribed from Claude for the last couple of months, and looks like it's time to get back on it.

More about Claude 3.7 Sonnet and Claude Code Anthropic

Sky-T1: Train your own O1 preview model within $450

novasky-ai.github.io

Stanford's Sky Lab announced the "Sky-T1" model that performs competitively in reasoning and coding while comparison to OpenAI's o1 model, while using a small compute budget.

They set about to produce this open-weights model because the current leaders like o1 and gemini 2.0 flash thinking while excel in reasoning, showing the ability to solve complex tasks by producing a long internal chain of thought, among other advancements. However, the technical details and model weights are un-accessible.

Summary:

  • They used QwQ to generate training data (with some cleanup using GPT-4o-mini)
  • The training data was then used to FT Qwen2.5-32B-Instruct (non-reasoning model)
  • Result was that Sky-T1 performs slightly worse than QwQ but much better than Qwen2.5 on reasoning tasks.

This is pretty interesting as it shows how you can FT a foundation model to do better at reasoning.


Inference time compute is still underutilized for AI deployments. It is better to distill the reasoning from larger models like R1 for specific tasks. Even better, one can mix in custom thinking instructions for specific sub-problems, so that a fine-tuned model learns o mix of task specific reasoning and custom logic. This can often beat custom prompt iteration. 🔗

This Guide: Train a Reasoning Model | Kiln AI Docs goes into how to distill for thinking models.

More about Sky-T1: Train your own O1 preview model within $450

Flat Github - see data hosted on github

flatgithub.com

Flat explores how to make it easy to work with data in git and GitHub. It builds on the “git scraping” approach pioneered by Simon Willison to offer a simple pattern for bringing working datasets into your repositories and versioning them, because developing against local datasets is faster and easier than working with data over the wire.

An example of this in action is - All .gov domains via HN

More about Flat Github - see data hosted on github

Johnny.Decimal - A system to organise your life

johnnydecimal.com

Johnny.Decimal is designed to help you find things quickly, with more confidence, and less stress.

You assign a unique ID to everything in your life.

These IDs help you stay organised. They impose constraints that make it harder to get lost. And you create your own index to link everything in your life together.

More about Johnny.Decimal - A system to organise your life

Pinboard Database Schema

static.pinboard.in

the mysql database schema that powers pinboard.in. useful if you are trying to create your own pinboard like service.

-- MySQL dump 10.13   
--  
-- Pinboard database schema  
-- Feel free to use this however you like. Send questions to support@pinboard.in. 
-- For best results, use the Percona version of MySQL! http://www.percona.com/software/percona-server/  


CREATE TABLE `bookmarks` (  
    `id` int(11) NOT NULL,  
    `url` mediumtext,        -- verbatim URL (may differ from actual URL referenced by url_id)  
    `title` varchar(255),  
    `description` mediumtext,  
    `user_id` int(11) NOT NULL,  
    `toread` tinyint(1) DEFAULT '0',  
    `private` binary(1) DEFAULT '0',  
    `url_id` int(11),     
    `slug` char(20),         -- opaque token for use in URLs  
    `snapshot_id` int(11),  
    `code` char(3),          -- http response code (if crawled)  
    `source` smallint(6),    -- numeric     
    `added_at` datetime,     -- date added to Pinboard  
    `created_at` datetime,   -- stated creation date  
    `updated_at` datetime,  
  
    PRIMARY KEY (`id`),  
    UNIQUE KEY `slug` (`slug`),     
    UNIQUE KEY `bookmark` (`user_id`,`url`(255)),  
    KEY `created` (`created_at`),  
    KEY `user` (`user_id`),  
    KEY `private` (`private`),  
    KEY `url` (`url_id`),  
    KEY `toread` (`toread`),  
    KEY `updated` (`updated_at`),  
    KEY `snapshot` (`snapshot_id`),  
    KEY `code` (`code`),  
    KEY `multi` (`user_id`,`private`,`toread`,`created_at`)  
) ENGINE=InnoDB DEFAULT CHARSET=utf8;  
     
  
-- Table structure for table `btags` (short for 'bookmark tags')  

  
CREATE TABLE `btags` (  
    `id` int(11) NOT NULL,     
    `user_id` int(11) NOT NULL,  
    `bookmark_id` int(11) NOT NULL,  
    `url_id` int(11),  
    `tag` varchar(255),  
    `created_at` datetime,     
    `private` tinyint(1),     
    `seq` tinyint(4),         -- preserve display order  
    PRIMARY KEY (`id`),  
    UNIQUE KEY `btag` (`user_id`,`bookmark_id`,`tag`),  
    KEY `user` (`user_id`),  
    KEY `tag` (`tag`),  
    KEY `bookmark` (`bookmark_id`),  
    KEY `url` (`url_id`),  
    KEY `private` (`private`),  
    KEY `usertag` (`user_id`,`tag`)  
) ENGINE=InnoDB DEFAULT CHARSET=utf8;   
     
  
  
  
-- Table structure for table `snapshots`  
-- (snapshots are directories created by wget)  
  
CREATE TABLE `snapshots` (  
    `id` int(11) NOT NULL,  
    `url_id` int(11) NOT NULL,  
    `crawled_at` datetime,     
    `slug` varchar(30),  
    `content_type` varchar(200),     
    `etag` varchar(255),                  -- from Etag header     
    `last_modified` varchar(255),         -- from Last-Modified header     
    `code` char(3),                       -- http status code  
    `content_length` varchar(20),         -- from Content-Length header  
    `num_files` smallint(6),                      
    `size` int(11),                       -- size in bytes of snapshot files  
    `filename` varchar(255),              -- which file in this snapshot to serve  
    `updated_at` datetime,  
    `user_id` int(11),  
    `remote_backup` datetime,                     
    `flagged` binary(1) DEFAULT '0',  
    `actual_url_id` int(11),              -- where we ended up after redirects  
    `server` varchar(200),                -- where this snapshot is stored  
    `charset` varchar(20),                -- detected charset (don't trust servers!)  
    PRIMARY KEY (`id`),  
    UNIQUE KEY `user_url` (`url_id`,`user_id`),  
    KEY `size` (`size`),  
    KEY `content_length` (`content_length`),  
    KEY `content_type` (`content_type`),  
    KEY `slug` (`slug`),  
    KEY `user_id` (`user_id`),  
    KEY `code` (`code`),  
    KEY `crawled` (`crawled_at`)  
) ENGINE=InnoDB DEFAULT CHARSET=utf8;  
     
  
  
     
--  
-- Table structure for table `urls`  
--  
  
CREATE TABLE `urls` (  
    `id` int(11) NOT NULL,  
    `url` mediumtext CHARACTER SET latin1,  -- latin1 reduces storage requirement  
    `create
More about Pinboard Database Schema

Perspective

perspective.finos.org

Perspective is an interactive analytics and data visualization component, which is especially well-suited for large and/or streaming datasets. Use it to create user-configurable reports, dashboards, notebooks and applications, then deploy stand-alone in the browser, or in concert with Python and/or Jupyterlab.

Github: https://github.com/finos/perspective

More about Perspective

Alexander Grothendieck

Note

Alexander Grothendieck on learning to be alone. "In those critical years I learned how to be alone. [But even] this formulation doesn't really capture my meaning. I didn't, in any literal sense learn to be alone, for the simple reason that…

More about Alexander Grothendieck

Quartz notesPermalink

notes#mathematics#person

David Lynch

Note

From David Lynch to curate Club Silencio, Paris - Trebuchet Magazine, his five favourite books (via)[https://www.reddit.com/r/davidlynch/comments/1el29g3/whatistheartlife]: Crime & Punishment by Fyodor Dostoevsky, The Metamorphosis by…

More about David Lynch

Quartz notesPermalink

notes#movies#person

DeepSeek

Note

DeepSeek is a AI research company from China that has been doing cutting edge work in the area of Large Language Models, including DeepSeek-R1. DeepSeek tried to do one thing: transplant its own model to Huawei Ascend 910B chip to run…

More about DeepSeek

Quartz notesPermalink

notes#llm#opensource