Chip Huyen:

While looking for these MLOps tools, I discovered some interesting points about the MLOps landscape:

1. Increasing focus on deployment
2. The Bay Area is still the epicenter of machine learning, but not the only hub
3. MLOps infrastructures in the US and China are diverging
4. More interests in machine learning production from academia

If MLOps is new to you, Practical AI did a deep dive on the topic that will help you sort it out. Or if you’d prefer a shallow dive… just watch this.

tmpsms is a command line utility written in POSIX sh that allows you to get a temporary phone number and receive SMSes. It uses Upmasked temporary SMS service in order to receive the messages. This is a very useful tool for those who use are testing applications during bug bounty hunting or just need some privacy and don’t wan’t to use your personal phone number.

I don’t know when I’d ever use this, but I love that it’s POSIX compliant and depends on just a few other CLI tools (curl, jq, and fzf).

Just drop your icon onto the page, select which versions you want (iOS, Android, macOS, etc.), and click the “Generate” button. Nifty!

Matthew Monahan:

dug is designed to help you check the global status of your DNS records. You can use the built in servers, update them from remote or local sources, specify servers, whatever. It also supports templated output in CSV or JSON for use in monitoring applications or just piping the results around.

Curious if and how your site would benefit from switching to modern JS syntax? Plug the URL into this tool and find out. Here’s what the output looks like when we point it changelog.com 👇

Benchmarking is often not done in CI because it’s so hard to get consistent results; there’s a lot of noise in cloud VMs, so you ideally want dedicated hardware. But, it turns out you can use a tool called Cachegrind to get consistent benchmarks results across different computers, allowing you to run benchmarks in GitHub Actions, GitLab CI, etc. and still get consistent results.

sops is an editor of encrypted files that supports YAML, JSON, ENV, INI and BINARY formats and encrypts with AWS KMS, GCP KMS, Azure Key Vault and PGP.

As Spotify buys up more & more podcasts to make them exclusive and closed, developers fight to keep them inclusive and open. ✊

You can use these RSS feeds in any podcast app. Just take the show ID from the end of the Show Link on Spotify and put it at the end of https://spotifeed.timdorr.com/

Who among us doesn’t fit into one of those 3 categories?

Lighthouse has been part of my daily work for the last few months and it is time to share how I am using the tool in a product used by millions of people and what I have discovered during this process.

In this post, I cover what is my tooling and how I am approaching the audit opportunities.

In which I detail A SQL query that helps you identify files in a codebase that have “churned” in the past year. In other words, list the files that have been changed by the most number of commits in the last year.

SELECT file,
       COUNT(*)
FROM   stats
       JOIN commits
         ON stats.commit_id = commits.id
WHERE  commits.author_when > DATE('now', '-12 month')
       AND commits.parent_count < 2 -- ignore merge commits
GROUP  BY file
ORDER  BY COUNT(*) DESC
LIMIT  50

k6 is a modern load testing tool, building on Load Impact’s years of experience in the load and performance testing industry. It provides a clean, approachable scripting API, local and cloud execution, and flexible configuration.

Okay this is pretty stinkin’ clever.

• GitHub Actions is used as an uptime monitor
  • Every 5 minutes, a workflow visits your website to make sure it’s up
  • Response time is recorded every 6 hours and committed to git
  • Graphs of response time are generated every day
• GitHub Issues are used for incident reports
  • An issue is opened if an endpoint is down
  • People from your team are assigned to the issue
  • Incidents reports are posted as issue comments
  • Issues are locked so non-members cannot comment on them
  • Issues are closed automatically when your site comes back up
  • Slack notifications are sent on updates
• GitHub Pages are used for the status website
  • A simple, beautiful, and accessible PWA is generated
  • Built with Svelte and Sapper
  • Fetches data from this repository using the GitHub API

Screenity is a Chrome extension that will help you level up your screen recording/sharing game. How does it compare with other offerings in this category? Here’s a google sheet with the feature breakdown.

Used to be written in Python, but is now 100% Rust.

If you’re on a mission to de-Google-ify your web analytics and you enjoy self-hosting what you can, then you might be reaching for Plausible Analytics because you can self-host it. But how?

This post from Guillermo Garron shares his process using Docker and Docker Compose.

It was designed to help remind *nix system administrators of options for commands that they use frequently, but not frequently enough to remember.

Let’s imagine a completely hypothetical world where it’s the umpteenth time you’ve used it, but you still can’t remember which flags to send to tar… so you run:

cheat tar

You’ll be greeted by:

# To extract an uncompressed archive:
tar -xvf '/path/to/foo.tar'

# To extract a .gz archive:
tar -xzvf '/path/to/foo.tgz'

# To create a .gz archive:
tar -czvf '/path/to/foo.tgz' '/path/to/foo/'

# To extract a .bz2 archive:
tar -xjvf '/path/to/foo.tgz'

# To create a .bz2 archive:
tar -cjvf '/path/to/foo.tgz' '/path/to/foo/'

The cheatsheets themselves are community-sourced.

ffmpeg is an incredibly powerful tool, but its many flags and options make it not the easiest thing to wield (especially if you use it just infrequently enough to forget the magic syntax you ginned up last time).

vdx makes ffmpeg more approachable for many of the common video processing operations you may need on a regular basis. Examples!

$ vdx '*.mov' --crop=360,640    # Crop to width 360, height 640
$ vdx '*.mov' --format=gif      # Convert to GIF
$ vdx '*.mov' --fps=12          # Change the frame rate to 12
$ vdx '*.mov' --no-audio        # Strip audio
$ vdx '*.mov' --resize=360,-1   # Resize to width 360, maintaining aspect ratio
$ vdx '*.mov' --reverse         # Reverse
$ vdx '*.mov' --rotate=90       # Rotate 90 degrees clockwise
$ vdx '*.mov' --speed=2         # Double the speed
$ vdx '*.mov' --trim=0:05,0:10  # Trim from time 0:05 to 0:10
$ vdx '*.mov' --volume=0.5      # Halve the volume

Ruurtjan Pul writes:

It’s been my side project for the past half year. In contrast to existing alternatives, my aim is for it to be simple, powerful, user-friendly. I’ll be adding more features the coming time, but it should be useful as is already.

I ran a few test lookups to kick the tires and the site is fast, simple, and displays the information in an easily digestible format. Worth a bookmark!

Romain Barissat:

I made this to be able to open-source parts of our monorepo while keeping the rest private.

The result is a tool that allows you to have one monorepo that is the source of truth for as many other repos as you want. It could also be used to create “workspace” repos if you onboard a freelance and you don’t want to give him access to your whole mono-repo.

We are using nx as a monorepo tool, here is an example of it using the Copybara Action

Based on Google’s Copybara project.

Taco de Wolff:

This is about the fastest minifier for web formats and is written in Go. For example, it can minify JS files at about 25MB/s, which is orders of magnitude faster than existing solutions that are typically 100-300 kB/s. There is also a command line tool that can be incorporated in your setup easily.

Listeners of The Changelog have already heard Plausible’s story. On that show we talked about self-hosting and how that was something the team was interested in, but hadn’t gotten around to it yet.

Well, now they’ve gotten around to it.

We started developing Plausible early last year, launched our SaaS business and you can now self-host Plausible on your server too! The project is battle-tested running on more than 5,000 sites and we’ve counted 180 million page views in the last three months.

This web server for static assets is “blazing fast” and executable with a single binary, but what excites me about it is the simplistic, singular config file: binserve.json

{
  "directory_listing": false,
  "enable_logging": true,
  "error_pages": {
    "404": "404.html"
  },
  "follow_symlinks": false,
  "routes": {
    "/": "index.html",
    "/example": "example.html"
  },
  "server": {
    "host": "127.0.0.1",
    "port": 1337
  },
  "static_directory": "static",
  "template_variables": {
    "load_static": "/static/",
    "name": "Binserve"
  }
}

This is like having a nice, OS-integrated GUI for all of your common scripts and tasks. It has a bunch of functions built in and scripting support is coming soon so you can add your own as well. $9 cheap or if you’re really cheap you can build it yourself from source. 😉

duf does for du what htop did for top.

In addition to the eye candy output you see below, you can also call it with the --json flag and pass the output to other programmer-y things.