Pinboard (jm)

isene/glass

jm — 2026-05-05T11:37:30+00:00

I love the purism of this -- "pure assembly terminal emulator. x86_64 Linux, no libc, X11 wire protocol".

Terminal emulator written in x86_64 Linux assembly. No libc, no runtime, pure syscalls. Speaks X11 wire protocol directly via Unix socket. Single static binary, ~155KB. No toolkit, no rendering library, no external font engine. The TTF rasterizer (glyph) is embedded in-binary via %include. Just your keystrokes, the X11 server, and the kernel. Part of the CHasm (CHange to ASM) suite: bare (shell), show (file viewer), glass (terminal emulator).

The fastest Linux timestamps

jm — 2026-04-27T11:42:47+00:00

lol -- "TL;DR: We can speed up timestamps on x86 Linux by 30% and maintain the same precision as the standard system clock by implementing our own timers without relying on vDSO. Almost nobody should do this" This is good info, I had to implement fast timestamps a few years back in Java and this would have been useful.

Debunking zswap and zram myths

jm — 2026-03-25T10:00:18+00:00

This is pretty compelling. I like this example:

We have some concrete numbers to show this in practice. On Instagram, which runs on Django and is largely memory bound, we ran a test where we moved from their existing setup (with swap entirely disabled) to a setup with disk swap and zswap tiering. Django workers accumulate significant cold heap state over their lifetime, like forked processes with duplicated memory, growing request caches, Python object overhead, you get the idea. The results were twofold: - We achieved roughly 5:1 compression. That's a huge benefit for such a memory bound workload, and also enables us to consider further stacking workloads. - Enabling zswap reduced disk writes by up to 25% compared to having no swap at all(!). As you can imagine, as a result of this test, Instagram has been using zswap for many years now.

A better way to limit Claude Code (and other coding agents!) access to Secrets

jm — 2026-01-15T09:55:40+00:00

Bubblewrap, a Linux CLI tool which uses namespaces to sandbox a specific command (and its subprocesses):

Bubblewrap lets you run untrusted or semi-trusted code without risking your host system. We’re not trying to build a reproducible deployment artifact. We’re creating a jail where coding agents can work on your project while being unable to touch ~/.aws, your browser profiles, your ~/Photos library or anything else sensitive.

Very nice, I hadn't heard of this tool before. The rest of the blog post details how to use it to isolate Claude Code specifically.

Solid state drive - ArchWiki

jm — 2026-01-05T11:02:18+00:00

the Arch Linux wiki page about SSD tuning and enabling TRIM -- extremely detailed and useful!

Linux Capabilities instead of setuid

jm — 2025-10-19T15:15:17+00:00

This seems like a pretty poor idea for Linux to have implemented:

The command setcap sets file capabilities on an executable. The cap_setuid capability allows a process to make arbitrary manipulations of user IDs (UIDs), including setting the UID to a value that would otherwise be restricted (i.e. UID 0, the root user). setcap takes a set of parameters, where - e: Effective means the capability is activated; - p: Permitted means the capability can be used/is allowed. Putting this together, we’re adding the cap_setuid capabilities to the Python binary: # setcap cap_setuid+ep /usr/bin/python3.12

And hey presto, "/usr/bin/python3 -c 'import os;os.setuid(0);os.system("/bin/bash")'" now works. Ouch

xcapture and xtop

jm — 2025-09-16T13:59:07+00:00

"0x.Tools: X-Ray vision for Linux systems". Linux Performance Analysis with Modern eBPF and DuckDB; dig into the captured DuckDB files using "xtop": "xtop is like the Linux top tool, but extended with x-ray vision and ability to view your performance data from any chosen angle [..]. This enables dimensional performance analysis on Linux and tools like top for wall-clock time and much more. You can use it for system level overview and drill down into indivual threads’ activity and even into kernel events like lock waits or memory stalls."

Orange-OpenSource/hurl

jm — 2025-06-20T09:42:49+00:00

"Hurl; run and test HTTP requests with plain text". This is pretty nice; a really simple plain-text file format to describe making a HTTP request or set of requests, and performing assertions on their results. The only thing I can spot missing is builtin support for OAuth

Debugging Azure Networking for Elastic Cloud Serverless

jm — 2025-06-10T08:46:06+00:00

Good writeup of fixing a Linux packet loss issue in Azure, using low-level access to the VMs running k8s nodes.

Elastic's Site Reliability Engineering team (SRE) observed unstable throughput and packet loss in Elastic Cloud Serverless running on Azure Kubernetes Service (AKS). After investigation, we identified the primary contributing factors to be RX ring buffer overflows and kernel input queue saturation on SR-IOV interfaces. To address this, we increased RX buffer sizes and adjusted the netdev backlog, which significantly improved network stability.

Jetrelay

jm — 2025-05-20T09:18:20+00:00

This is a great little hack: "jetrelay, a pub/sub server compatible with Bluesky’s “jetstream” data feed. Using a few pertinent Linux kernel features, it avoids doing almost any work itself. As a result, it’s highly efficient: it can saturate a 10 Gbps network connection with just 8 CPU cores." Specifically, these are the tricks in question: - Trick #1: Bypassing userspace with sendfile(); - Trick #2: Handling many clients in parallel with io_uring; - Trick #3: Discarding old data with FALLOC_FL_PUNCH_HOLE -- this is a nice way to avoid having to rotate between multiple files, nifty.

Atomicless Concurrency

jm — 2025-05-19T09:03:07+00:00

CPU-local (not just thread-local) concurrency in Linux using rseq(2) [via Tony Finch]

just-containers/s6-overlay

jm — 2025-04-09T10:50:22+00:00

s6-overlay -- a Docker process management system, current state of the art used by Paperless and the Linux-server.io teams, with the following goals: - Be usable on top of any Docker base image (Ubuntu, CentOS, Fedora, Alpine, Busybox); - Make it easy to create new images, that will operate like any other images; - Provide users with a turnkey s6 installation that will give them a stable pid 1, a fast and orderly init sequence and shutdown sequence, and the power of process supervision and automatically rotated logs.

My list of useful command line tools

jm — 2025-03-25T09:43:29+00:00

Here's a bunch of fantastic recent CLI tools I hadn't seen before; loads are by one guy, https://github.com/sharkdp , who seems very productive :)

LinuxPDF

jm — 2025-02-13T12:09:37+00:00

It's Linux, running inside a PDF file. "The humble PDF file format supports JavaScript – with a limited standard library, mind you. By leveraging this, [vk6] managed to compile a RISC-V emulator (TinyEMU) into JavaScript using an old version of Emscripten targeting asm.js instead of WebAssembly. The emulator, embedded within the PDF, interfaces with virtual input through a keyboard and text box." (via Fuzzix)

isd

jm — 2025-01-20T10:08:03+00:00

a curses UI for systemd, via Nelson

write(1) no longer part of util-linux

jm — 2024-11-18T09:39:22+00:00

util-linux (2.40.2-11) unstable; urgency=medium * The mesg(1) and write(1) programs are no longer provided. It is believed chatting between users is nowadays done using more secure facilities. -- Chris Hofstaedtler Wed, 13 Nov 2024 12:58:06 +0100 Sic transit gloria mundi. (via Doug on ITC Slack)

How to Learn: Userland Disk I/O

jm — 2024-11-08T13:21:19+00:00

This is an interesting hodge-podge of key bits of information about disk I/O, file integrity and durability, buffering or unbuffered writes, async I/O, and which filesystems to use for high-I/O database operation on Linux, MacOS and Windows. One thing that was new to me: "You can periodically scrape /proc/diskstats to self-report on disk metrics".

Twenty years of Valgrind

jm — 2024-08-29T08:59:33+00:00

It's been an amazing tool (or set of tools) over all those years! And thank goodness Purify never chose to enforce their patents, as I'm sure that would have killed the project in its infancy

OliveTin

jm — 2024-07-15T18:37:17+00:00

"Give safe and simple access to predefined shell commands from a web interface." This is great; my home server has a small set of hacky CGI scripts to run things like df(1), nice to have a nicer UI for this purpose

Linux maintainers were infected for 2 years by SSH-dwelling backdoor with huge reach | Ars Technica

jm — 2024-05-16T09:57:19+00:00

yikes.

Infrastructure used to maintain and distribute the Linux operating system kernel was infected for two years, starting in 2009, by sophisticated malware that managed to get a hold of one of the developers’ most closely guarded resources: the /etc/shadow files that stored encrypted password data for more than 550 system users, researchers said Tuesday.

DuckDB as the New jq - Paul Gross’s Blog

jm — 2024-03-22T09:59:27+00:00

tl;dr: this works:

% duckdb -c \
  "select license->>'key' as license, count(*) as count \
  from 'repos.json' \
  group by 1 \
  order by count desc"

This is very cool. I need to start looking into using `duckdb` as a go-to CLI tool.

Max Levchin's Shamir Secret Sharing story

jm — 2023-08-11T13:05:13+00:00

this is amazing. "This is the story of a catastrophic software bug I briefly introduced into the PayPal codebase that almost cost us the company (or so it seemed, in the moment.)" tl;dr: UNIX libc API standardisation failure bites again -- the getpass() API had differing behaviour between Linux and Solaris, where SysV compatibility caused passwords to be truncated after 8 bytes. horrific

Mountpoint for S3

jm — 2023-08-09T15:58:39+00:00

An officially-supported Linux filesystem client for Amazon S3, now GA

In defence of swap

jm — 2023-05-11T09:56:01+00:00

Common misconceptions about swap memory on Linux systems:

Swap is a useful tool to allow equality of reclamation of memory pages, but its purpose is frequently misunderstood, leading to its negative perception across the industry. If you use swap in the spirit intended, though – as a method of increasing equality of reclamation – you'll find that it's a useful tool instead of a hindrance. Disabling swap does not prevent disk I/O from becoming a problem under memory contention, it simply shifts the disk I/O thrashing from anonymous pages to file pages. Not only may this be less efficient, as we have a smaller pool of pages to select from for reclaim, but it may also contribute to getting into this high contention state in the first place.

(via valen)

Raspberry Pi alternatives

jm — 2023-02-02T10:58:47+00:00

Interesting thread on the current state of low-cost/low-power server hardware; I didn't realise thin client boxes were so viable for this use case, these days. (I've just replaced my current home server with an ODROID HC4, and I'm absolutely delighted with it, though...)

omni-epd

jm — 2023-01-24T10:26:42+00:00

A Python module to abstract usage of several different types of EPD (electronic paper displays), including Inky and Waveshare hardware.

Getting a root shell on a VTech Storio 3S tablet

jm — 2022-12-20T16:39:45+00:00

Quite a complicated process -- extracting the eMMC chip is way beyond my abilities! -- but using FCCID.io is a neat trick

Out-of-memory (OOM) in Kubernetes

jm — 2022-09-30T17:07:11+00:00

Extremely detailed writeup of how k8s handle's out of memory conditions, how the Linux OOM killer interacts with cgroups, and application runtime implications

durability - How can I extend the life of my SD card? - Raspberry Pi Stack Exchange

jm — 2022-08-14T21:03:08+00:00

A few good suggestions here. Absolutely to nobody's surprise, it turns out systemd quietly sets up swapping to /var/swap, so that's a good one to turn off if your RPIs are not RAM-bound

Taking The ZimaBoard For A Spin | LinuxServer.io

jm — 2022-07-27T21:52:32+00:00

Good review for the ZimaBoard, a pretty hefty looking SBC microserver platform with a real x86_64 CPU

How fast are Linux pipes anyway?

jm — 2022-06-04T16:33:40+00:00

Very enjoyable Linux hyper-optimization through splice and huge pages

Missing Manuals - io_uring worker pool

jm — 2022-02-09T11:53:13+00:00

'Calling io_uring just an asynchronous I/O API doesn’t do it justice, though. Underneath the API calls, io_uring is a full-blown runtime for processing I/O requests. One that spawns threads, sets up work queues, and dispatches requests for processing. All this happens “in the background” so that the user space process doesn’t have to, but can, block while waiting for its I/O requests to complete. A runtime that spawns threads and manages the worker pool for the developer makes life easier, but using it in a project begs the questions: 1. How many threads will be created for my workload by default? 2. How can I monitor and control the thread pool size? [.....] 3. What is an unbounded worker? 4. How does it differ from a bounded worker? Things seem a bit under-documented as is, hence this blog post. Hopefully, it will provide the clarity needed to put io_uring to work in your project when the time comes.'

Safely Backup Google Photos

jm — 2022-01-20T17:24:02+00:00

pretty simple tools on Ubuntu, from the looks of it

The CFS quota container throttling problem

jm — 2021-12-19T22:01:40+00:00

Well, this is quite a messy one:

Almost all services at Twitter run on Linux with the CFS scheduler, using CFS bandwidth control quota for isolation, with default parameters. The intention is to allow different services to be colocated on the same boxes without having one service's runaway CPU usage impact other services and to prevent services on empty boxes from taking all of the CPU on the box, resulting in unpredictable performance, which service owners found difficult to reason about before we enabled quotas. The quota mechanism limits the amortized CPU usage of each container, but it doesn't limit how many cores the job can use at any given moment. Instead, if a job "wants to" use more than that many cores over a quota timeslice, it will use more cores than its quota for a short period of time and then get throttled, i.e., basically get put to sleep, in order to keep its amortized core usage below the quota, which is disastrous for tail latency1. Since the vast majority of services at Twitter use thread pools that are much larger than their mesos core reservation, when jobs have heavy load, they end up requesting and then using more cores than their reservation and then throttling. This causes services that are provisioned based on load test numbers or observed latency under load to over provision CPU to avoid violating their SLOs. They either have to ask for more CPUs per shard than they actually need or they have to increase the number of shards they use.

Note that Kubernetes uses CFS to implement CPU quotas by default, too. In the twitter thread about this post, a commenter noted: "'By shrinking the CFS period, the worst case time between quota exhaustion causing throttling and the process group being able to run again is reduced proportionately'. Our P99s at previous gig reduced in line after I petitioned cloud provider to adjust setting." --- this at least seems like a relatively easy setting to tune.

Bug #1624320 “systemd-resolved appends 127.0.0.53 to resolv.conf...” : Bugs : systemd package : Ubuntu

jm — 2021-12-10T11:00:21+00:00

Wow; recent Ubuntu versions force name resolution to operate via the systemd-resolved DNS resolver, which has some pretty major bugs and omissions:

This bug just compromised every ubuntu machine on my network. It falsely says that DNSSEC is not supported by the nameserver and resorts to non-DNSSEC resolution. So every machine on my network just accepted bogus DNS replies from a MITM. Thanks.

Is there anything systemd can't break :(

Orange-OpenSource/bmc-cache

jm — 2021-09-20T09:14:30+00:00

In-kernel memcache based on eBPF (via Brendan Gregg):

BMC (BPF Memory Cache) is an in-kernel cache for memcached. It enables runtime, crash-safe extension of the Linux kernel to process specific memcached requests before the execution of the standard network stack. BMC does not require modification of neither the Linux kernel nor the memcached application. Running memcached with BMC improves throughput by up to 18x compared to the vanilla memcached application.

Framework Laptop Teardown: 10/10, But is it Perfect?

jm — 2021-08-30T09:24:19+00:00

10 out of 10 for repairability -- and it looks like a great laptop! nice one

gProfiler

jm — 2021-06-28T09:31:58+00:00

'a system-wide profiler, combining multiple sampling profilers to produce unified visualization of what your CPU is spending time on.' -- claims to have little impact on performance of running code, supports Linux, java and Ruby

Interesting AWS performance tip

jm — 2021-06-27T20:41:55+00:00

we determined that calls to time.Now() or time.Since(time.Time) in Golang were taking about 200 times longer on new servers than they were on old servers. We found similar impacts in Python, which lead us to the clocksource. It turns out that in our Grub boot parameters for AL2, we had added clocksource=hpet about two years ago, but all of our servers launched prior to 6/17 had a clocksource of kvm-clock, apparently ignoring the Grub config. Servers launched after 6/17 (with the same AMI, Grub config, everything) were honoring the specified clocksource, which caused our performance issue.

Turn Your Old, Cracked Android Phone Into a Backup Server

jm — 2021-06-21T16:34:16+00:00

It's gratifying to see that an apk called 'Linux Deploy' will run a chrooted Debian install on a rooted Android phone -- that's a great way to reuse and recycle old, nearly-dead hardware

Extreme HTTP Performance Tuning: 1.2M API req/s on a 4 vCPU EC2 Instance | talawah.io

jm — 2021-05-21T08:54:01+00:00

This is very cool. Updating the old "C10K" problem space to C1.2M -- the current state of Linux userspace networking -- using libreactor and a whole load of up-to-date tweaks. Interesting to note that this scale is feasible to run in Docker (using --network=host, of course).

File Descriptor Limits

jm — 2021-05-20T08:55:30+00:00

tl;dr: 'Don't use select() anymore in 2021.' Select(2) on Linux has a limit of 1024 fds

mjg59 | Exploring my doorbell

jm — 2021-05-06T09:39:37+00:00

Nice walkthrough of rooting and extending a bit of IOT hardware

How io_uring and eBPF Will Revolutionize Programming in Linux

jm — 2020-11-26T21:52:12+00:00

Nice writeup of how io_uring works, and how it improves performance

Feh/nocache

jm — 2020-09-23T10:43:42+00:00

minimize filesystem caching effects:

The nocache tool tries to minimize the effect an application has on the Linux file system cache. This is done by intercepting the open and close system calls and calling posix_fadvise() with the POSIX_FADV_DONTNEED parameter. Because the library remembers which pages (ie., 4K-blocks of the file) were already in file system cache when the file was opened, these will not be marked as "don't need", because other applications might need that, although they are not actively used (think: hot standby).

Raspberry Pi USB Boot - UASP, TRIM, and performance

jm — 2020-09-21T10:38:32+00:00

In the past few weeks, I reviewed USB drive performance on the Raspberry Pi 4, and the importance of UASP support for USB drive performance. Both posts generated great discussion, and there were three things I wanted to cover in this follow-up, namely: Which drives support UASP; Real-world performance benchmarks; TRIM support.

Experiencing WSL as a Linux Veteran

jm — 2020-01-20T10:22:54+00:00

Sounds like they've done a great job at integration

libeatmydata

jm — 2019-10-10T15:55:49+00:00

'a small LD_PRELOAD library designed to (transparently) disable fsync (and friends, like open(O_SYNC)). This has two side-effects: making software that writes data safely to disk a lot quicker and making this software no longer crash safe.' Good for tests....

GNOME Foundation facing lawsuit from Rothschild Patent Imaging

jm — 2019-09-26T10:42:50+00:00

Software patents are a cancer. 'The GNOME Foundation has been made aware of a lawsuit from Rothschild Patent Imaging, LLC over patent 9,936,086. Rothschild allege that Shotwell, a free and open source personal photo manager infringes this patent. Neil McGovern, Executive Director for the GNOME Foundation says “We have retained legal counsel and intend to vigorously defend against this baseless suit.”'

Isolating workloads with Systemd slices

jm — 2019-09-26T10:41:48+00:00

Systemd supports docker-like cgroups isolation, it seems, and ScyllaDB can take advantage of that

Open Source Could Be a Casualty of the Trade War

jm — 2019-06-24T10:08:50+00:00

ideologically, a core tenant of open source is non-discriminatory empowerment. When I was introduced to open source in the 90’s, the chief “bad guy” was Microsoft – people wanted to defend against “embrace, extend, extinguish” corporate practices, and by homesteading on the technological frontier with GNU/Linux we were ensuring that our livelihoods, independence, and security would never be beholden to a hostile corporate power. Now, the world has changed. Our open source code may end up being labeled as enabling a “foreign adversary”. I never suspected that I could end up on the “wrong side” of politics by being a staunch advocate of open source, but here I am. My open source mission is to empower people to be technologically independent; to know that technology is not magic, so that nobody will ever be a slave to technology. This is true even if that means resisting my own government. The erosion of freedom starts with restricting access to “foreign adversaries”, and ends with the government arbitrarily picking politically convenient winners and losers to participate in the open source ecosystem. Freedom means freedom, and I will stand to defend it. Now that the US is carpet-bombing Huawei’s supply chain, I fear there is no turning back. The language already written into EO13873 sets the stage to threaten open source as a whole by drawing geopolitical and national security borders over otherwise non-discriminatory development efforts. While I still hold hope that the trade war could de-escalate, the proliferation and stockpiling of powerful anti-trade weapons like EO13873 is worrisome. Now is the time to raise awareness of the threat this poses to the open source world, so that we can prepare and come together to protect the freedoms we cherish the most. I hope, in all earnestness, that open source shall not be a casualty of this trade war.

ITSCO

jm — 2019-04-08T11:22:46+00:00

super-cheap ancient Thinkpads etc., ideal for low cost linux laptop usage

Cloud Shell - Google Cloud Platform

jm — 2019-03-25T21:42:53+00:00

I had no idea about this -- every google user has instant in-browser shell access to a Linux VM with 1.7GB of RAM

What causes Ruby memory bloat? – Joyful Bikeshedding

jm — 2019-03-25T11:53:22+00:00

Another likely suspect is the memory allocator. After all, Nate Berkopec and Heroku remarked that fiddling with the memory allocator (either replacing it altogether with jemalloc, or setting the magical environment variable MALLOC_ARENA_MAX=2) drastically lowers [Ruby] memory usage.

The JVM in Docker 2018

jm — 2018-11-19T11:57:33+00:00

Later JDK versions have made it far easier to run a JVM application in a Linux container. The memory support means that if you relied on JVM ergonomics before than you can do the same inside a container where as previously you had to override all memory related settings. The CPU support for containers needs to be carefully evaluated for your application and environment. If you’ve previously set low cpu_shares in environments like Kubernetes to increase utilisation while relying on using up unused cycles then you might get a shock.

wifiscan.py

jm — 2018-11-07T21:46:52+00:00

A neat kragen hack:

Report wireless signal strength using audio synthesis. This quick kludge is useful for figuring out where the dead spots in your wireless network coverage are. They’re where the pitch goes high and maybe you start getting clicks from audio buffer underruns. Example audio output can be found at . This is based on a brilliant hack by Seth Schoen, in which he generated a tone controlled by the signal strength indication from his wireless card in order to get a sort of 21st-century software Theremin. This adds some envelope modulation so that it’s useful as a network diagnostic tool rather than a musical instrument. It depends on PulseAudio and the interface to the usual set of Linux commands: pacat, ping, and iwconfig. (I should really just read /proc/net/wireless instead of depending on iwconfig.)

Nginx tuning tips: TLS/SSL HTTPS – Improved TTFB/latency

jm — 2018-07-05T09:45:02+00:00

Must do these soon on jmason.org / taint.org et al.

Debugging Stuck Ruby Processes — What to do Before You Kill -9

jm — 2018-04-23T10:30:12+00:00

good tips on using gdb to gather backtraces (via Louise)

Uses This / Leonard Lin

jm — 2018-04-11T09:28:18+00:00

lhl describes the stuff he uses, day to day. Lots of travel gear, drones, Linux and a surprising lack of Macs

Another reason why your Docker containers may be slow

jm — 2018-04-06T11:33:20+00:00

TL;DR: fadvise() is a bottleneck on Linux machines running many containers

Hardening Docker containers and hosts against vulnerabilities: a security toolkit | StackRox: Security built in

jm — 2018-01-18T17:02:02+00:00

Another docker security checklist

Securing Docker Containers on AWS | nearForm

jm — 2018-01-18T17:00:33+00:00

'On most projects at nearForm we are deploying our solutions within Docker containers. There are tasks that are repeated on each project to secure and harden off those deployments and we built this packer template to produce a quick and easy way for you to spin up an AWS AMI that passes the Docker-Bench-Security script. The Docker-Bench-Security repo is a work product of the above mentioned consolidation efforts by the Docker team.'

How To Measure the Working Set Size on Linux

jm — 2018-01-17T23:18:14+00:00

A nifty metric:

The Working Set Size (WSS) is how much memory an application needs to keep working. Your app may have populated 100 Gbytes of main memory, but only uses 50 Mbytes each second to do its job. That's the working set size. It is used for capacity planning and scalability analysis. You may never have seen WSS measured by any tool (I haven't either). OSes usually show you virtual memory and resident memory, shown as the "VIRT" and "RES" columns in top. Resident memory is real memory: main memory that has been allocated and page mapped. But we don't know how much of that is in heavy use, which is what WSS tells us. In this post I'll introduce some new things I've developed for WSS estimation: two Linux tools, and WSS profile charts. The tools use either the referenced or the idle page flags to measure a page-based WSS, and were developed out of necessity for another performance problem.

(via Amy Tobey)

The mysterious case of the Linux Page Table Isolation patches | Hacker News

jm — 2018-01-03T12:55:01+00:00

good HN comments on the horrible security bug du jour -- Intel CPUs potentially allowing privileged data leaks cross-VM and cross-process

How to configure Backblaze B2 with Duplicity on Linux

jm — 2017-11-27T12:26:23+00:00

sorry S3, Backblaze is cheaper nowadays!

Cronic

jm — 2017-10-23T09:56:13+00:00

'A cure for Cron's chronic email problem'

poor man's profiler

jm — 2017-10-06T16:23:56+00:00

'Sampling tools like oprofile or dtrace's profile provider don't really provide methods to see what [multithreaded] programs are blocking on - only where they spend CPU time. Though there exist advanced techniques (such as systemtap and dtrace call level probes), it is overkill to build upon that. Poor man doesn't have time. Poor man needs food.' Basically periodically grabbing stack traces from running processes using gdb.

Share scripts that have dependencies with Nix

jm — 2017-10-02T14:07:17+00:00

Nice approach to one-liner packaging invocations using nix-shell

Linux Load Averages: Solving the Mystery

jm — 2017-08-21T13:17:17+00:00

Nice bit of OS archaeology by Brendan Gregg.

In 1993, a Linux engineer found a nonintuitive case with load averages, and with a three-line patch changed them forever from "CPU load averages" to what one might call "system load averages." His change included tasks in the uninterruptible state, so that load averages reflected demand for disk resources and not just CPUs. These system load averages count the number of threads working and waiting to work, and are summarized as a triplet of exponentially-damped moving sum averages that use 1, 5, and 15 minutes as constants in an equation. This triplet of numbers lets you see if load is increasing or decreasing, and their greatest value may be for relative comparisons with themselves.

awslabs/aws-ec2rescue-linux

jm — 2017-07-21T09:54:23+00:00

Amazon Web Services Elastic Compute Cloud (EC2) Rescue for Linux is a python-based tool that allows for the automatic diagnosis of common problems found on EC2 Linux instances.

Most of the modules appear to be log-greppers looking for common kernel issues.