In Ruby, both Proc and Lambda are objects that encapsulate blocks of code, but they behave differently in certain scenarios.

Answer:

“Duck Typing” is a programming concept that emphasizes an object’s behavior (methods and properties) over its class or inheritance hierarchy. The name comes from the saying, “If it looks like a duck and quacks like a duck, it’s probably a duck.”

In Ruby, this means that the type or class of an object is less important than the methods it implements. This allows for more flexible and dynamic code.

Answer:

Ruby uses a garbage collector (GC) to automatically manage memory allocation and deallocation, freeing the developer from manual memory management. The primary goal of GC is to reclaim memory occupied by objects that are no longer in use, preventing memory leaks.

• Mark and Sweep Algorithm:

  • Mark Phase: The GC traverses all accessible objects starting from “root” objects (like global variables, local variables in the current scope, etc.), marking them as “alive.”
  • Sweep Phase: After marking, the GC scans the entire object space. Objects not marked as “alive” are considered unreachable and are thus collected (i.e., their memory is freed).

• Generational Garbage Collection:

  • Ruby 2.1 and later versions implement generational GC, which is based on the observation that most objects die young. It categorizes objects into “young” and “old” generations, frequently collecting young objects while less frequently collecting old ones. This improves performance by reducing the time spent in each GC cycle.

• Incremental Garbage Collection:

  • Introduced to reduce pause times during GC by performing collection in small steps rather than all at once.

Developers can interact with the GC using the GC module, which provides methods like GC.start to manually trigger garbage collection, although this is generally discouraged unless for specific performance tuning or debugging.

Answer:

Mixins in Ruby are a way to incorporate modules into classes, allowing the sharing of methods across multiple classes without using inheritance. They provide a form of multiple inheritances, which Ruby doesn’t support directly.

Answer:

Managing dependencies in a Ruby project is primarily handled using Bundler and the Gemfile. Here’s how it works:

• Bundler:

  • A tool that provides a consistent environment for Ruby projects by tracking and installing the exact gems and versions needed.

• Gemfile:

  • Located at the root of the project, the Gemfile specifies the gems required.
• Gemfile.lock:
  • Generated by Bundler, it locks down the specific versions of all gems, including nested dependencies, ensuring consistency across different environments.
• Common Commands:
  • bundle install: Installs the gems specified in the Gemfile.
  • bundle update: Updates gems to the latest possible versions as allowed by the Gemfile.
  • bundle exec: Executes a command in the context of the current bundle, ensuring the correct gem versions are used.
• Version Constraints:
  • Gems can have version constraints to prevent unwanted updates. For example, '~> 2.0' allows updates up to but not including version 3.0.

Using Bundler and the Gemfile ensures that all developers and deployment environments use the same gem versions, preventing “it works on my machine” issues and maintaining consistency throughout the development lifecycle.