End blog posts with a byline and shorten their update notes :doc:

Each post now ends with its author and publication date. The update
notes on the imported posts are cut down to what has changed in Ruby or
Facets since each was written; they no longer list the corrections made
to the posts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: trans

docs/_layouts/post.html

@@ -9,5 +9,8 @@
   {%- if page.subtitle %}<p>{{ page.subtitle }}</p>{% endif %}
   {%- endif %}
 </div></section>
-<article class="archive-article shell">{{ content }}</article>
+<article class="archive-article shell">
+{{ content }}
+<footer class="post-byline">{{ page.author | default: site.author }} · Published <time datetime="{{ page.date | date_to_xmlschema }}">{{ page.date | date: "%B %-d, %Y" }}</time></footer>
+</article>
 <div class="archive-back shell"><a class="text-link" href="{{ '/blog/' | relative_url }}">← All posts</a></div>

docs/_posts/2006-07-22-from-singleton-to-legion.md

@@ -3,16 +3,7 @@ title: From Singleton to Legion
 date: 2006-07-22
 ---
 
-> **Update, November 2026:** Ruby 1.9.2 added `Kernel#singleton_class`,
-> which made "singleton class" the official name. Ruby still keeps a single
-> singleton class per object, so on an unpatched Ruby the second `def o.x`
-> below replaces the first, and its `super` raises `NoMethodError`. But
-> Ruby 2.0 added `Module#prepend`, and prepending a module to the singleton
-> class gives much the same layering: after
-> `o.singleton_class.prepend(Module.new { def x; super + "x"; end })`,
-> `o.x` returns `"xx"`. Facets carried both `eigenclass` and `qua_class` as
-> `Kernel` methods. Facets 3.2 deprecated them in favor of `singleton_class`
-> or Facets' `meta_class`, and they will be removed after 2027-09-30.
+> **Update, November 2026:** Ruby 1.9.2 settled the naming question with `singleton_class`, and Facets has since deprecated its `eigenclass` and `qua_class` in its favor. An object still gets only one singleton class, but Ruby 2.0's `prepend` gives much the same layering: prepend a module to the singleton class and call `super` from there.
 
 <!-- ---
 title: From Singleton to Legion

docs/_posts/2006-08-17-main-is-a-dry-pain.md

@@ -3,20 +3,7 @@ title: Main is a DRY Pain
 date: 2006-08-17
 ---
 
-> **Update, November 2026:** Ruby 2.0 gave `main` a `define_method` of its
-> own, which defines a method on `Object`, so the first error below no
-> longer happens, though `main` still has no `ancestors`. Ruby 2.0 also
-> made `main`'s `include`, `public` and `private` private methods, so on
-> Ruby 3.4 the `public_methods` comparison below returns `[]`, and
-> `singleton_methods` returns only `[:to_s, :inspect]`. Ruby 3.0 fixed the
-> Module Inclusion Problem ([#9573](https://bugs.ruby-lang.org/issues/9573)):
-> a module included into `Kernel` now reaches every object, so in the last
-> example both `m` and `Q.new.q` return `"m"`. Methods defined in `main`'s
-> singleton class are still not visible anywhere else, as the `class << self`
-> example shows. I've corrected the method name in that example's error
-> message, which said `s`. I took up the question of `main` as a
-> self-extended module again in
-> [Kill the Proxy and Save Toplevel]({{ site.baseurl }}{% post_url 2012-06-17-kill-the-proxy-and-save-toplevel %}).
+> **Update, November 2026:** Things are better now. Ruby 2.0 gave `main` its own `define_method`, and Ruby 3.0 fixed the module inclusion problem ([#9573](https://bugs.ruby-lang.org/issues/9573)), so a module included into `Kernel` now reaches every object. But `main` still isn't a module. I came back to that idea in [Kill the Proxy and Save Toplevel]({{ site.baseurl }}{% post_url 2012-06-17-kill-the-proxy-and-save-toplevel %}).
 
 <!-- ---
 title: Main is a DRY Pain

docs/_posts/2006-08-18-vote-kernel-for-toplevel-object.md

@@ -3,18 +3,7 @@ title: Vote Kernel for Toplevel Object
 date: 2006-08-18
 ---
 
-> **Update, November 2026:** Ruby 2.0 added the kind of top-level method
-> matz mentions below: `main` now has its own private `define_method`,
-> which defines methods on `Object`. Because `main` finds its own
-> `define_method` first, the example below never calls the hand-written one.
-> It still prints `true` and `false`, though, because `main` is still not
-> `Object`. Taskable didn't last in
-> Facets: by version 1.8 (January 2007), taskable.rb had been dropped
-> because its "implementation won't work as toplevel include". For a while
-> Facets also had main_as_module.rb (later main.rb), which made `main` act
-> more like a module; Facets 2.9.3 spun it off as the main_like_module gem.
-> Ruby's top level is still not a module. I took up the idea again in
-> [Kill the Proxy and Save Toplevel]({{ site.baseurl }}{% post_url 2012-06-17-kill-the-proxy-and-save-toplevel %}).
+> **Update, November 2026:** Ruby 2.0 did add a top-level `define_method`, much as matz suggests below. But `main` is still a stand-in for `Object`, not `Object` itself, so the example still prints `true` and `false`. I came back to the idea in [Kill the Proxy and Save Toplevel]({{ site.baseurl }}{% post_url 2012-06-17-kill-the-proxy-and-save-toplevel %}).
 
 As a follow up to my last post on the "pain that is main", I want to offer a potential improvement for Ruby 2.0. I approached the topic on ruby-talk this week and while Matz initially took some interest, he hasn't followed up since his last comment:
 

docs/_posts/2006-08-21-main-campaign-out-of-object-now.md

@@ -3,18 +3,7 @@ title: 'Main Campaign: Out of Object Now!'
 date: 2006-08-21
 ---
 
-> **Update, November 2026:** The top level still works as matz describes,
-> and `Object` still defines no methods of its own: run as a script on
-> Ruby 3.4, the first example below still returns `[]`. The `Foo.check`
-> example needs a qualification. A top-level method is a private method of
-> `Object`, so a call with an explicit receiver, like `Foo.check("foo")`,
-> goes to `Foo.method_missing`, and the lazy load works. The top-level
-> `check` only gets in the way when it is called without a receiver from
-> inside `Foo`, or through `send`, or in irb before Ruby 2.0, where
-> top-level methods were public
-> ([Bug #5776](https://bugs.ruby-lang.org/issues/5776)). irb now makes them
-> private, as a script does. I took up the idea of Main again in
-> [Kill the Proxy and Save Toplevel]({{ site.baseurl }}{% post_url 2012-06-17-kill-the-proxy-and-save-toplevel %}).
+> **Update, November 2026:** Top-level methods are private, so in a script an explicit call like `Foo.check("foo")` still reaches `method_missing`. Where the clash bites is irb, which made top-level methods public until Ruby 2.0. I came back to the idea of Main in [Kill the Proxy and Save Toplevel]({{ site.baseurl }}{% post_url 2012-06-17-kill-the-proxy-and-save-toplevel %}).
 
 The word from Matz on Kernel as toplevel object:
 

docs/_posts/2006-08-26-the-persnickety-order-of-self-serving-modules.md

@@ -3,13 +3,7 @@ title: The Persnickety Order of Self-Serving Modules
 date: 2006-08-26
 ---
 
-> **Update, November 2026:** Ruby 3.0 fixed this
-> ([#9573](https://bugs.ruby-lang.org/issues/9573)). Including a module now
-> also reaches the classes and modules that already included the receiver,
-> and that covers `Q`'s singleton class, which got `Q` through `extend self`.
-> So on Ruby 3.0 and later, `Q.x` returns `"x"` whichever order the two
-> lines come in. I've fixed the irb prompts in the transcripts below, which
-> read `orb`.
+> **Update, November 2026:** Ruby 3.0 finally fixed this ([#9573](https://bugs.ruby-lang.org/issues/9573)). `Q.x` now works whichever order the two lines come in.
 
 This one caught me off guard.
 

docs/_posts/2006-09-21-i-no-longer-believe-in-methods.md

@@ -3,14 +3,7 @@ title: I No Longer Believe in Methods
 date: 2006-09-21
 ---
 
-> **Update, November 2026:** Methods are still not persistent objects in
-> Ruby: `method` and `instance_method` still return a new object every time
-> they are called. Since Ruby 2.1, `def` returns the method's name as a
-> Symbol, so calls like `help` and `valid` below can wrap a definition
-> directly, the way `private def announce` does, but they still work by
-> name. Annotations left Facets in 2.5.0 (2008) for the separate Anise gem,
-> so `require 'facet/annotation'` no longer works with current Facets. I
-> have also fixed a few typos in the code samples.
+> **Update, November 2026:** Still true: `method` and `instance_method` hand back a new object every time. Since Ruby 2.1, `def` returns the method's name, which allows decorator-style calls like `private def announce`, but that's still just passing a name around. Annotations moved out of Facets into the Anise gem in 2008.
 
 Yes, that's right. I no longer believe in methods. Why? Because this is OOP and if the methods aren't honest to goodness objects from the start, without exception, then they are not really methods. They're just glorified functions.
 

docs/_posts/2006-11-10-separation-of-church-and-state.md

@@ -3,9 +3,7 @@ title: Separation of Church and State
 date: 2006-11-10
 ---
 
-> **Update, November 2026:** Nothing relevant has changed since this was
-> written: Ruby never adopted `obj.@ivar` or `def @ivar`, and both are still
-> syntax errors.
+> **Update, November 2026:** Ruby never adopted `obj.@ivar` or `def @ivar`.
 
 Have you ever had a class so choke full of interrelated data and function members that you had trouble avoiding name clashes between the two. Of course it's a rare problem when you're in full control of the members, but when you're designing extensible classes, it becomes a major issue and you have to resort to some less-than-lovely work around.
 

docs/_posts/2006-11-11-we-all-live-in-a-yellow-submarine.md

@@ -3,12 +3,7 @@ title: We All Live in a Yellow Submarine
 date: 2006-11-11
 ---
 
-> **Update, November 2026:** Ruby hasn't changed on this: a class still
-> can't be included, a module still can't be instantiated, and the
-> `Module#new` trick at the end still works in Ruby 3.4. Facets added that
-> trick as `module/new` in 1.8 (2007); today it is the `Instantiable` mixin
-> (`require 'facets/instantiable'`), which gives any module that includes it
-> a `new` method.
+> **Update, November 2026:** Nothing has changed here: classes still can't be included, and modules still can't be instantiated. The `Module#new` trick at the end still works, and Facets offers it today as the `Instantiable` mixin.
 
 Anyone having read my previous posts, here and on ruby-talk, knows I love to explore ideas. It doesn't matter if they are considered "good" or "bad". Most cannot be judged without first expounding on them anyway. In fact, half the time I have no idea where an idea might lead until I sit down and blog it.
 

docs/_posts/2006-12-03-negative-arrays.md

@@ -3,14 +3,7 @@ title: Negative Arrays
 date: 2006-12-03
 ---
 
-> **Update, November 2026:** Ruby 2.3 gave String its own unary minus,
-> `String#-@`, which returns a frozen copy of the string (deduplicated since
-> Ruby 2.5). So `-'InstalledFiles'` now means something else, and an
-> `Object#-@` like the one proposed here never sees strings. Facets did take
-> up the `'-InstalledFiles'` form for a while: `Dir.multiglob` accepted `+`
-> and `-` prefixes in 2007, but Facets 2.1.2 dropped them, and today it just
-> takes a list of patterns. I have also corrected the code samples: the
-> unary minus method is `-@`, not `@-`.
+> **Update, November 2026:** Ruby 2.3 gave strings their own unary minus, which returns a frozen copy, so `-'InstalledFiles'` can't be used this way anymore. Facets' `Dir.multiglob` did support `+` and `-` prefixes for a while, but they were dropped in Facets 2.1.
 
 My current work involves the creation of an extensive configuration file format representing project information. In a number of cases I have had need of an inclusion list, representing files and file patterns to include for some operation --say, what files to include in a package. In such a case I generally end up with at least two parameters which I basically label include and exclude. While include is the list of files to use, exclude is a list of files to exclude from the included list. Using exclude makes it easier to specify a large selection and then subsequently omit a file or two. The include list typically has a suitable default value, so a third parameter is sometimes also of use, append, which concats to the defaults as opposed to replacing the include parameter outright.