TILs - Fueling Curiosity, One Insight at a Time

At Codemancers, we believe every day is an opportunity to grow. This section is where our team shares bite-sized discoveries, technical breakthroughs and fascinating nuggets of wisdom we've stumbled upon in our work.

Published
Author
user-image
Sujay
Steps to merge one repo into another

Step 1: Clone Repo1 locally

Code

git clone  repo1
cd repo1


Step 2: Fetch all the branches and commits from Repo2

Code

git remote add repo2 
git fetch repo2


Step 3: Create a branch

Code

git checkout -b merge-repo2


Step 4: Merge keeping full history

Code

git merge --allow-unrelated-histories repo2/main (Since the repositories have separate histories, this option allows Git to combine them, potentially requiring manual conflict resolution)


Step 5: Resolve Merge Conflicts

Code

git add .
git commit -m "Resolved merge conflicts"


#git
Published
Author
user-image
Mohammad hussain
System Analyst
pagy_array This method is the same as the generic pagy method, but specialized for an Array.

Code

require 'pagy/extras/array'
@pagy, @items = pagy_array(an_array)


#CU6U0R822 #ruby
Published
Author
user-image
Mohammad hussain
System Analyst

```
pagy_array
Published
Author
user-image
Nived Hari
System Analyst
each_with_object is an enumerable method in Ruby that allows you to iterate over a collection while building up an object (like an array or hash). Unlike map, which creates a new array, each_with_object lets you modify an existing object in a single pass.

Syntax

Code

collection.each_with_object(initial_object) do |item, object|
  # Modify the object inside the block
end


• collection: The array or enumerable you're iterating over.
• initial_object: The object that will be modified (e.g., {} for a hash or [] for an array).
• item: The current element in the iteration.
• object: The object that accumulates the results.
Example Usage
Using each_with_object with a Hash

Code

numbers = [1, 2, 3, 4, 5]
squares = numbers.each_with_object({}) do |num, hash|
  hash[num] = num**2
end

puts squares
# Output: {1=>1, 2=>4, 3=>9, 4=>16, 5=>25}


Why use each_with_object?
• Avoids the need to initialize an empty {} before the loop.
• Eliminates the need to return the object explicitly.

#CU6U0R822 #ruby
Published
Author
user-image
Mohammad hussain
System Analyst
When to use collection_select over select in rails
Use collection_select when you need to populate a dropdown with a collection of ActiveRecord objects. It is built on top of select and provides a convenient way to display object attributes instead of a simple array of strings.
select is used for manually defining options, typically from an array of strings or key-value pairs.
collection_select is specifically designed for selecting records from an ActiveRecord collection, making it useful when working with database associations.
Published
Author
user-image
Nived Hari
System Analyst
Rake tasks in Rails let you run custom scripts from the command line.
You can define your own tasks inside the lib/tasks directory.

How to Create a Custom Rake Task

1. Create a new .rake file in lib/tasks/

Code

touch lib/tasks/custom_tasks.rake


Define the task inside the file:

Code

namespace :custom do
  desc "Say hello from a custom rake task"
  task :hello do
    puts "Hello from custom Rake task!"
  end
end


Run the task from the terminal:

Code

bin/rake custom:hello


Use :environment if your task interacts with the database or models

#CU6U0R822 #rake
Published
Author
user-image
Nived Hari
System Analyst
The inverse_of option in ActiveRecord helps Rails recognize bidirectional associations in memory, reducing redundant database queries.
For example:

Code

class Employee < ApplicationRecord
  belongs_to :department, foreign_key: 'department_code', primary_key: 'code', inverse_of: :employees
end

class Department < ApplicationRecord
  has_many :employees, foreign_key: 'department_code', primary_key: 'code', inverse_of: :department
end


Why Use inverse_of?
• Prevents extra queries when accessing related objects
• Keeps objects in memory, improving performance
• Ensures associated objects reference the same instance
Without inverse_of, Rails may reload the association unnecessarily:


Code

employee = Employee.first
department = employee.department  # Triggers a SQL query
department.employees.include?(employee)  # Without `inverse_of`, this could trigger another query


With inverse_of, Rails avoids the extra query because it knows department.employees already includes employee

#CU6U0R822 #active_record
Published
Author
user-image
Nived Hari
System Analyst
In dry-validation contracts, values is a hash containing all the parameters being validated. When defining rule blocks, you can access specific parameters using hash-like syntax.
Example:

Code

class MyContract < Dry::Validation::Contract
  params do
    required(:category).filled(:string)
  end

  rule(:category) do
    key.failure("is not allowed") unless values[:category] == "approved_value"
  end
end


Key Points:
• values holds all input parameters.
• Use values[:key] to access specific parameters inside rule blocks.
• This allows custom validation logic beyond basic schema definitions.
#ruby #dry_validation
Published
Author
user-image
Nived Hari
System Analyst
You can manually send messages to a Kafka topic using Karafka's producer. This is useful for debugging, testing, or custom event handling.
Example:

Code

payload = {
  id: 123,
  name: "Sample Item",
  status: "processed",
  timestamp: 
Time.now.to_i
}

Karafka.producer.produce_sync(
  topic: "your_topic_name",
  payload: payload.to_json
)


Key Points:
• produce_sync ensures the message is sent before proceeding.
• topic specifies the Kafka topic where the message will be published.
• payload should be serialized into JSON or another supported format.
#karafka
Published
Author
user-image
Nitturu Baba
System Analyst
Searching in vector databases

1️⃣ Convert Text to Embeddings
• Text is transformed into numerical vectors using AI models like OpenAI, BERT, or Sentence Transformers.
2️⃣ Index & Organise Embeddings
• Instead of scanning all vectors, the database groups similar embeddings into clusters (buckets) to speed up search.
• Common indexing methods:
◦ HNSW (Hierarchical Navigable Small World) – builds a graph where similar embeddings are connected, reducing search time.
◦ IVFFLAT (Inverted File Index) – divides embeddings into clusters (buckets) and searches only the most relevant ones.
3️⃣ Search Using Similarity Metrics
• The query is converted into an embedding and compared to stored vectors using:
◦ Cosine Similarity: Cosine Similarity measures the angle between vectors while ignoring their magnitude, where a higher value means greater similarity (1 = identical, 0 = unrelated, -1 = opposite). It is commonly used for text similarity, such as document searches.
◦ Euclidean Distance: Euclidean Distance calculates the straight-line distance between points, where a lower value means greater similarity (0 = identical). This method is ideal for spatial data, like image or geographical searches.
• The database searches only the closest clusters, making it faster.
4️⃣ Return the Closest Matches
• The best matches (top K documents) are ranked and returned based on similarity scores.
📌 Convert text → embeddings, group them into clusters, search only relevant ones, return the top K ranked results.

#vectordatabase

Showing 8 to 10 of 82 results

Ready to Build Something Amazing?

Codemancers can bring your vision to life and help you achieve your goals

Let's Talk