Is trauma associated with plant-based diet choice? - ScienceDirect

Theoretically, plant-based diets may be more common among trauma exposed because those with trauma may have increased empathy.

papers vegan

The Effect of Deactivating Facebook and Instagram on Users’ Emotional State

People who deactivated Facebook for the six weeks before the election reported a 0.060 standard deviation improvement in an index of happiness, depression, and anxiety, relative to controls who deactivated for just the first of those six weeks. People who deactivated Instagram for those six weeks reported a 0.041 standard deviation improvement relative to controls.

papers

[2405.02318] Autoformalizing Natural Language to First-Order Logic: A Case Study in Logical Fallacy Detection

ai papers

Building Websites With LLMS

Fun stuff with CSS transitions.

htmx

LLM Agent as a Graph Tutorial

ai

Intuiting TLS | protty

cryptography security

CaMeL offers a promising new direction for mitigating prompt injection attacks

ai security

humanlayer/12-factor-agents: What are the principles we can use to build LLM-powered software that is actually good enough to put in the hands of production customers?

• Factor 1: Natural Language to Tool Calls
• Factor 2: Own your prompts
• Factor 3: Own your context window
• Factor 4: Tools are just structured outputs
• Factor 5: Unify execution state and business state
• Factor 6: Launch/Pause/Resume with simple APIs
• Factor 7: Contact humans with tool calls
• Factor 8: Own your control flow
• Factor 9: Compact Errors into Context Window
• Factor 10: Small, Focused Agents
• Factor 11: Trigger from anywhere, meet users where they are
• Factor 12: Make your agent a stateless reducer

ai

Nix derivations by hand, without guessing | Max Bernstein

nixos

Four Lectures on Standard ML

cs functional papers

Filesystems unfit as backend for distributed storage (pdf)

distributed systems papers

practical process control

control systems

What makes Elixir great for startups?

elixir

whose github actions am I running?

devops security

Scaling Prometheus: From Single Node to Enterprise-Grade Observability

devops sre

[2310.15505] The Quantum Tortoise and the Classical Hare: A simple framework for understanding which problems quantum computing will accelerate (and which it will not)

cs physics quantum

Testing concurrent code with testing/synctest - The Go Programming Language

golang

Resilience: some key ingredients

resilience sre

Versioning versus Coordination - Marc’s Blog

distributed systems

Beej’s Guide to Git

devops

Let’s Implement Consistent Hashing From Scratch

distributed systems golang

Gravy Pitcher by Myrtle Pedals

Track featuring the mystery pedal that uses my artwork.

art guitar

How AI generated code compounds technical debt - LeadDev

ai

Systems Correctness Practices at AWS

cs

Normalize chart data using Ecto and PostgreSQL

databases elixir

Meta’s Hyperscale Infrastructure Overview and Insights

distributed systems sre sysadmin

How doctors handoff patients (how it applies to incidents) : sre

I-PASS stands for:

• Illness Severity
• Patient Summary
• Action List
• Situation Awareness & Contingency Planning
• Synthesis by Receiver

sre

Representing graphs in Postgresql

databases

Summary of How I write HTTP services in Go after 13 years:

• The NewServer constructor - big constructor that takes all dependencies as parameters. returns http.Handler. configures its own muxer and calls out to routes.go. includes setting up middleware, CORS, logging. ** Long argument lists - type safety in arguments.
• Map the entire API surface in routes.go
• func main() only calls run() - run() returns an error and accepts OS fundamentals as parameters for easier testing. background context is created in main but all other context handling is done in run. ** Gracefully shutting down - pass context through and check it at each level. ** Controlling the environment - use flags.NewFlagSet inside run. make a replacement os.Getenv for tests and pass that to run (or the real thing for main).
• Maker funcs return the handler - creates a readable closure for each.
• Handle decoding/encoding in one place - for JSON/XML encode/decode.
• Validating data - single method interface with Valid(ctx context.Context) (problems map[string]string)
• The adapter pattern for middleware - take an http.Handler and return one.
• Sometimes I return the middleware ** An opportunity to hide the request/response types away - keeps global space clear.
• Use inline request/response types for additional storytelling in tests
• sync.Once to defer setup - anything expensive during handler setup, defer to the first time it’s called to improve overall app startup time.
• Designing for testability ** What is the unit when unit testing? - multiple levels of options from run() down to calling individual handler functions. ** Testing with the run function ** Waiting for readiness - loop on hitting a /healthz endpoint until the server has started.

golang

Probabilistic Increment: A Randomized Algorithm to Mitigate Hot Rows

algorithms distributed systems sre

Improved evaluation times with pre-resolved Nix store paths

nixos

Persistent packages on Steam Deck using Nix

nixos

Black-Scholes

finance math

Build a Modern Godot 4 MMO with Golang | Tristan Batchler

golang

rewrite.md

Really good writeup of Roc’s decision to rewrite their compiler in Zig (original version written in Rust).

roc rust zig

scalable oltp in the cloud: what’s the big deal?

databases distributed systems

Data evolution with set-theoretic types - Dashbit Blog

elixir

Go All the Way: Why Golang is Your Swiss Army Knife for Modern Development

golang

Out-of-the-box Elixir telemetry with Phoenix - Honeybadger Developer Blog

elixir

Phoenix LiveView: Presenting DateTime in User’s Time Zone - Mike Zornek

elixir

Market Structure Primer

finance

The Modifications I Make to Every New Phoenix Project - John Elm Labs

elixir

Packer: How to Build NixOS 24 Snapshot on Hetzner Cloud - Developer Friendly Blog

devops nixos

Functional programming self-affirmations - NorikiTech

cs functional

How Distributed Systems Avoid Race Conditions using Pessimistic Locking?

distributed systems

TLA+ from first principles

cs math

Designing a distributed circuit breaker for disabling webhook endpoints in Golang

distributed systems golang

An Alternative Construction of Shannon Entropy

math

You built an Erlang

erlang

From ALB to Caddy - Our Wandering Path to Supporting Thousands of Domain Names

distributed systems sysadmin