Here’s how you can do that:

Download the Audio from Youtube

Install yt-dlp and ffmpeg:

brew install yt-dlp ffmpeg

Download and extract the audio:

yt-dlp --extract-audio --audio-format mp3 --audio-quality 0 -o "%(title)s.%(ext)s" "https://www.youtube.com/watch?v=YOUR_VIDEO_ID"

Save to Spotify

Install save-to-spotify:

curl -fsSL https://saveto.spotify.com/install.sh | bash -s -- --no-skills

Then authenticate with your Spotify account:

save-to-spotify auth login

Now you can:

• Add a new episode and create a new show:

save-to-spotify upload file.mp3 --title "TITLE" --new-show "SHOW"`

• Add a new episode to an existing show:

save-to-spotify upload file.mp3 --title "TITLE" --show-id spotify:show:abcd1234

If --show-id is not specified, it will use the most recently created show.

Then visit your Spotify account and find the show and episode in your library (it takes a few minutes to show up there).

One Command

To combine yt-dlp and save-to-spotify in one command, the following bash script gets the audio, description, and thumbnail from Youtube and saves them to Spotify:

#!/usr/bin/env bash
set -euo pipefail

usage() {
  echo "Usage: $0 <video-id> [--new-show NAME | --show-id ID]"
  exit 1
}

[[ $# -lt 1 ]] && usage

URL="https://www.youtube.com/watch?v=$1"
shift

SHOW_ARGS=()
while [[ $# -gt 0 ]]; do
  case "$1" in
    --new-show) SHOW_ARGS+=(--new-show "$2"); shift 2 ;;
    --show-id)  SHOW_ARGS+=(--show-id "$2"); shift 2 ;;
    *) usage ;;
  esac
done

TMPDIR="$(mktemp -d)"
trap 'rm -rf "$TMPDIR"' EXIT

echo "Downloading audio, thumbnail, and metadata..."
yt-dlp \
  --extract-audio --audio-format mp3 --audio-quality 0 \
  --write-thumbnail --convert-thumbnails jpg \
  --write-info-json \
  -o "$TMPDIR/%(id)s.%(ext)s" \
  "$URL"

AUDIO="$(ls "$TMPDIR"/*.mp3)"
INFO="$(ls "$TMPDIR"/*.info.json)"
THUMB="$(ls "$TMPDIR"/*.jpg 2>/dev/null || true)"

TITLE="$(python3 -c "import json,sys; print(json.load(open(sys.argv[1]))['title'])" "$INFO")"
DESC="$(python3 -c "import json,sys; print(json.load(open(sys.argv[1])).get('description','')[:4000])" "$INFO")"

UPLOAD_ARGS=(--title "$TITLE")
[[ -n "$DESC" ]] && UPLOAD_ARGS+=(--summary "$DESC")

if [[ -n "$THUMB" ]]; then
  THUMB_SIZE="$(stat -f%z "$THUMB" 2>/dev/null || stat -c%s "$THUMB" 2>/dev/null)"
  if [[ "$THUMB_SIZE" -le 1048576 ]]; then
    UPLOAD_ARGS+=(--image "$THUMB")
  else
    echo "Thumbnail exceeds 1 MB, skipping."
  fi
fi

echo "Uploading to Spotify..."
save-to-spotify upload "$AUDIO" "${UPLOAD_ARGS[@]}" ${SHOW_ARGS[@]+"${SHOW_ARGS[@]}"}

echo "Done! '$TITLE' saved to Spotify."

Save it as yt2spotify.sh and make it executable:

chmod +x yt2spotify.sh

Then run:

yt2spotify.sh VIDEO_ID
yt2spotify.sh VIDEO_ID --new-show "YouTube Listens"
yt2spotify.sh VIDEO_ID --show-id spotify:show:abc123

Comment? Reply via Email, Mastodon or Twitter.

A good morning ritual needs to be flexible enough to adapt to these shifts. In order to do this, treat it like an opening chess move. On your ideal mornings, you’re going first. You get to decide which move to take. An opening move may be to make your usual breakfast, and doing something creative before you handle your professional or personal commitments.

I just want to quote the full post here, but it’s just four short paragraphs, so go read it on his blog.

source

Comment? Reply via Email, Mastodon or Twitter.

It took me a while to adapt. The breakthrough was realizing I could run Claude Code inside VS Code’s integrated terminal and use the Git extension to review changes. This became central to my workflow: I don’t let AI tools do whatever they want. I stay in the loop. Even when I’m vibe-coding a throwaway script, I want to quickly review what the AI is doing.

Once I figured out the workflow, I was pretty happy with Claude Code. It explored codebases more efficiently than Cursor, and I could see the model’s thinking traces, the reasoning behind each decision. This was huge for me. I could see how the model interpreted my request, catch wrong assumptions early, and course-correct before wasting time on the wrong path.

Then Claude Code 2.0 happened.

The Breaking Point

Anthropic updated Claude Code to be more accessible to everyone, not just power users. The VS Code extension got prettier, the UI got cleaner, and the thinking traces got hidden.

This was the moment I realized I couldn’t continue using Claude Code as-is. The thinking traces weren’t just a nice-to-have for me, they were essential. Without them, I had no way of knowing if the model had misunderstood my request until it finished working. Sometimes you ask something ambiguous, and instead of asking for clarification, the model assumes. Those assumptions are obvious in the thinking traces. Without them, you’re flying blind.

In this example, you can see the model debugging a SQL error, catching its own mistakes (“Actually wait”, “Wait, let me count…”), and reconsidering assumptions in real-time. This is exactly what you lose when thinking traces are hidden.

So I did what any stubborn power user would do: I disabled auto-updates and pinned my version to the latest 1.x release.

Why I Customize Claude Code

Here’s my problem with the defaults: Claude Code has access to too many tools. In theory, more tools means more capabilities. In practice, it means more complexity for the model to navigate, more tokens consumed on tool selection, and worse results.

Take plan mode. Claude Code has multiple tools for entering plan mode, exiting plan mode, asking questions in plan mode. All of this consumes tokens and adds cognitive load for the model. But plan mode is just… a markdown file where the model writes without editing your actual code. You can achieve the same thing by telling the model: “Don’t edit anything. Plan first, ask me questions, save your plan in a markdown file.” You don’t need dedicated tools for this.

Or sub-agents. The main model can spawn another agent to explore the codebase and summarize findings. Sounds useful, but I found it performs worse for my use cases. The sub-agent summarizes what it found, and the main model works with that summary instead of the actual code. It’s like playing telephone, context gets lost. I’d rather have the main model read the code itself, even if it uses more tokens and hits the context limit faster. At least it’s working with the real thing.

My Setup

I’ve ended up with a Claude Code config that’s leaner, faster, and more predictable. Here’s what I changed.

Restoring Thinking Traces

The API still returns thinking traces, Claude Code just hides them in the UI since version 2.0. I found claude-code-patches , a community project that patches thinking traces back to being fully expanded by default.

First, install a compatible Claude Code version:

npm install -g @anthropic-ai/claude-code@2.0.62

Then apply the patch:

git clone git@github.com:aleks-apostle/claude-code-patches.git
cd claude-code-patches
node patch-thinking.js

Restart Claude Code, and thinking blocks now display inline.

Why version 2.0.62? That’s the latest version the patch maintainer has officially supported. Other contributors have submitted PRs for newer versions, and the patch is just one JS file, so it’s trivial to adapt. But 2.0.62 has everything I need, and I’d rather wait for the maintainer to officially update than risk a broken patch.

Recent versions have actually gotten worse for power users. Version 2.1.20 started hiding even more information , showing vague summaries like “Read 3 files” instead of the actual file paths. When I read about this, I was glad I’d pinned my version. If a future Claude Code version introduces a feature I really want, I’ll upgrade and use a community patch. Until then, I’m staying put.

Settings

In ~/.claude/settings.json:

{
  "includeCoAuthoredBy": false,
  "env": {
    "DISABLE_AUTOUPDATER": "1",
    "CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY": "1",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
    "CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS": "50000"
  }
}

What each setting does:

• includeCoAuthoredBy: false - Disables the “Co-authored-by: Claude” line in git commits. I don’t ask Claude to commit often, and when I do, I prefer clean commit messages.
• DISABLE_AUTOUPDATER - Prevents automatic updates. I update manually after reviewing changelogs.
• CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY - Disables the “rate your session” popups. They appear frequently and break the flow.
• CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC - Keeps things fast and minimal.
• CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS: 50000 - The default is 25,000 tokens. When Claude reads files larger than that, it gets truncated and errors out. I keep documentation files in my project directories (Cloudflare Workers docs, API references, etc.) that exceed 25k tokens, and I want Claude to read them fully.

Disabling Token-Heavy Tools

I use a shell alias that runs Claude Code with max thinking tokens and disables tools I don’t want:

# In ~/.zshrc
alias claude='MAX_THINKING_TOKENS=31999 claude --disallowedTools \
  "Task,AgentOutputTool,ExitPlanMode,NotebookEdit,AskUserQuestion,SlashCommand,EnterPlanMode"'

This disables:

• Task / AgentOutputTool - Sub-agents that explore and summarize. I prefer the main model to read code directly.
• EnterPlanMode / ExitPlanMode - Plan mode tools. I just ask the model to plan in a markdown file instead.
• NotebookEdit - Jupyter notebook editing conflicts with VS Code’s live rendering. It doesn’t work well and wastes tokens. I don’t use Claude for notebooks much anyway.
• AskUserQuestion - Part of plan mode. Claude can just ask questions in regular text, and I respond in text. No special tool needed.
• SlashCommand - I’ve never used it.

The last three are more opinionated. If you use Jupyter notebooks heavily or like slash commands, keep those tools enabled.

Why use an alias instead of settings? When you specify --disallowedTools, these tools are completely removed from the model’s context. The model doesn’t even know they exist. This makes the context leaner and, I believe, improves the model’s focus.

Disabling Auto-Compaction

You can toggle this via /config in Claude Code, or directly in ~/.claude.json:

{
  "autoCompactEnabled": false
}

This one is important. By default, Claude Code reserves 22.5% of the model’s context (45k tokens out of 200k) for auto-compaction. When you approach this threshold, it summarizes the conversation and starts a new context. The summary is lossy, 99% of the time the model in the new session doesn’t have enough context about what you’ve tried, what worked, what didn’t.

After disabling auto-compaction, I rarely hit the context limit anyway. I keep my sessions short by default: start a session, work on a feature or bug, clear and start fresh. This leads to higher quality results.

For those times when I’m debugging something nasty and the context grows long, I’d rather continue the current session until it hits the actual limit. Here’s something nice about Claude Code: when you’re at 0% context remaining, it doesn’t immediately error out. It starts removing tool call results from the oldest messages (that test run from 30 messages ago, for example). You can often continue for 10-20 more messages before hitting the real API limit.

When I do hit the limit, I use /export to save user messages, assistant messages, and tool call titles to a text file. Then I start a fresh session and reference the transcript. This preserves more context than auto-compaction’s summary. I sometimes paste the export to another model (Gemini, for example) to get a second opinion on a tricky problem.

Why I Don’t Use MCPs

MCP servers let you connect Claude Code to external services: Google Drive, Jira, Notion, databases, etc. I don’t use any of them, except the VS Code MCP that Claude Code adds automatically when running in VS Code’s terminal (it provides useful things like IDE diagnostics).

My reasoning is the same as with the built-in tools: each MCP adds tools to the context. Some people add tens or even hundreds of tools via MCPs. The model then has to evaluate all of them for every request. More tools means more token overhead and, I believe, worse decision-making.

For services I actually need, I use CLI tools instead:

• GitHub - I mention in my CLAUDE.md that the gh CLI is available and authenticated. Claude knows how to use it.
• BigQuery - Same approach. I have bq CLI authenticated and add minimal instructions to CLAUDE.md.

For rarely-used integrations like Google Docs or Jira, I ask myself: what percentage of my Claude Code messages actually need Google Drive access? Maybe 1 in 100? 1 in 1000? For those rare cases, I just:

• Export the Google Doc as markdown, add it to the project directory, reference it manually
• Or ask Claude to write to a markdown file, then copy-paste into Google Docs

This takes 30 seconds and doesn’t pollute every session with tools I rarely use.

The exception: Skills. Skills are similar to MCPs but more minimal. The model only sees a one-sentence description of each skill until it’s actually needed. When triggered, it dynamically loads the full instructions.

For example, I have an Obsidian skill. The description says “use when the user mentions Obsidian or daily notes.” The full instructions (vault location, how to find daily notes, formatting preferences) only load when relevant. When I’m working on code and not mentioning Obsidian, my context stays clean.

For use cases like this, Skills are more efficient than MCPs. I’ll continue using them selectively.

The Result

My Claude Code setup is leaner: fewer tools in context, no auto-compaction overhead, full visibility into thinking traces. I spend less time wondering what the model is doing and more time actually working. When something goes wrong, I can see exactly where the model’s assumptions diverged from mine.

Here’s the difference. Running /context in a fresh session:

Before (default settings):

After (my setup):

Is it perfect? No. I’m pinned to an older version and relying on a community patch. But the tradeoff is worth it for the control I get back.

Your mileage may vary. If you’re happy with the defaults, that’s fine. But if you’re a power user who wants more control, and who wants to understand what the AI is doing rather than just trusting it, these customizations might help.

The goal isn’t to use AI tools less. It’s to use them with your eyes open.

Update — April 2026

My pinned v2.0.62 eventually stopped working. Every message returned “interrupted” immediately, without me actually interrupting anything. Turned out Anthropic started sending an effortLevel parameter in API responses that older Claude Code versions don’t know how to handle — they just crash. This GitHub issue confirmed it.

The main patches repo hasn’t been updated, but a contributor named anthrotype has been keeping the patches current independently. I upgraded to v2.1.112 (latest Claude Code at time of writing is 2.1.118) and applied two patches from their open PRs:

1. Thinking traces — PR #9 . Same as before, restores thinking blocks inline.
2. Tool visibility — PR #12 . Fixes a newer Anthropic regression that collapses tool call details into vague summaries like “Read 3 files” instead of showing the actual file paths.

npm install -g @anthropic-ai/claude-code@2.1.112

git clone git@github.com:anthrotype/claude-code-patches.git
cd claude-code-patches

git checkout update-v2.0.73
node patch-thinking.js

git checkout update-tool-visibility-patch
node patch-tool-visibility.js

and add the followings to cat ~/.claude/settings.json (alongside the existing settings):

{
  "env": {
    "MAX_THINKING_TOKENS": "31999",
    "CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING": "1"
  },
  "showThinkingSummaries": true,
  "alwaysThinkingEnabled": true
}

Restart Claude Code and both patches are active.

Comment? Reply via Email, Mastodon or Twitter.

When I moved here in 2022, one of the very first things I bought was a new tennis racket – even before I found a permanent apartment! I was eager to play, but I quickly realized I had a lot to learn about how tennis works in the Netherlands. I spent time hitting against a wall, researching clubs, and slowly finding my way. This blog post is my way of sharing what I’ve learned to help you get on the court faster and with less guesswork.

Dutch Tennis Clubs

This was a big one for me. Back in my home country, we didn’t really have “tennis clubs” in the same way. You’d just rent a court by the hour. In the Netherlands, tennis clubs are a huge part of the scene.

What’s a Tennis Club? Think of it as a community. You pay a yearly membership fee, and that usually gives you:

• Court Access: Play on the club’s courts for free whenever they’re available. Peak hours can be busy, though.
• Club Events: Most clubs have fun social events like “toss” evenings (more on that later!), ladder competitions, and small club tournaments.
• Coaching: Clubs usually have coaches, and lessons can be cheaper if you’re a member because you’re not paying extra to rent the court.
• A Tennis Community: You become part of a group of people who love tennis.

While there are some places where you can just book a court by the hour, joining a club is often the best and most cost-effective way to play regularly.

It’s good to know that club memberships are typically for the full calendar year. So, when you register, you become a member until the end of that year, and it usually gets automatically renewed for the next year if you don’t cancel it in time. This means you generally can’t be a member for just the summer months, for example.

Finding and Joining a Club

Search online or on Google Maps for clubs in your area. The good news is there are clubs everywhere – big cities, small towns, even villages! In Amsterdam, you can usually find a club within a 30-40 minute commute.

Most clubs have websites (often in Dutch). Look for info on:

• Membership: Are they accepting new members? Popular city-center clubs might have waiting lists.
• Fees: How much does it cost per year?
• How to Join: Usually, you fill out an online form and transfer the membership fee to their bank account (IBAN).

• Types of Membership:
  • Full/Adult Membership: The standard option with all benefits.
  • Junior/Senior Memberships: Often cheaper for younger or older players.
  • Off-Peak Membership: Some clubs offer cheaper rates if you only play during less busy times, like weekdays before 5 PM.

Bardienst (Bar Duty)

Many Dutch tennis clubs have a bar or café run by the members themselves. This means you’ll likely be scheduled for “bardienst” (bar duty) a few times a year (usually 2-3 times, for 3-4 hours each shift).

• Is it mandatory? Usually, yes, to get full club benefits.
• What’s it like? It can actually be a fun way to meet other members and serve drinks or snacks.
• Can I skip it? Most clubs let you pay a fee (around €30 per duty) if you can’t or don’t want to do it.

Types of Courts

You’ll mostly find clay courts (often called “gravel” in Dutch) or smash courts (a type of artificial clay). Some clubs also have artificial grass, and less commonly, hard courts or indoor carpet courts.

Finding Hitting Partners

Okay, you’ve joined a club (or are thinking about it), but who will you play with?

• Online: Websites like the Global Tennis Network have pages for Dutch cities where people post looking for partners. I found a couple of my regular hitting buddies this way.
• Your Network: Ask around, colleagues at work, fellow students, or friends might play or know someone who does. Use your company’s Slack or a student WhatsApp group.
• At the Club: Visit clubs, watch people play, and if you see someone around your level, don’t be shy to ask if they’re open to a game.
• Club Activities: “Toss” evenings and ladder competitions (see below) are fantastic for meeting new players.
• Be Open: I’ve even had people stop me on the street when they saw my racket sticking out of my bag and ask to play. We became doubles partners and played tournaments together.

Finding a Coach

Want to improve and sharpen your skills?

• Club Coaches: If you’re a member of a club, definitely ask them first about lessons or if they know coaches who teach there. This is often cheaper because you won’t need to pay extra for court rental – just the coach’s fee.
• Ask Around: Chat with your tennis friends or hitting partners. They might have had good experiences with a coach and can give you a recommendation.
• Online Search: Some coaches have their own websites with contact details. You can even reach out to people in the tennis community (like me, if you need a suggestion!).

• Private or Group: You can usually choose between one-on-one lessons or cheaper group sessions.
• Cost: Expect to pay around €50-€60 per hour for the coach’s time, plus court fees if applicable.

Club Activities & Official Competitions

This is where the Dutch tennis scene really shines.

Club-Level Events

• “Toss” Events: These are super popular. Usually, one evening a week, members just show up, have a coffee or beer, and get randomly paired up (“tossed”) for fun singles or doubles matches. It’s very social and a great way to meet people.
• Ladder Competitions: A bit more serious than toss, but still unofficial (so it doesn’t affect your official rating). You join a ladder in your club, challenge people around your rank, and try to climb up. You usually schedule matches with your opponent when it suits you both. You can often choose how many matches you want to play (e.g., one every two weeks, or more if you’re keen!).

Official KNLTB Events (Tournaments & Competition)

The KNLTB is the Royal Dutch Lawn Tennis Association. Playing in their official events can affect your national tennis rating.

Tournaments

• How to Join: You’ll need to be a club member or buy a KNLTB tournament pass (€25 per year).
• Finding Them: Check the KNLTB tournaments website . You can filter by location, level, singles/doubles, etc.
• When: Mostly April to August, peaking in May and June, but there are tournaments year-round.
• Format: Often week-long (e.g., Saturday to the following Sunday) knockout events. Sometimes there are one-day tournaments. If there aren’t many players in your category, it might be a round-robin (everyone plays each other).

Competitie (League Competition)

• Team-Based: You need to be part of a club and join or form a team (men’s, women’s, or mixed).
• How it Works: Your team plays against other teams, usually on a set day each week for a season. There are different formats (e.g., a certain number of singles and doubles matches per team encounter). There’s typically a spring competition (around March-May) and a fall competition (around September-October). Since it’s team-based, you can try to find a team looking for players, and many teams also need substitutes now and then.
• Your Rating: Only the matches you personally play will affect your KNLTB rating, not your team’s overall win or loss for the day.

Your KNLTB Rating

When you join the KNLTB (either through a club or a tournament pass), you’ll be asked to self-rate yourself.

• The Scale: It’s from 1 (pro level) to 10 (complete beginner). This is the opposite of the US system, so a lower number is better.
• Starting Point: If you’ve played matches and are comfortable with strokes and serving, you might start at an 8.
• How it Changes: Winning official tournament or competition matches, especially against someone with a better (lower number) rating, will improve your rating (make your number smaller). Losing, especially to someone with a worse (higher number) rating, will make your rating worse (make your number bigger).
• Doubles: Your doubles rating is separate and works similarly, based on the average rating of your team versus your opponents.

I started at an 8 for both singles and doubles and have bounced between 9 and 7 as I’ve played more.

How Much Does It All Cost?

There are universal costs that you pay when you play tennis anywhere (rackets, shoes, balls). But here are some Netherlands-specific ones:

• Club Membership: Roughly €100 to €300+ per year, depending on the club’s location and facilities. Amsterdam city center clubs tend to be pricier.
• Coaching: Around €50-€60 per hour for the coach, plus court fees if you’re not taking lessons at your own club.
• Tournament/Competition Fees: Usually around €15 to enter a tournament. Competition fees are often paid as a team and might be around €10 per player per season.
• Court Rental (if not a member):
  • Outdoor (Summer): Around €20+ per hour in areas like Amsterdam.
  • Indoor (Winter): Much more expensive, as courts are limited. Expect €40-€50+ per hour, especially at peak times.
• Bar Duty Buy-Out: If you opt out of your “bardienst,” it’s usually around €30 per shift. So, if you have three shifts, that’s an extra €90.

The Tennis Season

You can pretty much play tennis all year round if you don’t mind the cost of indoor courts in winter.

• Outdoor Season: Generally from mid-March to mid-November (about 8 months). Yes, it rains, and yes, it can be windy. But I’ve found that most of the time, the weather is fine for playing. Light rain is often playable, especially on artificial surfaces. Serious wind that truly ruins a game is rare, maybe 10% of the time in my experience. July and August can get hot in the middle of the day.
• Indoor Season: Mid-November to mid-March. You’ll need to find and book indoor courts for December, January, and February. Although they can be expensive, you can find indoor courts in winter. It’s often easier and cheaper if you’re lucky enough to be available to play during off-peak hours. I’ve personally played at about 5 different indoor facilities around Amsterdam and one in Haarlem.

Getting Your Tennis Gear

If you’re new to tennis or just setting up in the Netherlands, you’ll need some gear:

• Tennis Racket: Obvious, but important.
• Proper Tennis Shoes: Don’t play in running shoes. Tennis shoes are designed for side-to-side movements and will help prevent injuries.
• Tennis Balls: You’ll need to buy cans of balls regularly.
• Racket Restringing: If you play often, your strings will eventually break or lose tension.
• Tennis Clothes: Comfortable sportswear.

Where to Buy

I do most of my tennis-specific shopping online. Some websites I’ve used and can recommend include tennispro.nl , tennis-point.nl , tennisdirect.nl , tenniswarehouse-europe.com , kctennis.nl , and tennis-voordeel.nl .

Tennis equipment can get expensive, but here are a few tips:

• Look for Discounts: Online stores often have sales, especially around Black Friday, Christmas, or during Grand Slam tournaments.
• Buy in Bulk: For items you use frequently like tennis balls, racket strings, or overgrips, buying larger packs (e.g., 12 cans of balls, a pack of 60 overgrips) is usually cheaper in the long run.
• Test Rackets Before Buying: If you’re unsure about a new racket model, many online shops offer a racket testing service. For a small fee (around €10-€15), they’ll send you a test racket to try for a week or two. This is much cheaper than buying a €200-€300 racket you might not like! You can try a few different models this way before committing.

A Few Things to Know

Based on my experience, here are a couple of common practices you’ll see on and off the court:

• Sweeping the Court: This isn’t unique to the Netherlands but is very common due to the many clay and smash courts. After you finish playing (a practice session or a match), you need to sweep the court with the large brooms provided. This keeps it in good condition for the next players. In an official match, you’ll sweep your half, and your opponent will sweep theirs.
• Post-Match Socializing: Dutch tennis community is generally quite social. It’s common for the winning player or team in a tournament event to offer their opponent(s) a drink at the club bar after the match. Many people will hang around and chat for a bit. Competition is even more of a social event. The home team usually provides snacks and will buy drinks (coffee, tea, etc.) for the visiting team. Before, between, and especially after all the matches are done, both teams will often sit together, have refreshments, and chat about tennis and life in general.

Playing tennis in the Netherlands has been a fantastic experience for me. It’s a great way to stay active, meet new people, and feel more connected to local life. While it might seem a bit different at first, the system is well-organized, and there are tons of opportunities to play at every level.

I hope this guide helps you navigate the Dutch tennis scene. Grab your racket, find a club or a partner, and enjoy the game! Good luck, and maybe I’ll see you on the court. Feel free to reach out to me via email if you’re an intermediate tennis player in the Netherlands and looking for new people to play with.

More Resources

• Expat Info Holland: Tennis in Netherlands

Comment? Reply via Email, Mastodon or Twitter.

When you’re independent you feel less desire to impress strangers, which can be an enormous financial and psychological cost.

The wild thing about all this effort is how easy it is to overestimate how much other people are thinking about you. No one is thinking about you as much as you are. They are too busy thinking about themselves.

Even when people are thinking about you, they often do it just to contextualize their own life. When someone looks at you and thinks, “I like her sweater,” what they actually may be thinking is, “That sweater would look nice on me.” I once called this the man-in-the-car-paradox: When you see someone driving a nice car, rarely do you think, “Wow, that driver is cool.” What you think is, “If I drove that car, people would think I’m cool.” Do you see the irony?

When you’re truly independent you rid yourself of this silly burden. It can be such a relief when you do. Only when you stop caring what strangers might think of you do you realize how much effort you may have previously put into their validation.

But also:

Independence does not mean you don’t care what anyone thinks of you. It means that you strategically decide whose attention you seek.

When you independently choose who you want to include in your small circle of life, the actions you take, the work you pursue, and even the values you hold can completely flip. Rather than trying to appease everyone (foolish, impossible) you select the life you want to live and focus your attention on a smaller group of people whose love and support you deeply desire.

source

Comment? Reply via Email, Mastodon or Twitter.

We can finally just take a photo of a textbook problem that has no answer reference and no discussion about it and prompt an LLM to help us understand what’s missing in our understanding of the problem, if our solution is plausible and how we could verify it.

LLM changed nothing though. It’s just boosting people’s intention. If your intention is to learn, you are in luck! It’s never been easier to teach yourself some skill for free. But if you just want to be a poser and fake it until you make it, you are gonna be brainrot waaaay faster than usual.

I wholeheartedly agree with this take. While internet forums are full of arguments on benefits and dangers of LLMs on various aspects of human life including learning, from a personal point of view it’s a waste of resources and opportunities if we don’t make use of the recent advancements in LLMs to learn. It can be a new language (I’m getting LLMs’ help to learn Dutch these days), a technical skill, or many other things.

source

Comment? Reply via Email, Mastodon or Twitter.

Simon himself developed a llm-hacker-news plugin that fetches all the comments in a HackerNews discussion and provides that to llm as an extra context (i.e. a fragment).

Today I developed and released a simple python library which is a plugin for llm, and introduces a new fragment type to this tool. It’s called llm-url-markdown , and uses the Jina Reader API to fetch the markdown content of a web url and provide that as a fragment to llm.

To use this plugin, first you need to make sure you have llm installed:

brew install llm

or:

pip install llm

Then setup an API key for OpenAI (or follow llm’s docs to setup local models or other cloud LLMs):

llm keys set openai

Next, install llm-url-markdown:

llm install llm-url-markdown

That’s it! Now you can use it with md: like following:

llm -f md:github.com/simonw/llm 'What is the main goal of this LLM tool?' -m gpt-4o-mini

source

Comment? Reply via Email, Mastodon or Twitter.

I recommend reading the original post if you’re interested in generating alt text with local llm, specially since he has posted a couple of follow up posts on updating his approach.

His blog post made me curious in what type of photography he does, so I was fascinated to find out he publishes many photos on his blog , neatly categorized in photo albums . This is what I always wanted to do, but the setup sounds like too much work, but I will add a photo album section to my website at some post.

I also quite liked his style of photography , explored a few of his recent photo albums. As he’s taking candid photos of his own life, I was curious what camera he uses, it must be a portable one. Searching for photography posts on his blog, lead to the analysis of his photography history , in which he mentions he’s been using a Leica M10-R as of 2022. I currently own a Sony a7cii, it is one of the most portable full-frame cameras out there, but I still find it cumbersome to carry when I don’t intentionally go out for photography. That’s why I purchased a second hand Ricoh griii last week to hopefully make it easier for myself to always carry a camera with me and take good photos of life.

source

Comment? Reply via Email, Mastodon or Twitter.

Before calling a meeting, ask yourself: What’s the goal? If it’s just to convey information—like a status update—then yes, this meeting can (and should) be an email.

Meetings should be dialogues, not monologues. If all you’re doing is delivering information that doesn’t require back-and-forth discussion, spare your team the calendar block and just send an email.

Many of the worst offenders aren’t one-off meetings—they’re recurring meetings that have outlived their usefulness. A weekly status update that’s just a series of individual reports? That’s not a meeting—it’s a series of monologues that could be handled asynchronously.

On the flip side, some conversations shouldn’t happen over email—especially when they involve complexity, emotion, or collaboration. These are the types of interactions where being able to read tone, ask clarifying questions, and get immediate feedback is essential.

source

Comment? Reply via Email, Mastodon or Twitter.

If you are interested in the technical implementation, the complete codebase is available in this github repository .

Creating an Articles Dataset

Step 1: Initial List of Liked Articles

Daily browsing of RSS feeds involves scanning through many articles, where sometimes engaging titles lead me to read their opening paragraphs. Through my established content workflow , I save interesting items to Pocket using Inoreader’s built-in feature.

Initially, I planned to use a list of RSS items that I had clicked on. However, Inoreader doesn’t provide an API to access this reading history, which led me to explore other options.

Looking further into my workflow, I found a better solution: my archived items in Pocket. While I regularly read through my Pocket items, I never delete them - just archive them. This gave me a valuable collection of reading history.

Using the Pocket API , I retrieved around 4,000 URLs, dating back to December 2022. Though some archived items might be less relevant now, the dataset reflects my reading interests well. Later, I could add features like upvoting and downvoting to refine the content selection, but that’s beyond the current scope.

Each item in the dataset includes this basic information:

{
  "pocket_item_id": 5598506,
  "given_url": "https://nat.org/",
  "resolved_url": "http://nat.org/",
  "title": "Nat Friedman",
  "time_added": 1736940058,
  "word_count": 451,
  "domain": "nat.org"
}

Step 2: Text Content of Articles

To build an effective recommendation model, we need the actual content of each URL, not just its metadata, but unfortunately Pocket doesn’t provide that. While I love writing scrapers, for this project I want to focus on developing the recommendation model itself.

The Jina Reader API offers a straightforward solution, converting webpage content into markdown format. Here’s an example of what we get (shortened version, full content available here ):

The converted content is excellent, but it has two main challenges:

1. Markdown formatting adds unnecessary complexity for our use case. Plain text would work better.
2. Articles vary greatly in length - from short paragraphs to long essays - which could make comparing them via semantic similarity difficult later.

Step 3: Summarizing the Markdown Content

To solve both issues at once, I used the gemini-2.0-flash model to create consistent-length summaries of each document. Here’s an example summary for https://nat.org/:

By having the model to wrap summaries in XML tags (<summary> ... </summary>), I achieved two things:

• Clean extraction of just the summary text, in case LLM generates other texts before or after the summary (e.g. if it starts with Sure, I can help you with summarizing the content ...).
• Easy identification of broken links and error pages. This helped remove 141 invalid entries, leaving me with 3,642 quality documents.

The summaries created a more balanced distribution of text lengths:

Next Steps

The final dataset now contains well-organized entries with clean metadata and text summaries:

{
  "pocket_item_id": 5598506,
  "given_url": "https://nat.org/",
  "resolved_url": "http://nat.org/",
  "title": "Nat Friedman",
  "time_added": 1736940058,
  "word_count": 451,
  "domain": "nat.org",
  "text": "Title: Nat Friedman\n\nURL Source: https://nat.org/\n\nMarkdown Content:\n\nI'm an investor, ...",
  "summary": "I'm an investor, entrepreneur, and developer who's been online since 1991, considering it my true hometown. I went to ..."
}

Next week, I’ll work on creating a user profile by concatenating these text summaries and metadata and converting them into vectors using Embedding models . I’m also researching how modern recommendation systems work with transformers and LLMs, which will help guide this project. After all, learning is the main goal here.

I welcome any thoughts or questions about this series - feel free to reach out!

Comment? Reply via Email, Mastodon or Twitter.

Documenting my own life and the events influencing me and the people close to me is one of the main reasons I love photography, but I haven’t spent enough effort on doing this. That’s why this blog post from 2018 stood out to me, which offers a few tips on how to create memorable photos.

It’s fine to take pictures that capture a moment for those who were present. But if anyone could have taken that photo, don’t expect anyone to care.

People pictures matter the most. Especially the non-staged ones. The formal pictures of special occasions, where we kids are lined up like we’re in front of a firing squad, are not the ones that bind us.

The best family photos are the ones where we’re clowning around and laughing, or where we’re doing something together, or a moment captured without the subject realizing it. The most precious are those where the family is putting up a pup tent, or using the water pump, or packing the car for a trip.

In general, try to capture your family when they are actively doing something, ideally an entire process. Let it be a photo essay: “Mom making Thanksgiving dinner” or “Daddy taking the kids to the petting zoo.” Don’t choose only the “reveal” moments such as Mom presenting the turkey to the table; include a picture of her hurriedly putting on lipstick before Grandpa arrives, or the kids conked out, asleep in the back seat, on the car trip home.

Include the photographer. I have few pictures of my father, because he was always the guy behind the camera. When he did ask someone to take a picture it was always posed, such as “Mom and Pop standing in front of the Grand Canyon.”

Take photos of daily life. I’m stunned by the pictures my father didn’t take. There isn’t a single photo that represents what my parents did for a living. They weren’t the type to attend company picnics, fine. But I found nothing indicating “take your daughter to work” or “Mom typing up a report” or “the building I worked in” or “the woman Mom commuted to work with for 10 years.” That would be more understandable if my parents disliked their jobs, but both of them were passionate about their careers.

source

Comment? Reply via Email, Mastodon or Twitter.

A workaround for this problem is to use RAG to provide LLM with a few relevant sql queries that it can use to understand the tables and data structure to respond to user’s query. But again, this is easier said than done, since typical semantic and keyword based retrieval techniques don’t work well enough for code and sql queries.

The team at Timescale explain a clever trick for building text-to-sql using LLMs that aims to solve this limitation by creating synthetic summaries for sample SQL queries. The generated summaries then can be used in the retrieval process, matching user’s query with the most relevant sample SQL queries.

Here’s the basic idea:

1. We take existing SQL queries and create detailed summaries of what they do.
2. We use these summaries, rather than the raw SQL, when trying to match user questions to relevant queries.
3. We can generate more of these summaries as needed, allowing us to improve our system continually.

Synthetic summaries: We use AI to create detailed summaries of tables and SQL code. These summaries help us understand the information better than just looking at keywords. Retrieval augmented in-context learning: Our system employs a two-step process to enhance SQL generation:

• We first identify relevant tables and snippets.
• The retrieved tables and code examples are used to provide context-rich instructions to our large language model (LLM), enabling it to better understand and apply specific business rules when generating SQL queries.

… this approach has shown some promising results:

• It improved accuracy in finding the right information from 81 % to 90 %.
• It maintained good performance even when we added irrelevant data.
• It seemed better at capturing business-specific logic than traditional methods.

source

Comment? Reply via Email, Mastodon or Twitter.

On the other hand, the posts that I shortlist from my RSS feeds and read or listen to, end up on a curated repository of articles that have passed my personal quality threshold, so I have access to a valuable collection of content (on Pocket ) that is relevant to my interests. This made me wonder, can I utilize this data, and create a content recommendation system tailored to my preferences? Can I build a system that would review new posts from feeds where only 1 in 20 posts might match my content priorities, and filter those for me?

Over the following weeks, my goal is to build this content recommendation system, and to document my thoughts, process, and lessons learned in a blog post series, of which this is the first one. The rough process in my mind includes analyzing the corpus of previously liked content, building a model of personal interests based on content embeddings, and comparing new content against this model to predict the likelihood of interest. If you want to follow along, follow my blog’s RSS feed or subscribe to my newsletter to get notified about new posts.

The process

The heart of this project is experimenting with different recommendation algorithms, but solid groundwork comes first. Before diving into the mechanics of the recommender system, I need to establish a clean, reliable dataset. Here’s my initial roadmap:

1. Get a list of the liked articles from Pocket
   • I can use Pocket API to fetch the data and store it in a sqlite db or a csv file.
2. Extract and clean up the text content from liked articles
   • Using content extraction tools like r.jina.ai or readability , which strip away advertisements and formatting while preserving the core article text.
3. Summarize the text content into a few paragraphs using a large language model
   • The articles I’ve saved on Pocket range from a few short paragraphs to tens of pages. The corpus needs to be normalized somehow, and I can use Gemini flash or a local LLM to summarize each content in 2-5 paragraphs.
   • The extracted texts and summaries will need to be inspected and cleaned up, as I anticipate some URLs returning 404 or blocking my scraper.
4. Generate embeddings for each content summary using an embeddings API (Gemini or OpenAI) or a local embedding model with sentence-transformers
5. Store the embeddings for comparison with new content
   • Probably in a sqlite db using sqlite-vec
6. Build the content recommendation system
   • Honestly I’m not quite sure how this will be done yet.
7. Check for new content from desired sources every day
   • Using GitHub Actions or some other sort of cron job.
8. Extract the text, summarize, and generate embeddings for the new content
9. Find the ones that are close to my interests and add them to an RSS feed

Admittedly, the later stages of building the recommendation system are unclear, but that’s exactly why I’m documenting this process. The immediate focus is clear: preparing a clean, reliable dataset. Meanwhile, I’ll be diving deeper into recommendation system architectures to prepare for the more complex challenges ahead.

Open questions

Thinking about the challenges ahead, I’m faced with some questions I currently don’t have answers to. If you can provide any guidance or feedback, feel free to reach out via email , bsky , or twitter .

• How do I build the content recommendation system?! No, but seriously, how do we compare the embeddings of liked content to those of new, unknown content?
  • Calculate the similarity score (cosine similarity) of the average of the liked content with the new content? But I have a diverse set of liked content in the dataset.
  • Should I cluster the liked content into categories and figure out if the new content is close enough to one of the clusters?
  • What if a new content is close to a cluster (e.g. Photography) but still not relevant to my interests at all (e.g. I read photography stuff only if they are related to street or landscape photography, or about the Sony camera I own)?

Read the part two of this blog series: Data Processing and Cleaning

Comment? Reply via Email, Mastodon or Twitter.

{
  "primary_category": "bugfix",
  "other_relevant_categories": ["testing", "infrastructure"]
}

Today I learned there’s a python library that helps getting these logprops from the OpenAI’s structured response in a convenient way, and it’s called structured-logprobs . Here is how to use it:

import math
from openai import OpenAI
from structured_logprobs.main import add_logprobs


## generate structured output with openai
client = OpenAI(api_key="your-api-key")
completion = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "system",
            "content": (
"""Please output metadata about the following function:
def say_hello():
    print("Hello World")
"""
            ),
        }
    ],
    logprobs=True,
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "answer",
            "schema": {
                "type": "object",
                "properties": {
                    "function_name": {"type": "string"},
                    "language": {"type": "string"},
                    "version": {"type": "string"},
                },
            },
        },
    },
)

## using the structured-logprobs library:
chat_completion = add_logprobs(completion)

print(json.loads(chat_completion.value.choices[0].message.content))

This gives me:

{ "function_name": "say_hello", "language": "Python", "version": "3.x" }

As you can see, I’ve intentionally added the version to the expected output, and I’m expecting the model to be less confident about its generation for version compared to say_hello and langugae. Let’s examine the logprobs and probabilities:

print(chat_completion.log_probs[0])

Output:

{
  "function_name": -2.6073003596138733e-6,
  "language": -0.16022545099258423,
  "version": -0.26306185549037764
}

Converting to probabilities to make the numbers more intuitive:

data = chat_completion.log_probs[0]
transformed_data = {
    key + "_prob": [round(math.exp(log_prob), 2) for log_prob in value]
    if isinstance(value, list)
    else round(math.exp(value), 2)
    for key, value in data.items()
}
print(transformed_data)

Outputs:

{ "function_name_prob": 1.0, "language_prob": 0.85, "version_prob": 0.77 }

As expected, we get the absolute highest number (1.0) for function_name, since it’s already in our prompt. A very high number for language, since our function was obviously a python function. And a lower (but still relatively high!) number for version. As I mentioned previously, these numbers don’t necessarily represent the absolute correctness of the values, but they rather are extra information for us to gauge the usefulness of the generated output.

source

Comment? Reply via Email, Mastodon or Twitter.

1. Created a free Supabase account .
2. Created a new project.
3. Created a new table in the project and called it feature_request, and added a new column called text.
4. Grabbed the unique API URL and API Key from Project Settings > API.
5. Made an API call in Python:

import requests

supabase_url = "https://ufcgesssclkrciknuaey.supabase.co"
table_name = "feature_request"
endpoint = f"{supabase_url}/rest/v1/{table_name}"
supabase_key = "<my-supabase-project-api-key>"

## The request will fail if either of apikey or Authorization are not provided
headers = {
    "apikey": supabase_key,
    "Authorization": f"Bearer {supabase_key}",
    "Content-Type": "application/json",
    "Prefer": "return=representation"  # This returns the inserted row
}
data = {"text": "this is a new feature request ..."}
response = requests.post(endpoint, json=data, headers=headers)

response.json()
# [{'id': 1,
#  'created_at': '2025-01-02T16:52:44.738549+00:00',
#  'text': 'this is a new feature request ...'}]

And visiting the table in the Supabase dashboard confirms that the data is inserted as a new row.

Comment? Reply via Email, Mastodon or Twitter.

As I’m drafting this post, my camera’s shutter count is at 6663, and if I include the period of the year I was still using my old camera, I’ve shot 7719 photos in 2024. I’ve had many short trips in the Netherlands, and I’ve also traveled to Norway, Sweden, Portugal, Belgium, and Turkey, with my camera being my constant companion. When reviewing the photos I took this year, I felt confident enough to select my top 10 favorites to share in this blog. So here they are, ordered by the date taken.

January 2024

At the beginning of the year I came across a photography contest called life framer , and decided to pay for the annual membership and join the contest. I knew I was nowhere close enough to win a photography contest and winning wasn’t the point, but the monthly theme of the contest sounded like an appealing challenge to me. It would motivate me to take my camera outside and push myself to capture new moments.

The January theme of the contest centered on night life photography, and with no travel plans ahead, I walked towards the center of Amsterdam with the only camera I owned back then, the a7ii. After a couple of shots, I realized my camera and lens weren’t capable of capturing anything compelling in low light situations, and this probably was the time I decided to think about switching to another camera.

While I was disappointingly watching the area around Pathé City, I noticed this bright advertisement panel of Anya Taylor-Joy in front of the tram stop. Oh thank god, something bright enough my poor camera could capture. I took a few uninspiring shots, and then figured this might be the time to try a long exposure shot for the first time in my photography journey.

April 2024

I continued the life framer’s monthly challenges in February (theme: animals) and March (theme: colors), but looking back at the shots, none are particularly noteworthy. I got my new a7cii camera in April and immediately loved using it. I was more motivated to carry this smaller, lighter, and more performant camera with me, and soon realized I didn’t need an external challenge for taking photos anymore.

On a beautiful spring day in April, I noticed this gorgeous sunset from the balcony of my apartment in Diemen and quickly grabbed the camera to photograph the scene. I was lucky to get some birds in frame.

May 2024

I’m quite shy about photographing people in general. I love documenting candid moments of life, but I’m always hesitant to point my lens towards strangers. As practice for getting over this fear, I grabbed my small but mighty Sony 50mm f/2.5 G lens, walked towards the center of Amsterdam, aiming to capture street life. It was a cloudy gray day and the shots lacked color or light contrast, so for the first time I decided to edit the photos in black and white to magnify the attention on the subjects.

June 2024

We visited Madeira in June and stayed in Porto Moniz for a week. I wasn’t prepared for the island’s breathtaking beauty, and Madeira definitely is one of the places I’ll have to visit more in future. I was hiking a steep uphill route around Porto Moniz, physically exhausted from climbing, turned around to view the landscape behind me, and faced this gorgeous vista.

We also had a short visit to Seixal and I took many photos, including this spectacular view from the balcony of a small restaurant where we grabbed lunch.

I like that I’ve included some foreground elements in both of these pictures. They’ve elevated the images by providing a nice perspective of the scene, helping the viewer imagine themselves in those places. I’ve found myself drawn to this technique throughout the year.

July 2024

To try something completely new, I joined the Dutch Shooters team in July to have a daylong photography trip to the Formula 1 event at Spa-Francorchamps in Belgium. I stayed at a hotel in Eindhoven the night before so I could join them early in the morning. The photography trip was excellent, with many professional and amateur photographers around the circuit. It was the perfect opportunity to practice panning shots and I managed to capture a few images of these super fast cars.

August 2024

We visited Norway in August, spending the first few days exploring Oslo. I found the Oslo Public Library to be a fascinating place to shoot, as it contains various types of shapes, lights, colors, people, and even some reflections.

There are many of these old phone booths around Oslo converted into small libraries. I came across several while walking around and exploring the city, including this one. I took a few ordinary shots, none of them meeting my satisfaction threshold. Then I saw a gentleman approaching with books in his hands, and I captured this moment. I love how the color of his shirt matches the phone booth.

We left Oslo and stayed in a cabin house around Halden for a few days. The cabin was surrounded by woodland and water, offering an absolutely peaceful experience of nature.

September 2024

Of course I had my camera with me during a work trip to Stockholm in September. One night when I finally found a few hours of alone time, I walked around the city to photograph some night life and got several memorable shots. Reflections always intrigue me, and here I found its combination with the empty section of the advertisement created a perfect frame to capture someone walking by. Several people passed, and this man’s height, sweater color, and headphones made for the best composition of the evening.

It’s always challenging to find and compose shots at night, especially with an f/2.8 lens, as there’s not enough light reaching the lens to work with. My attention was drawn to the colors and the light in front of this store, and I was fortunate to catch someone crossing, illuminated by the store’s lighting.

October 2024

Autumn was quickly fading, and I desperately wanted to have a colorful autumn photo in my 2024 portfolio. I brought my camera to tennis practice, so I could go shooting afterward without needing to return home. I photographed some autumn leaves, but nothing spectacular. I lost the daylight and the theme of the day became night life photography.

I walked toward the center of Amsterdam and took many unremarkable shots. On my way to the city center, I came across these green lights around the building of the Van Gogh Museum . I started photographing the empty but lit walls of the building, and waited for people to pass so I could potentially get a minimalistic silhouette shot, but I ended up with something even more beautiful.

Since my previous attempt at getting an autumn shot was unsuccessful, I grabbed the camera another day and explored the Amsterdamse Bos seeking the yellow and orange colors of nature. I took many shots in the following spot, where the colors on the trees in the background were stunning. I was quite pleased with this image of the family and their dog enjoying their time.

November 2024

I traveled to Izmir to spend a few days with a friend. I always keep my camera bag on my lap in airplanes, in case an interesting scene appears. This time when the airplane was approaching the Istanbul airport, I captured this beautiful night scene of this megacity, with boats sailing in the water. I almost lost my lens cap while taking this shot, since the airplane landed a few moments after, and I lost control of the items on my lap. Luckily I found it lying on the ground later.

My friend and I stayed in Manisa, a small town near Izmir. We drove to Izmir daily, explored the city, played tennis, and took photos. The first two days, I was amazed by the layers of mountains in the background along the road, but I was driving and there was no safe place to stop for photography. The third day I couldn’t resist anymore, so I stopped at a gas station, and quickly took this shot. I’m glad that an old red car appeared in the frame as well, adding more visual interest.

I continued practicing street photography and taking photos of strangers in Turkey, hoping to gradually overcome this fear. A few times people noticed I was photographing them, and I worried they’d be angry or at least complain, but to my surprise they asked for my Instagram account and requested me to take more photos and share them!

During one of our walks around Izmir, I suggested my friend visit the city’s old Kemeraltı bazaar hoping I could get some unique and colorful shots of the chaotic environment, but I couldn’t capture anything compelling. When we left the bazaar, people were seated around the Clock Tower of Izmir, and I noticed this lady with a box of red roses in her hand. I waited to see if an interesting moment would unfold, and then took this shot when she handed a rose to another lady, with a bright smile on her face.

Looking back at these photos, I can see how my journey in photography has evolved throughout 2024. From my hesitant first attempts at long exposures in January to confidently approaching street photography in Turkey, each image represents not just a moment captured, but a step in my growth as a photographer.

I recently purchased a photo printer, and these ten images will be among the first I’ll print. There’s something special about seeing photographs on paper rather than just on screens, and I’m excited to experience these memories in a more tangible form. As I look forward to 2025, I’m eager to continue exploring and developing my photographic style, particularly in areas that still challenge me, like street photography.

I’d love to hear which of these photos resonates with you and why. Whether you’re a fellow photography enthusiast or simply enjoy viewing images, feel free to reach out to share your thoughts or discuss photography. You can follow my photography work on Instagram , 500px , or flickr .

Comment? Reply via Email, Mastodon or Twitter.

Today I found out about label-studio which is an easy to use framework (backend and frontend) for data annotation task. It provides various annotation templates for text, image, audio, and video data!

I tried it with uv locally, but it can be self-hosted using docker-compose as well:

uv add label-studio
uv run label-studio

Then a very nice looking UI pops out in the browser, you need to sign up (why?) and create a new project. When creating a project, I selected Labeling setup > Natural Language Processing > Text Classification and saved it with the default choices (positive, negative, neutral). I then imported a sample dataset from huggingface and ended up with this clean and user friendly interface for lebeling the data.

Label-studio supports multiple users, and it records which user has annotated which record and when. You can export the lebeled data in various formats including CSV. And another cool feature of label-studio is its integration with ML and AI tools, so you can run the same annotated records with a model and compare the output with the human annotated values.

I will use label-studio next time I have a data labeling work.

Comment? Reply via Email, Mastodon or Twitter.

Leopards provides following filters:

• eq: equals and this default filter
• gt: greater than.
• gte: greater than or equal.
• lt: less than
• lte: less than or equal
• in: the value in a list of a tuple.
  • e.g. age__in=[10,20,30]
• contains: contains a substring as in the example.
• icontains: case-insensitive contains.
• startswith: checks if a value starts with a query strings.
• istartswith: case-insensitive startswith.
• endswith: checks if a value ends with a query strings.
• iendswith: case-insensitive endswith.
• isnull: checks if the value matches any of NULL_VALUES which are ("", ".", None, "None", "null", "NULL")
  • e.g. filter__isnull=True or filter__isnull=False

A quick example of its usage with filters:

from leopards import Q

data = [{"name":"John","age":"16"}, {"name":"Mike","age":"19"}, {"name":"Sarah","age":"21"}]
filtered = Q(data, {"name__contains":"k", "age__lt":20}) ## this returns a generator
print(list(filtered))
## [{"name": "Mike", "age": "19"}]

It also provides a few aggregation functions: Count, Max, Min, Sum, Avg

Count for example can be used as following:

from leopards import Count

data = [{"name": "John", "age": "16"}, {"name": "Mike", "age": "19"}, {"name": "Sarah", "age": "21"},{"name":"John","age":"19"}]
output = Count(data, ["age"])
## dict_values([{"age": "16", "count": 1}, {"age": "19", "count": 2}, {"age": "21", "count": 1}])

To use leopards on CSV files and perform the above filters and aggregations:

import csv
from leopards import Count

data = csv.DictReader(open("filename.csv"))
output = Count(data, ["age"])

Comment? Reply via Email, Mastodon or Twitter.

I looked for an affordable and user friendly observability tool and settled on using axiom . It has a generous 500GB ingestion on free tier plan, but you can only view the events for the past 30 days time period. So I’ve been exporting the logs every month into a csv file, since I want to be able to view the trend of some behaviours over time.

Today I came across a new observability tool from pydantic team called logfire . It sounds like an excellent tool, and a brilliant way for the team to monetize their work. Logfire has 10M events per month limit on its free tier, and its SDK can be integrated with OpenAI (for logging your LLM API calls), FastAPI, and databases. These three are the main areas that I’d like to have observability around on my projects, and the SDK sounds very easy to implement into any new or existing project:

1. Create a new Logfire account and setup a project .
2. Get a write token and set it as an envoironment variable:

3. Send data to Logfire:

import logfire

logfire.configure()
logfire.info("Hello, {name}!", name="world")

• Integrate with OpenAI:

import logfire
import openai

client = openai.AsyncClient()
logfire.instrument_openai(client) ## Add this

...

async def stream_openai(messages: list[ChatMessage]):
    chunks = await client.chat.completions.create(
        mode1="gpt-4o",
        messages=messages,
        stream=True
    )

...

• Integrate with FastAPI:

import logfire
from fastapi import FastAPI

app = FastAPI()
logfire.instrument_fastapi(app)

...

@app.get("/1lm/ask/stream/{chat_id}")
async def llm_stream(chat_id: str) -> StreamingResponse:
    ...

• Integrate with Python’s logging library:

import logging
import logfire

logfire.configure()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.INFO)
LOGGER.addHandler(logfire.LogfireLoggingHandler())

Logfire also has a 30 days retention period, but they are planning to add more options to their paid plans.

To view the logs you can view the live dashboard of the project, or run the following query on the explore page:

select * from records

You can use SQL syntax to further adjust the query and get what you’re looking for in the logs.

It’s not possible to export the log data from Logfire’s UI at the moment, but this is possible with their API (more info ).

Comment? Reply via Email, Mastodon or Twitter.

If you want to make a good RAG tool that uses your documentation, you should start by making a search engine over those documents that would be good enough for a human to use themselves.

This is exactly what I’ve been trying to communicate in my org in the past few months. It’s 2024 and we still can’t have a proper search engine in organizations to find relevant information from various sources. While this problem remains to be solved, organizations are adapting RAG and AI into their tooling, but are missing the important R of the RAG: Retrieval. I’ve been an advocate of prioritizing search engines over any AI related tool in the past few months, and I found it refreshing to read about this somewhere else:

Imagine you’re a company that wants to build an LLM-powered documentation experience. If you think of a vector database as just providing an expanded memory to your language model, you might just embed all of your company’s product docs, and then let users ask questions to your bot. When a user hits enter, you do a vector search for their query, find all of the chunks, load them into context, and then have your language model try to answer the question. In fact, that’s the approach we initially took at Stripe when I worked on their AI docs product.

Ultimately though, I found that approach to be a dead-end. The crux is that while vector search is better along some axes than traditional search, it’s not magic. Just like regular search, you’ll end up with irrelevant or missing documents in your results. Language models, just like humans, can only work with what they have and those irrelevant documents will likely mislead them.

If you want to make a good RAG tool that uses your documentation, you should start by making a search engine over those documents that would be good enough for a human to use themselves. This is likely something your organization has considered before, and if it doesn’t exist it’s because building a good search engine has traditionally been a significant undertaking.

source

Comment? Reply via Email, Mastodon or Twitter.

from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

## rest of the code as you would use openai

It support basic text generation, image input, function calling, structured output, and embeddings. More info and code examples can be found on Gemini docs .

Comment? Reply via Email, Mastodon or Twitter.

Abroad, I meet local people who don’t hang out with expats because they have their Martas. Every time I hear a Dutch or British person say “we’ve known each other since we were little”, I can’t help but feel a pang of regret. I’m moving countries, schools and jobs and leaving those valuable connections behind, while people who stay in their neighbourhood are easily bound to their friends by time and proximity.

And then I look at Facebook at the people who I’ve known since I was little, and think: thank God we’re no longer friends!

Old friendships will cocoon you in familiarity, but they won’t keep up with changes in your life. Unless you make the same choices as your school friends, they will not understand you. If you live your own life, you will outgrow your old friendships.

And indeed, I look at the types of interactions that locals have with their old friends (their cosy bbqs and gesellige borrels) and I’m convinced that for me, they are not a solution. They do not bring me joy.

As a person who moved cities and countries, I also sometimes think about my school friends, even trying to find them online, just to know what they’re doing and what would’ve been like if we were still friends. And almost always I’m happy we’re not friends anymore.

When instead of trying harder, you stop — that’s maturity

I figured out that making an effort to see people who didn’t make an effort to see me was too tiring. So I stopped doing that.

I also figured that even though it’s meant to be good for me to see people when I don’t feel like it, it didn’t feel like it was good for me. So I stopped doing that, too.

I considered the stress that surface interactions give me and the benefit they are meant to carry. The stress balance was too high to justify engaging in them.

Just like I don’t wear sunscreen when it’s not sunny (and I know some people do), I decided I won’t try to be more social when I’m not lonely.

Because — most importantly — I realised that I was not lonely and my social life was perfectly fine.

It’s not the social life from Friends and How I Met Your Mother, but it fits my personality and it brings me joy.

Completely agreed.

If there’s a friendship muscle, it looks different for every person.

Don’t torture yourself with exercises that don’t benefit your friendship muscle and instead, find the ones that make sense for you.

Fridays are not for friends, not for dates, but for whatever the f… you want.

Some of my favourite Friday nights included cleaning the flat, doing Duolingo, writing a diary, going to the gym, eating cereal.

source

Comment? Reply via Email, Mastodon or Twitter.

We used to get Dove Bars and beers all the time. It felt like free food was on offer at least once a week, usually with a pretense of some small milestone to celebrate. Why did we cut stuff like this? (I know the boring fiscal reasons why. I’m asking the deeper why, as in, “Was it worth the savings? Is Microsoft better now that we’ve cut these costs?”)

One day, a sign appeared on a soda fridge in RedWest saying something to the effect of, “Did you know that drinks cost Microsoft [ed: millions of dollars] a year? Sodas are your perk at work. Don’t bring them home.” This depressed me on too many levels to enumerate, but I’ll toss out a few:

1. Someone had enough time to get these signs professionally printed and affixed to our fridges.
2. It was someone’s salaried, 40-hour-a-week job to do things like this.
3. Someone thought soda smuggling was a big enough “problem” at Microsoft to draw attention to it.

How much soda can a person steal? How much does that same person cost the company per hour in salary and benefits? Our most interesting profits will come from capitalizing on huge opportunities, not from micromanaging costs.

source

Comment? Reply via Email, Mastodon or Twitter.

In a number of countries consent is needed for just taking a photograph of one or more identifiable people, not to mention publishing it and/or using it commercially, even if the person is in a public place.

However, there are many exceptions (orange cells) in the table, which indicates these rules are very complicated and it’s not practical in many cases.

This list is incomplete: Just because a country isn’t listed here, it does not reflect a fact that everyone is free to take/publish/commercially use pictures of people in public spaces in that country.

source

Comment? Reply via Email, Mastodon or Twitter.

I’m currently working on a project to classify pull requests in my company’s code repositories. The model needs to look at the PR title, description, and code changes, then categorize the PR and explain its reasoning. I thought there must be a way to fine-tune these models with any format I see fitting this specific use-case, and sure there is: Template-free Axolotl

This seemed exactly what I was looking for, but the emphais on “masking inputs” made me confused:

If you declare a dataset format such as alpaca or chatml, axolotl knows what is an input (i.e. human) vs. an output (i.e. the assistant) and masks the input labels so that your model can focus on predicting the outputs only. You can construct your prompts without a template by using the input_output format, by setting type: input_output in your configuration file. Unlike type: completion, which is also template-free, type: input_output allows you to mask segments of your text.

This was the first time I came across the concept of input masking. It felt counterintuitive at first - why would we want our model to ignore parts of the training data? Isn’t all of it important? Wouldn’t masking the input prevent the model from learning to respond properly when encountering similar cases during inference time? After going deeper in the Axolotl docs and codes, I’ve learned some stuff I’d like to share.

What is input masking?

Input masking is a technique where we intentionally hide parts of the input data from the model during training. It’s like covering up certain words in a sentence and asking the model to focus on predicting only the uncovered parts. But why should we do this? There are several facts we need to know:

• Distinction between input and output: In many fine-tuning scenarios, particularly for instruction-following or question-answering tasks, we want the model to learn to generate appropriate responses (outputs) given certain prompts or questions (inputs). By masking the input, we’re emphasizing that the model should focus on generating the correct output rather than simply memorizing and repeating the input.

• Preventing overfitting to prompt templates: If we train the model on both the input and output, it might start to rely too heavily on specific phrasings or templates in the input. By masking the input, we encourage the model to be more flexible and generalize better to variations in how questions or instructions might be phrased.

• Focusing on task completion: The goal is often to have the model learn to perform a task or generate relevant information, not to reproduce the exact input format. Masking helps direct the model’s attention to the core task.

• Efficiency in fine-tuning: By not training on inputs, we can potentially reduce the amount of computation needed during fine-tuning, as the model doesn’t need to adjust its parameters to predict the input tokens.

• Handling different prompt structures: This allows for more flexibility in how prompts are structured in our training data, as the model isn’t learning to reproduce specific prompt formats.

To mask or not to mask

Based on the above facts, there are scenarios that we might want to use input masking when fine-tuning a language model:

• Chatbots and conversational AI
• Question-answering models
• Instruction-following tasks

In these cases, we care more about the model generating good responses than repeating exact input phrasings. However, masking isn’t always the best choice. We might want to avoid it when:

• Every detail in the input is crucial for the task
• The model needs to understand and reference specific parts of the input
• We’re working with specialized or technical content where context is key

My use case: classifying pull requests

As I mentioned previously:

I’m currently working on a project to classify pull requests (PRs) in my company’s code repositories. The model needs to look at the PR title, description, and code changes, then categorize the PR and explain its reasoning.

For this task, I’ve decided not to use input masking. Here’s why:

• Importance of input details: In PR classification, every detail in the title, description, and code changes could be crucial for making an accurate classification. By training on the full input, we allow the model to learn important patterns and correlations between specific input features and the resulting classifications.

• Contextual understanding: PRs often contain technical jargon, project-specific terms, or code snippets that are important for understanding the nature of the changes. Training on these inputs helps the model build a better contextual understanding of my company’s development practices and codebase.

• Reasoning requirement: Since my task includes providing reasoning for the classification, the model needs to learn how to reference and analyze specific parts of the input. This is more effectively achieved if the model is trained to process and potentially reproduce relevant parts of the input.

• Limited output structure: Unlike more open-ended generation tasks, my output has a specific structure (JSON with classification and reasoning). The risk of the model simply copying large portions of the input into the output is lower, given this constrained format.

• Potential for implicit feature extraction: By training on the full input, the model might learn to identify subtle features or patterns in PR descriptions or code changes that are indicative of certain classifications. This implicit feature extraction could lead to more accurate classifications.

• Handling variations in input: PRs can vary greatly in length, structure, and content. Training on full inputs helps the model handle this variability more effectively.

Let me know if I have missed anything or if you know a good learning resource on this topic.

Comment? Reply via Email, Mastodon or Twitter.

The problem is, that this blueprint is limited to one motion entity, so if you want to control a light in a large area that can’t be covered with one single sensor, you need to create a more complicated automation. This made me procrastinate on adding a second motion sensor to my bathroom for months, but when I got back to finally doing this last week, I found out that you can use the same blueprint to control a light with multiple sensors using Home Assistant Groups .

To create a new group:

1. Visit Settings > Devices & services > Helpers > Create Helper > Group > Binary sensor group in your Home Assistant instance.
2. Choose a name like Bathroom motion sensor group .
3. Add the entities of the motion sensors in the Members section.
4. Click Submit .
5. After creating the group, edit it and choose Motion for Show as (otherwise, it won’t show up in the motion-activated light blueprint in the next step).
6. Create a simple motion-activated light sensor using the automation blueprint, and choose the recently created group as the trigger.

That’s it. Now the light in the bathroom will automagically be toggled on and off when either of the motion sensors detect motion.

To make this more interesting, I wanted the light to stay on if the smart speaker in the bathroom is playing music (even if there is no motion, which means I’m taking a shower but the shower curtain blocks the motion sensors from detecting motion). To achieve this, I needed to add the state of my smart speaker to the group created above:

7. Create a new binary sensor using templates to aggregate states like playing and paused as on , and others ( idle and off) as off for the smart speaker by visiting: Settings > Devices & services > Helpers > Create Helper > Template > Template a binary sensor.

8. Choose a name like Smart speaker is playing.

9. State template: {% if is_state('media_player.your_speaker_entity_id', 'playing') or is_state('media_player.your_speaker_entity_id', 'paused') %} true {% else %} false {% endif %} .

10. Device class: Motion .

11. Now edit the group that we created in step 5, and add this new binary sensor as another member to the group.

Let me know if you have any questions.

Comment? Reply via Email, Mastodon or Twitter.

Biological health is upstream of mental health and mental health is upstream of productivity.

Adding to this, I believe engaging in physical activities and working on improving one’s fitness has tremendous effect on productivity in long term. I play tennis regularly, the fact that I make progress in the court and I improve and become a better amateur player increases my confidence in me. I can later use that boost of confidence in my work and personal life.

source

Comment? Reply via Email, Mastodon or Twitter.

A surprising learning is that content funnels do not work. In theory, you produce entertaining, shortform content to get attention. Then once people are hooked they start consuming your deeper, educational, longform content. Except that this doesn’t happen. People who consume entertaining, shortform content are not interested in longform content. They just want more entertaining, shortform content.

source

Comment? Reply via Email, Mastodon or Twitter.

Transformer-based single embedding models have traditionally had 512 token context windows because of the usage of the original BERT encoder. Newer models, like the BGE-M3, have expanded the token window to much larger scales. It could be tempting to forget chunking and just embed long texts as they are. However, that would mean mashing many topics and entities you might want to search for into a single vector representation, which doesn’t sound like a good idea.

I conducted a quick experiment to find out if the advertised long context window truly works well. I embedded all test set articles without chunking using the BGE-M3 dense single embedding representation with the maximum 8192 context window setting. Then, we can compare test set results against the chunked version (maximum of 512 tokens per chunk).

As we can see, long context single embedding retrieval gets very poor MRR@K scores compared to the chunked version. … Mashing the whole article into a single embedding clearly does not perform well when there are targeted questions about different parts of the content.

This is a great finding. Another advantage of chunking the source documents and retrieving chunked texts when building a RAG service is you’ll end up with much smaller number of tokens in your LLM prompt, and this saves you in cost and latency.

source

Comment? Reply via Email, Mastodon or Twitter.

He explains each part of the diagram in details in the post. I highly recommend reading it.

source

Comment? Reply via Email, Mastodon or Twitter.

When it comes to prompts, less is more

Not enumerating an exact list or instructions in the prompt produces better results, if that thing was already common knowledge. GPT is not dumb, and it actually gets confused if you over-specify.

This has been my experience as well. For a recent project, I first started with a very long and detailed prompt, asking the LLM to classify a text and produce a summary. GPT-4, GPT-3.5, Claude-3-Opus, and Claude-3-Haiku all performed average or poorly. I then experimented with shorter prompts, and with some adjustments I was able to get much better responses with a very much shorter prompt.

GPT is really bad at producing the null hypothesis

“Return an empty output if you don’t find anything” – is probably the most error-prone prompting language we came across. Not only does GPT often chooses to hallucinate rather than return nothing, it also causes it to just lack confidence a lot, returning blank more often than it should. It basically doesn’t know how to say “I don’t know”.

Again, very true. Be cautious in asking an LLM to return “nothing” or to respond with “I don’t know” if condition. I’ve found the models from Anthropic (specially Claude-3-Haiku) to be terrible in responding negatively. They really want to respond with something satisfying to the prompt, even if the condition to respond “I don’t know” is met.

source

Comment? Reply via Email, Mastodon or Twitter.

… a better way to frame luck is by asking: what isn’t repeatable? Did Jeff Bezos get lucky creating Amazon? Not in the same way a lottery winner is lucky, of course. He was visionary and ambitious and savvy to a degree you only see a few times per century.

But could he, starting today, without any money or name recognition, create a new multi-trillion dollar business from scratch? Maybe, but probably not. There are so many things that helped Amazon become what it is that can’t be replicated – growth of the internet, market conditions, old competitors, politics, regulations, etc. Bezos is enormously skilled in a way that is not luck. But a lot of what he did was not repeatable. Those points are not contradictory.

It’s so important to know the difference between the two when attempting to learn from someone. You want to try to emulate skills that are repeatable. The great thing when you ask, “is this repeatable?” is that you start to focus on things that you and I – ordinary lay people – have a chance of repeating ourselves. You can learn a lot from Warren Buffett’s patience. But you can’t replicate the market environment he had in the 1950s, so be careful copying the specific strategies he used back then.

source

Comment? Reply via Email, Mastodon or Twitter.

The cheapest GPU instance on modal.com is Nvidia T4 which costs $0.000164 per second and uses AWS infrastructure behind the scenes. The free starter plan on modal.com includes $30 credit, enough to experiment and try their services. Although the documentation is good enough, it took me some time to figure out how to quickly run my code on a T4 GPU without worrying about docker images, so here is a quick guide on how to run your Python code on GPU instances on modal.com from scratch.

Preparation

After creating an account on modal.com , install their Python library:

pip install modal

and run the setup command:

modal setup
## or: python3 -m modal setup

This will open a web browser and if you’re logged in to your modal account, it will automatically generate a token and save it on your device.

Our code

You’ll first need to define the environment in which your code will be running. Start my_code.py with:

import modal

image = modal.Image.debian_slim()
app = modal.App(image=image)

Then include what you want to run remotely (on a GPU instance in this case) and wrap it with @app.function decorator:

@app.function(gpu="t4")
def square(x):
    print("This code is running on a remote worker!")
    return x**2

And finally, define an entry point function to call from your local machine when triggering the remote instance:

@app.local_entrypoint()
def main():
    print("the square is", square.remote(42))

So the final state of my_code.py should be:

import modal

image = modal.Image.debian_slim()
app = modal.App(image=image)

@app.function(gpu="t4")
def run_remote(x):
    print("This code is running on a remote worker!")
    return x**2

@app.local_entrypoint()
def main():
    print("the square is", run_remote.remote(42))

Note that t4 is the cheapest GPU available, and you can use other GPU instances if you’d like. To run this dummy run_remote function on a GPU instance, trigger it with the following command on your local terminal:

modal run my_code.py
## or python3 -m modal run my_code.py

Nice! We were able to run a simple function on GPU. You can view the logs by clicking on the URL in the terminal (https://modal.com/<your-username>/apps/ap-<blah-blah-blah>) and monitor your credit usage on your billing page .

More serious code

The above sample code can easily be found on the modal’s documentation, but stuff gets more complicated if you want to do more serious work. Getting back to my text-to-speech code, I had to add a few steps:

• Include a local audio file (what I want to transcribe) from my device.
• Install Python libraries (openai-whisper and faster-whisper).
• Install ffmpeg (it’s required for openai-whisper to work).

Let’s start by refining our image and environment:

image = (
    modal.Image.debian_slim()
    .apt_install("ffmpeg")
    .pip_install("openai-whisper", "faster-whisper")
    .copy_local_file(
        local_path="/<path-to-our-local-file>/<filename>.m4a",
        remote_path="./tmp/",
    )
)
app = modal.App(image=image)

And update our run_remote function with what we’ll need for transcribing an audio file:

@app.function(gpu="t4")
def run_remote():
    print("This code is running on a remote worker!")
    import time
    import whisper
    from faster_whisper import WhisperModel

    file_path = "/tmp/<filename>.m4a"

    whisper_model = whisper.load_model("tiny.en")
    t1 = time.perf_counter()
    result = whisper_model.transcribe(file_path)
    print("time passed with openai-whisper: ", time.perf_counter() - t1)

    model = WhisperModel("tiny.en", device="cuda", compute_type="float16")
    t1 = time.perf_counter()
    segments, info = model.transcribe(file_path, beam_size=5)
    ## note: `segments` is a generator, so we'll need to iterate over it to
    ##       be able to get the transcription.
    segments_result = list(segments)
    print("time passed with faster-whisper: ", time.perf_counter() - t1)

    return


@app.local_entrypoint()
def main():
    run_remote.remote()

Note that we need to include the imports inside our run_remote function, as that’s what actually will be getting executed on the remote instance.

This is all we need, and by running the modal run my_code.py command and waiting for our audio to get transcribed (twice in this case), we should get the following result (of course, the actual values of time passed will be different depending on what GPU instance you use and the length of the file):

We can see that by running this transcription process on GPU, we reduced the time it takes to do the job from 120 seconds to 31 and 14 seconds. A very nice achievement, but we should take the important factor of pricing into account as well (maybe in a future post).

Troubleshooting

If you’re getting the following error when running faster-whisper (or any other code) with cuda:

you can fix it by explicitly setting the path of the cuda installations in your image definition using env (took me some time to figure out this fix):

image = (
    modal.Image.debian_slim(python_version="3.11")
    .env(
        {
            "LD_LIBRARY_PATH": "/usr/local/lib/python3.11/site-packages/nvidia/cublas/lib:/usr/local/lib/python3.11/site-packages/nvidia/cudnn/lib"
        }
    )
    .apt_install("ffmpeg")
    .pip_install("openai-whisper", "faster-whisper")
    .copy_local_file(
        local_path="/<path-to-our-local-file>/<filename>.m4a",
        remote_path="./tmp/",
    )
)
app = modal.App(image=image)

Using Jupyter notebook

If you’d like to have a quick exploration using a jupyter notebook, you can run the following command to spin up a GPU instance and experiment with your code:

modal launch jupyter --gpu t4

Note that you’ll be using your credit for the whole amount of time that this jupyter instance is up, even if you don’t run any code. Make sure to stop it by terminating the command on your terminal.

Comment? Reply via Email, Mastodon or Twitter.

If you want to do something, like really want to do it, you need to prove it. That starts with you proving it to yourself.

In difficult circumstances, do you make excuses? Or do you face your problem head on? Are you willing to make difficult decisions to do what you’ve committed to? Are you willing to put out bad work in order to improve? Are you open to taking feedback—even if it hurts—in order to improve?

Doing these things proves to you that you want to do it. People will see that and gravitate towards it, because it’s so unusual. Not doing these things suggests to you that you’re pretending. People will see that too.

source

Comment? Reply via Email, Mastodon or Twitter.

Them: Can you just quickly pull this data for me?

Me: Sure, let me just:

SELECT * FROM some_ideal_clean_and_pristine.table_that_you_think_exists

source

Comment? Reply via Email, Mastodon or Twitter.

Many introverts value depth and thoughtfulness in their work over noise and showmanship. They’re content to contribute without constant recognition or the spotlight.

And the consequences part also checks out:

While this tendency is admirable, it comes with pitfalls, especially in the modern, remote-first work world where being “out of sight” often equates to being “out of mind.” Perhaps you’ve been overlooked for a promotion because a senior leader wasn’t aware of you or your accomplishments. Or maybe your quiet demeanor has been mistaken for a lack of passion. These experiences may have awakened you to the fact that in today’s competitive workplace, hard work isn’t enough. You need to make sure your efforts are seen and acknowledged to unlock new opportunities and support.

We’re living in a very sad world that it’s not enough to work hard, you should make sure people know you’re working hard, and this doesn’t come naturally for us introverts.

Melody has some advice:

Speak up early in meetings

… introverts, with their tendency for introspection, can sometimes fade into the background during meetings, over-indexing on listening, deliberating too long (or overthinking) their contributions, or deferring to authority figures in the room. If you’ve ever held back in a meeting, waiting for the “right moment” to jump in, you know how quickly the moment can pass you by. The longer you wait, the tougher it gets to interject, and before you know it, all the good ideas are already out on the table. As the meeting progresses, your anxiety builds, making the hurdle to speak up seem even higher. You can circumvent this cycle by challenging yourself to be the second or third person to contribute in a meeting. This pushes you to overcome the initial barrier of participation, which is often the hardest part. Plus, it gets your voice and perspectives out there early when everyone’s still paying attention. Once you’ve broken the ice, you’ll likely find yourself feeling more at ease and ready to contribute even more.

Ditch self-deprecation

… introverts tend to habitually downplay their ideas and achievements. But habitually using disqualifiers like “I’m no expert on this” can lead others to underestimate your knowledge and capabilities, unintentionally signaling you’re not a go-to resource or thought leader in your area, even when the opposite is true. Over time, this can diminish your authority and influence. To change how your communication is received, swap self-deprecating statements for more assertive language. For example:

• Instead of, “This may not be right, but…” try, “Another approach could be…”
• Instead of, “Just throwing this out there…” try, “I’d like to propose…”
• Instead of, “Sorry if this is off-topic…” try, “To broaden our perspective…”
• Instead of, “I haven’t looked into this much…” try, “My initial thoughts are…”
• Instead of, “This is just my opinion…” try, “Based on my understanding…”

Leverage asynchronous methods of communication

Unlike real-time conversations that demand immediate responses, asynchronous communication allows for a more reflective and deliberate exchange, which is a perfect fit for introverts. This gives you the opportunity to organize your thoughts and articulate your insights without the pressure of responding on the spot.

source

Comment? Reply via Email, Mastodon or Twitter.

Here are humans’ core needs in the BICEPS model:

Belonging

• Community: A feeling of friendship and closeness with a group, or being part of a tight community of any size.
• Community well-being: People are cared for, the whole group feels happy and healthy.
• Connection: Feeling kinship and understanding with

Improvement/Progress

• Progress towards purpose: You are helping make progress towards an important goal for the company, your team or your own career/life.
• Improving the lives of others: You see how your work helps improve things for others
• Personal growth: Learning/seeing fast growth in yourself in skills that matter to you.

Choice

• Choice: Having flexibility, the chance to have more control over key parts of your world
• Autonomy: Having clear ownership over a domain where you can do as you wish, without asking for permission
• Decision-making: The ability to have make decisions about the things that matter to you

Equality/Fairness

• Access to resources (money, time, space, etc) feels fair/equitable
• Access to information is fair: All groups/people have access to information that is relevant to them
• Equal reciprocity: You support each other equally
• Decisions are fair and everyone is treated as equally important

Predictability

• Resources: There’s enough certainty about resources (money, personnel hours, space) so you can focus on your job
• Time: There’s certainty about when things will occur/when you can prepare for them.
• Future challenges: You can anticipate and thus can prepare for future challenges
• Direction: Goals, strategy, and direction stay consistent and don’t change too often/fast

Status

• Status: You hold a title/role that honors your worth among your peers/your industry
• Visibility: Your work is highly visible to people that matter
• Recognition: Your work is recognized and appreciated in ways that feel good.

source

Comment? Reply via Email, Mastodon or Twitter.

There are thousands of computational devils in details like how to handle nulls. For analysts, describing these specifics in English is inefficient and inexact. For everyone else, they wouldn’t know they need to describe them at all.

LLMs as a better interface to data models and semantic layers are great. LLMs as a Eucharistic for transubstantiating sketches of queries into real ones are great. But LLMs as an analyst, turning novel business questions into full queries? Seems unwise.

source

Comment? Reply via Email, Mastodon or Twitter.

… one of the most effective ways of dealing with spammers is to “shadowban” them. Allow them to use your service, but don’t indicate to them that you’ve identified them as malicious. For instance, when dealing with chat spammers, allow them to chat, but do not show their chats to other users. Another level would be to allow them to chat, but only show their chat to other shadowbanned users. … If the malicious actor doesn’t know they’ve been marked as malicious, they do not know they need to change their behavior.

The second most effective thing is making the malicious actor use some sort of resource. Such as a payment or a time commitment (eg new accounts can only create 1 link a day), or some other source of friction. The idea is that for legitimate users the friction is acceptably low, but for consistent spammers the cost becomes too high.

The 3rd thing I’ve found effective is that lots of spam comes from robots, or perhaps robots farming tasks to humans. If you can determine how the traffic is coming in and then filter that traffic effectively without indicating failure, robots can happily spam away and you can happily filter away.

source

Comment? Reply via Email, Mastodon or Twitter.

Sometimes what people think is quickness is actually extensive prep. I had a 30 minute meeting the other day to ask a team to do something I didn’t think they would want to do. It ended up going really smoothly and they just took my word for it, but had they not, I spend several hours preparing for that meeting, gathering data, preparing charts to illustrate the data, thinking of the possible objections and responses to said objections.

I find that I never really have a good answer on the spot, but I often have already been thinking about the problems around the workplace for long enough that I at least have a hunch or opinion. That’s not quick-wit, it’s just pre-thinking. But it works well enough for me. One skill I learned during grad school was spending lots of time going over conversations or presentations or even upcoming meetings in your head. This “warms up” your cache, and helps you play out possible Q&A, so that you have more opinions ready. And another skill I learned was actually learning to control the meeting to a certain extent. I’d come in with something like a limited “choose your own adventure” conversation tree in my head, and then I’d try to present choices or questions to those I was meeting or talking with, so that I could at least have a fallback. And finally with experience comes wit. The 10th time you enter a situation you’re much more likely to have something to say than the 1st time. And eventually, you’ll start to recognize similarities in conversations.

I agree with theshrike79:

This is exactly the reason all meetings should have an agenda posted beforehand. Not everyone is able to make decisions on the fly, they need the chance to prepare first.

source

Comment? Reply via Email, Mastodon or Twitter.

• A clear hierarchy of headings and subheadings on a page helps LLMs understand the relationships between different sections of your documentation.
• Troubleshooting sections formatted as Q&A are an effective source for LLMs as they mirror the questions users often ask, making it easier for LLMs to understand and respond to similar questions.
• Including small, self-standing code snippets can be helpful, especially for products that rely on large and often complex SDKs or APIs.
  • Have a brief description above the code to clarify its purpose and usage.
  • Include comments within the code to explain the logic and functionality.
• Keep relevant content directly in your docs rather than in linked files such as PDFs, as LLMs have a harder time parsing these.
• Ensure information conveyed through screenshots is also described in text, as LLMs parse text more efficiently.
• Clarify all acronyms and specialized terminology within your documentation to aid LLM comprehension.

source

Comment? Reply via Email, Mastodon or Twitter.

… I frequently ask questions when there’s something I don’t understand or know, from basic stuff, “what does [some word] mean?” to more subtle stuff. On the flip side, one of the most common failure modes I see with junior engineers is when someone will be too afraid to look stupid to ask questions and then learn very slowly as a result; in some cases, this is so severe it results in them being put on a PIP and then getting fired.

… being willing to look stupid is also highly effective at work. Besides the obvious reason that it allows you to learn faster and become more effective, it also makes it much easier to find high ROI ideas. If you go after trendy or reasonable sounding ideas, to do something really extraordinary, you have to have better ideas/execution than everyone else working on the same problem. But if you’re thinking about ideas that most people consider too stupid to consider, you’ll often run into ideas that are both very high ROI as well as simple and easy that anyone could’ve done had they not dismissed the idea out of hand. It may still technically be true that you need to have better execution than anyone else who’s trying the same thing, but if no one else trying the same thing, that’s easy to do!

I don’t actually have to be nearly as smart or work nearly as hard as most people to get good results. If I try to solve some a problem by doing what everyone else is doing and go looking for problems where everyone else is looking, if I want to do something valuable, I’ll have to do better than a lot of people, maybe even better than everybody else if the problem is really hard. If the problem is considered trendy, a lot of very smart and hardworking people will be treading the same ground and doing better than that is very difficult. But I have a dumb thought, one that’s too stupid sounding for anyone else to try, I don’t necessarily have to be particularly smart or talented or hardworking to come up with valuable solutions. Often, the dumb solution is something any idiot could’ve come up with and the reason the problem hasn’t been solved is because no one was willing to think the dumb thought until an idiot like me looked at the problem.

source

Comment? Reply via Email, Mastodon or Twitter.

… for me, in the era of paid subscription software overtaking everything, I don’t need yet another $8–10/month siphon on my bank account. By the time you’ve paid for Raycast Pro for a year, you could’ve paid for Alfred for a lifetime.

I absolutely agree. Due to Alfred being a one-time purchase and its wonderful speed and performance, I tend to agree with Josh that:

… power users (i.e., the folks who care most about getting things done as efficiently as possible) tend to gravitate towards Alfred. Conversely, users who just have a small handful of specific things they want to be easier tend to pick Raycast …

source

Comment? Reply via Email, Mastodon or Twitter.

Hamel’s blog post makes it clear that you should not blindly trust any of the LLM libraries, because some of them are just using some (stupid) prompt “engineering” behind the scene to provide you with good looking output, and they’re performance is pretty much hit and miss (unless you’re able to view they’re prompts and to verify they’re not doing anything silly).

An example from his post, investigating the API calls for guardrails :

from pydantic import BaseModel, Field
from guardrails import Guard
import openai

class Pet(BaseModel):
    pet_type: str = Field(description="Species of pet")
    name: str = Field(description="a unique pet name")

prompt = """
    What kind of pet should I get and what should I name it?

    ${gr.complete_json_suffix_v2}
"""
guard = Guard.from_pydantic(output_class=Pet, prompt=prompt)

validated_output, *rest = guard(
    llm_api=openai.completions.create,
    engine="gpt-3.5-turbo-instruct"
)

print(f"{validated_output}")

## {
##    "pet_type": "dog",
##    "name": "Buddy

Not a valid JSON output!

What is happening here? How is this structured output and validation working? Looking at the mitmproxy UI, I can see that the above code resulted in two LLM API calls, the first one with this prompt:

Followed by another call with this prompt:

Woof. That’s a whole lot of ceremony to get structured output!

source

Comment? Reply via Email, Mastodon or Twitter.

The GROUP BY ALL clause groups rows by inferring grouping keys from the SELECT items. It will exclude expressions with aggregate and window functions, constants, and query parameters for a smart GROUP BY. So instead of GROUP BY name, city, device, browser, date or GROUP BY 1, 2, 3, 4, 5 you would use GROUP BY ALL.

An example from documentation :

WITH PlayerStats AS (
  SELECT 'Adams' as LastName, 'Noam' as FirstName, 3 as PointsScored UNION ALL
  SELECT 'Buchanan', 'Jie', 0 UNION ALL
  SELECT 'Coolidge', 'Kiran', 1 UNION ALL
  SELECT 'Adams', 'Noam', 4 UNION ALL
  SELECT 'Buchanan', 'Jie', 13)
SELECT
  SUM(PointsScored) AS total_points,
  FirstName AS first_name,
  LastName AS last_name
FROM PlayerStats
GROUP BY ALL;

/*--------------+------------+-----------+
 | total_points | first_name | last_name |
 +--------------+------------+-----------+
 | 7            | Noam       | Adams     |
 | 13           | Jie        | Buchanan  |
 | 1            | Kiran      | Coolidge  |
 +--------------+------------+-----------*/

Another example from the Linkedin post:

source

Comment? Reply via Email, Mastodon or Twitter.

• concrete.css
• water.css
• pico css
• simple css
• classless.de
• mvp.css
• NES.css
• drop-in minimal css
• Oat : HTML components plus some additional ones

Usage example

To use water.css , just paste this into the <head> of your HTML:

<link
  rel="stylesheet"
  href="https://cdn.jsdelivr.net/npm/water.css@2/out/water.css"
/>

Update 2024-06-30: A more comprehensive list of classless CSS libraries with a screenshot of how they look can be found in this repository .

source

Comment? Reply via Email, Mastodon or Twitter.

Why

I used to visit Twitter frequently during the day, sometimes 2-3 hours each day, to find out what’s happening in the world and what cool stuff some cool people are talking about. But over time I realized I was a Twitter addict that consumes hours of trash content on the platform without any meaningful benefits. Twitter’s algorithm promotes engagement seekers and influencers over actually useful content, and it’s just been worse with Elon. I needed to spend my precious time on more useful and rewarding stuff.

I was also a content hoarder, saving anything I found mildly interesting in Pocket or in the browser bookmarks, and I rarely read anything from the pile of the saved items in my read-it-later apps. I had accumulated more than 1000 articles in my Pocket account over the years and had hundreds of bookmarks on Firefox and Chrome. This content clutter was very depressing to me, as I didn’t see myself benefiting from anything that I came across.

Lastly, the fact that I was leaving my content consumption inputs to the hands of Twitter, Google, and other algorithms or chance wasn’t appealing to me. I wanted to take over control of what I read, at what pace, and from whom.

RSS feeds & other content inputs

I have tried a few RSS feed reader apps like Feedly and Readwise Reader in the past, but I have currently settled down on using Inoreader as my RSS reader app.

Inoreader: Pros

Inoreader has many nice functionalities, but for me, the most important features are:

• Very smooth experience between web, android, and iOS apps (I’m mentioning this first, as many other apps I’ve tried are flaky)
• Mark as read while scrolling (Very important for quickly shortlisting items from the feed. This is probably the main reason I’ve been able to replace Inoreader with social media apps.)
• Rules to auto-delete duplicated items or if the title contains specific words
• Its Firefox and Chrome extensions and Android and iOS apps can easily and quickly find RSS feeds of websites
• Subscribe to newsletters (max 20 newsletters, that’s why I don’t use this feature anymore. I use kill-the-newsletter instead)
• Feed generators for websites that don’t have an RSS feed (the max 20 feed generations limit made me start using RSS-Bridge instead of this feature)
• Customization of sharing options (so I’ve Pocket the first option and it allows me to quickly share an item into my Pocket account if needed)

I’ve customized Inoreader’s app to make it more pleasing to my taste:

• Changed the feed layout to list, to get rid of the article thumbnails.
• Sorted the lists chronologically, and “oldest first”. Firstly, I don’t want Inoreader’s algorithm to decide what is worth my attention. Second, by reading the oldest first, I make sure that nothing gets buried and forgotten at the end of the list, and also when I view an item in the list, the hype dust around it, whatever it is has settled a bit (note that I’m usually reading items from 5-6 days ago, so this is not true about any kind of hype).
• Disabled the “popularity indicator”, to have fewer distractions and be focused on the titles.
• Changed the content font to a serif one (just a personal preference for reading content).

Inoreader: Cons

Of course, Inoreader is not perfect:

• They have increased the subscription price many times in the past few years. They’ve used to have a Black Friday discount for everyone for years, but they limited the offer to new users last year and it pissed off the existing users and many complained on Reddit.
• Inoreader is a cool product, but they’ve been focusing on developing new features and capabilities for the enterprise and business customers in the past two years, and they seem to be on a path to enshitification .

I’m considering self-hosting a FreshRSS in the future and using it with FeedMe app if I could make sure it has all the features I need.

RSS feeds I follow using Inoreader

• Blogs and websites: I started following a handful of blog feeds around 18 months ago. Over time, when I came across an interesting post from a blog or website, I added its feed to Inoreader, and the total is currently 1659 RSS feeds. I recommend you do the same, but you can get an OPML list of blog posts from HackerNews users , or reach out to me if you’re interested in my OPML list.
• HackerNews and lobste.rs front page: Thousands of links are submitted to HackerNews every day, and you probably don’t have time to even scroll through all of them, and many of them are spam or not interesting. But thanks to the power of the community, the ~100 items that reach its front page every day are mostly interesting. The issue with its front page RSS feed is the many duplicated items in the list (I’m not sure what exactly happens when a moderator updates an item’s title, but many times I see the same item with different titles in my feed reader). Fortunately, I’ve been able to remove duplicates automatically using Inoreader’s duplication rule (I’ve set it to remove any item with the same URL within 24 hours). lobste.rs is a similar but smaller community to HackerNews.
• Blogs or websites without an RSS feed: I use RSS-Bridge (mostly CSS Selector and XPathBridge ) to create RSS feeds for blogs and websites that don’t provide a feed (If you’re writing on the web and don’t provide an RSS feed to your readers, please consider adding one). I used to use Inoreader’s feed generator, but the Pro plan has a maximum of 20 feed generations and I quickly reached the limit. Honestly, very strange limit on Inoreader’s service.
• Email newsletters: I use kill-the-newsletter to subscribe to email newsletters. It’s a free service that provides you a unique email address and a unique RSS feed, you subscribe to the newsletter using that email address, and whenever a new email arrives, it updates your RSS feed. Very nice. I used to use Inoreader’s newsletter feature, but the Pro plan has a max 20 newsletter subscription limit (although you can technically use the same email address in multiple newsletters). Some newsletter platforms like Substack, Ghost, and Buttondown provide an RSS feed on the newsletters’ archive page and I directly use that feed.

Where I don’t use RSS

• News: I don’t proactively follow any news publisher, neither general news media like the New York Times, nor tech media like Verge. Anything important will be shared either on HackerNews, or it will reach me somehow via friends and colleagues.
• YouTube: Ideally I should follow the RSS feed of the YouTube channels that I like, but I currently just browse YouTube’s home page and if something sounds interesting, I save it into the watch later playlist (or a few other playlists that I’ve created). Nothing fancy here, just a typical YouTube user (who sorts his YouTube watch later playlist on “oldest first”), so won’t go into the details of this.
• Twitter: I deleted my Twitter account in 2021 for reasons that I mentioned at the beginning of this post. Last year I realized there are still a handful of interesting people on the platform, so I created a new Twitter account and I currently follow 60 users via a Twitter list that I’ve created. Whenever I find someone who tweets interesting and useful stuff (like @simonw or @vicki ) I add them to my list. Fortunately, Elon hasn’t destroyed Twitter’s list feature yet (although he surely will), so I can browse through the latest tweets from these people in chronological order without any ads. I do this every morning on Twitter’s web app, and if there is something very interesting to read later (an article or paper, or a GitHub repo) I use the same shortlist flow as my RSS feeds, which I explain soon. I tried Inoreader’s Twitter integration but it stopped working since Elon killed Twitter’s API access. I also tried following my list’s RSS feed using Nitter , but apparently, that’s also going to stop working soon. The experience of reading a handful of tweets in a list on Twitter’s web app is generally ok for now.
• Podcasts: Many (or all?) podcasts have RSS feeds, and I can follow them on Inoreader, and I used to do so, but I came to the conclusion that I’m not a podcast person. The ratio of the “useful information” per “time spent” is extremely low with podcasts for me, so I’ve decided to spend my listening time on audiobooks and articles (using Text-to-Speech, more on this later), or if I’m not in the mood and I just want to entertain myself while walking or shopping for groceries, I highly prefer listening to music. Therefore, I’m following and listening to zero podcasts now.

Shortlisting

So, overall RSS feeds are the main inputs in my workflow, and as I mentioned before, I’m following 1659 RSS feeds as of today (most of them rarely post new stuff though), which means I consume between 200 to 300 items in my Inoreader feed on average every day. Consumption in this step means scrolling through the feed, which I do throughout the day when waiting for my coffee or tea to be ready, waiting in a doctor’s office, commuting via bus and metro, and any other place and time that I’d go for scrolling social media apps before.

When scrolling my RSS feed reader, if a title grabs my attention, I open the article (or the discussion, if it’s a HackerNews page for example), I quickly skim the content (or comments), if interesting, I shortlist the item by either saving it into my Pocket account or the Inoreader’s starred items. Both of these saving options are easily accessible on Inoreader’s interface.

Why bother saving in two separate places? Over time I’ve realized a few facts about myself and the types of content I consume:

1. I don’t like reading long stuff on my phone.
2. Some content requires deep reading, reviewing, highlighting, or some other activity in parallel to reading (like trying the code in a blog post that introduces a new Python library).
3. I don’t need to “read” everything, I can enjoy listening to some content.

So when I shortlist an item, if it has:

• many visual elements that help understand the content (e.g. a photography tutorial, a how-to guide on using a Python visualization library, etc), or
• many code snippets

I save it into Inoreader’s starred items, and I get back to these items later on my MacBook (More on this later). Otherwise, I save the item into my Pocket account, which it then gets synced with Omnivore, and I listen to these items later while doing chores at home. This part of the workflow is a bit messy, I know but I’ve experimented with various tools to create a streamlined process of saving items from feeds and listening to them on a high-quality text-to-speech service, and this is what serves me well at the moment:

• Every item that must be listened to gets saved into Pocket. Why Pocket?

  • Firstly, because Pocket is a well-known read-it-later tool that has been integrated into many other tools, including Inoreader, so I can save items from my feed to Pocket with just one tap.
  • Second, since Pocket is integrated into many tools, and the average lifetime of the productivity and reading tools is shorter than the memory of a fish, I’m not sure if I’ll be using Omnivore, Readwise, or any other tool next year, but I’m fairly certain that Pocket will be around (please Mozilla, don’t kill it) and any new tool in this ecosystem will have some sort of Pocket integration.
  • [update 2024-10-31]: Omnivore recently [accounced](https://blog.omnivore.app/p/omnivore-is-joining-elevenlabs ) they’re shutting down the whole project, and it made me remember the above paragraph of my blog post and I was reminded that a battle tested old school tool like Pocket is more reliable than a new tool that we don’t know if it will exist in a year.

• I’ve written a Python script to get the new items from Pocket and save them into Omnivore every day. The script is on Github and using a schedule: cron job on Github Actions and it’s running once every day.

Reading with text-to-speech

When I realized that by listening to articles I could finally transform myself from a content hoarder to a content consumer, I looked into affordable but high-quality apps that would provide this feature. I of course started with Pocket’s own TTS feature, but it’s honestly just trash. I couldn’t bear listening to Android’s cacophonous default TTS engine voices for more than 30 seconds. I then came across this tts-server-android thing that I think somehow replaces your Android phone’s TTS engine with more realistic voices (I honestly don’t how it works, and yeah, I was brave enough to install the APK file on my phone). It was ok, but still not at a level that I’d enjoy listening to. Inoreader also offers a TTS feature for its Pro users, but it’s mostly a joke as it has 200K characters per month (which approximates ~20 articles based on my unscientific measurements).

Later I found out about Readwise Reader , which was a new product in beta from the Readwise team. Readwise originally is a sync-your-highlights app, but they started working on their Reader app which is a … everything app?! It aims to be your feed reader, read-it-later, e-book reader, PDF reader, and many more. Luckily for me, its TTS feature was the best one I had tried until then, and $8/month was a price that I was fine paying for a good TTS app (Readwise Reader was using Microsoft TTS service, but they have switched to Unreal Speech recently). Readwise Reader has a nice (one-way) Pocket integration, and it gets the newly saved items from Pocket every time you open the app, no extra action is required.

After using Readwise’s semi-human-like TTS feature for a few months (with many glitchy UX behaviors of their Android app), I was introduced to Omnivore with this YouTube video . I started trying out Omnivore’s TTS, and wow! The voices were impressively high-quality and the experience was the closest to a human narrator (at 1.5x speed). Omnivore is an open-source app , and upon browsing in their codebase and issues I found out they’re using PlayHT as their TTS engine. It’s still a question mark to me if they are using a not-very-cheap third-party service, how and why they’re offering this for free, and what’s the business plan, but I’d be happy to pay a reasonable monthly subscription to be able to continue using it. Omnivore is a free and open-source app, so I probably can’t complain, but I will anyway:

• TTS is only available on the iOS app, so as an Android user I need to use my iPad or work phone to listen to my saved articles.
• There is no stable sync between Omnivore’s own apps. Sometimes I remove or archive an item on the web, but it’s still available on the iOS app, even if you refresh the feed, close the app, or get back to it next week. (I created an issue on Oct 2023, but no responses yet)
• It has a Pocket integration (told ya!), but it (used to) have an “import” button in the settings > integrations page, so you’d need to click on this button every few days to make Omnivore to fetch the newly saved items from Pocket. No auto-import, yikes, but it was fine. But why do I say “used to”? Because they changed they completely removed the “import” button a few months ago, and you have to disconnect and re-connect your Pocket integration (and login, re-authorize, etc on Pocket’s website) each time you want to import the new items! Why?! I created an issue for this on Dec 2023, but no response from devs yet. This is why I need to write my own script to fetch my saved articles from Pocket and store them in Omnivore, and it’s been working mostly fine in the past few months.

Deep reading

Text-to-speech is not suitable for content with many visual elements or code snippets. I need to see the chart when the narrator says “… and here is how my indie app’s revenue changed last year”, and to read the code when you hear “… but you can implement the same functionality with the following 10 lines of Python”. There are also cases that I’ll need to browse a couple of web pages (like when I come across a HackerNews thread that many interesting tools have been recommended), and this is much easier on a laptop, compared to a phone.

More importantly, one of the critical benefits of doing all the steps of the workflow I’ve described so far is to somehow retain the useful information I consume. What should I do when I find a potentially useful Python library or a tip on how to fine-tune a language model? Just say “ok, cool” and close the tab? I at least have to take a small note about it and make it easier for myself to find it later if I ever needed it. I have a very simple personal knowledge management system on Obsidian . I can easily search for my notes using the obsidian-omnisearch plugin’s fuzzy and weighted search features.

I spend 15-30 minutes a day going through the starred items on Inoreader, sorted on “oldest first”. Depending on the length and depth of the saved item, I can skim, read, highlight, and take notes of 2-10 articles within this timeframe. Obviously, not everything merits a persistence on my memory, I usually find myself taking note of 15-20% of the items I read from Inoreader starred items, while others get an "ok, cool", close tab. If an item is very long or very dense (information-wise), I usually convert it to a PDF file and save it in my “articles” folder on iCloud, so I can read it in another scheduled 15-30 minutes time slot on my iPad. I use an app called Documents but I’m in a hunt for a better PDF reader for iPad.

A side note worth mentioning is that I currently utilize open tabs of Chrome on my phone in parallel to Inoreader’s starred feature. Sometimes I just keep an interesting link open as a tab on my phone, and thanks to Chrome’s excellent “tabs open on other devices” feature, I browse them regularly on MacBook, similar to what I do with starred items on Inoreader.

Other types of content

• Social media: I’ve already talked extensively about Twitter, and I also spend 5-10 minutes a day browsing Instagram and Reddit, but usually nothing beneficial on either of them.
• Paper books: I unfortunately don’t spend enough (or any, to be honest) time on reading books on paper. Although I’m covering books by reading ebooks and listening to audiobooks, but I’d love to add physical books to my days as well.
• E-books: I used to read e-books on my Kindle, but I find myself using the iPad for this.
• Audiobooks: For the same reason as liking to listen to articles, I sometimes prefer listening to books (obviously when the topic permits, meaning it’s not full of code or math formulas). I used Storytel for a few months, I’m currently using Spotify for listening to audiobooks.

Conclusion

I started using RSS and Inoreader less than 18 months ago, and I’ve built this workflow over time, based on learnings of what has worked and what hasn’t for me. I have experienced many benefits by doing this, including but not limited to:

• I don’t feel cluttered with content. The number of my read-later items on Pocket remains steady at around 30, and take-note items on Inoreader are somewhat steady at around 170 (yeah, I need to speed this up a bit). I have replaced my pile of content with a flow of content, I consume from the pile at the same rate that I store into it.
• By regularly exposing myself to high-quality content, I’ve been learning many new things consistently. The ratio of the “useful information” per “time spent” has been significantly higher for me following this workflow.
• I’ve been known as a person who shares useful and interesting content with friends and colleagues. I have received much positive feedback at work appreciating me sharing articles and my findings.

The workflow will surely change over time, as tools die and new tools emerge, and also as I as a person change. I’ll update this post in the future with notes if I make changes to any parts of this workflow. Please reach out to me if you have any questions, or if you have any recommended tools that you think would fit or improve my workflow.

Comment? Reply via Email, Mastodon or Twitter.

• uicolors.app : I’ve used this one when working on redesigning the user interface for my latest side project. The nice feature of uicolors.app is its Tailwind export functionality which allows you to quickly export the color palette as a Tailwind config code snippet.
• tints.dev : Palette Generator + API for Tailwind CSS
• colorjs.io
• huemint.com
• adevade.github.io/color-scheme-generator
• colorcolor.in
• colormind.io
• paletton.com
• huehive.co : Generate palettes with ChatGPT

source

Comment? Reply via Email, Mastodon or Twitter.

There is a huge gap in generative AI between the quality you observe when you’re playing with it open endedly, and the quality you observe when you try to use it for a task where you have a specific end goal in mind. This is I think where most of the hype/reality mismatch occurs.

This accurately sums up my experience using generating AI in a daily base and building products with this technology.

source

Comment? Reply via Email, Mastodon or Twitter.

Slow down other teams

If other teams move quickly, your team can become a bottleneck. That never looks good. When a wild animal is chasing you, you need to not be the slowest. Slow down your peer teams by asking for info, or starting processes. As a bonus, you look as if you’re holding a high bar.

• “But have you done a user study?”
• “Did you get a security review?”
• “That design looks interesting! Could you get a principal review before you move forward?”

Once you’ve slowed them down, they’ll be a bottleneck, and it will demonstrate that your leadership is superior.

source

Comment? Reply via Email, Mastodon or Twitter.