Forem: Shaher Shamroukh

AI Can Write Code But It Still Can’t Think Like a Developer

Shaher Shamroukh — Wed, 07 Jan 2026 17:32:16 +0000

Everyone is talking about AI replacing developers. Some say junior devs won’t even find jobs in 2026. As someone running a dev team at RobinReach, I think this is overblown and here’s why.

Writing Code Is Not the Same as Solving Problems

A lot of people think coding is just typing lines of code or building a simple website. Real software development is way more than that. You have to understand what a feature should actually do, how it should behave in tricky situations, track down bugs and find the root cause, design a system that is scalable and maintainable, and make decisions about trade-offs between speed, performance, security, and user experience.

And when it comes to full web apps, it gets even more complex. You are not just writing HTML or CSS. You have databases, backend logic, routing, state management, APIs, integrations, and frontend frameworks. AI cannot grasp the full system in context or reason about how all the pieces interact.

Static Websites Versus Full Web Apps

This is where people get confused. A static website is something simple, like a landing page or portfolio. You can set up a WordPress site or a Wix page in a couple of hours without any AI. It’s straightforward and there is nothing revolutionary about AI doing the same thing a little faster.

Full web apps are a different story. They have databases, backend logic, authentication, APIs, dynamic routing, state management, error handling, and scaling. Building and maintaining these apps requires problem-solving, debugging, and architectural thinking. AI is not ready to do that.

What Research Says

A recent MIT CSAIL study reported by IBM Think confirms this. It says that AI can churn out code but cannot think like a software engineer. AI struggles with planning long-term code, understanding an entire codebase, and handling legacy systems or specialized libraries.

Even the best AI does not remember previous prompts or understand how a project evolves over time. AI can write code but it cannot replace the reasoning, problem-solving, and judgment that real developers provide.

You can read the full article here: IBM Think – AI can write code, but can it beat software engineers?

My Experience at RobinReach

Even with AI tools, my junior developer drives the AI, not the other way around. They review suggestions, debug issues, validate fixes, and make architectural decisions. AI speeds up repetitive work but the thinking, problem-solving, and judgment are still fully human.

The Future of Development

The future is not AI replacing developers. It is humans working with AI. Developers who learn to use AI effectively will be faster and more productive. But understanding systems, reasoning through problems, and building robust software will always be human work.

Are we overestimating AI, or is the future really about developers guiding AI to solve real software problems?

Managing Multiple Brands in Rails: Multi-Tenant Patterns from RobinReach

Shaher Shamroukh — Mon, 22 Dec 2025 20:47:02 +0000

Scaling a SaaS application is one thing; letting a single user manage multiple brands, each with its own isolated data, is another.
At RobinReach, we faced this challenge head-on: users needed to handle multiple workspaces, each with its own social profiles, posts, and team members, all while switching seamlessly between them.
Here’s how we built it in Rails, and the lessons learned along the way.

The Challenge: Multi-Brand Management

Imagine a user managing three different companies on your platform. Each company has:

Its own social media profiles
Scheduled posts
Team members and roles
Analytics and performance data

Without proper isolation, cross-tenant data leaks become a nightmare.
Multi-tenancy is not just a database pattern, it’s a mindset for every layer of your application.

Workspace-Based Multi-Tenancy

At RobinReach, we modeled each brand or workspace as a tenant. All core models—Posts, SocialProfiles, Members, are scoped to a tenant. We use a thread-safe Current object to hold the tenant context:

class Current < ActiveSupport::CurrentAttributes attribute :company end

This allows all models to reference the current tenant easily:

class Post < ApplicationRecord belongs_to :company default_scope { where(company_id: Current.company.id) } end
With this pattern, every query automatically respects tenant boundaries.

Seamless Workspace Switching

Users expect to switch between workspaces without logging out. We store the current workspace in the session:
def switch_workspace(company_id) session[:current_company_id] = company_id Current.company = Company.find(company_id) end
This ensures that every action like viewing posts, scheduling content, or managing members, is scoped correctly to the selected workspace.

Background Jobs in a Multi-Tenant Environment

Multi-tenancy isn’t just about database queries; background jobs must also respect tenant boundaries.

Lessons Learned:
Always pass the tenant ID to background jobs.

Make jobs idempotent to prevent cross-tenant side effects.

Use Sidekiq queues strategically; high-volume tenants might need separate queues.

Best Practices for Workspace Multi-Tenancy

Enforce tenant isolation at all layers – models, services, jobs, and controllers.
Use thread-safe context objects (Current) for tenant information.
Design for fast workspace switching in the UI.
Keep background jobs idempotent and tenant-aware.
Cache per tenant when appropriate to reduce database load.
Monitor performance per workspace to detect heavy tenants early.

Conclusion

Building a multi-brand SaaS in Rails isn’t just a technical challenge, it’s a design mindset.
RobinReach demonstrates that with careful scoping, background job design, and workspace isolation, you can deliver a seamless multi-tenant experience.

For Rails developers building SaaS platforms, these patterns can save you from future headaches and set your app up for scale.

Building an AI Social Media Manager with Ruby on Rails: Architecture, Automation, and Lessons Learned

Shaher Shamroukh — Thu, 23 Oct 2025 19:56:33 +0000

Building an AI Social Media Manager with Ruby on Rails: Architecture, Automation, and Lessons Learned

In a previous post, How We’re Building a Social Media Empire with Rails and Sidekiq,
I shared how we scaled background jobs and task automation using Rails and Sidekiq. That article focused on how RobinReach
Our social media management platform handled large-scale post scheduling and media processing.

This time, we’re taking a deeper dive into how we integrated AI into our architecture and how Ruby on Rails continues to be the backbone of everything we build.

Why Rails Still Works for AI SaaS

Even in 2025, Ruby on Rails remains a perfect fit for startups building fast, scalable, and flexible SaaS products. When we started building RobinReach, we needed to:

Move fast with a clean architecture.
Handle complex background automation.
Support multi-tenant data isolation for agencies.
Integrate AI models that evolve quickly.

Rails gave us that foundation. With Hotwire and Tailwind CSS, we kept the frontend lean and responsive, no heavy SPAs needed.

Our Service-Driven Architecture

One of our early decisions was to adopt a service-driven architecture. Every core component from AI post generation to video rendering lives inside a dedicated service class.

That means each domain (posts, media, analytics, automation) can evolve independently while staying testable and predictable.

Example:

class Ai::ContentGeneratorService
 def initialize(post)
  @post = post
 end

 def call
  prompt = "Create a social media caption about #{@post.topic} in an engaging tone."
  response = RubyLLM::Client.new(model: "gpt-4o-    mini").complete(prompt)
 @post.update!(caption: response.text)
 end
end

By keeping logic inside services, we avoid bloated models and controllers, and it makes it easy to reuse across background jobs.

Using AI for Content Refinement

We started with the ruby-openai gem, but later switched to ruby-llm for its flexibility and broader model support.

Our AI layer powers features like:

RobinGen → generates captions, hashtags, and text variations.
RobinPilot → automates post creation from articles or ideas.
Content refinement → rewrites existing drafts to fit platform tone (LinkedIn, Instagram, etc.).

The workflow is simple:

User drafts or uploads content.
AI refines tone, grammar, or platform style.
User reviews and approves before scheduling.

We use background jobs to handle API calls asynchronously, ensuring the dashboard stays responsive while posts are being “AI-polished.”

Media Handling with MiniMagick and FFmpeg

For visuals, we rely on MiniMagick for image resizing and Streamio-FFmpeg for short-form video generation. These two tools help us dynamically create social media content that looks like it was edited manually.

Multi-Tenant Design for Agencies and Brands

RobinReach was designed for both businesses and marketing agencies. Each company account can manage multiple brands, each brand having its own users, social profiles, posts, and analytics.

We use a company context service to isolate data automatically:

Every query is scoped by company.
Each background job inherits that context.
Admins can switch between brands instantly.

This approach ensures data security and scalability without introducing unnecessary complexity.

Lessons Learned Building RobinReach

AI integration works best when it’s optional and assistive, not intrusive.
Service objects keep Rails clean and maintainable as complexity grows.
Multi-tenancy needs clear boundaries early, retrofitting it later is painful.
Rails still excels when paired with modern, lightweight tools like Hotwire and Tailwind.

Closing Thoughts

Building RobinReach has been a continuous learning process. We’ve learned that Rails is still one of the best frameworks for quickly turning complex ideas, like AI-driven automation, into production-ready features.

Our next steps include making RobinReach’s AI even smarter, from better content understanding to predicting the best times to post.

If you’d like to follow our journey or see how AI can simplify your social media workflow, you can check out RobinReach at https://robinreach.com/en
.

How We’re Building a Social Media Empire with Rails and Sidekiq

Shaher Shamroukh — Tue, 05 Aug 2025 21:23:22 +0000

It’s been a minute since I last published a blog post, mostly because we’ve been busy building RobinReach, a modern social media management platform powered by Ruby on Rails.

If you’ve ever tried building a tool that posts to multiple social platforms, handles different time zones, supports team approvals, automates publishing, and still provides clean analytics… you know it’s not a walk in the park.

What could’ve easily turned into a tangled mess of conditionals, platform-specific logic, and fragile scheduling code became a clean, maintainable, and scalable system thanks to Rails' service-oriented design and Sidekiq for background job handling.

The Stack That Powers RobinReach
RobinReach runs on a streamlined and modern Rails stack:

Ruby on Rails 7
PostgreSQL
Sidekiq + Redis for background jobs
Hotwire + Stimulus for reactive UI
TailwindCSS for styling

We manage thousands of scheduled posts across platforms like Instagram, LinkedIn, TikTok, Twitter, and YouTube, all orchestrated through Sidekiq workers that handle everything from publishing to AI content generation.

🧩 Why a Service-Oriented Architecture?
Each social media platform comes with its own rules: different APIs, content requirements, authentication flows, error handling, rate limits, the list goes on.

Instead of cluttering models or controllers with conditional logic, we split the logic by platform using dedicated service classes, like this:

module SocialMedia
  module InstagramDirect
    class Post < SocialMedia::ApplicationService
      def initialize(post, profile)
        # setup context
      end

      def call
        # 1. create media container
        # 2. wait for readiness
        # 3. publish
        # 4. return success or failure
      end
    end
  end
end

We use the same structure for:

SocialMedia::Twitter::Service
SocialMedia::LinkedIn::Service
Each class is responsible for only one job: posting to its platform.

What This Gives Us:

A clean interface: PlatformService.new(post, profile).call
Separation of concerns
Platform-specific logging + error handling
Easier testing, mocking, and maintenance

⏱ Why Sidekiq?

Publishing a post isn’t instant:

It needs to go out at the scheduled time
Some platforms require polling
Others need multi-step media uploads
You don’t want users waiting for any of that

Welcome Sidekiq.

We use Sidekiq to handle everything asynchronously and at scale.

A Typical Flow:

User schedules a post for a future time
We enqueue the job like this:

PostJob.perform_at(post.publish_time, post.id)

The job runs, finds the post, and calls the right service object
Everything happens in the background, with automatic retries if things fail.

💡The Sweet Spot: Service + Sidekiq
Here’s why the combination is so powerful:

🔧 Service Objects ⏱ Sidekiq
Encapsulate platform logic Handles execution & timing
Keep jobs thin Makes everything async
Testable, predictable Retryable, resilient
Modular per platform Scalable with queues

We can:

Add new platforms without touching existing logic
Retry failed posts automatically
Track errors in logs or monitoring tools
Move fast without fearing regression

🧪 Testability Bonus

Each service object is unit-tested on its own.
Jobs are tested separately with inline Sidekiq workers.
Because logic is separated, we can:
Mock external API calls in services
Simulate platform failures
Write isolated tests for platform behaviors

This would be a nightmare with fat models or controllers.

Final Thoughts
If you’re building a Rails app that interacts with third-party APIs, handles user actions asynchronously, or needs to scale beyond a weekend project…

💡 Split logic into service objects
🧠 Run tasks with Sidekiq

That combo gave us:

A cleaner codebase
Faster iteration cycles
Fewer bugs
Less stress

Rails gives you the foundation. These two patterns help you build skyscrapers on top of it.

Oh, and one more thing…
Turns out we’re not the only social media management tool built with Rails, shoutout to Publer, whose product and UX has definitely inspired us along the way.

Rails is alive and well. And with service objects + Sidekiq, it scales beautifully.

How to Integrate Your SaaS with AppSumo: A Step-by-Step Guide

Shaher Shamroukh — Thu, 13 Mar 2025 16:23:53 +0000

If you're launching your SaaS on AppSumo, integrating with their API is crucial for a smooth user experience. This guide walks you through the AppSumo authentication and license verification process, using a fully working Ruby on Rails example.

This article was inspired by RobinReach’s AppSumo integration.
Check out RobinReach for automated social media management! 🎯

Whether you're a founder or developer, this guide will help you integrate AppSumo seamlessly.

Why Integrate with AppSumo?

AppSumo offers lifetime deals (LTDs) to a large number of users.
To streamline onboarding and license verification, they provide an OpenID-based authentication system. By integrating with AppSumo's API, you can:

Verify purchases and activate licenses automatically
Handle license upgrades/downgrades
Respond to AppSumo webhook events
Improve user onboarding

Step 1: Setting Up the Authentication Flow

The first step in the integration is to set up an authentication flow that allows users to sign in via AppSumo.

1.1 Create an OAuth Redirect to AppSumo

In AppsumoAuthController, we define a method to generate the OAuth authorization URL and redirect users:

class AppsumoAuthController < ApplicationController
  skip_before_action :authenticate_user!
  skip_before_action :verify_authenticity_token

  CLIENT_ID = Rails.application.credentials.appsumo.client_id
  REDIRECT_URI = 'https://robinreach.com/appsumo/callback'

  def redirect
    auth_url = "https://appsumo.com/openid/authorize?client_id=#{CLIENT_ID}&response_type=code&redirect_uri=#{REDIRECT_URI}"
    redirect_to auth_url, allow_other_host: true
  end
end

This method constructs the OAuth authorization URL, allowing users to authenticate via AppSumo. Upon successful authentication, users are redirected to the specified callback URL.

1.2 Handle the Callback and Exchange Code for an Access Token

When users approve the authentication, AppSumo redirects them back with an authorization code. We exchange this code for an access token:

def callback
  code = params[:code]
  return redirect_to auth_url if code.blank?

  response = fetch_access_token(code)
  if response['access_token']
    session[:appsumo_access_token] = response['access_token']
    session[:appsumo_refresh_token] = response['refresh_token']
    redirect_to appsumo_license_path
  else
    render json: { error: response['error'] || 'Failed to authenticate' }, status: :unauthorized
  end
end

The fetch_access_token method sends a request to AppSumo to retrieve the access token:

def fetch_access_token(code)
  response = self.class.post('/token/', headers: { 'Content-Type' => 'application/json' }, body: {
    client_id: CLIENT_ID,
    client_secret: Rails.application.credentials.appsumo.client_secret,
    code: code,
    redirect_uri: REDIRECT_URI,
    grant_type: 'authorization_code'
  }.to_json)

  response.parsed_response
end

This step is essential for securely retrieving an access token, which will be used for further API requests.

Step 2: Fetch and Validate the License Key
Once authenticated, we need to fetch the license key to check if the user has a valid AppSumo purchase

def fetch_license
  access_token = session[:appsumo_access_token]
  if access_token
    response = self.class.get("/license_key/", query: { access_token: access_token })
    if response.success?
      license_key = response.parsed_response["license_key"]
      handle_license_verification(license_key)
    else
      refresh_access_token
    end
  else
    redirect_to new_user_session_path
  end
end

This method retrieves the license key and checks if it belongs to an existing Company. If not, the user is directed to sign up.

Step 3: Handling Webhook Events

AppSumo sends webhooks for key events like purchases, upgrades, and deactivations. We need to process them accordingly.

def webhook
  payload = JSON.parse(request.body.read)
  license_key = payload['license_key']
  event = payload['event']
  tier = payload['tier'].to_i

  case event
  when 'activate', 'purchase'
    REDIS.set(license_key, { license_key: license_key, tier: tier }.to_json, ex: 60 * 60 * 24 * 60)
    render json: { success: true, event: event }, status: :ok
  when 'upgrade', 'downgrade'
    update_license(license_key, payload['prev_license_key'], tier)
  when 'deactivate'
    deactivate_license(license_key)
  else
    render json: { success: false, error: 'Unknown event' }, status: :bad_request
  end
end

Why Store in Redis?

We use Redis to temporarily store the license data for quick access. This reduces the number of database queries and speeds up license verification. The data is set to expire after 60 days, ensuring that stale licenses are not kept indefinitely.

Updating the Company Based on the Event

For events like purchases or upgrades, we update the Company record to reflect the new subscription tier:

def update_company_license(license_key, tier)
  company = Company.find_by(license_key: license_key)
  if company
    company.update(plan_tier: tier)
  else
    Company.create(license_key: license_key, plan_tier: tier)
  end
end

This ensures that companies have the correct access level based on their AppSumo purchase.

Step 4: Securing Webhooks with Signature Verification
Since webhooks can be exploited, we verify requests using HMAC-SHA256 signatures:

def verify_signature
  timestamp = request.headers['X-Appsumo-Timestamp']
  signature = request.headers['X-Appsumo-Signature']
  body = request.raw_post

  return render json: { success: false, error: 'Missing headers' }, status: :unauthorized unless timestamp && signature && body

  message = "#{timestamp}#{body}"
  calculated_signature = OpenSSL::HMAC.hexdigest('SHA256', API_KEY, message)

  unless ActiveSupport::SecurityUtils.secure_compare(signature, calculated_signature)
    render json: { success: false, error: 'Invalid signature' }, status: :unauthorized
  end
end

This prevents unauthorized requests and protects your system from fraudulent webhooks.

Final Thoughts

Integrating AppSumo’s API into your SaaS can automate user onboarding, license management etc.

Key Takeaways:

✅ Implement OAuth authentication for AppSumo users
✅ Retrieve and validate AppSumo license keys
✅ Handle webhook events for upgrades, downgrades, and deactivations
✅ Secure webhooks using signature verification

This integration ensures that your SaaS can handle AppSumo deals efficiently while providing a seamless experience to users.

🔗 Next Steps:

Test OAuth flow and webhook processing.
Monitor webhook logs for debugging.

For more details, refer to the AppSumo Licensing Guide.

This guide is inspired by RobinReach’s integration with AppSumo. Discover how RobinReach simplifies social media management with automation and smart scheduling! 🚀

Just Launched RobinReach: Multi-Channel Social Media Management 🚀

Shaher Shamroukh — Wed, 18 Dec 2024 09:40:19 +0000

Hey Everyone! 👋

I’m excited to share that RobinReach, my social media management platform, is now live on Product Hunt! 🎉

RobinReach is built with Ruby on Rails and designed for small businesses, teams, and agencies to simplify their social media workflows.

Here’s what makes it stand out:

🌍 Multi-channel support: Manage all your social media accounts (Instagram, LinkedIn, Facebook, Twitter, and more) in one place.

✍️ Content creation: AI-assisted tools for generating and optimizing posts.

🔁 Content repurposing: Easily reuse and adapt content for different platforms to maximize reach.

📊 Analytics: Actionable insights to measure performance and improve engagement.

Whether you're scheduling posts, repurposing old content, or reviewing metrics, RobinReach aims to save time and boost results.

💡 Built primarily with Ruby on Rails, integrated with ChatGPT, FFmpeg, and Unsplash. It also supports features like TikTok/YouTube Shorts video generation and Canva image editing.

👉 Check it out here: RobinReach on Product Hunt.

Would love to hear your thoughts on:
1️⃣ The concept—does it fill a gap you see in social media management?
2️⃣ The tech side—any feedback or tips on scaling multi-channel management features?
3️⃣ Advice on making the most of a PH launch if you've done one before!

Let’s chat—I'm happy to answer questions about the tech stack, challenges, or lessons learned. 🚀

ActiveRecord Calculations

Shaher Shamroukh — Tue, 29 Mar 2022 16:40:24 +0000

Let's talk about some useful methods that are very handy when we need to do some calculations to our database records.

So what is activerecord calculations?

ActiveRecord Calculations provide methods for calculating values of columns in the ActiveRecord models.

`count` Method

Let's start with a method that is widely knowing for simple count.

User.count 
#returns the number of users.

Keep in mind that count is not always the most performant with that being said
this article demonstrates the difference between count, size, length.

But count has much more to offer 🔥 so let's see the different usage of count below 👇

User.count(:address)
# returns the count of all users whose address exist in our db.

User.distinct.count(:city)
# returns the count of different cities we have in our db.

User.group(:city).count
# returns a hash with each city and it's count.
#{ 'Cairo' => 5, 'Qina' => 3 }

We can also do the above 👆 with multiple columns

Post.group(:status, :category).count
# {["draft", "business"]=>10, ["published", "art"]=>5}

`maximum` Method

User.maximum(:age)
# 98
# returns the maximum value on the given column.

`minimum` Method

User.minimum(:age)
# 18
# returns the minimum value on the given column.

`average` Method

User.average(:age)
# 27.5
# returns the average value on the given column.

`sum` Method

User.sum(:age)
# 7845
# returns the sum of the values on the given column.

`ids` Method

User.ids
# returns the users ids

Summary

Please check out the documentation for reference.

I hope you found the article useful and enjoyed reading as much as i enjoyed writing it 😃.

Ruby Sets

Shaher Shamroukh — Tue, 15 Feb 2022 20:06:25 +0000

What is a Ruby Set

Ruby Set is a class implementing the mathematical concept of Set.
Meaning it stores items like an array without duplicate items so all the items in a set are guaranteed to be unique and it is a lot more faster and has some special capabilities.

Before getting into how to use set class let's first determine when do we use it.

When to use sets

Here are the few cases where sets work better:-
1- Elements order does not matter.
2- No duplicate values allowed.
3- The sequences needs to be compared for equality regardless of the order.

How to use sets

>> require 'set'
>> fruits = Set.new
>> fruits << "Apple"
>> fruits.add("Orange")
>> fruits
=> #<Set: {"Apple", "Orange"}>

We can also do this

>> numbers = Set[1, 2, 3, 4]
=> #<Set: {1, 2, 3, 4}>
Notice no duplicates allowed:
>> numbers << 3
=> #<Set: {1, 2, 3, 4}>

Here are some useful methods to use with sets

#include?
>> numbers.include?(4)
=> true

#delete
>> numbers.delete(2)
=> #<Set: {1, 3, 4}>

#disjoint?
>> numbers
=> #<Set: {1, 3, 4}>
>> numbers.disjoint? Set[5, 6]
=> true      #No elements in common the opposite is intersect?

#union or |
>> numbers
=> #<Set: {1, 3, 4}>
>> numbers.union Set[2, 4, 5] 
=> #<Set: {1, 3, 4, 2, 5}>
>> numbers | Set[2, 4, 5] 
=> #<Set: {1, 3, 4, 2, 5}>

#delete_if & It's opposite keep_if
>> fruits
=> #<Set: {"Apple", "Orange", "melon"}>
>> fruits.delete_if { |f| f == "melon"}
=> #<Set: {"Apple", "Orange"}>

#clear
>> numbers.clear
=> #<Set: {}>

As well as the method above Set is easy to use with Enumerable objects.

For more details please check out ruby-doc

Now we know how to use ruby sets for better performance and easier coding.
So if you are using Ruby in your current project and you think that any of the cases above apply to you, you should consider using ruby sets.

I hope you enjoyed reading the article as i enjoyed writing it if so Please share it so more people can find it 🙂

Working With Folders & Files In Ruby

Shaher Shamroukh — Fri, 08 Oct 2021 20:05:27 +0000

How to work with folders and files in ruby?

Ruby has two built in classes for us to work with files and folders those classes are Dir for directories and File for the files.

Ruby `Dir` class.

To create a Dir instance, you pass a directory path to new like the following:

d = Dir.new("/home/shaher/work/test")
d.entries
=> ["..", ".", "file.txt", "main.rb", ".csv"]

We can also use the class method

Dir.entries("/home/shaher/work/test")
=> ["..", ".", "file.txt", "main.rb", ".csv"]

We can get hold of the entries using the entries method,
or using the glob technique.
And the main difference is that globbing the directory doesn’t return the hidden entries (entries whose names start with a period.)
It also permits the wildcard matching and the recursive matching in the subdirectories.

Now with entries method we have the files in a nicely structured array so let's dive into the file class to do the work on our files.

Ruby `File` class

To create the file and write value we can do the following

f = File.new("comment.txt", "w")

Now you will see the file created and we have the object to use.
Let's add some text to the file we just created and close the file

f.puts "this text meant to be added to the comment file"
f.close

well we added the text but we wanna add more and update the file then we do the following

f = File.new("comment.txt", "a")
f.puts "we added this extra text to update the file"
f.close

Now we have our file holds the text we added and updated.

But using File.new to create a File object make us close the file ourselves.
Ruby as always being elegant and meant for our happiness it provides an alternate way to open files that puts
the task of closing the file in it's hands.
File.open with a code block.

When we call File.open with a block, the block receives the File object as its single argument.
So we use that File object inside the block and When the block ends, the File object is automatically closed.

In the following example our file is opened and read in line by line for processing.

File.open("comment.txt") do |f|
  f.each do |line|
    puts line.upcase
  end
end
=> THIS TEXT MEANT TO BE ADDED TO THE COMMENT FILE
=> WE ADDED THIS EXTRA TEXT TO UPDATE THE FILE

Ruby stops iterating when it hits the end of the file and closes the file.

Another method ruby provides is readlines which reads the whole file into an array like the example below:

File.readlines("comment.txt") do |f| 
  f.each do |line| 
    puts line
  end
end
=> ["this text meant to be added to the comment file\n", "we added this extra text to update the file\n"]

But why all that and not just iterate on the file and avoid wasting the space required to hold the file’s contents in memory?

Summary

Along with File and Dir classes there is also FileUtils module which provides some practical and convenient methods that make it easy to manipulate files from Ruby in a concise manner and in ways that correspond to familiar system commands.
File class reference
Dir class reference

I hope you enjoyed reading this article and found it useful! 🙂

Ruby Regular Expressions

Shaher Shamroukh — Mon, 04 Oct 2021 18:18:47 +0000

What is Ruby regular expressions (ruby regex)?

Regular expressions appear in many programming languages, with minor differences.

Their purpose is to specify character patterns that subsequently are determined to match or not match.
Pattern matching, in turn, serves as the basis for operations like parsing log files, testing keyboard input for validity, etc.

Regular expressions have a reputation of being incredibly powerful.

Regular expressions are instances of the Regexp class.
and it's literal constructor is a pair of forward slashes:
//

//.class
=> Regexp

Between the slashes we add the specifics of the regexp.
Now Any pattern-matching operation has two ends: a regexp and a string.
and the simplest way to do that with the match method.
we can do this either way since regular-expression
objects and string objects both respond to match.
Ruby also provides pattern-matching operator,
=~(equal sign and tilde).

p "Match!" if /ruby/.match("ruby is wonderful")
=> "Match!"

p "Match!" if "ruby is wonderful"=~(/ruby/)
=> "Match!"

Building regular expression pattern

When we write a regexp, we put the definition of the pattern between the forward slashes //.
and what we are putting simply a set of predictions that we want to look for in a string.

regex components

Literal characters,/r/ “match this character”.
The dot wildcard character (.), “match any character”.
Character classes, [aeiou] matches any vowel.

So far, we’ve looked at basic match operations which are true/false tests.

regex.match(string)
string.match(regex)

Till now we got the basics of regexp, and for everyone
I definitely recommend trying out Rubular to build your own regexp taking advantage of it's quick reference, which is awesome for practice, and it is very interactive.

I hope you enjoyed reading the topic as much as i enjoyed writing it. 🙂

Most Handy Ruby Array Methods

Shaher Shamroukh — Mon, 06 Sep 2021 20:01:58 +0000

The Handiest Ruby Array Methods

Array is a fundamental class in ruby, so whether you are building a ruby program or developing a rails app, having a good knowledge of array methods will be very helpful.
and it's a most to know some of these methods.

If you want to know more about Ruby arrays, take a look at Ruby-Docs

Quick tip😉
You can have access to ruby docs via the terminal by running the following command rvm docs generate
then you can look up anything for example we will see the .first array method so we run ri Array#first also by running ri Array this will output all the information about the array class and it's instance methods as well it's class methods.

So without further ado let's create our array and get started.

arr = Array(1..5) that's same as arr = [1, 2, 3, 4, 5]

.first

As the name implies this method gets the first element of the array.

arr.first
=> 1

.last

As the name implies this method gets the last element of the array.

arr.last
=> 5

.length

This the most common one, this method will return the number of elements in the array

arr.length
=> 5

.take

The method returns an array with the number of elements we pass to it as an argument.

arr.take(4)
=> [1, 2, 3, 4]

.drop

The method returns an array without the number of elements we pass to it as an argument.

arr.drop(4)
=> [5]

.shift

This will remove the first element of an array.

arr.shift
=> 1

arr
=> [2, 3, 4, 5]

.pop

This will remove the last element of an array.

arr.pop
=> 5

arr
=> [2, 3, 4]

.unshift

This will add the element to the beginning of the array.

arr.unshift(1)
=> [1, 2, 3, 4]

.push

This will add the element to the end of the array.

arr.push(5)
=> [1, 2, 3, 4, 5]

.insert

With this method we can add elements to the array at any position.

arr = [1, 2, 3, 4, 5]
arr.insert(3, nil, true, "Mango")

=> [1, 2, 3, nil, true, "Mango", 4, 5]

.compact

This method will remove the nil values from the array

arr = [nil, 1, 2, nil, 3, 4, 5, nil]
arr.compact
=> [1, 2, 3, 4, 5]

array index

When we want to access a specific element in the array we use it's index since each element in the array has an index which starts at 0, and if the index does not exist in the array we get nil returned.

arr[0]
=> 1

arr[3]
=> 4

arr[-1]
=> 5

arr[2] = 7
arr
=> [1, 2, 7, 4, 5]

Another way to access a particular array element is by using the at method

arr.at(0)
=> 1

.delete_at

This method will remove the element based on the index we provide as an argument.

arr.delete_at(0)
=> [2, 3, 4, 5]

.reverse

This method will reverse the array items, keep in mind it will not mutate the array.

arr.reverse
=> [5, 4, 3, 2]

arr
=> [2, 3, 4, 5]

.include?

This method checks if the given argument included in the array or not.

arr.include?(5)
=> true

arr.include?(9)
=> false

.empty?

This method checks whether an array contains any elements at all.

arr = [1, 2, 3, 4, 5]
arr.empty?
=> false

arr = []
arr.empty?
=> true

.concat

The concat method takes multiple arrays as an argument and returns one array.

arr = [0, 1, 2, 3]
arr.concat([4, 5, 6, 7], Array(8..10))

=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

.uniq

This method returns the unique elements in a given array and remove the duplicate ones

arr = [1, 2, 2, 2, 3, 4, 4, 5]
arr.uniq

=> [1, 2, 3, 4, 5]

Now on top of those methods the Array class include the Enumerable module, as stated in the ruby API The Enumerable mixin provides collection classes with several traversal and searching methods.

Please checkout the Ruby-Guide.

I hope you enjoyed the reading as i have enjoyed writing it😄😄😄

Top 5 Tips to Boost your rails app performance

Shaher Shamroukh — Tue, 17 Aug 2021 13:08:56 +0000

The performance of the web application is crucial and the app speed really matters, as it plays a great role of it's success.

so what techniques will help us improve the performance of our application?

Here we will talk about the top 5 easy techniques to boost the performance of the rails app.

1- Caching

Caching caching caching

Caching is crucial to significantly improve the app performance.
To put it simply, caching means storing the results of a complex (or not so complex) computation in some storage and later returning them right away without the need to re-compute everything.
Also "cache" is a French word that means "to hide" and "cache-cache" is a hide-and-seek game.

Now caching is a long topic to cover in one article so i will list the resources that cover everything you need to know about rails caching.

Caching with Rails: An Overview rails guides

Everything You Ever Wanted To Know About View Caching In Rails honeybadger

How Active-record Uses Caching To Avoid Unnecessary Trips To The Database honeybadger

Mastering Low Level Caching in Rails honeybadger

2- N+1 query problem

This is a very popular and simple optimization technique
but it deserves the first mention since this mistake is so prevalent.
To eliminate the N+1 problem make use of the MySQL database joins and the Rails Active-record includes functions.

Here is a good article about eliminating the n+1 query problem and taking advantage of the bullet gem.

3- Use `size` Instead of `length` or `count`

Here is why
count will perform an SQL COUNT query
length will calculate the length of the resulting array
size will try to pick the most appropriate of the two to avoid excessive queries.
Take a look at this article about size vs length vs count.

4- Use `pluck`

pluck can be used to query single or multiple columns from the underlying table of a model. It accepts a list of column names as an argument and returns an array of values of the specified columns with the corresponding data type.

Unlike select, pluck directly converts a database result into a Ruby Array, without constructing Active-record objects. This means better performance for a large or frequently-run query.

To see the example and usage of pluck method check it out on rails guides

5- Upgrade Ruby and rails

New versions tend to bring performance improvements as well as security and new methods that often faster for their case uses.
Here is a good article about Why Is It Important to Upgrade Your Rails Application.

I hope you enjoyed reading the article as i have enjoyed writing it.

Forem: Shaher Shamroukh

AI Can Write Code But It Still Can’t Think Like a Developer

Managing Multiple Brands in Rails: Multi-Tenant Patterns from RobinReach

Building an AI Social Media Manager with Ruby on Rails: Architecture, Automation, and Lessons Learned

How We’re Building a Social Media Empire with Rails and Sidekiq

How to Integrate Your SaaS with AppSumo: A Step-by-Step Guide

Just Launched RobinReach: Multi-Channel Social Media Management 🚀

ActiveRecord Calculations

So what is activerecord calculations?

ActiveRecord Calculations provide methods for calculating values of columns in the ActiveRecord models.

count Method

maximum Method

minimum Method

average Method

sum Method

ids Method

Summary

Ruby Sets

What is a Ruby Set

When to use sets

How to use sets

Here are some useful methods to use with sets

Working With Folders & Files In Ruby

How to work with folders and files in ruby?

Ruby Dir class.

Ruby File class

Summary

Ruby Regular Expressions

What is Ruby regular expressions (ruby regex)?

Building regular expression pattern

regex components

Most Handy Ruby Array Methods

The Handiest Ruby Array Methods

.first

.last

.length

.take

.drop

.shift

.pop

.unshift

.push

.insert

.compact

array index

.delete_at

.reverse

.include?

.empty?

.concat

.uniq

Top 5 Tips to Boost your rails app performance

1- Caching

2- N+1 query problem

3- Use size Instead of length or count

4- Use pluck

5- Upgrade Ruby and rails

`count` Method

`maximum` Method

`minimum` Method

`average` Method

`sum` Method

`ids` Method

Ruby `Dir` class.

Ruby `File` class

3- Use `size` Instead of `length` or `count`

4- Use `pluck`