sui generis (Lyjia's blog)

Best Practices For Transferring Vinyl Records to Digital Files

Thu, 02 Apr 2026 23:54:24 +0000

Old Faithful...

If you, like me, have a sizable vinyl record collection, then at some point you may want to make digital copies of them ("vinyl rips") so you can play them out or enjoy them on your phone or computer. I've done this a fair amount of times -- probably about a hundred records -- and let me tell you: there is a lot that can go wrong and affect the quality of your transfers!

A friend of mine recently asked for some tips on vinyl ripping his own collection, so the following started as a comment on his Facebook post. However, after posting, I realized that some of this knowledge may not be very widely known, so I thought I would polish it up and make a blog post of it!

This is not a step-by-step guide for beginners; I am assuming you already have your turntable, software, and audio setup worked out. (I am also kind of assuming you are an electronic music DJ, but this advice should work for anyone.) So if you want your hand held, look elsewhere! This post is more about the little things you want to think about before you hit Record:

Check your pitch calibration using the dots on the side of the platter and the red light. You want to make sure that the '0' on the pitch control corresponds with exactly 33 or 45 RPM. This is especially important for accurate BPM readings, beatgridding, and beatmatching. If you don't know how to do this, here is a good guide.
It helps to have two turntables: one for recording (deck 1), and one for prepping the next disc you want to record (deck 2).
Do a quick cleaning on the disc right before you record to reduce dust. A wet cleaning would be best; I usually do this on deck 2 while deck 1 records. You can put a fan on it so it dries fast. This way all you will have to do on the disc you are recording is a quick dusting or dry clean, mainly to catch dust from the slipmat (if you use those) or the rubber mat.
Use a fresh needle; worn needles will impact sound quality!
Use a good preamp. it will make a huge difference! The preamps on my Pioneer XDJ controller are complete ass. Preamps are usually kind of expensive, but I've had good luck with some of the cheap Chinese units you can get off Amazon. (Fosi Audio makes a pretty good hybrid tube/solid state preamp that isn't too expensive.)
If you're using a digital recorder, it can be annoying to match up generically-named audio files to their original disc. So, on a notepad, or in your phone's notes, write down the file name on the recorder next to the record name or Discogs ID. Then, it will be easy to match which file goes to each disc, and then you can add other metadata later. (And be sure to hit the 'track cut' button, or hit stop and then record again!)
For electronic music: even with the Technics direct drive, even if you calibrate it with the red light and the dots, there is very slight pitch wobble and BPM won't usually be a perfect round number. I believe this is a symptom of analog being analog both on your turntable and on the record cutter that produced the original mother that your disc is stamped from. This makes accurate BPM readings and setting up beatgrids on DJ software a much bigger pain in the ass than you might be used to with digital files. Be careful playing these out with SYNC enabled!
If possible, you should record in 32-bit float format. This way it is practically impossible to clip the recording! Then you can set audio levels in post and bounce the final cut to 16-bit. 32-bit float has such a wide dynamic range that clipping is never going to happen. (That said, I don't think this benefits sound quality very much if at all; but there are those who would argue that you should record in at least 24-bit. My suspicion is that this is an audiophile's old wives' tale. My own research indicates that vinyl's dynamic range is equivalent to something closer to 12-bit digital audio.)
Recording in anything above 44.1khz is probably overkill -- but if you want a higher sample rate do an integer multiple like 88.2khz. This way, you can minimize the chances of downsampling adding weird quantization artifacts. Again, there are those who would argue you should record in the highest sample rate you can, but in my opinion this more audiophile cargo-culting. (The exception here is if you plan on doing weird stuff to the resulting audio file, like pitching it down, sampling, or running it through an FX chain. In those cases a higher sample rate would be better.)
Set your needle weight to something a little higher than usual, so that you can minimize skips.
Make sure the needle is as close to perpendicular to the disc as possible; a slanted needle will produce stereo audio levels that are slightly higher in one channel than the other. If possible you will want to verify this with level meters before getting started.

And one bonus tip: handle your needles and the tonearm very carefully! Don't be like me and drunkenly clip the cartridge with your arm, sending the needle skidding across the record like a crashed motorcycle. The tonearm+cartridge+needle assembly is very delicately balanced and shocks like that can throw something out-of-whack!

Finally, I don't have any recommendations for needles or cartridges, other than the venerable Shure M44g, if you can get your hands on one. I'm still pissed that Shure stopped making them. When I run out of spares I will be a very sad panda. (Though I have heard good things about JICO's clones.)

Run Alembic Migrations Outside of a Transaction Block

Thu, 12 Jun 2025 19:55:10 +0000

Sitting around the campfire

I recently ran into the following error when adding some indices to a PostgreSQL database from within an Alembic migration:

CREATE INDEX CONCURRENTLY cannot run inside a transaction block

Which makes sense, particularly if you're creating the table with the index in the same migration (transaction block) -- how can `CREATE INDEX` know anything about a table that doesn't exist yet?

There are a variety of SQL schema transforms (a.k.a. DDL statements) that work this way. Alembic migrations are always run inside a transaction, and breaking out a given statement is not immediately obvious. Luckily, Alembic provides a way for us to end the transaction early and execute statements on their own ("autocommit"):

def upgrade():
    with op.get_context().autocommit_block():
        op.execute("ALTER TYPE mood ADD VALUE 'soso'")

It's important to note that any statements before the autocommit block will be committed! So it is probably best to do this last, at the end of your migration, in order to keep things simple.

And while this blog post speaks of PostgreSQL, this should apply to any database that SQLAlchemy supports!

More info: Alembic Documentation
H/T Stack Overflow

It's Technological / The Dream Now Available on Streaming!

Fri, 20 Dec 2024 17:44:07 +0000

It's Technological / The Dream

Selected tracks from my debut album, Listen E.P., are now available for your enjoyment on streaming platforms worldwide! It's Technological / The Dream can be found on Spotify, Apple Music, and many others! Give em a listen today!

How to Set an Empty Dictionary/Hash as Default Value for a PostgreSQL HSTORE Column

Tue, 30 Jul 2024 17:51:59 +0000

Do you have an HSTORE column on your PostgreSQL database that you don't want to be `null` but need to have a default value? The syntax for this is a little irregular; so I'm posting it here for my own reference and yours:

my_column HSTORE DEFAULT '' NOT NULL

is the line in your `CREATE TABLE`command that you want.

In Ruby on Rails, using an ActiveRecord migration, you would use:

t.hstore :my_column, default: {}

In Python, using an Alembic migration, you would use:

sa.Column('my_column', HSTORE(), nullable=False, server_default=sa.text("''")),

Additionally, if you want your SQLAlchemy model object to initialize this column with said empty dictionary (instead of `None`), per this StackOverflow post you need take a couple of extra steps in your model:

from sqlalchemy.dialects.postgresql import HSTORE
from sqlalchemy.ext.mutable import MutableDict

class Item(db.Model):
    my_column = db.Column(MutableDict.as_mutable(HSTORE), nullable=False, default={}, server_default='')

    def __init__(self, **kwargs):
        kwargs.setdefault('my_column', {})
        super(Item, self).__init__(**kwargs)

The More You Know!

Lyjia's Directory of Free, Open Collections of Historically Significant Art

Thu, 27 Jun 2024 17:49:31 +0000

Girl with a Pearl Earring by Johannes Vermeer (Mauritshuis)

Every so often I find myself looking for art for some reason or another -- maybe a blog post, or referencing something I saw in a museum, or maybe just for plain enjoyment -- and oftentimes it can be found in an open image collection! I've kept a small working list of these places in my head over the years, and I realized it might be useful to write them down and figure out what else is out there. As it turns out, there is a lot!

This is a collection of high-resolution, open-access, free-download, free-to-use image libraries, focusing on the visual arts like painting or photography. There are other styles of art (like sculptures, audio, or archaeological artifacts) in some of these links but that is not the focus. Most of these links are free to use in any application -- commercial or non-commercial -- but not all. Please check the license before using anything you find here commercially. The images in these links should be a mixture of public domain and Creative Commons-licensed content.

This list was last updated in July 2024.

Libraries

New York Public Library Public Domain Collections

The British Library (on Flickr)

Library of Congress Free to Use

Space

NASA Image and Video Library

WEBB Image Library

Museums

National Gallery of Art Open Access

The Getty Collection (Los Angeles)

The Metropolitan Museum of Art Open Collection (New York)

Smithsonian Open Access (Washington D.C.)

Cleveland Museum of Art Open Access

Belvedere Open Content (Vienna)

Kunstmuseum Basel Collection Online

Los Angeles County Museum of Art

Mauritshuis (The Hague)

Minneapolis Museum of Art Open Access

Museum of New Zealand Collections Online

Nationalmuseum Stockholm (via Wikimedia Commons)

Paris Musées Collections

Rijksmuseum Image Requests (Amsterdam)

Lenbachhaus Collection Online (Munich)

Statens Museum for Kunst (Copenhagen)

Wellcome Collection (London)

Tokyo National Museum Collection

Taipei National Palace Museum Open Data

MoMa UK Public Domain Images for Artists

Universities

Art Institute Chicago Open Access

University of Heidelberg Digital Library

Harvard Art Museums Open Access

Yale University Art Gallery Open Access

Single-Artist Collections

Munch Museum Norway (Edvard Munch)

Aggregators

Europeana

Other Lists

Open Access Image Libraries - A Handy List (Apollo Magazine)

Visual Arts: Open Access Art & Architecture Image Resources (UCSD)

Fix Broken Beatport MP3 Downloads in Serato

Tue, 20 Feb 2024 00:39:54 +0000

It kinda be like that...

If you're experiencing a problem with Serato DJ, where MP3s purchased on Beatport cannot seem to save key, BPM, or track analyses and overviews, then perhaps a tool that I have written might help!

Check out MP3TagRebuilder, a simple Python script I wrote to address this issue with my own DJ library!

This tool addresses an issue I've been encountering somewhat frequently over the last few years, where my Beatport music purchases have a weird glitch in Serato where overviews and tag data won't save, even after using the "Analyze" feature. The only solution I have found, even after writing Serato support, is to rebuild the MP3 files' ID3 tags destructively.

However, every program that I know of that does this ends up dropping important tags, such as Album Art, because none of them provide a direct pathway to simply destroying the ID3 tags and then rebuilding them with a new datastructure; most of them only seem to support converting from ID3v2 to ID3v1 and back again. So I wrote my own!

If you are encountering this issue and are feeling bold enough to test my code on your own library (MAKE SURE YOU HAVE A BACKUP AND TEST IT!!!!), head on over to Github and check it out!

You will need a working Python environment and must be comfortable with a command prompt. Instructions for running this tool are included in README.md, and instructions for installing Python can be found here.

Get it from Github here: https://github.com/lyjia/mp3-tag-rebuilder

Annoucing my first album release: Listen EP!

Wed, 10 Jan 2024 18:30:00 +0000

I am pleased to announce the release of my first album, a love-letter to DnB and bass music titled Listen EP!

Cover art by K. Kam

Almost half an hour of trippy, psychedelic beats spanning halftime and techstep Drum-n-Bass, and finishing with a soothingly psychedelic downtempo closer! I've commissioned cover art from the fellow San Diego-based artist K. Kam, and had the album mastered by DnB industry veteran and Metalheadz alum Villem!

While this album is available for FREE STREAMING on Soundcloud and YouTube, I would really prefer if you would support me by purchasing a copy (for streaming or download) at Bandcamp! It's only $5 ... for less than the price of a cup of coffee you'll get unlimited access to stream and download the album and use it in your own DJ sets!

I've poured my heart and soul -- not to mention two years of my life -- into making this the best-sounding album it can possibly be! And today, you get to hear the fruits of that effort!

Releases on Spotify, Apple Music, Shazam, and many other stores is planned for very soon! So watch this space!

Get out there and show your support by picking up a copy of Listen EP today! It's only five bucks!

Surviving the Slashdot Effect: Caching Web Traffic with Rails and Cloudflare

Tue, 12 Sep 2023 22:40:43 +0000

So you've got a content-oriented website, maybe your own blog or something, and maybe you've (like me) decided to ignore the advice about using static site generators. You build your Rails site, and it is wonderful and beautiful and dynamic, and every page it replies with delights readers with your artisanally-crafted HTML. Maybe you've got some internal caching (Rails has you covered here), maybe it's all roundtrips to the database. But who cares! Your site is up and receiving traffic!

Then, suddenly, a storm hits. Congratulations! You've made it to the top of Reddit/Slashdot/Hacker News! You now have thousands, if not millions, of people beating down your door to read your content. But now your site is down! The link's comment thread is filling up with complaints about being hugged to death, and a few helpful souls are posting the archive.org equivalent of your link and siphoning away your traffic.

How do we fix this?

You could throw more compute resources at it -- think "scaling vertically/horizontally" -- which I'm sure your server/application host would ab$olutely love.

Or, you could install some sort of proxy cache in front of it. The traditional answer here is to use nginx or Varnish as a caching proxy, but if you use a content delivery network (such as Cloudflare) it may be better to use that CDN's caching features instead. (Some might recommend using both your own cache and your CDN's cache, but I wouldn't advise this because troubleshooting cache issues is already difficult enough, and having multiple layers only makes debugging even more confusing. If you do this, you should understand your web application thoroughly.)

Since this site is fronted by Cloudflare, I want to make use of its page cache: it's free and comes with the service!

However, setting this up is not as simple as it may first appear: in a default configuration, Rails doesn't permit caching (the Cache-Control headers it sends don't allow for it), and as a result, nearly every request you receive bypasses the cache and gets passed directly to the app server. This is a screenshot of my Cloudflare dashboard showing the percentage of page requests cached before I applied the fixes I describe here (those peaks top out at ~10%):

Uh.... that's not very good!

Now, you can set up rules in the Cloudflare dashboard to override Rails' requested caching behavior, but this does not solve the underlying root cause: Rails is requesting no caching, because the Cache-Control request header it sets explicitly forbids it:

Cache-Control: NO CACHE!

Setting the Correct Cache-Control Headers with Rails

NOTE: The directions given here apply to Ruby on Rails version 7, though expires_in and fresh_when have existed since at least version 2, and concerns have been available since version 4.

Luckily, Rails makes changing this behavior fairly simple. We don't even need to really dive into how Cache-Control works! (Though here is a good guide if you want to know.) You simply call the expires_in and/or fresh_when functions in your controller, supplying an expiry and ensuring that you set public to true. Like this:

expires_in 1.hour, public: true
# or
fresh_when(@article, public: true)

However, setting this for every route is both tedious and a pretty egregious violation of DRY. Instead, we can set as much as we can once and then propagate it through our application using either class inheritance or composition (via ActiveSupport's concerns) feature. And while inheritance may be slightly easier, composition is a bit more modern and flexible; here we will be taking the latter approach.

To start, we will want to make a new concern and call it "Cacheable". The easiest way to do this is to simply go to the $RAILS_ROOT/app/controllers/concerns folder and create a new file, naming it cacheable.rb. In this file, we want to make one small action (called "set_cache_headers") and call expires_in within it. Here is a very basic and usable example, which also prevents page caching when a user is logged in:

# app/controllers/concerns/cacheable.rb
module Cacheable
  extend ActiveSupport::Concern

  included do
    before_action :set_cache_headers, unless: current_user
  end

  def set_cache_headers
    expires_in 1.hour, public: true
  end

end

Then, for each controller whose content you wish to cache, simply add "include Cacheable" at the top right below the class declaration. Here is an example pulled directly from this site's code, for the controller that powers the "About" feature:

# app/controllers/static_controller.rb
class StaticController < ApplicationController
  include Cacheable
  def about
    @page_title = "About"
  end
end

Once this is done you will see that Cache-Control is indeed being set correctly:

Objective achieved!

But! You are not finished yet! You may notice that while your 'cached' stats are going up, they aren't going up as much as one might think. This is because there is another component to page caching that we have not yet discussed: etags.

Setting the Correct Etag Headers with Rails

This is where things get a bit more tricky: Rails generates another header, called an Etag, that, in theory, is supposed to be unique for each page. (For the more technically inclined, you can think of an Etag as like a SHA256 hash for your page.) But Rails, by default, makes this tag unique per request. Both your browser cache and your CDN cache read this header to determine whether a given request is a cache hit or cache miss, and so we will need to configure Rails' to set it correctly, based on our rendered page content (or other context).

Enter fresh_when, which provides further direction to Rails on how to render the correct etag header. You provide it with an object that describes what the page renders -- generally the model instance for the given page (the Rails docs use @article in their examples) -- and it generates a hash that is used for the Etag header.

Using fresh_when with Dynamic Pages

For dynamic pages backed by a model instance, such as the blog post example described above and in the Rails docs, simply call fresh_when and pass it your model instance plus a value for public, inside the controller route. Like so:

# app/controllers/articles_controller.rb
def show_article
  fresh_when @article, public: !current_user
end

When combined with aforementioned Cacheable, this is sufficient to avoid page-caching in the case of logged-in users, as the expires_in directive is never called when current_user exists, and Rails reverts to its default, zero-expiry "private" cache behavior.

If you aren't using Cacheable, as described above, you will need to consult the documentation as you need to provide additional information.

Using fresh_when with Collections or ActiveRecord Relations

If your first parameter to fresh_when is an ActiveRecord relation (such as what is returned with a .where() call), passing the relation object will cause the entire collection it represents to be loaded into memory. For other kinds of collections, you will again be feeding it the entire array. This is not ideal!

Instead, you will want to pass it a single value representing the freshness of that collection, such as the most recent updated_at value. For ActiveRecord relations, that can be retrieved with something like @relation.maximum(:updated_at).

Using fresh_when with Static Pages

Static pages are a little bit simpler, as all we really need to include in the etag is controller_name and action_name, as well as something to identify the logged-in user.

So, we craft another concern, this time called StaticCacheable, and include this in each controller serving static content. Once again, like Cacheable, this is a controller-level solution; if you need something per-action that is an exercise left up to you.

To make this concern, create a new file called static_cacheable.rb and save it to your $RAILS_ROOT/app/controllers/concerns folder, right next to cacheable.rb. Note that we will include a reference to Cacheable from within StaticCacheable, so that you only need to include StaticCacheable on your static controllers. In the action it defined we simply grab the controller name, action name, and current user status and feed that into fresh_when:

# app/controllers/concerns/static_cacheable.rb
module StaticCacheable
  extend ActiveSupport::Concern

  included do
    include Cacheable
    before_action :set_static_cache_headers, unless: -> { :current_user || Rails.env.development? } #dont do this during development
  end

  def set_static_cache_headers
    # Use Rails built-in asset tracking which automatically includes asset versions
    # The template option ensures ETags update when views change
    fresh_when(
      etag: [controller_name, action_name, current_user&.email],
      template: action_name,
      public: !current_user
    )
  end
end

Finally!

Once your Cache-Control and Etag headers are under control and correctly set, and you have correctly configured your proxy service, your site should be well-equipped to handle large volumes of traffic without falling over. Hurray!

A Quick Note About Cloudflare and Implementing This

It's worth noting that Cloudflare seems to strip the Etag header when Cache-Control renders it useless, as is the case when Cache-Control is set to private. This may seem annoying but it punches out your browser cache, presumably to ease troubleshooting.

You can still see the Etag header if you pull requests directly from your webserver (by its IP address), and it will also be visible during development. Unfortunately, it seems like you will have to rely on unit tests or Cloudflare's provided statistics to verify your cache strategy is working.

How To Set Your Windows Taskbar Application Icon with pyQT/pySide

Mon, 12 Jun 2023 21:30:19 +0000

If you are writing a Windows-only or cross-platform application using pyQT or pySide (version 6, as of this time of writing), you may discover that you need to change your application's icon, as it appears in the taskbar. By default, it is a boring, generic "window" icon, and, naturally, you will want to change it!

But the instructions for doing so aren't very clear. This StackOverflow post gets us started, but the given (and accepted) solutions seem to advise the unnecessary extra step of saving a copy of the icon as a Python variable itself!

There is a simpler way, and it involves just a few lines of code. Inside the __init__() function of your QT window's code, add the following:

from pathlib import Path
from PySide6.QtGui import QPixmap, QIcon #substitute the equivalent pyQT line if you're using pyQT

# load window icon
path_to_icon = 'res/icon.png' #the path to your icon file, relative to the project root
pixmap = QPixmap()
pixmap.loadFromData( Path( path_to_icon ).read_bytes() )
appIcon = QIcon(pixmap)
self.setWindowIcon(appIcon)

And voilà! You now have a pretty icon in the taskbar for your program.

Introducing... My Photography as Wallpapers!

Tue, 23 May 2023 21:18:37 +0000

There's a new "Photography" section on this site, and I want to highlight something I've been doing for years that has kind of flown under the radar: for a while, I maintained some galleries on Flickr of my photography formatted for display as wallpapers for your devices. It was cool, but it kind of languished, lost in a sea of public Flickr galleries that few ever saw.

So, I decided to integrate those galleries with this website. Now, with this site and blog in full swing, I can bring a bit more attention to it! Plus, the images have been recut and polished just a wee bit more!

They're available from the Photography dropdown right above this post, or straight from this hyperlink!

These are some of my favorites:

Sunset Cliffs Misty Seas

Oceanside Wave I

Fiery Sunset from Ocean Beack