Recently, I finally removed devise from an old project and replaced it with the generated authentication code. This turned out to be far easier than expected. Here are my notes:

Run the generator

The first thing to do is to run the generator:

rails generate authentication

This creates a bunch of files and overwrites some of our existing code, especially the User model. (Here’s an excellent walkthrough of the generated code.)

Create a new migration for users table

The generator creates a CreateUsers migration, but we already have a users table. I deleted the generated migration, and created a new one that updates the table to match what the generated code expects.

class MigrateUsersFromDevise < ActiveRecord::Migration[8.1]
  def change
    rename_column :users, :email, :email_address
    rename_column :users, :encrypted_password, :password_digest

    change_column_default :users, :email_address, nil
    change_column_default :users, :password_digest, nil

    remove_index :users, name: "index_users_on_reset_password_token"

    remove_column :users, :reset_password_token, :string
    remove_column :users, :reset_password_sent_at, :datetime
    remove_column :users, :remember_created_at, :datetime
  end
end

The generator uses email_address instead of Devise’s email column. Keeping the name could have worked, but I decided to switch to the new name for the sake of consistency across projects.

Restore the User model

The generator overwrote app/models/user.rb. Keep the generated has_secure_password, has_many :sessions, and normalizes :email_address lines, then restore all the other validations, associations, or any methods that you might have.

class User < ApplicationRecord
-  devise :database_authenticatable, :registerable,
-    :recoverable, :rememberable, :validatable
+  has_secure_password
+  has_many :sessions, dependent: :destroy
+
+  normalizes :email_address, with: ->(e) { e.strip.downcase }
+
+  validates :email_address, presence: true, uniqueness: true
+  validates :password, length: { minimum: 6 }, allow_nil: true
  
  # other code
end

Update the routes

The generator would already have added the new routes for sessions and passwords, but we still have a devise_for :users line, which should be removed.

Fix up ApplicationController

Devise exposes a current_user helper that I use everywhere in the views, but the generated code exposes the current user using CurrentAttributes. I decided to add the helpers I was already using to ApplicationController:

class ApplicationController < ActionController::Base
  include Authentication

  def current_user = Current.user
  def user_signed_in? = Current.user.present?
end

Fix test helpers

Devise::Test::IntegrationHelpers was included in test_helper.rb, so I removed it. The generator added a test/test_helpers/session_test_helper.rb file with a sign_in_as method. I added a sign_in alias for that method, so I don’t have to change all the existing tests in the same PR.

The fixtures file got replaced by the generator, which needed to be cleaned up. I made sure that the fixtures I needed were still there:

<% password_digest = BCrypt::Password.create("password", cost: 1) %>

admin:
  email_address: admin@example.com
  password_digest: <%= password_digest %>

Add RegistrationsController

The generator doesn’t add a sign up route, so I had to manually add it. This is documented in my previous post about the authentication generator.

Replace devise path helpers

The devise path helper names are different, so we need to update those in the views:

• Login: new_session_path instead of new_user_session_path
• Logout: session_path instead of destroy_user_session_path

Fix system tests

Devise includes Warden::Test::Helpers in ApplicationSystemTestCase, which provides a login_as helper. Warden is no longer a dependency, so we need to remove that and the teardown block that references it:

class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
-  include Warden::Test::Helpers
-
-  teardown do
-    Warden.test_reset! # Reset Warden after each test
-  end
end

We can now replace the helper with a new method:

class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
  # ...

  def sign_in(user)
    session = user.sessions.create!
    visit root_url
    signed_value = signed_cookie_value(session.id)

    page.driver.browser.manage.add_cookie(
      name: "session_id",
      value: signed_value,
      path: "/",
    )
    visit current_url
  end

  private

  def signed_cookie_value(value)
    key_generator = ActiveSupport::KeyGenerator.new(
      Rails.application.secret_key_base, iterations: 1000
    )
    secret = key_generator.generate_key("signed cookie")
    ActiveSupport::MessageVerifier.new(secret).generate(value)
  end
end

Remove devise completely

Now that everything else is fixed, we can remove all references to devise in the code:

• Remove gem "devise" from Gemfile and run bundle install
• Delete config/initializers/devise.rb
• Delete config/locales/devise.en.yml

Wrapping up

With that, I was able to remove another dependency from the project. If I had more complex authentication requirements, I’d have kept devise on. However, it is overkill for an app only for myself. The migration was quite easy, and now I have one less dependency to worry about.

First, we add the sorbet and tapioca gems to the Gemfile.

gem "sorbet"
gem "tapioca", require: false

Next, we add a sorbet/config file that includes all the arguments that we would pass when running the srb typecheck command:

--dir
lib
--enable-experimental-rbs-comments

And that’s basically it! You can now type check your Ruby codebase with bundle exec srb typecheck.

Based on my experience adding Sorbet to a Rails app in the past, I expected this to be more cumbersome. Having seen how straightforward it is to get started, I think sorbet is going to be part of even my smaller Ruby projects.

This editor is a VS Code fork like Cursor, which made it easier to get started. It was able to import my Cursor settings as soon as I opened the app, so there wasn’t much to set up.

Fixing some bugs

To take it for a spin, I decided to fix some bugs in devlibrary.org’s Elixir codebase. I’ve been putting off fixing some annoying bugs there because my Elixir is a bit rusty, so AI assistance is a great way to build some momentum. I picked a note I made about an annoyance and just pasted it in the chat without any additional context:

When a search has no results, there’s an “add book” button. I don’t want it anymore

Gemini 3 Pro was able to figure out the context and make the changes quickly. However, this was a very simple fix, so I decided to pick something a fair bit more complex. Again, my prompt was just the text from my todo list:

Fix bug that prevents saving book with newly created authors or categories

This was a bug with a LiveSelect component that I’d unsuccessfully tried to fix with Cursor a few times. However, Antigravity has a browser agent that opens up the local server in the browser and clicks around to reproduce the issue. This is particularly effective when fixing UI bugs. It’s also great when I want to offload some manual testing to the agent.

Tab completion

Cursor’s strongest feature has always been tab completion. I think Cursor is still far ahead of Antigravity in this regard. When you rename a variable, Cursor lets you hit tab rapidly to jump to the next instance and update it. Antigravity does have a similar tab feature, but it feels slower and less reliable. It has sometimes ended up inserting a tab character rather than jumping to the next position.

Available models

Antigravity is the showcase for Gemini 3 Pro, but also provides Claude Sonnet, Opus, and GPT-OSS 120B. Since I started using this, they have added Gemini 3 Flash as well. Being a lightweight model, Flash has more generous limits.

I’ve really enjoyed using Gemini Flash. It is extremely fast, and great for offloading lightweight, boilerplate-y work to AI. It may not be the best for serious work, but for small hobby projects, you probably don’t need the firepower of Gemini 3 Pro or Opus.

Cursor has a wider range of models, with many versions of GPT5 being available in addition to Claude and Gemini, but I’ve hardly reached for GPT in the past year. Claude models are easily the best available option, with Gemini not far behind, so I’m not missing much.

Rate limits

I’m still playing with the free tier, where I hit the rate limits for both Gemini and Claude’s bigger models in 3 days, and had to wait 4 more days for it to reset. Gemini Flash lasted much longer, but I eventually ran into limits there as well. That said, I was still surprised by how long I was able to use it with the free quotas. The browser agent also has rate limits, which is rather frustrating.

There’s been a lot of chatter lately about how much Google is limiting the quotas even in the Pro plans. However, considering how generous the free tier is, I don’t think I’ll run into the limits if I got the Pro plan. For personal use, it’s not a dealbreaker, and for work, the Ultra plan is probably better suited.

The AI Pro plan costs $20 (27 CAD here in Canada) and includes 2TB of storage. Considering that I already pay 14 CAD for that much storage right now, the pricing looks very tempting compared to the $20 that I’m paying Cursor for the sporadic use.

Verdict

So far, I’m really enjoying using Antigravity. The experience is similar to that of Cursor for the most part, even though the UX does feel a bit less polished at times.

The pricing makes it a very attractive option. It’s easy to play around with the free tier. But even the $20 tier is a steal considering the 2TB of storage, and increased rate limits for non coding AI tools.

Non fiction

A Random Walk Down Wall Street (Burton G Malkiel)

Malkiel is one of the earliest advocates for index funds, so a lot of today’s personal finance wisdom comes from this book. Originally written in the 1970s, but regularly updated, it has remained relevant through half a century. He also weaves the narrative much better than most personal finance writers, so it is a delightfully engaging read. He can easily jump from the Dutch tulip bulb craze to Japanese real estate bubble to the 2008 recession and explain the forces of economics at the same time.

100 Ways to Improve Your Writing (Gary Provost)

Not only does Provost teach you how to write better, he gives you beautiful prose that you can learn from along the way. This book has one of my favourite pieces of writing:

This sentence has five words. Here are five more words. Five-word sentences are fine. But several together become monotonous. Listen to what is happening. The writing is getting boring. The sound of it drones. It’s like a stuck record. The ear demands some variety. Now listen. I vary the sentence length, and I create music. Music. The writing sings. It has a pleasant rhythm, a lilt, a harmony. I use short sentences. And I use sentences of medium length. And sometimes, when I am certain the reader is rested, I will engage him with a sentence of considerable length, a sentence that burns with energy and builds with all the impetus of a crescendo, the roll of the drums, the crash of the cymbals–sounds that say listen to this, it is important.

The Innovator’s Dilemma (Clayton M Christensen)

Explores why disruptive technologies usually come from small startups repackaging existing technologies at a lower cost, and existing successful companies fail at this. The primary example is the disk drive industry, and how the established players couldn’t release disruptive technologies, and instead doubled down on established, “sustaining” technologies.

A Philosophy of Software Design (John Ousterhout)

One of my new favourite technical books. This was an interesting contrast to books like Sandi Metz’s Practical Object Oriented Design in Ruby and Bob Martin’s Clean Code. Sometimes, I wonder if I’m pushing ideas from those books (like short methods) too far. This book pulls back from those ideas a bit too much for my liking, but it can help you figure out a good middle ground for dealing with complexity in software.

A People’s History of the United States (Howard Zinn)

A retelling of the American history from the perspective of the marginalized groups. The original book is a massive tome, but I listened to an abridged audiobook narrated by Matt Damon. Even the abridged version can be a bit dry at times, but thoroughly illuminating about the origins of modern America.

Careless People (Sarah Wynn-Williams)

Wynn-Williams was an exec at Facebook, in charge of government relations. She chronicles the toxic work environment and the leadership’s disregard for ethics as they tried to expand into authoritarian nations like China and Myanmar. Heard about this because Meta Streisand-ed themselves by trying to get it banned.

The Notebook: A History of Thinking on Paper (Roland Allen)

Fascinating history of the notebook, going all the way back to clay tablets, through to da Vinci, Newton, the evolution of double entry bookkeeping, police notebooks and the creation of Moleskine notebooks. When this was recommended to me, I was skeptical it would be interesting to someone who doesn’t use a physical notebook. I was wrong to doubt it, though!

On Writing (Stephen King)

One of the masters of storytelling writes about the craft of writing, interleaving it with a memoir about his own writing journey. An entertaining read, even if you don’t want to become a writer.

A Bite-Sized History of France (Stéphane Hénaut, Jeni Mitchell)

A thoroughly entertaining history of France, told primarily through the lens of the history of French cuisine. Having recently visited France for the first time, this was a great way to understand the French love for food.

Fiction

All The Light We Cannot See (Anthony Doerr)

The book introduces us to two children in the 1930s - Marie Lauer, a blind Parisian girl and Werner, a German boy with a knack for fixing radios who later becomes a soldier. From there, we follow their journey on the opposite sides of WW2, until they finally encounter each other in the midst of a battle. Incredibly beautiful writing, and one of the more powerful world war novels I’ve ever read.

Nettle & Bone (T Kingfisher)

Beautifully written fairy tale. A princess puts together a group to go on a mission to rescue her sister from her abusive husband, who also happens to be the prince of a powerful kingdom.

The Iron King (Maurice Druon)

Set in the 1300s, the book follows the court of Philip the Fair, and the aftermath of his persecution of the Knights Templar. There’s political intrigue set in a medieval world, with lots of gritty violence, and reminds of Game of Thrones, without dragons. In fact, George R R Martin has cited this as an influence on the series.

Parable of the Sower (Octavia E Butler)

The teenage protagonist suffers from hyper-empathy, feeling the pain of others, and needing to hide it to survive. She lives in an American society that has fallen into anarchy. Escaping violence, she and a couple of friends have to make the dangerous trip North to find a safer place. This part is reminiscent of Cormac McCarthy’s The Road. While a brilliant read, one weak area is that it takes a hard turn into the spiritual side. I would have preferred it as a pure speculative, dystopian novel.

Wind and Truth (Brandon Sanderson)

Not the best entry in the Stormlight Archive, but the last 400-500 pages whizzed by. Sanderson is really good at writing finales, and he was able to resolve the dozens of plot lines he had in motion reasonably well. The book is structured as 10 separate sections, each dealing with one day. This brought an interesting sense of urgency to parts of the story, but the first half was quite slow.

Stats

This year, I started collecting some additional stats about my reading:

• 35 books, 17000+ pages
• 18 non-fiction vs 17 fiction
• Formats: 23 audiobooks, 11 ebooks, 1 physical book
• Top genres: 8 science fiction, 5 fantasy, 4 history, 4 business.
• 241 hours of audiobook listening time (I listen at 1.5 to 2x, so this was probably closer to 120-150 hours)

2026

Some goals for the new year:

• Balance physical/ebooks with audiobooks: I’ve fallen behind on spending time sitting down with a book, and have relied mostly on audiobooks while walking outside. I want to make more time for actual reading.
• Read genres other than SFF: My reading has skewed a lot towards science fiction lately. I’ve been working through the list of Hugo award winners, reading 15 winners in the past two years. I want to ease up on that and read more of other genres in the coming months, especially detective fiction.
• Explore literature in other languages: I haven’t explored much of Kannada, Malayalam or Hindi literature because I can’t read those languages at a comfortable pace. Audiobooks should be great for exploring them.

Although it’s a major version bump, there shouldn’t be any serious breaking changes. This version bump is to celebrate 30 years since the first public release of Ruby.

Ruby::Box

Ruby::Box is an experimental feature that brings isolated namespaces to Ruby. This can be enabled by setting the RUBY_BOX=1 environment variable. This can allow you to do things like loading two versions of a library at the same time like this:

# foo_v1.rb
class Foo
  def hello
    "Foo version 1"
  end
end

# foo_v2.rb
class Foo
  def hello
    "Foo version 2"
  end
end

# main.rb

v1 = Ruby::Box.new
v1.require("./foo_v1")

v2 = Ruby::Box.new
v2.require("./foo_v2")

v1::Foo.new.hello #=> "Foo version 1"
v2::Foo.new.hello #=> "Foo version 2"

I find the syntax rather confusing, with the need for instantiating a Box object. But this is still an experimental feature, so we’ll hopefully have better ergonomics with the final version.

Ractor

Ractor’s API has been redesigned to use Ractor::Port as the means for communicating between ractors. As a result Ractor.yield and Ractor#take have been removed. Now, you would use a ractor port like this:

port = Ractor::Port.new

Ractor.new(port) do |p|
  p << "first value"
  p << "second value"
end

puts port.receive #=> "first value"
puts port.receive #=> "second value"

In Ruby 3.4, this would have looked like this:

ractor = Ractor.new do
  Ractor.yield "first value"
  Ractor.yield "second value"
end

puts ractor.take  # => "first value"
puts ractor.take  # => "second value"

ZJIT

A new JIT compiler called ZJIT has been merged into Ruby. This implements a method based JIT compiler, compared to the lazy basic block versioning compiler that YJIT uses. Using a more traditional type of JIT will hopefully make the codebase more accessible to new contributors.

Although ZJIT is faster than the interpreted code, it hasn’t yet caught up with YJIT. The latter is still the recommended JIT for production. However, this sets the stage for some more speedups in the next year.

Logical operators on the next line

The following syntax is now allowed for logical operators and, or, && and ||.

if condition1?
  && condition2?
  && condition3?
  # do something
end

# The above is the same as what we can currently do with:

if condition1? &&
  condition2? &&
  condition3?
  # do something
end

Ruby top level module

The Ruby top level module was reserved in Ruby 3.4, but now it actually has some constants defined in it:

Ruby::VERSION
#=> "4.0.0"

Ruby::DESCRIPTION
#=> "ruby 4.0.0preview2 (2025-11-17 master 4fa6e9938c) +PRISM [x86_64-darwin24]"

# Other constants in the module:
Ruby.constants
#=> [:REVISION, :COPYRIGHT, :ENGINE, :ENGINE_VERSION, :DESCRIPTION,
#    :VERSION, :RELEASE_DATE, :Box, :PLATFORM, :PATCHLEVEL]

instance_variables_to_inspect

When inspect is called on an object, it includes all instance variables, including memoization variables, which can get noisy in larger classes. For instance, the @area variable shows up below after the area method is called.

class Square
  def initialize(width)
    @width = width
  end
  
  def area
    @area ||= @width * @width
  end
end

square = Square.new(5)
puts square #=> #<Square:0x000000011f280ff8 @width=5>

square.area #=> 25
puts square #=> => #<Square:0x000000011f280ff8 @area=25 @width=5>

However, by defining which variables should be shown like this, we can make the inspect output less noisy.

class Square
  # ...

  private
  
  def instance_variables_to_inspect = [:@width]
end

square.area # 25
puts square #=> => #<Square:0x000000011f280ff8 @width=5>

Array#rfind

Array#rfind has been implemented to find the last element matching a condition. This is a more efficient alternative to reverse_each.find. It avoids an array allocation that happens when calling Enumerable#reverse_each.

# new
[2, 2, 3, 4, 6, 7, 8].rfind(&:odd?) #=> 7

# old
[2, 2, 3, 4, 6, 7, 8].reverse_each.find(&:odd?) #=> 7

At the same time, Array#find has also been added, which is a more efficient implementation than Enumerable#find that was being used before.

Other changes

• Object allocations are significantly faster - over 2x without JIT and almost 4x with JIT enabled.
• RJIT has been extracted into a separate gem.
• Set and Pathname are now core classes. Previously, Set was an autoloaded stdlib class, while Pathname was an autoloaded default gem.
• CGI library has been removed from default gems, but a few commonly used features such as CGI.escape and related methods are retained and can be used by requiring cgi/escape.

Further reading

This post highlights changes that I personally found most interesting, and skip over features I might not use. If you’re looking for a more comprehensive look at the release, I highly recommend looking at the release announcement, and changelog. The Ruby References website is another fantastic resource if you want a deeper dive into all of the changes in this version.

This review is about 3 years too late, because the newer Airpods Pro 3 are already out. But most of these observations are about using the Airpods Pro 2 with Android, which should mostly also apply to the newer generation.

I’ve avoided the Airpods Pro 2 in the past because they have a reputation of not working too well with Android. But after using it for 3 months, I realized it’s a viable choice for Android users, albeit rather pricy for the features available, compared to other options in the price range.

What works well

Sound quality is leagues above the Jaybird Vista and the Galaxy Buds Live that I’ve been using daily until now. I’m not an audiophile, but I’d say they sound about as good as the Sennheiser HD1 over the ear headphones that I used in the past.

Noise cancellation is where it really blew me away. The in-ear fit is great, so I found the noise cancellation better than that of the HD1s. The Galaxy Buds Live are technically ANC earbuds, but they do a worse job than the non-ANC Jaybirds with isolating noise, so the Airpods are huge jump.

Controls. You can use the stem to control a bunch of things, like answering calls, play/pause, volume and toggling noise cancellation. You’ll need an Apple device to change what each action does, but I’ve been happy with the default settings.

Battery life is pretty decent at 6 hours, and with the charging case that goes up to 30 hours, so I’ve only ever run out of battery a couple of times. Even then charging for a few minutes will top it up enough for a while. With wireless charging support, it’s easy to throw it on to a charging pad, and not worry about it for days.

What doesn’t work well

Spatial audio is something I didn’t know I wanted until I tried using it with the iPad this week. The head tracking makes it so much more immersive, and it sounds a lot better. Really wish this worked on Android.

Conversation awareness automatically lowers the volume and enhances voices when it detects that you’re speaking to someone. This is exclusive to Apple devices. On Android, it only turns off noise cancellation when nothing is playing, which isn’t particularly useful.

Automatic ear detection is the other one where taking off one of the earbuds will pause whatever’s playing, but this doesn’t work with Android either.

Battery status isn’t visible when connected to Android. This is a bit annoying, but I’ve mostly not had to worry about battery levels, so it’s not a huge downside.

Firmware updates will only work if it’s connected to an Apple device, which is a problem if you don’t have any devices you can connect it to.

Customizing the settings of the Airpods can only be done on Apple devices. The stock settings work well for me so it’s not a big problem, but having a Macbook to tweak it is nice. Apple doesn’t let you easily tweak the EQ even within their ecosystem, so this is mostly for customizing the controls on the buds.

Device switching works seamlessly between my Macbook and iPad. I could have two videos open, and it will switch to whichever device starts playing. This is one where I can understand why this won’t work on Android.

Other factors

Comfort: They are very lightweight, but I still found them less comfortable than the Jaybird Vista. The latter have fins to stabilize the earpods for workouts, so I find them better for longer use, while the Airpods become tiring after a couple of hours. Ironically, I’ve been using the Airpods more for workouts, and the Vistas for long calls!

No AptX codec suport, so you’ll have to switch to AAC codecs on Android. AptX has lower latencies which is useful for keeping audio in sync with video. I haven’t been able to notice any lag, and AAC does have better sound quality, so I’m not too bothered by the lack of AptX support.

No voice assistant unless you have an iPhone. I wouldn’t feel comfortable talking to a voice assistant in public anyway, so not having to use Siri is actually a pro, in my book.

Verdict

Overall, I’m happy with the Airpods. Now that I’ve tried out spatial audio, I’m going to miss that on the phone, and ear detection would have been nice, but i’m still happy with everything else. However, if there are things that really bother you, installing Librepods should solve most problems.

I got the Airpods for free as part of a promo, but if I were buying a pair of today, I’d look more closely at alternatives that work well with Android. Both Sony and Bose seem to have similar earbuds that work great with Android. However, despite the flaws, the Airpods would be right up there for consideration.

I have a bunch of movie ratings in my notes, and I wanted to display them as stars rather than numbers. The ratings are stored as properties on the notes:

type: [[Movies]]
rating: 4

Now that I have this data, it’s easy to create a view by querying for notes of type: [[Movies]], and adding ratings as one of the properties.

I wanted star ratings to make this easier to read. I came across this article by Tyler Sticka with a formula for star ratings:

'⭐⭐⭐⭐⭐'.slice(0, rating).split('').map(icon('star'))

Here’s how it looks:

This works for whole numbers, but I use half stars in my ratings. Something rated as 4.5 stars will show up as 4 stars. To add half stars, we need to modify the formula to this:

[
  '⭐⭐⭐⭐⭐'.slice(0, rating).split('').map(icon('star')),
  if(number(rating) - number(rating).floor() >= 0.5, icon('star-half'), '')
].flat()

This adds a half star when needed:

However, I wasn’t too happy with the appearance of the builtin star icons, and I prefer the use of the emoji ⭐️ for this. This makes the first part of the formula much simpler:

'⭐⭐⭐⭐⭐'.slice(0, rating)

Now, there’s no half star emoji, so I decided to use the ½ character instead, so the final formula looks like:

[
  '⭐⭐⭐⭐⭐'.slice(0, rating),
  if(number(rating) - number(rating).floor() >= 0.5, '½', '')
].flat()

This is what the table finally looks like:

I like how easy it is to customize these tables, and how well these formula functions are documented.

I considered Obsidian and Notion. I like Notion’s features and polish, but Obsidian won because it uses local markdown files, just like Logseq. If I decide to move to another app, the migration should be as easy as this one.!

Migrating the notes

Logseq and Obsidian both use markdown files to store notes, so the migration isn’t particularly complicated. You can even point Obsidian to the folder containing your Logseq notes, and things will mostly work.

That said, there are some differences in how things like tags and namespaces work, so I used theLogSeqToObsidian script to clean up the notes. This made the transition easier. Here’s the command I ran:

uv run convert_notes.py \
  --logseq ~/Documents/logseq \
  --output ~/Documents/Obsidian \
  --overwrite_output \
  --convert_tags_to_links \
  --tag_prop_to_taglist \
  --journal_dashes \
  --ignore_dot_for_namespaces

This isn’t perfect, though. Some Logseq specific annotations are still around, but I’m not too worried about them. I can clean them up gradually as and when I encounter them.

What I’m enjoying about Obsidian

Editing experience: Obsidian is the best markdown editor I’ve ever used. I’m already using it to draft blog posts, starting with this one. Jotting down observations about the migration in my daily notes made it easy to bring everything together into this post.

Performance: The app is so snappy, both on desktop and mobile. This was a huge problem with Logseq, especially on mobile, which made writing very frustrating.

Mobile app: The Logseq mobile app is a mess. Sometime the text that I typed would just disappear. Or text would flow outside the viewport, so I can’t see what I’m typing. The bottom bar containing the search button, would often disappear. Meanwhile, the Obsidian app has worked flawlessly so far. In fact, I’ve even done some editing and proofreading of this post on my phone.

Bases: Obsidian’s databases feature is called Bases, and I much prefer this approach for querying structured data to Logseq’s datalog queries, which I could never understand. There’s a UI for filtering results, rather than queries. But there are also formulas that you can reach for if you need something more.

Polished UI: Although both Logseq and Obsidian mostly look similar, I’m enjoying the polish that Obsidian brings. I like being able to rearrange UI elements like the bookmarks pane. The table view for bases is also much nicer than the query results table in Logseq. The default theme is also pretty great, so I haven’t had to look for alternatives.

Plugins: The plugin ecosystem looks so much richer in Obsidian. The plugins API also seems to allow more complex functionality to be added by third parties. I’m starting slow with plugins, and only have a couple of plugins so far. There are a few others that I want to try, such as Journaling and Smart Connections.

Focus on markdown: The Logseq team is rebuilding the app to use a DB instead of markdown files. This still hasn’t shipped, and in the meanwhile, work on the markdown version has stalled for over two years. Obsidian’s focus on markdown means that the app is constantly getting updates. And if I decide to move to another app, the data will still be portable.

What I miss from Logseq

Namespaces: Being able to organize travel notes as Travel/2025/Paris was really convenient. If you went to the Travel page, you could see links to the subpages (Travel/2025, Travel/2025/Paris etc), but now if I link to that page, I will only see the last part (Paris). It’s confusing if you have a separate page for notes about the city. Now I’m thinking of using dashes in the file name (like Travel - 2025 - Paris) and adding metadata for organization. There’s going to be a fair bit of manual work updating notes where I used namespaces.

Journals timeline: Logseq has a nice chronological view for journal entries, which makes it easy to scroll through last few days’ notes. In Obsidian, you have to type the date to actually go to a page. It’s also missing an easy shortcut to go to previous/next day’s entry. I needed to install a third party calendar plugin to navigate journal dates. I might try the Journaling plugin to see if that helps.

Flashcards: Obsidian doesn’t have a native spaced repetition feature like Logseq does. It’s not a dealbreaker, and I don’t use it all that much, but it was nice to have.

Inline metadata: Logseq lets you add metadata to any node anywhere. For instance, you could add a node for a book directly in today’s journal entry, and add a rating to it. Obsidian, on the other hand, only supports metadata at the page level, so you’ll have to create a separate page for each book and then attach metadata to it.

Outliner: Working with bullet points everywhere was very convenient for journal entries in Logseq. I’m going to miss that. I’m using bullet points out of habit anyway, even though you don’t get any benefits of structuring notes that way.

Pasting links into text: In Logseq, I can select some text and paste a URL, and it will automatically link it, while Obsidian will replace that text with the URL. There are plugins that fix this, but this should be the default behavior.

Organizational system

I’m not trying too hard to put in an organization system this early. For now, most notes are stored in the root folder. Search and links are doing a good enough job.

There are a few exceptions. Daily notes live in journals. Notes containing structured information that I query in bases, such as books or movies, have their own folders.

Sync and pricing

Both Logseq and Obsidian have basic sync options that let you sync your data across devices, starting at $5/month. However, Logseq is much more generous about limits, allowing 10 graphs with 10GB of storage, while Obsidian allows one vault and 1GB storage. You’ll need to pay twice as much to get similar limits as Logseq.

The basic plan is more than enough for me. Most of my 1600+ files are plain text, so I’m using about 1% of that limit.

Final thoughts

The transition has been surprisingly easy. A big part of this is because both tools are markdown-based, so it’s easy for one to read files created by the other. I’m writing more now because it’s almost as easy to jot down thoughts on the phone as it is on the laptop.

I’ll continue using Logseq at work for now because it’s the recommended notes app there. My vault is strictly local and mainly used for tracking todos, so many of my biggest gripes about the app don’t apply there.

One common example is when there’s a class that wraps a Hash object. Hashes in Ruby are quite well optimized, so do you really need to memoize the result of the hash lookup? Let’s benchmark and find out.

Benchmarks

Let’s start with a simple Setting class that takes a data hash with type and value keys.

class Setting
  def initialize(data)
    @data = data
  end

  def type
    @data["type"]
  end

  def type_memoized
    @type ||= @data["type"]
  end
end

There’s a type method here, and I’ve added a type_memoized method for comparison. Now let’s benchmark the two methods:

setting = Setting.new({ "type" => "string", "value" => "hello" })

Benchmark.ips do |x|
  x.report("type") { setting.type }
  x.report("memoized type") { setting.type_memoized }
  x.compare!
end

Running this showed that memoization does indeed make things faster. On my 2019 Intel Macbook, this showed a 1.31x improvement:

ruby 3.4.4 (2025-05-14 revision a38531fd3f) +PRISM [x86_64-darwin24]
Warming up --------------------------------------
         type     1.339M i/100ms
memoized type     1.586M i/100ms
Calculating -------------------------------------
         type     12.411M (± 1.0%) i/s   (80.57 ns/i) -     62.954M in   5.072739s
memoized type     16.214M (± 1.0%) i/s   (61.68 ns/i) -     82.453M in   5.085992s

Comparison:
memoized type: 16213611.7 i/s
         type: 12411448.7 i/s - 1.31x  slower

However, you will notice that in actual time per method call, the difference is tiny - less than 20 nanoseconds on my 6 year old Macbook! Unless you’re calling this thousands of times in a loop, this will likely never be a bottleneck in your code.

Looking up nonexistent keys

Let’s look at one other case. What happens when we memoize a lookup for a key that doesn’t exist?

setting_without_type = Setting.new({ "value" => "hello" })

Benchmark.ips do |x|
  x.report("missing key") { setting_without_type.type }
  x.report("memoized missing key") { setting_without_type.type_memoized }
  x.compare!
end

This time, the memoized version is actually 1.2x slower! This is because @data["type"] returns nil every time, so we don’t ever return the memoized value.

         missing key     13.163M (± 1.4%) i/s   (75.97 ns/i) -     66.077M in   5.021125s
memoized missing key     10.853M (± 4.3%) i/s   (92.14 ns/i) -     55.153M in   5.091847s

Comparison:
         missing key: 13162501.1 i/s
memoized missing key: 10852595.0 i/s - 1.21x  slower

Update: As @phallstorm mentions in the comments below, we could prevent the cache misses by using the if defined?(@type) memoization pattern.

def type_memoized_correctly
  return @type if defined?(@type)
  @type = @data["type"]
end

At this point, we’ve achieved similar performance as the case where the key is present. However, the downside is that more than half the method is now memoization logic, without too much performance benefit.

Nested keys

Finally, let’s see what happens when we’re dealing with nested hashes:

class Setting
  # ...

  def nested_value
    @data["nested"]["value"]
  end

  def nested_value_memoized
    @nested_value ||= @data["nested"]["value"]
  end
end

setting = Setting.new({ "nested" => { "value" => "hello" } })

Benchmark.ips do |x|
  x.report("nested key") { setting.nested_value }
  x.report("memoized nested key") { setting.nested_value_memoized }
  x.compare!
end

This time the memoized version is about 1.6x faster.

         nested key     10.654M (± 5.6%) i/s   (93.86 ns/i) -     54.107M in   5.097061s
memoized nested key     16.867M (± 1.3%) i/s   (59.29 ns/i) -     85.219M in   5.053237s

Comparison:
memoized nested key: 16866963.5 i/s
         nested key: 10654347.8 i/s - 1.58x  slower

Conclusion

The highlights from the benchmarks are:

• Hash lookups are already extremely fast, in the order of nanoseconds.
• 🔼 1.3x speedup on memoizing a hash lookup
• 🔼 1.6x speedup if memoizing a two-level nested hash
• 🔻 1.2x slowdown on memoizing a hash lookup where the key doesn’t exist.

So, do you really need to memoize a hash lookup? Most likely not. Hash lookups are already optimized at the language level, so the difference between that and instance variable lookups is already tiny.

Reserve memoization for cases where it really matters, such as database calls or really expensive computations.

There’s no need to optimize at this level unless a profiler has showed you that it will speed things up. There’s probably something in there that is multiple orders of magnitude slower that you can optimize.

The sequel gem allows connecting to one database, and dumping the contents into another.

First, let’s import that dump into local postgres database.

psql devlibrary_development < devlibrary-dump.sql

Next, we’ll install sequel and sqlite3 gems.

gem install sequel sqlite3

Finally, we can dump the postgres database straight into an sqlite3 database using:

sequel -C postgres://localhost/devlibrary_development \
    sqlite://storage/development.sqlite3

And that’s it - we now have a sqlite3 file that can be used by a Rails app. In fact, devlibrary is now actually backed by a sqlite database!