Forem: Mati Palak

Rails Built-in Rate Limiting: A Deep Dive

Mati Palak — Sun, 03 Aug 2025 14:23:12 +0000

Ruby on Rails 7.2 introduces a powerful, built-in rate limiting mechanism directly into Action Controller. This eliminates the need for third-party gems like rack-attack for many common use cases, offering a first-party, integrated solution for protecting your application from abuse.

How the Rails rate limiter works?

At its core, the Rails rate limiter allows you to define how many requests a client (by default, an IP address) can make to specific controller actions within a set time window. If the client exceeds this rate, Rails automatically returns a 429 Too Many Requests HTTP response. You can also configure a custom response if needed.

Here’s a simple example of how to use it:

class SessionsController < ApplicationController
  rate_limit to: 10, within: 3.minutes, only: :create
end

This configuration limits each unique IP address to 10 calls to the create action (e.g., for login attempts) within a three-minute window.

Customization options

The rate_limit method is highly flexible, offering several options for tailoring its behavior to your specific needs:

- to: The maximum number of requests allowed within the defined time window.
- within: The duration of the time window for the rate limit.
- only: Specifies the controller actions to which the rate limit should be applied.
- except: Specifies the controller actions to exclude from the rate limit.
- by: A lambda that defines a custom key for rate limiting. By default, this is request.remote_ip. You can use it to limit based on, for example, a current_user.id or a domain.
- with: A lambda for custom handling when the limit is exceeded. Instead of the default 429 Too Many Requests response, you could, for instance, redirect the user.
- store: Allows you to specify a different cache store for the rate limiting data, which is crucial for scaling. By default, it uses config.action_controller.cache_store.
- name: Useful for defining multiple, separate rate limits within the same controller.

Here are some practical examples of these customization options:

# Custom grouping logic: Limit based on user ID
rate_limit to: 100, within: 1.hour, by: -> { current_user.id }

# Custom response when the limit is exceeded
rate_limit to: 5, within: 1.minute, with: -> { redirect_to login_path, alert: "Too many attempts." }

# Using a Redis cache store for distributed rate limiting
RATE_LIMIT_STORE = ActiveSupport::Cache::RedisCacheStore.new(url: ENV["REDIS_URL"])
rate_limit to: 10, within: 3.minutes, store: RATE_LIMIT_STORE
Under the Hood: Source Code Insights
The rate_limit method isn't magic; it's implemented efficiently using existing Rails infrastructure.

The rate_limit method itself is a class method defined in ActionController::RateLimiting::ClassMethods.

It sets up a before_action callback. This callback triggers a private method, rate_limiting, before the specified controller actions are executed.

The request counter is incremented and stored using Rails’ ActiveSupport::Cache. The default cache store is determined by config.action_controller.cache_store, but, as shown above, you can override it per controller or action.

Cache keys are generated by combining the controller path, an optional name (if specified), and the value returned by the by block (e.g., an IP address or user ID). For example, a cache key might look like rate-limit:sessions:create:192.168.0.1.

If the count of requests exceeds the to threshold, Rails will either respond with a 429 status or execute your custom with: callback.

Here’s a simplified look at the core implementation from action_controller/metal/rate_limiting.rb: Link to source code

def rate_limit(to:, within:, by: -> { request.remote_ip }, with: -> { head :too_many_requests }, store: cache_store, name: nil, **options)
  before_action -> { rate_limiting(to: to, within: within, by: by, with: with, store: store, name: name) }, **options
end

private

def rate_limiting(to:, within:, by:, with:, store:, name:)
  # Constructing a unique cache key based on controller, optional name, and the 'by' value
  cache_key = ["rate-limit", controller_path, name, instance_exec(&by)].compact.join(":")
  # Atomically increments the counter in the cache store and sets an expiration time
  count = store.increment(cache_key, 1, expires_in: within)
  # If the count exceeds the limit, execute the 'with' callback
  if count && count > to
    instance_exec(&with)
  end
end

How `store.increment` works with Redis?

When ActiveSupport::Cache::RedisCacheStore is used as the store, the store.increment(cache_key, 1, expires_in: within) method directly leverages Redis's atomic INCR command combined with an EXPIRE command.

Atomic incrementing: The INCR command atomically increases the integer value stored at the given key. If the key doesn't exist, Redis creates it and sets its initial value to 1. This guarantees thread-safe and reliable counting, even under high concurrency.

Automatic expiration: The expires_in: option tells Rails to set a Time-To-Live (TTL) for the key. Redis's EXPIRE command is used to automatically delete the key after the specified duration (e.g., 3 minutes). This effectively resets the counter for the next time window.

Atomicity and safety: The atomicity of INCR in Redis ensures that even if multiple web or worker processes hit the same key simultaneously, the counters remain consistent and reliable.

This mechanism ensures that each "limit key" (e.g., an IP address or user ID) gets its own independent counter in Redis, which increments with each request, is safely reset after the time window, and is automatically cleaned up for memory efficiency. If more requests arrive after a key has expired, the counter starts fresh at one.

Client IP resolution: `request.remote_ip` vs. `request.ip`

By default, the Rails rate limiter uses request.remote_ip to identify the client. This is crucial for accurate rate limiting, especially when your application is behind a proxy or CDN like Cloudflare.

Here's a breakdown of the two methods for obtaining a client's IP in Rails:
- request.ip: This method originates from Rack. It retrieves the IP address without advanced logic, often returning the address of the last proxy (e.g., Cloudflare, load balancer) rather than the actual client's IP. If your server is behind a CDN or proxy, this method is more likely to give you the intermediary's IP.
- request.remote_ip: This is a Rails-specific method that leverages the ActionDispatch::RemoteIp middleware. It intelligently inspects and interprets HTTP headers like X-Forwarded-For and Client-IP, considering a list of trusted proxies (which you can configure). It aims to determine the "most probable" client IP address by bypassing known proxy/CDN addresses. It also incorporates logic to detect IP spoofing, offering a more robust and accurate client IP.

Cloudflare and `request.remote_ip`

When using Cloudflare, your server typically sees Cloudflare's IP addresses, not the end-user's actual IP. Cloudflare sends the original client's IP in the CF-Connecting-IP header and adds its own IPs to X-Forwarded-For.

To ensure request.remote_ip accurately identifies the client behind Cloudflare, you must configure trusted proxies in your Rails application. In config/environments/production.rb, you would add Cloudflare's CIDR IP ranges:

config.action_dispatch.trusted_proxies = [
  # Cloudflare IP CIDR list – see: https://www.cloudflare.com/ips/
  IPAddr.new('173.245.48.0/20'),
  # ... and so on for all Cloudflare ranges
]

Alternatively, you can use the cloudflare-rails gem, which automatically updates the trusted proxy list and ensures both request.ip and request.remote_ip behave correctly.

For production environments behind Cloudflare or any other reverse proxy, configuring trusted_proxies and relying on request.remote_ip is essential for the rate limiter to function as intended.

Advantages of built-in rate limiting

- First-party: No need for additional gems or external dependencies for standard rate limiting, simplifying your Gemfile and reducing potential conflicts.
- Declarative: Offers a simple and expressive API directly within your controllers, making it easy to understand and implement.
- Flexible: Provides extensive customization options with by: and with: for custom grouping logic and response handling.
- Cache-backed: Leverages Rails' ActiveSupport::Cache, enabling scalability with support for distributed cache stores like Redis, Memcached or Solid Cache.
- Multiple limits: You can apply different rate limits to different actions or define multiple, distinct limits within the same controller using the name: option.

Limitations and considerations

While powerful, the built-in rate limiter has a few considerations:
- Dependency on Rails cache: The rate limiter is ineffective if caching is not enabled or properly configured. For example, in development mode, you might need to run rails dev:cache or ensure a cache directory (like tmp/cache) exists for file_store caching to function. A common pitfall is the rate limiter silently failing if the cache store isn't operational.
- Per-process cache (default): With certain cache stores (like MemoryStore), rate limits are not shared between server processes. For production deployments, you must use a shared, centralized cache store to ensure consistent rate limiting across all your application instances.
- Testing gotchas: If your test suite uses a persistent or memory-backed cache store, rate limits might not reset between tests, potentially leading to flaky or unexpected test failures. Be mindful of cache clearing in your test setup.
- Non-distributed by default: For global rate limits that span your entire infrastructure (e.g., limiting requests across all microservices), you'll need to explicitly configure a common, shared backing cache.

Anecdote: The mystery of the non-working rate limiter

During my initial implementation, I encountered a frustrating debugging session that perfectly illustrates one of the system’s key dependencies. I tested it locally by hammering the endpoint with dozens of requests, expecting to see 429 errors after the second request. But nothing happened, every request succeeded, and I couldn’t trigger the rate limit no matter how many requests I sent.
After checking and rechecking my code, examining the source implementation, and even adding logging to verify the rate limiting code was executing, I finally discovered the issue: my local development environment didn’t have caching enabled.
Rails needs a functional cache store to persist the request counters. Without the tmp/caching-dev.txt file, the cache store was effectively a no-op, so every increment operation was silently discarded. The rate limiter was running, but it couldn’t count anything! A simple rails dev:cache command immediately fixed the issue, and suddenly my rate limits worked perfectly. This experience taught me to always verify cache store functionality before debugging rate limiting logic – it’s the foundation everything else depends on.

Conclusion

Rails built-in rate limiting feature provides an easy, first-class, and expressive way to protect your application from various forms of abuse directly within your controllers. It's an ideal solution for most typical scenarios, offering high configurability and leveraging Rails' established caching infrastructure for scalability.

For more complex or unusual policies, such as global quotas across multiple services, sophisticated "burst" algorithms, or advanced whitelisting, more specialized third-party libraries or external solutions (like those provided by CDNs or reverse proxies) might still be required. However, for most application-level rate limiting needs, the new Rails feature is a significant and welcome improvement.

Have you tried the built-in Rails rate limiter in your applications? How does it compare to other solutions you've used? I'd love to hear your experiences!

What I learned while building ActiveRubyist

Mati Palak — Fri, 30 May 2025 19:04:20 +0000

Back in July 2024, I published my last post on this blog. Since then, I’ve been quiet — at least here. Behind the scenes, I’ve been busy building something I’ve wanted for a long time: a dedicated platform for Ruby developers to stay up to date, share resources, and connect.

That platform is ActiveRubyist.com, and in this post, I’ll walk you through what it’s become, how it started, what I’ve learned from building it solo — and where it’s heading next.

From idea to working product

The idea for ActiveRubyist was born around mid-2023. I was starting a new job and found myself wishing for a central place to keep up with news, tutorials, blog posts, and tools from the Ruby and Rails ecosystem.

The first version of ActiveRubyist was extremely simple — it pulled content from a handful of RSS feeds and presented them in a basic interface. I built it using Ruby on Rails 7.0, PostgreSQL as the database, and Tailwind CSS with a pre-made theme that I lightly customized. It was deployed on Hetzner using Hatchbox.

Then, life happened. My new job demanded most of my attention, and the project sat idle for several months. But in fall 2024, I returned to it with fresh motivation and a desire to bring it to the next level.

By then, Rails 8 had been released, along with a new deployment tool: Kamal. It felt like the right moment to modernize the app and explore what the latest version of Rails had to offer.

Technical stack and development choices

Working with Ruby and Rails has never felt better. Rails has evolved into a full-stack framework that allows you to build powerful applications without constantly reaching for third-party tools or JavaScript-heavy solutions.

ActiveRubyist is now a Progressive Web App (PWA) with Hotwire-based interactivity. For authentication, I use devise, and for real-time notifications, noticed. Where possible, I lean into default Rails features: for background jobs, I use Solid Queue instead of Sidekiq, keeping everything aligned with the Rails way.

This project also became a playground. I tried out new gems, explored new APIs, and dove into areas I rarely get to touch at work — from performance tuning to monitoring production errors. One unexpected challenge? Dealing with spam bots registering fake accounts. I quickly integrated Cloudflare Turnstille - a verification tool to replace CAPTCHAs, which worked surprisingly well.

In short: this app became not just a project, but a real-world sandbox. And real-world problems always teach you more than toy apps ever can.

No community? No problem (yet)

One thing I haven’t focused on - yet — is building a user base or community around the project. ActiveRubyist isn’t promoted, doesn’t have a social media presence, and doesn’t even collect emails.

But there is one integration that’s live and active: every blog post on dev.to tagged with ruby is automatically aggregated and displayed on the ActiveRubyist posts page. So if you’re blogging about Ruby here, you’re already contributing to the platform — thank you!

Down the line, I’d love to create ways for users to submit content, recommend resources, and maybe even form local or topic-based groups. But for now, this remains a personal, ongoing project.

The most important lessons

Over the past year, I’ve learned more than I ever expected — not just about Rails, but about product building in general.

Build for production early. The sooner your app is running in production, the sooner you’ll hit the kinds of issues that never show up locally — real-world traffic, bot attacks, caching quirks, performance bottlenecks.
Keep things boring (and stable). Using default Rails solutions like Solid Queue instead of external dependencies reduces friction and increases focus. I spend less time configuring and more time shipping.
End-to-end ownership is invaluable. From infrastructure and deploys to user experience and error monitoring, I now understand how much goes into running even a small app — and how satisfying it is to see it work.

Most of all, I gained confidence: that I can take an idea, build it, deploy it, and iterate on it without waiting for permission, a team, or a perfect plan.

Where ActiveRubyist is heading next

Today, ActiveRubyist is more than just a news aggregator. It now includes:

Community groups
Event creation and discovery
Calendar with map integration
Ticket generation for events
Support for user-submitted RSS feeds

Users can already submit their own feed sources, which are summarized and linked directly to the original articles. This keeps credit where it's due, while still surfacing great content in one place.

I’m currently working on external platform integration: the idea is to allow event organizers to post once on ActiveRubyist and have their events sync across other calendars and platforms.

Beyond that, I plan to return to blogging more regularly. I want to share what I’m learning — not just about Ruby and Rails, but about the full lifecycle of building and maintaining software as a solo developer.

Final thoughts

This past year wasn’t a break from coding — it was a deep dive into independent development, platform design, and production responsibility. I built something I wanted to use, learned from every mistake along the way, and still have a long roadmap ahead.

If you’d like to see where the project goes next, feel free to check out activerubyist.com.

And if you’re writing Ruby content on dev.to — your posts are already on the site. 😉

Got feedback, questions, or just want to say hi? Drop a comment below or reach out. I'm always happy to connect with fellow Rubyists!

The Role of Mentorship: How mentors played a crucial role in my development and success.

Mati Palak — Wed, 31 Jul 2024 16:20:47 +0000

Understanding Mentorship

Mentorship is a supportive relationship where an experienced individual (mentor) shares their knowledge, guidance, and advice with a less experienced person (mentee). This kind of relationship can play a crucial role in helping the mentee navigate personal or professional challenges, set and achieve goals, and foster development and success.

Mentorship can be divided into two main categories: direct and indirect mentoring. Direct mentoring involves a one-on-one relationship where the mentor provides personalized advice, feedback, and support. This can occur face-to-face, via video calls, or through regular written communication. Indirect mentoring, on the other hand, relies on learning from someone without their direct involvement, by observing their actions, consuming their content (such as books, blogs, or videos), and applying their methods and principles to your own context.

My Mentorship Experience

In my journey, I didn’t have a direct mentor. Instead, I learned a great deal through indirect mentoring by observing and following the work of experts in my field. One figure who significantly impacted my development is Jaroslav Shmarov, a YouTube content creator. Through his videos, I learned invaluable lessons that I applied to my own work. Eventually, I had the pleasure of meeting Jaroslav in person at a conference.

Having a mentor, even indirectly, can significantly accelerate the learning process and highlight crucial areas for growth. While there is an abundance of material available on the internet, many people lack a structured path that guides them step-by-step. Mentors help provide a roadmap, eliminate unnecessary distractions, and focus on what truly matters.

As I gained more experience, I felt a strong desire to give back to the community. I volunteered as a mentor at firstrubyfriend.org, where I help budding programmers start their journeys. Initially, I wondered why people would dedicate their time to mentoring others for free. Now, I understand that it's a mix of altruism and personal development. Mentoring offers a deep sense of satisfaction and allows me to repay the support I once received. Additionally, teaching others forces me to stay up-to-date and well-organized, which also benefits my own knowledge.

Finding a Mentor

Finding a mentor for Ruby developers can significantly accelerate your learning curve and provide valuable guidance. Here are some great resources to consider:

Online Platforms and Communities

LinkedIn
Utilize LinkedIn to connect with experienced Ruby developers. Join relevant groups and participate in discussions to meet potential mentors.
Meetup
Search for local or virtual meetups related to Ruby programming. These meetups often have experienced developers who might be open to mentoring.
Reddit
Join subreddits like r/ruby and r/learnprogramming. Participating in discussions can help you connect with potential mentors.
Ruby User Groups (RUGs)
Many cities have Ruby User Groups that meet regularly. These groups can be a great way to meet experienced Ruby developers. Check out the official list of RUGs on the Ruby website.

Professional and Networking

Conferences and Workshops
Attend Ruby conferences and workshops. These events are excellent opportunities to meet experienced developers who might be open to mentorship.
Open Source Contributions
Contributing to open source projects is a great way to meet experienced developers who can mentor you. Platforms like GitHub are essential for finding Ruby projects to contribute to.

Lastly, don't be afraid to reach out directly. Whether it's through a social media platform, a professional network, or in person at a conference, many experienced developers are open to mentoring if you show genuine interest and enthusiasm.

In conclusion, mentorship—whether direct or indirect—plays a crucial role in personal and professional development. It offers guidance, support, and a clear path forward. I encourage everyone to seek out mentors and consider sharing their knowledge by mentoring others. It's a rewarding experience that benefits both the mentor and the mentee.

Do you have a mentor or someone you look up to? Share your experiences in the comments below!

Learning to Program: The resources and methods I used to teach myself coding.

Mati Palak — Mon, 01 Jul 2024 22:58:56 +0000

Hello everyone! Today, I want to share my journey in the world of programming. Changing careers can often be a significant challenge, but with the right resources and learning methods, it is achievable. Here are some of the most effective and popular methods for learning programming, along with my experiences with them.

Effective and Popular Methods for Learning Programming

- Online Courses: Structured and often very comprehensive, allowing you to learn at your own pace. Platforms like Udemy, Coursera, and edX offer courses ranging from beginner to advanced levels, often taught by industry experts.
- Interactive Coding Platforms: Websites offering interactive exercises and projects for practice, such as Codecademy, freeCodeCamp, and SoloLearn. These platforms allow you to learn by doing, which is incredibly effective.
- Books: Traditional sources of knowledge that provide in-depth theoretical understanding. Although less interactive, they are excellent sources of detailed information and best practices.
- YouTube Tutorials: Free resources that offer visual and practical tips on various programming topics.
- Coding Bootcamps: Intensive, short-term training programs that cover a lot of material in a short time. These can be more expensive options but provide quick and comprehensive preparation for a career in programming.
- Participating in Open Source Projects: Getting involved in open-source projects to gain real-world experience. This is a great way to get hands-on experience and collaborate with other programmers.
- Engaging with the Community: Participating in programming communities through forums, social media, and meetups to get support and make connections. Platforms like Stack Overflow, Reddit, and local meetups can be extremely helpful.

My Journey and the Resources I Used

Online Courses

1. Arkademy - "From Zero to Apps"

Link: Arkademy Courses by Arkency
Description: This was the first course I took. Unfortunately, it is no longer available. It was quite basic and better suited for those who already have some programming background and want to learn Ruby on Rails through practical examples. It helped me understand fundamental concepts and the mindset of a programmer.

2. Codecademy

Link: Codecademy
Description: Realizing I needed a solid foundation, I turned to Codecademy. Their interactive approach helped me understand the basics of Ruby and Rails through hands-on tasks. The step-by-step exercises and immediate feedback were very motivating.

3. Udemy

Link: The Complete Ruby on Rails Developer Course
Link: Ruby on Rails 6: Learn 20+ Gems & Build an e-Learning Platform
Description: Udemy offers a vast array of programming courses. These two courses, in particular, helped me develop my skills in Ruby on Rails.

4. SupeRails by @superails
Links: SupeRails platform, blog, youtube channel
Description: Yaroslav's platform and YouTube channel are fantastic resources. He explains everything step-by-step and often debugs live, which helped me understand common problems and their solutions. Regularly updated content and the ability to see real debugging processes were very valuable.

Books

1. The Ruby Way by Hal Fulton

Description: This book provided me with a deeper understanding of Ruby principles and best practices. It’s a comprehensive guide to the language, containing many examples and detailed explanations.

2. Design Patterns in Ruby by Russ Olsen

Description: I learned how to write more efficient and maintainable code by applying design patterns in Ruby. This book helped me understand how to structure code in a more advanced way.

Polish Resources

As a native Polish speaker, I also used several resources in my native language and the best one is:

GrubyKurs by @rafalpiekara
Link: GrubyKurs
Description: This is a complete course designed for absolute beginners. It offers a full learning path, community support through Discord, and a newsletter that proved very helpful during recruitment interviews. Rafał publishes new materials and supports his students, creating a friendly learning environment.

The Importance of Knowing English

It’s worth noting that most high-quality programming resources are available in English. When I started learning programming, I struggled with English. Over time, improving my language skills was crucial for accessing better materials and understanding programming concepts. This experience showed me the importance of being open to learning new languages and skills, as they can significantly impact our careers.

Conclusion

Learning programming took me about a year, after which I landed an internship that opened the doors to my career as a programmer. My journey to becoming a programmer was full of challenges, but with perseverance and the right resources, I achieved my goal. If you are considering a similar path, I highly recommend exploring different learning methods and finding those that work best for you. Remember, every minute spent learning and practicing brings you closer to realizing your dreams. Good luck!

Choosing Ruby: What made me choose Ruby as my primary programming language.

Mati Palak — Fri, 21 Jun 2024 16:05:11 +0000

Choosing a programming language can be a daunting task for many developers. There are countless options available, but Ruby continues to attract a loyal following. Why? Ruby is beloved for its readability, elegance, and simplicity. It’s a language that allows developers to write concise and intuitive code, leading to faster and more enjoyable application development.

Why Do People Choose Ruby?

Developers choose Ruby for several compelling reasons:

- Readable and Intuitive Code: Ruby was designed with the goal of maximising code readability. The philosophy that "programming should be enjoyable" best describes this language. Ruby's syntax is close to natural language, making the code easy to understand even for those who aren't experienced programmers.
- Ruby on Rails Framework: One of the most popular tools for rapid web application development, Rails makes building applications simpler with ready-to-use libraries and structures. For many developers, it’s a game-changer that allows quick transition from concept to a working application.
- Active Community: Ruby boasts a large and active ecosystem, meaning plenty of available resources, tutorials, and pre-built solutions. The Ruby community is known for supporting newcomers and actively backing open-source projects.
- Wide Range of Applications: Ruby is used by both startups and large corporations alike. From web applications to DevOps tools, and even automation and testing—Ruby has a broad array of applications.

Examples of Applications Using Ruby

Ruby and Ruby on Rails have been employed to develop many well-known applications, such as:

- Basecamp: A project management tool that became one of the first high-profile Ruby on Rails applications, gaining massive popularity for its simplicity and effectiveness.
- GitHub: A platform for hosting and reviewing code. GitHub has become the collaboration center for millions of developers worldwide.
- Shopify: A popular e-commerce platform enabling entrepreneurs to set up online stores quickly and easily.
- Airbnb: A short-term rental platform that started its journey with Ruby on Rails. This framework helped Airbnb swiftly develop features and scale globally.
- SoundCloud: A music sharing platform that uses Ruby on Rails to handle vast amounts of data and user interactions.
- Hulu: A popular streaming service offering a wide range of movies and TV shows.
- Zendesk: A customer service tool also built using Ruby.
- Hey: A modern email platform created by the makers of Basecamp.
- Dribbble: A social platform for graphic designers and creative professionals to showcase their work.
- Kickstarter: A crowdfunding platform that helps creators gather funds for their projects.
- Heroku: A platform-as-a-service (PaaS) offering cloud app hosting.
- Coinbase: A popular cryptocurrency exchange.
- Cookpad: A social recipe-sharing service.

Ruby is NOT Dead!

Every so often, rumours surface in the developer community about the "downfall" of a particular language. However, if you visit isrubydead.com, you’ll quickly see that Ruby is very much alive! With robust community support and new tools like Hotwire, Ruby remains one of the top programming languages. In reality, Ruby is continuously evolving, gaining new technologies that enhance its functionality and performance.

My Journey to Choosing Ruby

My journey with Ruby began quite by accident. While scrolling through Instagram, I came across the profile of @andrzejkrzywda At that time, Andrzej was regularly sharing stories about programming, business, and, of course, Ruby. His insights and enthusiasm piqued my interest.

Andrzej encouraged learning Ruby and offered a course titled "From zero to first application." I decided to give it a shot and enrolled in the course (I'll discuss the course and my learning process in a separate post). This course turned out to be a perfect fit, providing me with solid foundations and guidance on building my first application.

I wanted to create web applications, and Ruby, along with Ruby on Rails, was the ideal tool for that. Thanks to its readable syntax and the powerful capabilities of the Rails framework, I quickly managed to build my first applications, reaffirming my choice. Ruby also allowed me to focus on real business problems, avoiding overly complex technical implementations.

Conclusion

Choosing a programming language always depends on individual needs and goals. For me, Ruby turned out to be the best choice, especially for web application development. The buzz around Hotwire further solidified my belief that Ruby is a language of the future. If you're looking for simplicity, elegance, and powerful tools for building your projects, Ruby is worth a shot.

For me, it was a bullseye, but I'm curious about your opinions!
Do you use Ruby? What are your experiences with this language? Maybe you have other favourite programming languages? Share your thoughts in the comments! Your feedback is invaluable, and I'd love to hear about your experiences and perspectives.

Mati

The Reason Behind My Career Change: Why I Decided to Leave My Previous Job and Pursue Programming

Mati Palak — Thu, 13 Jun 2024 17:28:14 +0000

Changing careers is a significant decision, and it's rarely an easy one. Many people find themselves at a crossroads, questioning their current job and wondering if there's something more fulfilling out there. There are several common reasons why individuals decide to change careers and venture into the world of programming:

Lack of Job Satisfaction: Many people feel unfulfilled in their current roles and seek a career that aligns more closely with their passions and interests.
Better Opportunities: The tech industry offers numerous opportunities for growth, innovation, and financial stability, attracting those looking for a more promising future.
Desire for Flexibility: Programming can offer flexible working conditions, including remote work, which is appealing to many.
Intellectual Challenge: For those who love problem-solving and continuous learning, programming provides an intellectually stimulating environment.

While these reasons can be compelling, making a career change is not easy. It requires a lot of dedication, learning new skills, and sometimes starting from scratch. This journey demands resilience, patience, and a willingness to face and overcome challenges.

My Personal Journey

For me, the decision to change careers was driven by a need for significant changes in my life. After my divorce, I realized that I needed to reevaluate my path and find something that would bring me true satisfaction and allow me to grow.

In my previous jobs, I often felt a lack of fulfillment. The work I was doing did not offer the opportunities for personal and professional development that I craved. I knew I had to make a change, but I wasn't sure what direction to take. My previous career paths had left me feeling stagnant, with no real prospects for growth or advancement. I wanted more from my professional life and needed to find a field that would challenge me and allow me to evolve.

Interestingly, my passion for technology started at a young age. As a teenager, I used to upload simple websites to the internet using FTP. Although my family thought I would become a builder, it wasn't until years later that I discovered my true calling: building applications. This realization was both a surprise and a revelation. The idea of constructing something new and innovative, even if it was digital, resonated deeply with me.

Why Programming?

Choosing programming, and specifically Ruby, as my new career path was a decision born out of this rediscovered passion. Programming offered me the creative outlet I was looking for, and the ability to build something from scratch gave me a sense of accomplishment that I hadn't found in my previous roles.

Ruby, in particular, stood out to me because of its elegant syntax and supportive community. The language's focus on simplicity and productivity made it an ideal choice for someone like me, who was diving into a new field and needed a language that was both powerful and accessible.

Overcoming Challenges

The journey hasn't been without its challenges. Learning to code and transitioning into a new industry required a lot of hard work and perseverance. There were times when I doubted my decision and wondered if I had made a mistake. The learning curve was steep, and the field of programming can be overwhelming for a newcomer.

However, I was fortunate to have the support of mentors and the programming community. Their guidance and encouragement played a crucial role in my development. They helped me navigate the complexities of coding and provided invaluable advice on how to advance in my new career.

Finding Fulfillment

Today, I can say with confidence that making the switch to programming was one of the best decisions I've ever made. I now have a career that not only challenges me intellectually but also provides a sense of purpose and fulfillment. The satisfaction of solving complex problems and creating functional, elegant solutions is unparalleled.

Giving Back

Now, it's time for me to give back to the community that has supported me throughout this journey. I owe a debt of gratitude to the mentors, colleagues, and friends who have helped me along the way. Through this blog, I hope to repay that debt by sharing my experiences and insights, and by helping others who are considering or undergoing a similar transition.

Join the Conversation

If you're reading this and contemplating a career change, I encourage you to reflect on what truly fulfills you and where your passions lie. What are the reasons driving your desire for change? I'd love to hear your thoughts and experiences. Share your story in the comments below, and let's engage in a meaningful discussion about career changes, programming, and personal growth.

Stay tuned for more posts, and don't hesitate to leave comments or questions. I look forward to connecting with you!

Happy coding!

Mati

Welcome to My Journey: From Career Change to Ruby Developer

Mati Palak — Thu, 06 Jun 2024 08:27:59 +0000

Hello everyone and welcome to my blog! I’m thrilled to have you here as I share my journey of changing careers and becoming a Ruby developer. This blog will cover various topics related to my experiences, the lessons I’ve learned, and tips for anyone looking to embark on a similar path.

What to Expect

In the upcoming posts, I’ll be discussing a range of topics, including:

The Reason Behind My Career Change: Why I decided to leave my previous job and pursue programming.
Choosing Ruby: What made me choose Ruby as my primary programming language.
Learning to Program: The resources and methods I used to teach myself coding.
The Role of Mentorship: How mentors played a crucial role in my development and success.
Conference Highlights: My experience meeting tech celebrities at a conference on my first day of employment.
Overcoming Challenges: How I handled being laid off and quickly found a new job.
Career Growth: Doubling my salary as a junior developer and the strategies that helped me achieve this.
Embracing Opportunities: The importance of recognizing and seizing opportunities as they come.

I’m excited to share more about my journey, the technical challenges I encounter, and the strategies that help me overcome them. Whether you’re considering a career change or are already on your path to becoming a developer, I hope my experiences and insights will inspire and guide you.

Thank you for reading, and I look forward to embarking on this adventure together. Stay tuned for more posts!

Feel free to leave comments or questions below. I’d love to hear from you and engage in meaningful discussions about career changes, programming, and everything in between.

Happy coding!

Mati

Forem: Mati Palak

Rails Built-in Rate Limiting: A Deep Dive

How the Rails rate limiter works?

Customization options

How store.increment works with Redis?

Client IP resolution: request.remote_ip vs. request.ip

Cloudflare and request.remote_ip

Advantages of built-in rate limiting

Limitations and considerations

Anecdote: The mystery of the non-working rate limiter

Conclusion

What I learned while building ActiveRubyist

From idea to working product

Technical stack and development choices

No community? No problem (yet)

The most important lessons

Where ActiveRubyist is heading next

Final thoughts

The Role of Mentorship: How mentors played a crucial role in my development and success.

Understanding Mentorship

My Mentorship Experience

Finding a Mentor

Learning to Program: The resources and methods I used to teach myself coding.

Effective and Popular Methods for Learning Programming

My Journey and the Resources I Used

Polish Resources

The Importance of Knowing English

Conclusion

Choosing Ruby: What made me choose Ruby as my primary programming language.

Why Do People Choose Ruby?

Examples of Applications Using Ruby

Ruby is NOT Dead!

My Journey to Choosing Ruby

Conclusion

The Reason Behind My Career Change: Why I Decided to Leave My Previous Job and Pursue Programming

My Personal Journey

Why Programming?

Overcoming Challenges

Finding Fulfillment

Giving Back

Join the Conversation

Welcome to My Journey: From Career Change to Ruby Developer

What to Expect

How `store.increment` works with Redis?

Client IP resolution: `request.remote_ip` vs. `request.ip`

Cloudflare and `request.remote_ip`