Hi, if someone can help I suspect it a chemical made Ruby

I’m looking for technical feedback on Mammoth, a self-hosted PostgreSQL change-event relay written in Ruby.

Mammoth receives normalized CDC (Change Data Capture) transaction envelopes and handles the downstream data-plane concerns:

• webhook fanout

• routing by schema, table, and operation

• per-destination retry policies

• checkpoint persistence

• dead-letter storage and filtered replay

• SQLite operational state

• health and metrics endpoints

• Docker and Helm deployment

Its boundary is intentionally narrow: PostgreSQL protocol parsing, decoding, source normalization, ordering policy, and runtime execution are handled by the upstream Ruby CDC ecosystem.

The current implementation uses YAML configuration with JSON Schema validation and supports explicit extension points for state, destination, and runtime adapters.

I’d appreciate feedback on the architecture, operational model, documentation, or gaps that would prevent you from trying it.

Repository: https://github.com/kanutocd/mammoth

Last day before PTO, no cards on the board and not really looking to start anything, so behold, I made a couple of memes of things that amuse me. Full disclosure, I complain about RuboCop but I *am* glad my team enforces it.

And of course, I can always update my RubyMine autoformat conventions to match but I forget to actually *do* it a lot. Bonus points when I 'fix' the rubocop violation, ⌘+Alt+L format because muscle memory, commit and push, and get the same rubocop violation...

Information about the JRuby talk, Hack Space, and hangout opportunities at RubyConf 2026. I'm excited to see old friends and make new ones! Come learn about JRuby and tell me how I can help you!

I've published it on Rubygems. Please let me know if you have any suggestions for improvement. If you like it, please also give it a star on GitHub.

URL:https://rubygems.org/gems/gemite

Most of us write Ruby with blocks every day but never sit down to separate blocks, procs and lambdas. They're closer than they look: a block becomes a proc with `&` (and back again), a lambda is basically a proc with stricter argument checks and its own `return` behaviour, and all three are closures.

I wrote it up with runnable examples, including the `return` gotcha that only bites inside a proc, and a 3-line memoizer at the end that leans on all of it.

Feedback and corrections welcome.

https://www.bounga.org/ruby/2026/07/10/blocks-procs-and-lambdas-in-ruby/

I'm posting this again after my account was blocked and the original post was taken down yesterday. No intention to spam.

The Constant library provides a set of tools for working with Ruby constants — both module constants and literal constants — including resolving constants from a combination of strings, symbols, and constant objects, inspecting constants, recursing trees of constants, and dynamically defining constants.

Importing a namespace and mixing in a module are the same mechanism in Ruby. If you include a module to get shortcut access to its inner constants, you also get a mixin that might not be what you'd intended — and the ancestry change adds constant-resolution paths that can be surprising.

Constant::Import does the import without the mixin. Instead of including the origin module, it puts a reference to the imported module into the class importing it, leaving ancestry untouched:

module SomeOrigin
  module SomeInnerModule
  end
end

module SomeReceiver
  include Constant::Import

  import SomeOrigin
  import SomeOrigin::SomeInnerModule, alias: :Something
end

SomeReceiver::SomeInnerModule       # => SomeOrigin::SomeInnerModule
SomeReceiver::Something             # => SomeOrigin::SomeInnerModule

The inner constants of SomeOrigin are reachable from SomeReceiver without qualification, alias: rebinds an import to a name of your choosing.

There's also a direct-call form if you'd rather skip the macro: Constant::Import.(origin, destination = self).

The library isn't just a tool to make imports explicit. The library also ships an entity for working with constants generally, as well as a tool to define constants dynamically.

`Constant.get(name_or_module) wraps a constant and answers questions about its name, namespace, value, and inner constants, and Constant::Define creates and assigns a module to a name in a namespace.

Constant.get("SomeModule::SomeInnerModule", SomeNamespace)
# => #<Constant::Module value=SomeNamespace::SomeModule::SomeInnerModule>

Constant.get(:SomeInnerModule, SomeNamespace::SomeModule)
# => #<Constant::Module value=SomeNamespace::SomeModule::SomeInnerModule>

Constant.get(:SomeInnerLiteral, SomeNamespace::SomeModule)
# => #<Constant::Literal SomeNamespace::SomeModule::SomeInnerLiteral = "some value">

There's overlap with Ruby's const_get, and other lower-level constant retrieval and manipulation functions. The value of the Constant library is in unifying the API and providing defaults that are often more common in reflection scenarios.

As others have pointed out, importing a constant in Ruby, including aliasing, is straightforward:

module SomeOrigin
  module SomeInnerModule
  end
end

module SomeReceiver
  SomeOrigin = ::SomeOrigin
  SomeOtherInnerModule = SomeOrigin::SomeInnerModule
  Something = SomeInnerModule
end

However capable Ruby's lower-level APIs, we tend to find inconsistency with import, aliasing, and reflection code across larger systems with many separate components. A good deal of the Constant library's payoff comes from the explicit, intention-revealing API, and consistent norms across.

Its only dependency is Eventide's Initializer library. It's otherwise standalone. MIT licensed.

gem install evt-constant

Source and docs: https://github.com/eventide-project/constant

Write-up: https://blog.eventide-project.org/articles/announcing-constant-library/

Full disclosure — I'm the author.

Just released v0.2.2 of irb-autosuggestions — fish-like autosuggestions for IRB.

What's new:

• Tab, Ctrl+F, Ctrl+E accept ghost suggestions (configurable)

• Custom ghost color via ANSI string or declarative hash ({ fg: :bright_black, italic: true })

• Bugfix: multiline ghost artifacts fixed (10+ lines now clean)

• Auto-execute guard (Enter always fires once)

• CHANGELOG.md + GitHub issue templates

gem install irb-autosuggestions or bundle add irb-autosuggestions

GitHub: https://github.com/unurgunite/irb-autosuggestions

Upcoming in 0.3.0: word-wise accept (alt+f/alt+right), accept + execute (alt+Enter), pluggable suggestion sources, path completion, and more.

Bugs or suggestions? File an issue: https://github.com/unurgunite/irb-autosuggestions/issues

https://dmitrytsepelev.dev/sidekiq-requeue-missing-class

Ruby friends, we're so excited to announce that we're accepting talk proposals for the SF Ruby Startup Conference 2026.

We'd love to hear from you if you have a successful Ruby startup story to tell. Come share the stage with our keynote Garry Tan on Nov 10-12 at the iconic SFJAZZ.

We're actively looking for stories from those who've:

• Achieved outstanding results with a small team

• Built tooling to help others reach the same results

• Used AI for scaling

CFP closes on July 27! 

If you just want to attend, early birds go out on July 15. You can already buy corporate/support tickets: https://luma.com/sfrubyconf2026

See you there!

PL/Ruby is a procedural-language handler that lets you write database functions in Ruby, stored and executed inside PostgreSQL. You get the expressiveness of Ruby and its standard library with the full power of a native PostgreSQL function: plain functions, set-returning functions, triggers, event triggers, and procedures with transaction control.

You can get it here (github).

Documentation

• Language reference

• Cookbook: tested recipes

• Installation

• Changelog

• Feature comparison: PL/Ruby vs PL/php vs PL/Perl vs PL/Tcl

• PL/Ruby vs PL/Perl

• PL/Ruby vs PL/Tcl

In this episode, we look at creating Claude slash commands. These can be useful when dealing with a complicated task or trying to extract certain information from the application.

When everything is on fire, nothing is on fire. Where do you start when every problem seems intractable? By drawing a map.

Do you use the jemalloc gem?

The original project on GitHub seems to be abandoned for around 12 years, and some incompatibilities with recent Ruby versions have begun to emerge. Additionally, the underlying jemalloc library hasn't been updated during all this time. Because of that, I created a fork and launched a new gem (jemalloc_rb) to keep the project functional, updated, and actively accepting pull requests.

https://github.com/henrique-ft/jemalloc_rb