deno on S Anand

Things I Learned - 08 Feb 2026

Sun, 08 Feb 2026 00:00:00 +0000

This week, I learned:

The Disconnected Git Workflow explains how to use the git send-email workflow. That’s like using email instead of GitHub as the collaboration mechanism - decentralizing and reducing dependencies.
Grok throws a HTTP 431 when you pass it a query over 6,890 characters in the URL. Here’s an example with 6,900 characters.
As of now, there’s no way to tell uv to use the cache and install only missing repos (#15454). But this is Deno’s default behavior, making Deno a slightly better choice in this regard.
Shelling Out Sucks shares common pitfalls when calling the shell from programs. Suggestion: Shell-escape ALL inputs. Use set -o pipefail to detect failures in the middle of a pipe chain. Explicitly check the error code, not just stderr.
dax, which is based on zx, is a simpler Deno-based alternative to shell scripts. See examples. ChatGPT. However, scripting language matters more when humans maintain shell scripts. Since I’m using AI, it’s easier to use bash scripts and let it handle any complexities.
git push --force-with-lease is like git push --force but won’t overwrite if others have pushed in the meantime. Default to this instead of --force – it’s safer.
Microsoft’s docfind generates a WASM search index for documents, building a dependency free browser based compact and fast search.
diffs seems a promising library for rendering diffs in the browser.
Genie 3 seems pretty good. We should expect to see World Models becoming usable in a few months.

How to build and deploy custom GitHub Pages

Tue, 01 Apr 2025 05:59:18 +0000

Here’s the GitHub Actions file (.github/workflows/deploy.yaml) I use to publish to GitHub pages.

name: Deploy to GitHub Pages

on:
  # Run when pushed. Use { branches: [main, master] } to run only on specific branches
  push:
  # Allow manual triggering of the workflow
  workflow_dispatch:
  # OPTIONAL: Run at a specific cron schedule, e.g. first day of every month at 12:00 UTC (noon)
  schedule:
    - cron: "0 12 1 * *"

permissions:
  # To deploy to GitHub Pages
  pages: write
  # To verify that deployment originated from the right source
  id-token: write

jobs:
  # Run as a single build + deploy job to reduce setup time
  deploy:
    # Specify the deployment environment. Displays the URL in the GitHub Actions UI
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}

    # Run on the latest Ubuntu LTS
    runs-on: ubuntu-latest
   \
    steps:
      # Checkout the repository
      - uses: actions/checkout@v4

      # Run whatever commands you want
      - run: echo '<h1>Hello World</h1>' > index.html

      # Upload a specific page to GitHub Pages. Defaults to _site
      - uses: actions/upload-pages-artifact@v3
        with:
          path: .

      # Deploy the built site to GitHub Pages. The `id:` is required to show the URL in the GitHub Actions UI
      - id: deployment
        uses: actions/deploy-pages@v4

This is based on Simon Willison’s workflow and some of my earlier actions.

This combines build and deploy jobs. For simple sites, that’s simpler and more efficient. For complex builds with parallel execution or need for better error recovery, multiple jobs will help.

I build sites with uv, node, or deno. Here are examples of each

A sample uv-based deployment.

# Install uv
- uses: astral-sh/setup-uv@v5
# Run a Python script
- run: uv run scraper.py

A sample node package.json deployment and an npx deployment.

# Install node
- uses: actions/setup-node@v4
  with:
    node-version: 20
    registry-url: https://npm.pkg.github.com/
# Install and build via package.json
- run: npm install
- run: npm run build
# Or, directly use npx. For example, generate HTML with Marp
- run: npx -y @marp-team/marp-cli@latest README.md -o index.html
# Update content directly, e.g. add an SVG favicon as a data URL
- run: sed -i 's/<\/head>/<link rel="icon" type="image\/svg+xml" href="data:image\/svg+xml;base64,..."\/><\/head>/g' index.html

A sample deno deployment.

# Install deno
- uses: denoland/setup-deno@v1
  with:
    deno-version: v1.x
# Run a Deno script. Use environment variables if needed
- env:
    OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
  run: deno run --allow-read --allow-write --allow-env --allow-net script.js

Things I Learned - 24 Nov 2024

Sun, 24 Nov 2024 00:00:00 +0000

This week, I learned:

OpenAI lets you download GPT instructions and execute arbitrary code in their containerized environment. This is not a bug. Ref
BM25 works as follows: Ref
- For each query term in the query, sum up the product of:
  - Inverse document frequency = LN(% of docs without the query term + 1) – with a small tweak
  - Term frequency = freq / (freq + k) – where k is usually between 1.2 to 2. Returns 0-1 with diminishing frequency benefit
    - k is multiplied by Document length normalization = 1 - b(1- DocLength/AvgDocLength). Longer documents have larger k, dampening frequency benefits.
- Some implications:
  - The actual BM25 score has no meaning. It’s just useful for ordering
  - BM25 scores for 2 queries can be compared ONLY IF the document sets don’t change
A list of Markdown to Website converters on this thread:
- Jekyll - Ruby - 2008
- MkDocs - Python - 2014
- GitBook - JavaScript (Node.js) - 2014
- MkDocs Material - Python (MkDocs-based) - 2016
- Docsify - JavaScript - 2016
- MdBook - Rust - 2017
- Antora - JavaScript (Node.js) - 2017
- Docusaurus - JavaScript (React) - 2017
- JupyterBook - Python - 2019
- Keenwrite - Java - ~2019
- Honkit - JavaScript (GitBook fork) - 2019
- Nextra - JavaScript (Next.js) - 2020
- Astro - JavaScript/TypeScript - 2021
- Hugo Book - Go (Hugo-based) - ~2020
- Clowncar - JavaScript/Node.js - ~2021
- Quarto - R and Python - 2022
- Starlight - JavaScript/TypeScript - 2023
DuckDB has an LLMs.txt. Today, 38 repos on GitHub support it
When identifying LLM use cases, it helps to tell LLMs what they can do. I use one or more of a list like below:
- Core capabilities:
  - Text Generation: Produce coherent and contextually relevant text across various domains.
  - Image Generation: Create realistic images that match the style and content of a given reference image.
  - Text to Speech: Convert text into natural-sounding speech with appropriate intonation and rhythm.
  - Speech to Text: Transcribe and interpret spoken language.
  - Vision: Analyze and describe visual content from images.
  - Video Analysis: Summarize and extract information from video content.
  - Text to Video: Generate realistic (and surrealistic) videos from text descriptions.
  - Function Calling: Execute predefined functions or access external tools to perform specific tasks.
  - Structured Output: Generate structured outputs like JSON, XML, HTML, YAML, DSLs, etc.
  - Tool Use: Utilize external applications or APIs to enhance functionality.
  - Code Generation: Write and debug code snippets in various programming languages.
- Cross-domain use cases:
  - Summarization: Understand and condense lengthy documents into concise summaries.
  - Translation: Convert text between multiple languages with high accuracy.
  - Question Answering: Provide precise answers to user queries based on provided information.
  - Reasoning and Planning: Solve complex problems and develop step-by-step plans.
  - Personalization: Tailor responses based on user preferences and historical interactions.
  - Dialogue Management: Engage in context-aware, multi-turn conversations.
  - Data Analysis: Interpret and generate insights from structured data.
  - Content Moderation: Identify and filter inappropriate or harmful content.
  - Sentiment Analysis: Detect and interpret emotions and opinions in text.
  - Robotics Integration: Interface with robotic systems for control and decision-making.
  - Knowledge Retrieval: Access and present information from vast datasets or knowledge bases.
  - Creative Writing: Generate poetry, stories, and other creative content.
  - Educational Assistance: Provide explanations and tutoring across various subjects.
  - Ethical Reasoning: Assess scenarios for ethical considerations and implications.
  - Accessibility Support: Assist users with disabilities through tailored interactions.
  - Simulation and Modeling: Create predictive models and simulate scenarios.
- Domain-specific use cases:
  - Legal and Medical Assistance: Offer information and guidance within legal and medical domains.
  - Gaming: Generate narratives, dialogues, and scenarios for interactive entertainment.
  - Scientific Research: Aid in literature reviews, hypothesis generation, and data interpretation.
  - Financial Analysis: Analyze market trends and provide investment insights.
  - Cultural Competence: Understand and respect diverse cultural contexts in interactions.
  - Security Applications: Detect and respond to potential cybersecurity threats.
  - Environmental Monitoring: Analyze data related to environmental changes and sustainability.
  - Healthcare Support: Assist in patient monitoring, diagnostics, and personalized treatment plans.
  - Supply Chain Optimization: Enhance logistics and inventory management through predictive analysis.
  - Customer Service: Provide automated support and resolve customer inquiries.
  - Market Research: Analyze consumer behavior and market trends for business insights.
  - Content Creation: Generate articles, blogs, and marketing materials.
  - Virtual Assistance: Manage schedules, reminders, and personal tasks.
  - Social Media Management: Craft posts and engage with audiences across platforms.
  - Human Resources: Assist in recruitment, training, and employee engagement strategies.
  - Event Planning: Organize and coordinate events, including logistics and communication.
  - Travel Planning: Provide itineraries, booking assistance, and destination information.
  - Real Estate: Analyze property markets and assist in buying or selling decisions.
  - Agriculture: Monitor crop health and optimize farming practices through data analysis.
  - Energy Management: Optimize energy consumption and monitor renewable energy sources.
  - Transportation: Enhance route planning and traffic management systems.
  - Urban Planning: Assist in designing sustainable and efficient urban infrastructures.
  - Disaster Response: Provide real-time information and coordination during emergencies.
  - Public Policy: Analyze data to inform policy decisions and predict societal impacts.
  - Art and Design: Generate visual art concepts and assist in creative design processes.
  - Music Composition: Create original music pieces and assist in songwriting.
  - Language Learning: Facilitate language acquisition through interactive exercises and feedback.
  - Historical Analysis: Interpret historical data and provide insights into past events.
  - Philanthropy: Identify charitable opportunities and assess the impact of donations.
  - Sports Analytics: Analyze player performance and game strategies.
  - Fashion: Predict trends and assist in clothing design and merchandising.
  - Culinary Arts: Generate recipes and provide cooking guidance.
  - Astronomy: Analyze celestial data and assist in space exploration research.
  - Psychology: Offer insights into human behavior and mental health support.
  - Linguistics: Analyze language patterns and assist in translation studies.
  - Archaeology: Assist in artifact analysis and historical site interpretations.
  - Literature Analysis: Interpret literary works and provide critical analyses.
  - Philosophy: Engage in discussions on ethical dilemmas and existential questions.
  - Mathematics: Solve complex equations and assist in theoretical research.
  - Physics: Model physical phenomena and assist in experimental design.
  - Chemistry: Analyze chemical compounds and predict reactions.
  - Biology: Assist in genetic research and ecological studies.
  - Geology: Analyze geological data and assist in natural resource exploration.
  - Meteorology: Predict weather patterns and analyze climate data.
  - Oceanography: Study marine ecosystems and assist in ocean exploration.
  - Anthropology: Analyze cultural data and assist in ethnographic research.
Style of writing impacts output style a lot. E.g. Adding an evil laugh makes Claude more creative. Ethan Mollick
For good structured mode output, we need good prompting.
- Mentioning examples and schema and “JSON” helps. When providing examples, using (user, assistant) message pairs helps (I think it’s because it’s easier for the LLM to parse).
- Using a {reasoning, answer} schema (with reasoning first) helps. Make reasoning concise and relevant Ref Arxiv
- We already know code in JSON is not a great idea. Ref
Just adding 3 real examples and regurgitation helped GPT 4o play chess much better. Both techniques may have more general use in prompting. Simon Willison
With Deno 2.0, the same .js file can run in Node.js as well as Deno. Example
jspm lets you generate import maps against any CDN.
You can click on htop columns on the terminal to sort by that column! Mouse events work on command line apps. Julia Evans
Alt Text will very likely be a browser feature. It’s important for the Alt text to flow as part of the content when listening to the page. Perhaps even become a part of the browser APIs like speechRecognition.
Langchain suggests multiple levels of agentic behaviour. LLM Call < LLM Chain < LLM Rounter < State Machine < Autonomous Langchain
A HTML quine: A page that, when rendered as HTML, shows the HTML source code of the page!
You can enable syntax highlighting just using fonts. Ref
HTML is all you need shows examples of using HTML for notebooks instead of Jupyter, Observable, etc.
Straive evaluated Gemini 1.5 Flash 002 and GPT 4o Mini for translation.
- Portugese: Flash is better than GPT 4o Mini. BLEU Word Overlap is 65.5% > 64.6% and METEOR (Semantic) is 84.9% > 78.9%
- Mandarin: Flash is better than GPT 4o Mini. BLEU Word Overlap is 25.0% > 15.9% and METEOR (Semantic) is 54.7% > 51.1%
The problem with Accept headers is that you can’t link to them. Simon Willison
Recraft v3 supports vector (SVG) generation Simon Willison. The output is 100% <path> elements (even for text). You get 50 free credits daily. Creating 1 image is ~2 credits. The API costs $1 per 1K credits. Some things I can create with it are:
- Base data visualizations that I can animate with code
- Icons in a specific style
- Comic strips
- Explainers for talks or student material
- Featured images for blog posts
- Architecture diagrams?

Things I Learned - 13 Oct 2024

Sun, 13 Oct 2024 00:00:00 +0000

This week, I learned:

DuckDB supports function chaining
DuckDB lets you create functions = macros
HTML for People is a nice introduction to HTML.
FlightRadar24 lets you watch airplanes live.
sq is like jq but for SQL.
Deno 2 is fully backward compatible with Node! via
O1 is good at solving problems where the solution is easy to verify and generating options helps get closer to the solution
Reverb ASR does diarration as well as transcription. It seems the state of art right now.
Gemini Flash and Gemini Flash 8b can be fine-tuned at zero cost. Inference is at the same price! Ref
Flux 1.1 Pro is released. I tried my Calvin & Hobbes test on it. Not great. ImageGen3 is better, ChatGPT is the best. Ref
Revisiting text to speech models. Nothing much has changed since July 2024.
- OpenAI TTS: $15/1M chars Ref
- Deepgram Aura: $15/1M chars Ref
- Azure AI Speech: $15/1M chars Ref
- Google TTS Neural2: $16/1M chars Ref
- AWS Polly Neural TTS: $16/1M chars Ref
- Cartesia Pro: $50/1M chars Ref
- Elevenlabs Scale: $300/1M chars Ref
GitHub co-pilot workspaces let you code using your mobile with AI and deploy it at one shot
If you need an Ubuntu Docker container with Python, install it via uv rather than compiling from source. via
VTracer is an open source library (and tool) to convert raster images to SVGs. via
If you want to create a console.llm() function, a browser extension is the best way, because some pages have Content-Security-Policy that block eval, form submission, fetch from other domains, and script execution.
PyPi lets you publish from GitHub Actions without a token. Also from Gitlab.com CI/CD and Google Cloud.
ActiveState which made ActivePython, ActivePerl, etc. made these products paid for commercial use around 2013 after a series of acquisitions.
Marimo supports:
- Publishing any notebook to static.marimo.app as a static app
- Creating a SINGLE link that embeds the ENTIRE notebook in the URL!
- Runnable via uvx marimo edit
Parables on the Power of Planning in AI: Giving models about 30 seconds of thinking time consistently improves results - as much as increasing parameter size by a factor of 1,000 to 100,000!
- This works particularly well for verifiable results (code, math, etc.)
- Technique: Ask an LLM hundreds of times at low temperature and pick the most common one. (Google’s Minerva used this on the MATH dataset.)
- Better Technique: Ask an LLM hundreds of times. Pick the best solution based on an evaluation metric (reward model)
- Better Technique: Apply a reward model at EACH step of the process. OpenAI’s “Let’s Verify Step by Step”
Late chunking is an interesting approach to adding context to embeddings. (I don’t understand it, but it’s cheap and effective.)
DeepInfra offers embedding models as APIs at about 0.5 to 1 cent per MTok in an OpenAI compatible API. It also supports text-to-image models like flux.dev and speech recognition models like Whisper.
Jake Heller:
- “One of the things we learned is (an LLM app) after it passes passes frankly even 100 tests, the odds that it will do, on any random distribution of user inputs, the next 100,000 100% accurately is very high.”
OpenAI’s O1 is like Daniel Kahneman’s System 2 thinking - as against other LLMs’ System 1 thinking.
Continue.dev is another AI coding editor. It supports OpenRouter. So now I have heard good things about:
- Github Copilot
- Cursor
- Cody
- Continue.dev (supports OpenRouter)
- Aider (supports OpenRouter)
- Maybe:
  - Codeium
- Not:
  - Amazon Q Developer

Things I Learned - 08 Sep 2024

Sun, 08 Sep 2024 00:00:00 +0000

This week, I learned:

When running a Hello world app:
- FastAPI takes ~26K RAM, 3% CPU
- NodeJS + Express takes ~62K RAM, 2% CPU
- Deno + Express takes ~62K RAM, 1% CPU
- Deno + Fresh takes ~54K RAM, 0.4% CPU
I was testing out different video LLMs:
- Luma Labs lets you create videos from text
- Runwal ML lets you create video from an image + text
- Viggle lets you add images to a video or move a character in a certain way
- Veed.io is a video editor that offers AI video editing features
- Deepmotion generates 3D animations from video
- Wonder Dynamics may be similar to DeepMotion
I tested out a few audio LLMs:
- Suno is fast, has a better UI, lots of examples
- Udio is slow, poor UI, creates richer music
Reflection 70b is one of the top models now, and is open source!. It works by making the LLM reflect on its answer inside <reflection>...</reflection> tags.
The best diarization model today is whisperX. Run on Colab T4 GPU with:
Scale’s SEAL Leaderboards seem fairly good.
coedit-xxl is Grammarly’s fine-tuned google/flan-t5-xxl model run on CoEdit - text editing dataset. It’s mainly for single-line editing, though, and far from a full-document or full-email zero-shot editor.

Things I Learned - 28 Apr 2024

Sun, 28 Apr 2024 00:00:00 +0000

This week, I learned:

Tough prompt to test: Gr brx vshdn Fdhvdu flskhu? is a quick way to assess LLM capability. Ref
Cheap cloud GPU services thread on Twitter lists:
- Runpod (17)
- Vast.ai (17)
- Modal Labs (8)
- fly.io (4)
- LightningAI (4)
- Colab (4)
- AkashNet (4)
- Lambda Labs (4)
- ShadeFormAI (3)
- Mac Mini (3)
- Tensor Dock (2)
- Hetzner (2)
- BrevDev (2)
JSR lets you publish Deno packages that can be imported by npm via. It also auto-evaluates documentation and scores it! via
Snowflake Arctic Cookbook explains how mixture of experts models work
A long list of LLM courses online
Embeddings can be averaged. So, to embed large documents, average the embeddings of their chunks! OpenAI suggests this.