Alexander Shagov alexshagov

So, you've come across deep search tools and are wondering if you can build your own. Well, you certainly can! Building one yourself might involve tasks like scraping web URLs, implementing your own RAG (Retrieval-Augmented Generation) system to find relevant information, and then summarizing it using an agent loop.

Luckily, the open-source community has already created tools that handle many of these steps. The purpose of this article is to demonstrate how easily we can spin up the necessary environment for such a tool using Nix. We'll focus not only on running the service, but also on development environment setup, making it easy to modify the tool if needed.

For demonstration purposes, I'll be using the gpt-researcher tool. Github link: https://github.com/assafelovic/gpt-researcher

The basic setup for almost any Python project often feels trivial: install Python, install requirements.txt, and you're good to go. However, if you manage tens of these projects on your machine, you'll quickly realize

Ruby on Rails: Your Service Layer is a Lie

If you're a Rails developer, you've probably seen (or written) code that looks like this:

class UserService
  def self.create(params)
    user = User.new(params)
    if user.save
 UserMailer.welcome_email(user).deliver_later

Why Use Nix package manager, Even on macOS?

Some time ago I wrote a short article on nix first steps (https://dev.to/alexander_shagov/nix-first-steps-4066). However, I realized that I need one more to quickly explain why generally prefer nix over non-nix setups. So here it is.

As a macOS user, you might wonder why you should consider using Nix (package manager) when you already have package managers like Homebrew.

⭐️ One of the most significant advantages of Nix is its ability to create reproducible environments. This means you can:

Easily share your exact development setup with teammates.

The "IO to the Boundary" principle

In software architecture, many principles and patterns have emerged over time. However, a lot of these can be boiled down to a single idea: the "IO to the Boundary" principle. This principle suggests that all input/output operations, like database queries, API calls, or file system interactions, should be pushed to the edges (or boundaries) of your application.

Let's look at what some other ideas tell us:

Functional Core, Imperative Shell: This principle suggests keeping the core of your application pure and functional, while handling side effects (IO) in an outer layer. This is basically another way of saying "IO to the Boundary."
Clean Architecture: Proposed by Robert C. Martin, this architecture emphasizes separating concerns and having dependencies point inwards, which fits with keeping IO at the edges.
Command Query Responsibility Segregation (CQRS): While not mainly about IO boundaries, CQRS often leads to separating read and write operations. This separ

Ruby on Rails: Rethinking Service Objects

In the Ruby on Rails community, service objects have gained popularity as a way to encapsulate business logic and keep controllers and models lean. However, there's a growing trend of misusing service objects, particularly those with "-er" or "-or" suffixes. This article aims to shed light on poorly implemented service objects and provide guidance on creating more effective, domain-focused alternatives.

Many developers tend to name their service objects with suffixes like -er or -or, such as ArticleCreator or UserAuthenticator. While this naming convention may seem intuitive, it often leads to a procedural style of programming rather than embracing the object-oriented nature of Ruby.

It's becoming evident that service objects the way we often see them are not actually "objects", but just a procedures.. or better to say, processess.

It might be overwhelming to dive into the Nix world, but this little glossary should help refine your understanding of the tools you might encounter when starting your journey.

UPD: I wrote one more short article to articulate why I prefer nix over non-nix setups in general: https://dev.to/alexander_shagov/why-use-nix-even-on-macos-786

Nix Package Manager – The core tool that allows declarative and reproducible package management.

NixOS – A Linux distribution built entirely on the Nix package manager. It's better to start with nix package manager alone before switching to NixOS completely.

Install GNU Emacs (26.3+)

brew install emacs && brew link emacs

Download the development branch

git clone -b develop https://github.com/syl20bnr/spacemacs ~/.emacs.d

	require 'rails_helper'

	RSpec.describe User, type: :model do
	subject { described_class.new(params) }

	let(:params) do
	{
	name: 'John'
	}
	end

	# frozen_string_literal: true

	### Usage

	# Helps to understand how operation run affects the database state
	# DatabaseChangesLogger.call(filename: 'output') { Operation.perform }

	module DatabaseChangesLogger
	EVENTS_TYPE = 'sql.active_record'
	OPERATION_REGEX = /Update\|Create/.freeze

	# ./spec/user_spec.rb

	require_relative '../../lib/user.rb'
	require 'ostruct'

	RSpec.describe User do
	subject { described_class.new(name: name, payment_service: payment_service) }

	let(:name) { 'John Doe' }
	let(:success_result) { true }