aesthetikx.info

What is Date::ITALY?

Mon, 20 Apr 2026 00:00:00 +0000

The other day I was perusing a Ruby backtrace and paused as something caught my eye: Date::ITALY. What could that be?

irb(main):001> Date::ITALY
=> 2299161

Allrighty, not exactly self-explanatory. Upon visiting the documentation for class Date, I was greeted by a few other unusual sounding constants, including ENGLAND, GREGORIAN, and JULIAN. What do the docs have to say about these?

ENGLAND
The Julian day number of the day of calendar reform for England and her colonies.

GREGORIAN
The Julian day number of the day of calendar reform for the proleptic Gregorian calendar.

ITALY
The Julian day number of the day of calendar reform for Italy and some catholic countries.

JULIAN
The Julian day number of the day of calendar reform for the proleptic Julian calendar.

First of all, I think it is humorous that the Ruby source code mentions England and her colonies as well as some catholic countries. Second, I learned the term proleptic, which refers to extrapolating calendar dates outside the time of their adoption or use. But OK, the question on everyone’s mind – what is a Julian day number? Well, not so fast, because first we have to cover the catholicism part.

The Gregorian Switchover

The Julian calendar, established by the eponymous Caesar, had been cooking along fairly accurately for quite some time. But, it wasn’t perfect, losing a day about every 128 years. By the time of Pope Gregory XIII in the 1580s, the date of Easter had unacceptably moved about two weeks towards the Summer. In 1582, the Papal bull Inter gravissimas declared that the day following Thursday, 4 October 1582 would be Friday, 15 October 1582. Indeed, Ruby conforms, raising an exception if you attempt to instantiate a date within that ten day period:

irb(main):001> Date.new(1582, 10, 5)
(irb):1:in 'Date#initialize': invalid date (Date::Error)

and helpfully hops right over them when iterating, like it never happened:

irb(main):001> Date.new(1582, 10, 4).next_day
=> #<Date: 1582-10-15 ((2299161j,0s,0n), +0s,2299161j)>

Wait a moment, where have we seen that number before? Yes, Date::ITALY encodes the Julian day on which Italy switched from the Julian calendar to the Gregorian calendar – Julian day 2,299,161. If you were ever wondering what those weird numbers were in Date#inspect, those are Julian Day numbers.

Julian Days

Like all good stories, this one starts over six thousand years ago. On a very special Monday, New Year’s day in 4713 BC, at exactly noon UTC, the three most important multi-year cycles of humankind were perfectly synchronized: the 28 year solar cycle, the 19 year lunar cycle, and of course the 15 year Roman tax collection cycle, commonly referred to as the indiction cycle. Indeed, the Julian day cycle is a period of 28 x 19 x 15 = 7980 years, which will roll over once again in the year 3268 AD.

Why do we need this? As we saw earlier, there are some ‘gaps’ in the accounting of days in human history. To add to the confusion, not all countries adopted the Gregorian calendar at the same time – England for example, waited until 1752, as the Protestants were hesitant to adopt Catholic innovation (hence, Date::ENGLAND). Therefore, a sort of ‘universal intermediary’ was required to compute back and forth unambiguously between various calendar systems. Thus a simple count of days from a somewhat arbitrary epoch was created. Literally 1 year after the introduction of the Gregorian calendar, scholar Joseph Scaliger proposed the Julian Period method. Unbelievably confusingly, this Period was not named for the Julian calendar, or Julius Caesar that it was named after – it was named after his father Julius Caesar Scaliger, who was himself named after Julius Caesar. This is not unlike the Caesar salad, famously named after Caesar Cardini (famously named after Julius Caesar (whose name is famously actually Gaius.))

Ok, back to Ruby. We now know that Date::ITALY and Date::ENGLAND define the Julian day number that Italy and England respectively adopted the Gregorian calendar. That leaves Date::GREGORIAN and Date::JULIAN. I bet you’ll never guess:

irb(main):001> Date::GREGORIAN
=> -Infinity
irb(main):002> Date::JULIAN
=> Infinity

Alrighty, not exactly self-explanatory. To make sense of this, we will have to understand the Date initializer:

new(year = -4712, month = 1, mday = 1, start = Date::ITALY)

Two things here: first, the default date is equivalent to Date.jd(0). If you have ever wondered why Date.new.to_s gives "-4712-01-01", now you know. Second, the optional start argument is the ‘start of the Gregorian calendar’, expressed in Julian Days.

If you were working on a SaaS product in England in the 1700s, you would express Sir Isaac Newton’s DOB as Date.new(1642, 12, 25, Date::ENGLAND) rather than Date.new(1643, 1, 4). This also means that Date.new(1582, 10, 5, Date::ENGLAND) does not raise an exception like it does for Date::ITALY. In English parlance, Isaac’s birthday expressed as 1642/12/25 would be called the ‘old style’, and 1643/1/4 the ‘new style’ date. This is why Ruby’s date_core.c often mentions os and ns.

If you always want to use the Julian calendar, you could kick the ‘Gregorian switchover’ can infinitely down the road. This is why Date::JULIAN is Float::INFINITY. Passing Date::GREGORIAN (-Float::INFINITY) implies that the switchover happened ‘infinitely long ago’, or in other words, ‘we have always been using the Gregorian calendar’.

Because these values are assumed to be Julian Days, you can also provide your own arbitrary values. For example, if you wanted to model dates in Russia, where the Gregorian calendar was adopted on 14 February, 1918, you would:

irb(main):001> Date.new(1918, 1, 31, 2421639).next_day
=> #<Date: 1918-02-14 ((2421639j,0s,0n),+0s,2421639j)>

God help us if we ever switch to a new calendar system, because a single start argument won’t cut it anymore!

Closing Thoughts

If you are wondering if Isaac Newton actually was born on Christmas or rather January 4th, well, that is exactly the issue that Gregory XIII was out to solve!

Because the Julian Period is a synchronization of three other cycles, it is referred to as a tricyclic system.

The indiction cycle may have been chosen as a third cycle because historical records often were linked not to a date but rather an indiction number.

Contrary to what I said above, it is contested as to whether the Julian Period was originally referring to the Julian calendar or rather named after Joseph’s father.

Conceptually, you can think of a Date as a (julian date, gregorian switchover) tuple, combined with methods that compute answers based on those two values. In the inspect format of a date, for example #<Date: 1582-10-15 ((2299161j,0s,0n), +0s,2299161j)>, you are seeing the date expressed as a Julian day number, plus the seconds and nanoseconds of a time component, then a time zone offset, and finally the provided Julian day of the Gregorian switchover. A DateTime will use the 0s, 0ns portion for the time component.

Left as an exercise for the reader, there are a few fun methods in class Date as well:

#gregorian_leap?
#julian_leap?
#jisx0301
#rfc2822
#rfc3339

Safely Adding Columns to Rails Applications

Fri, 27 Feb 2026 00:00:00 +0000

ActiveRecord has two behaviors by default that, when combined, can make it challenging to safely add a column to an existing table in high traffic applications.

First, it leverages a prepared statement cache. This allows the database to reuse queries of the same shape where only variables change, so that the query planner doesn’t have to re-evaluate a SQL statement each time, if only the value 3 changes in a query like:

SELECT users.* FROM users WHERE id = 3

When you see something in your logs that looks like

SELECT users.* FROM users WHERE id = $1 [["id", 3]]

this is Rails using prepared statements.

Second, by default, all columns from a table are selected (SELECT users.*), which makes SQL logs smaller (possibly a lot smaller for tables with lots of columns) and is sort of the de facto presumption that your ActiveRecord model always needs all columns on the underlying table.

With these defaults, if you run a migration that adds a column to an existing table, you may see a sudden blip of PreparedStatementCacheExpired exceptions. This is because your running application has existing database connections leveraging the prepared statement cache, and because we added a column, the arity or shape of SELECT table.* has changed, which is unexpected. Rails handles these exceptions to some extent by updating the statement cache, so you may only see one exception per thread or worker (per connection), however, this can still result in some user-facing 500s or retried background jobs, which is not ideal.

Working Around This Issue

The easiest way to do this historically has been to add an entry to the ignored_columns array on your model. For example:

class User < ActiveRecord::Base
  self.ignored_columns += ['a_new_setting']

  # ...
end

If you deploy this version of your application, Rails will no longer select all columns from your table, but rather select each individual column (with the exception of the ignored ones). So, your SQL statement may instead look like SELECT users.id, users.email, users.first_name, users.last_name anywhere you are using the User model. Once you have confirmed this version of your application is running in production, you can safely run your migration to add your column, because the prepared statement cache will not be broken by the addition of the new column. After the migration completes, you can deploy another version of your application with the ignored_columns removed.

Another Option

While the above works fine, it can be cumbersome to have a pair of deployments every time you want to add a column with zero downtime (one to add the ignored column entry, and a second to run the migration and remove the ignored column entry). For tables that have frequent additions (perhaps a settings or configuration table), we can instead leverage the relatively recent enumerate_columns_in_select_statements option. While this can be configured globally, I think it is sufficient to use it sparingly. For example:

class Settings < ActiveRecord::Base
  self.enumerate_columns_in_select_statements = true

  # ...
end

See the documentation for more details, or this pull request for the original discussion.

The Cat's Pajamas

Mon, 12 Jan 2026 00:00:00 +0000

A review of The Cat’s Pajamas by Ray Bradbury

One down, many to go! This is the first book I finished this year, and because of the format it was a pretty easy read.

The back of the book says there are twenty-two stories, but by my count there were only twenty? Overall, it was a pretty mixed bag. Originally most of these stories hadn’t previously been published, and I can kind of see why – unlike e.g. the Martian Chronicles, the stories don’t fit a cohesive theme, and some of them, while interesting, seem to have been written just to test a small idea.

One thing that I did notice, and I didn’t go back to prove this, but I believe every story has either the word Summer, Autumn, or Winter in it – Bradbury often introduces a story with a description including the time of year, which clearly has a nostalgic element to it. Although sometimes repetitive, this occasionally produces some delightful prose, for example:

He would watch the details of this dying summer, and it would give him much to think of. He would try to understand the summer all the way to the end of it. Autumn rose in a tidal wave, poised over him, ready to drop, suspended.

Another good one:

Or a snowball, thrown by some winter-haunted child, soundless in the night, on his way nowhere….

There wasn’t a lot of Martianchroniclesque Sci-Fi in here, but there was one that I found rather interesting where humans arrive at an alien planet with a very advanced and peaceful alien species. The humans try their best to learn from and fraternize with the species, but despite their best efforts and intentions they are unable to get over the fact that the aliens look like big spiders.

As usual Bradbury also hits on themes of racism and colonization, in unique ways. In one story, a group of drunk senators gamble away the entire United States at a Native American casino. It’s funny, and well written.

Overall, this was not my favorite Bradbury collection, but it was worth the read. In some ways, it makes me want to reread Martian Chronicles, but for now I’m going to move on.

Books to Read in 2026

Tue, 6 Jan 2026 00:00:00 +0000

This year, I am going to make a more organized effort to read books. I already read a lot; however, my unstructured approach has me starting lots of books without finishing them. Pair that with my bias for highly technical or otherwise ‘impossible’ reads, and overall I didn’t do a lot of successful reading last year. I’m starting with a list ahead of time, rather than choosing randomly.

The Cat’s Pajamas by Ray Bradbury

I am already a big fan of Ray Bradbury, having really resonated with The Martian Chronicles back in high school. This one is a collection of 22 stories published in 2004, wherein each individual story was written sometime between the mid 1940s through the early 2000s. I think this will be a good starting place because each story is only 10-15 pages.

Edit: finished this one.

Game Theory - Davis

I don’t know anything about this, other than my surfaise knowledge of game theory from that one movie. I’m not sure if this is a cornerstone work in the area, or just a one-off, but it looked interesting and not overly-long.

The Three Stigmata of Palmer Eldritch - Philip K Dick

Similar to Bradbury, I have been a fan of PKD for a while, because the movie adaptations were the sort of thing I liked to watch with my friends in high school (Bladerunner, a Scanner Darkly, Minority Report, etc.) This particular one I hadn’t heard of before, so I thought it would be a good reintroduction. I considered VALIS, but it is part of a trilogy and seems a bit much for now, given the synopsis.

The Last Blackrobe of Indiana and the Potawatomi Trail of Death - John William McMullen

This one is currently on loan to me from someone that lives near the area covered in the book. It spans French and American history in the 1800s, as well as Catholic and native American culture, so it should be interesting. It seems to be written in a story driven way rather than purely academic, though it is based on real accounts.

The Name of the Rose - Umberto Eco

Really I want to read Foccult’s Pendulum, because that keeps coming up as a reccomendation. However, my goal is to one day read that in the original Italian – perhaps too lofty of a goal. Regardless, I am going to start at the beginning of Ecos’ bibliography, even though I have already seen the film adaptation of this one. The film adaptation is quite enjoyable, so I guess I already know what happens, but I can compare the book to the movie in any case.

Inferno - Dante

This is something that I have already been reading, but I want to continue this year.

The One Year Chronological Bible

I find the bible fascinating for a variety of reasons, but I have never read it in its entirety. This version is arranged chronologically rather than by traditional book order, and is also chunked into 365 days. This is an alluring format for me, because it is already structured for daily progress.

Weird Ruby

Mon, 29 Dec 2025 00:00:00 +0000

Here is an ongoing collection of weird Ruby snippets that I have come across in my travels.

Camping R Helper

Camping uses a bizarre helper method R that acts as a stand-in for a parent class.

class Edit < R '/post/(\d+)/edit'
  def get(post_id)
    require_login!
    @post = Post.find(post_id)
    render :edit
  end

  # ...

See: https://github.com/camping/camping/blob/main/examples/blog.rb#L63

Decoding the implementation of this method left as an exercise for the reader… notably grep(Hash), gsub(CampTools.descape){$1}, and the h.any??.

def R(c,*g)
  p,h=/\(.+?\)/,g.grep(Hash)
  g-=h
  raise "bad route" if !u = c.urls.find{|x|
    break x if x.scan(p).size == g.size &&
      /^#{x}\/?$/ =~ (x=g.inject(x){|x,a|
        x.sub p,U.escape((a.to_param rescue a))}.gsub(CampTools.descape){$1})
  }
  h.any?? u+"?"+U.build_query(h[0]) : u
end

There is also this gem: (https://github.com/camping/camping/commit/6724a04b37902c48c44c568ec5ce53b2f1a28620)

class Object
  def meta_def(m,&b)
    (class<<self;self end).instance_eval{define_method(m,&b)}
  end
end

Later on in the camping/reststop library, we ammend the afforementioned R method with an even fancier REST method, featuring an all caps method name, a module_eval, a meta_def, and an all caps global.

def REST(r, options = {})
  crud = R "#{options[:prefix]}/#{r}/([0-9a-zA-Z]+)/([a-z_]+)(?:\.[a-z]+)?",
    "#{options[:prefix]}/#{r}/([0-9a-zA-Z]+)(?:\.[a-z]+)?",
    "#{options[:prefix]}/#{r}/([a-z_]+)(?:\.[a-z]+)?",
    "#{options[:prefix]}/#{r}(?:\.[a-z]+)?"

  crud.module_eval do
    meta_def(:restful?){true}

    $LOG.debug("Creating RESTful controller for #{r.inspect} using Reststop #{'pull version number here'}") if $LOG

    def get(id_or_custom_action = nil, custom_action =  nil) # :nodoc:
      # ...

WEBrick Method Names

The WEBrick HTTP server toolkit provides a way to implement custom behavior through the use of mounted ‘servlets’, which have funny looking method names (def do_GET).

class Simple < WEBrick::HTTPServlet::AbstractServlet
  def do_GET request, response
    status, content_type, body = do_stuff_with request

    response.status = 200
    response['Content-Type'] = 'text/plain'
    response.body = 'Hello, World!'
  end
end

See: https://github.com/ruby/webrick/blob/master/lib/webrick.rb

WEBrick Option Symbols

It’s not that unusual to see capital letters in symbols, but this line from the documentation alwasy strikes me as odd. Perhaps its just because of the hashrocket syntax…

server = WEBrick::HTTPServer.new :Port => 8000, :DocumentRoot => root

Syntropy Example

syntropy is a web framework for building multi-page and single-page apps. I’m no what this example does, but its cool looking:

export template {
  div {
    markdown <<~MD
      ```ruby
      @buffer << #{foo}
      ```
    MD
  }
}.tap { puts '!' * 40; puts Papercraft.compiled_code(it.proc); puts}

See: https://github.com/digital-fabric/syntropy/blob/main/examples/bad.rb