DEV Community: RubyCademy

How Learning Ruby Helped Me Succeed in My Agency

RubyCademy — Sun, 01 Dec 2024 17:29:38 +0000

A few years ago, I was running my agency with four clients at the same time.

On paper, it sounded great—steady projects, different challenges, and a growing business.

But the reality? It was very intense. Managing meetings, deliverables, and deadlines was already a full-time job. On top of that, I also had to handle the technical work—coding, debugging, and deploying—which made everything even more complicated.

Luckily, I had spent years learning advanced Ruby concepts, techniques, and patterns. More importantly, I knew how to combine these tools to create simple and effective solutions. This skillset became my superpower, allowing me to deliver results quickly and with confidence, no matter how tight the deadline or how complex the request.

That is the beauty of Ruby—it is a language designed to help developers focus on solving problems, not on repetitive code. With the knowledge I had built over the years, I could automate repetitive tasks, simplify complex requirements, and deliver maintainable code quickly.

The technical side of my work was no longer a burden; it became a source of confidence and clarity.

This change in my approach is one of the main reasons I created RubyCademy.

I wanted to help other developers learn this skillset—mastering advanced Ruby techniques and understanding how to apply them in real-world situations. I know how important it is when your technical skills allow you to take control of your work, face challenges with confidence, and succeed under pressure.

If you are managing multiple clients or projects and feeling the pressure, remember: investing in your skills is the most valuable thing you can do.

With the right knowledge and tools, you can turn the technical side of your work from a source of stress into a strength. Let Ruby be the foundation that helps you achieve more with less effort—and enjoy the process along the way.

🔗 rubycademy.com

12 Best Practices to ABSOLUTELY Destroy Your Codebase! 🧨

RubyCademy — Fri, 01 Sep 2023 12:40:01 +0000

Are you tired of writing clean, maintainable code?

Do you yearn for spaghetti code that's impossible to debug?

Well, you're in luck!

Today, we're going to explore the 12 best practices that will ABSOLUTELY destroy your codebase.

Let's dive right in and wreak some havoc!

1. Never Test Your Code

Testing is for cowards who are afraid of bugs.

Avoid writing tests for your code. Skip unit tests, integration tests, and end-to-end tests, making it difficult to catch and fix bugs.

Just push your code directly to production and let your users be your testers. They'll appreciate the surprise. 🎁

2. Overcomplicate Your Models

Who needs simple, straightforward models when you can create complex, convoluted ones?

Nest your models inside other models, and throw in a few circular references for good measure.

Also, create monolithic models with hundreds of methods and attributes.

This makes your models hard to maintain and understand.

And that's exactly what your team wants to deal with on a daily basis!

3. Mix Business Logic with Views

Embed complex business logic within your view templates, making it challenging to test and maintain.

After all, who doesn't love a good code puzzle, where the solution is hidden amidst layers of views, partials, and tangled logic?

4. Never Write Documentation

Documentation is for losers who want their code to be understandable.

Assume that everyone will understand your code intuitively.

Why waste time writing comments, READMEs, and API documentation? Let the code speak for itself, even if it's speaking gibberish.

5. Reinvent the Wheel

The framework has a ton of built-in features and libraries that can make your life easier.

IGNORE THEM!

Write your own authentication system, ORM, and routing framework. You'll definitely do it better. 💪

6. Monolithic Everything

Modularization is for the weak. Why break your application into small, manageable pieces when you can have one giant monolithic codebase?

The more dependencies, the better!

7. Nest Routes Excessively

Create deeply nested routes with many levels of resources.

This can lead to routing confusion and performance issues.

8. Don't Bother with Version Control

Git? Who needs it?

Just keep all your code on your local machine. It's not like you'll ever need to collaborate with others or roll back to a previous version.

9. Use Global Variables Everywhere

Why pass parameters when you can make everything a global variable?

It's a fantastic way to introduce hidden dependencies and make your code impossible to test.

10. Forget About Naming Conventions

Who needs conventions when you can name your variables and methods with a random assortment of characters?

Let's keep our fellow developers guessing and make sure no one understands our code.

11. Refactor Only When It's Too Late

If it ain't broke, don't fix it, right?

Wait until your codebase becomes an unmaintainable mess, and then attempt a massive refactor all at once. What could possibly go wrong?

12. Hardcode Everything

Constants, dynamic configurations, and environment variables are for amateurs.

Hardcode all your configuration settings and magic numbers directly in your code. Changing them will be a breeze!

Conclusion

So there you have it, 12 best practices guaranteed to turn your codebase into an unrecognizable disaster!

Of course, this blog post is intended purely for humorous purposes, and we hope you'll do the opposite of these suggestions in your actual development work.

Building maintainable, clean code is the way to go, so make sure to follow best practices and keep your codebase healthy and happy. Happy coding!

About Us

You can follow us on x.com as we're very active on this platform. Indeed, we post elaborate code examples every day.

Additionally, subscribe to RubyCademy if you aim to become a Ruby Ninja 🥷!

🔗 RubyCademy

💚

2 Critical Elements of the Rubyist Mindset

RubyCademy — Mon, 17 Jul 2023 08:07:56 +0000

In the realm of programming, a daunting battlefield awaits, demanding mastery of complex problem-solving and vast technical expertise.

But behold, within the Ruby programming world, a distinct mindset reigns supreme – the Rubyist mindset.

This mindset exalts simplicity, elegance, and the sheer ecstasy of coding.

Join us on this blog post as we delve into the core principles of the Rubyist mindset.

Embracing Simplicity

Rubyists believe in the power of simplicity when writing code.

The following example demonstrates how Ruby allows us to express complex ideas in a concise and readable manner

# Calculate the sum of all even numbers between 1 and 10

(1..10).select(&:even?).sum # => 30

In just one line of code:

we create a range of numbers from 1 to 10
select only the even numbers
and calculate their sum

This code showcases Ruby's expressive syntax and the ability to chain methods together, resulting in clear and readable code.

The Joy of Programming

Rubyists find joy and fulfillment in coding, considering it a creative endeavor.

Let's consider a simple example:

module PasswordGenerator
  CHARS = ( (?A..?Z).to_a + (?a..?z).to_a + (?1..?9).to_a ).freeze

  module_function def generate(length = 8)
    Array.new(length) { CHARS.sample }.join
  end
end

PasswordGenerator.generate     # => "9w6VAlO8"
PasswordGenerator.generate(10) # => "r6945143BH"

This Ruby code defines a module called PasswordGenerator that generates random passwords.

It includes a constant CHARS, which represents a frozen array containing uppercase letters, lowercase letters, and numbers from 1 to 9.

This module defines a single module function called generate.

The generate method takes an optional parameter length, which defaults to 8 if no argument is provided.

The method then generates a new array of length length using the Array.new method.

For each element in the new array, a random character is sampled from the CHARS array using the sample method.

Finally, the resulting array is joined together into a single string and returned as the generated password.

Rubyists take pleasure in writing clean and concise code that achieves the desired outcome.

The joy of programming lies in the ability to solve problems creatively and produce solutions that are both functional and elegant.

Conclusion

By adopting the Rubyist mindset, programmers can enhance their coding experience and produce clean, elegant, and maintainable code.

So, whether you're a Rubyist or not, incorporating the principles of simplicity, joy, and collaboration into your programming practice can transform the way you approach and experience coding, ultimately leading to better solutions and a more enjoyable programming journey.

To go further

You can follow us on x.com as we're very active on this platform. Indeed, we post elaborate code examples every day.

Additionally, we're currently finalizing our first online course: Ruby Mastery.

Join the list for an exclusive release alert! 🔔

🔗 Ruby Mastery by RubyCademy

💚

Embrace the Power of Ruby: A Programming Superhero

RubyCademy — Thu, 06 Jul 2023 10:47:26 +0000

If programming languages were 🦹‍♀️ superheroes 🦸‍♂️, Ruby would be the master of adaptability.

It fluently switches between paradigms like a skilled shape-shifter, empowering developers to solve problems using different programming styles, be it object-oriented elegance or functional simplicity.

Introduction

In this post, we'll cover the different programming paradigms present in Ruby.

But first, let's have a quick reminder of what is a paradigm.

What is a paradigm?

From Wikipedia:

In science and philosophy, a paradigm is a distinct set of concepts or thought patterns, including theories, research methods, postulates, and standards for what constitutes legitimate contributions to a field.

Let's have a look at the Object-Oriented Programming paradigm in to see a concrete example of what is a programming paradigm.

OOP in Ruby

This paradigm is composed of the following concepts:

objects and attributes
data encapsulation
data access control
methods
data manipulation via this or self
class as type
first-class objects
etc...

In Ruby, all these concepts are present as built-in features.

These are considered the backbone of the language.

As a result, Ruby is fundamentally tied to the Object-Oriented Programming paradigm.

Cool!

Now that we grasp the concept of programming paradigms, let's examine the range of paradigms that can be linked to Ruby, depending on its language features.

Programming Paradigms in Ruby

Here, we'll discuss 3 programming paradigms Ruby can handle:

the Procedural programming paradigm
the Functional programming paradigm
the Generic programming paradigm

The Procedural programming paradigm

This paradigm is based on the concept of procedure calls.

In computer programming, a procedure is mainly assimilated into a function.

A function - in opposition to a method - is defined from outside classes.

So, a procedure call can be seen as a function call.

In Ruby, functions don't exist.

But we can create methods outsides of classes

self # => main

def procedure1
  "I'm processing stuff.."
end

def procedure2
  "I'm processing another thing.."
end

procedure1 # => "I'm processing stuff.."
procedure2 # => "I'm processing another thing.."

Here, procedure1 and procedure2 are defined from outside classes.

Then we call these methods procedurally.

In fact, these methods are still defined within an object: the main object.

This way to use Ruby is popular among the DevOps community.

Indeed, they often need to build scripts to interact with the systems they use.

The functional programming paradigm

In the OOP paradigm, everything turns around objects.

In the functional programming paradigm, everything turns around functions.

There are 3 main concepts around functional programming:

Pure functions
Higher-Order functions
First-Class functions

Pure functions

A pure function is a function that always produces the same output for a given input

def pure_method(obj)
  obj * 2
end

pure_method(2)    # => 4
pure_method([42]) # => [42, 42]
pure_method('a')  # => "aa"

Here, pure_method always returns the result of the object passed as an argument, times 2.

For a given input, the output will always be the same.

By intent, the functional programming paradigm is strongly related to the concept of pure functions – as side effects are the enemies of this programming paradigm.

Higher-order functions

Higher-Order functions are functions that can take a function as an argument or return a function


add = -> (a, b) { a + b }

def process(operation, a, b)
  operation.call(a, b)
end

process(add, 1, 1)          # => 2
process(add, 'Bon', 'jour') # => "Bonjour"

Here, the process method takes an object that responds to call — a proc or a lambda for example — and passes a and b to call.

As it’s impossible to pass a method as an argument of another method, then we use a proc to bypass this issue.

First-Class functions

A programming language that proposes Higher-Order functions can be defined as a First-Class function programming language.

Ruby is not a First-Class object programming language.

But we can use lambdas and procs to elegantly simulate the behavior of a function passed as an argument.

Generic programming paradigm

Definition of Generic programming paradigm from Wikipedia:

Algorithms and methods are written in terms of types to be specified later that are then instantiated when needed for specific types provided as parameters.

Ruby dynamic typing coupled with the Duck Typing design already provides all the necessary tools to apprehend Ruby as a generic programming language

def gt(obj1, obj2)
  obj1 > obj2
end

gt(3, 2)         # => true
gt('bbb', 'aaa') # => true

Here, the gt method expects to receive 2 comparable objects as an argument.

The method doesn’t depend on the type of argument.

So this method is generic and can be used for any kind of comparable objects.

Conclusion

Ruby, is a fully Object-Oriented programming language. But it also cherry-picks — and implements — concepts from other programming paradigms.

This approach allows Ruby developers to use this language in a wide variety of applications.

Eager to learn more about Ruby

You can follow us on x.com as we're very active on this platform. Indeed, we post elaborate code examples every day.

Additionally, we're currently finalizing our first online course: Ruby Mastery.

Join the list for an exclusive release alert! 🔔

🔗 Ruby Mastery by RubyCademy

💚

Your journey as a mid-level Ruby on Rails developer

RubyCademy — Sun, 18 Jun 2023 14:31:18 +0000

You have been a Ruby on Rails developer for a couple of years.
You can finish a ticket from A to Z with a little technical help.
You want to strengthen your Ruby/Rails knowledge and skills.

Get on board and let's sail beyond the horizon.

🌊⛵️🏴‍☠️

This little voice

You have probably written enough lines of Ruby to feel that you are in your comfort zone!

That's great. But this little voice makes you feel uncomfortable about your stagnation.

So you probably started to dedicate a part of your time to learning new things: a little bit of StimulusJS, a little bit of ActiveRecord, etc...

You feel like you're not making significant progress.

No worries! You are actually in the right mindset!

The only thing you need is guidance! 🧭

🗺️ Your Treasure map

To become a better Rubyist you must take a month (or two) to learn the main concepts of OOP in Ruby.

Here is an exhaustive list of key concepts:

Ruby Object Model
The Ancestor Chain
The Method Lookup Path
Ruby Hook Methods
The Eigenclass
Private & protected + message handling
What are modules
The super keyword in Ruby
The yield keyword in Ruby

Once you've grasped these fundamental concepts, your coding confidence is bound to soar.

You'll approach your code with newfound assurance and expertise.

Your next step

In both our "Ruby for Beginners" and "Advanced Ruby" courses, as well as our 4 mini-projects, we cover the essential concepts and advanced techniques discussed in this blog post.

Our mini-projects are structured as production-ready gems, giving you a true taste of how professional Ruby projects are organized.

This isn’t just another collection of examples—you’ll gain practical skills that you can apply immediately.

Let RubyCademy be your guide on the path to mastering Ruby, helping you save valuable time and accelerate your learning.

🔗 https://www.rubycademy.com

Voilà!

💚

Unlearn programming to learn Ruby

RubyCademy — Mon, 29 May 2023 09:31:42 +0000

Introduction

Ruby is a different programming language for at least 2 reasons:

The language is very permissive

Indeed, most languages are restrictive. They create constraints for developers for their "safety".

On the other hand, Ruby is a permissive language backed by a set of design principles (duck typing, etc.).

The decision to follow these design principles (or not) is the responsibility of the developer.

The vocabulary of the language is human-friendly

In most programming languages, the language is seen as an intermediary between the machine and the developer.

In Ruby, the language is apprehended as a way for the developer to express ideas in a human-friendly way - The famous Developer Happiness First adage.

Ok. So, how about slightly reshaping your way of thinking when using Ruby to enable your full potential?

The way Ruby responds to a problem

When the Ruby Core Team implements a feature, it's always focused on developer usability. That's why the language seems so natural to use

list_cart unless @cart.include? 'pineapple'

Here, we can read this code as follows:

List the content of the cart unless the cart includes a pineapple.

In this statement, Ruby provides 3 tools:

the unless keyword
the one-liner syntax
the include? method

All these tools can be combined to provide a natural syntax close to what your mind can express to solve this problem. I guess you get the point here.

So, why do we need to unlearn programming to learn Ruby?

Learn to unlearn programming

It's exaggerated... You don't need to "unlearn" programming.

Because Ruby implements all the tools and concepts of CompSci. I want you to focus more about learning to "think" like a Rubyist and not like a developer.

In general, a developer adapts his way of thinking to a given program to respond to certain constraints imposed by the programming language.

So this adds layers between the developer's thoughts, the code, and the final program.

Conversely, Ruby tends to remove the barrier between developer thoughts and the code.

Now let's see how to reshape your way of thinking. To do so, there is a simple exercise that you can quickly implement:

Try to transcribe your thoughts into Ruby code.

For instance, how would you write the code for the following need in Ruby?

When the user receives a message then we send an email to this user.

Another way to express this need would be:

Send an email to the user if the user receives a message.

Keep your focus on the statement - and not the methods and objects you need to define for this statement.

For instance, I didn't define list_cart and @cart in the previous section.

list_cart unless @cart.include? 'pineapple'

It is in a second time that I will define the content of the methods and variables that I need for this sentence.

Feel free to let a comment to share your way to express this need!

Conclusion

Ruby is a different programming language. The Core team genuinely believes in developer happiness. It allows you to express your thoughts as close as possible to human language.

That's why you should tend to learn and use the tools provided by the language as much as possible to transcribe your thoughts into Ruby code.

You don't have as many constraints as most programming languages. So take advantage of what Ruby gives you!

Eager to learn more about Ruby?

You can follow us on x.com as we're very active on this platform. Indeed, we post elaborate code examples every day.

Additionally, we're currently finalizing our first online course: Ruby Mastery.

Join the list for an exclusive release alert! 🔔

🔗 Ruby Mastery by RubyCademy

💚