Interview Questions

include and extend in Ruby

The include and extend methods in Ruby are used to mix in modules into classes and objects.

include mixes a module’s methods into a class as instance methods. For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
module SayHi
  def hi
    puts "Hi there!"
  end
end

class MyClass
  include SayHi
end

obj = MyClass.new
obj.hi # Prints "Hi there!"

Here, including the SayHi module added the hi method as an instance method in MyClass.

extend mixes a module’s methods into an object as singleton methods. For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
module SayHi
  def hi
    puts "Hi there!"
  end
end

obj = Object.new
obj.extend(SayHi)

obj.hi # Prints "Hi there!"

Here, extending the object obj with SayHi added hi as a singleton method just for that object.

So in summary:

include mixes a module’s methods into a class as instance methods
extend mixes a module’s methods into an object as singleton methods

This allows reusable encapsulated modules to add behaviors to classes and objects.

Include and Extend in Ruby

Concept

In Ruby, include and extend are two methods used for mixing modules into classes or objects. They serve to “inject” methods defined in modules into classes, giving those classes additional functionalities.

Include: When a module is included using include, its instance methods become instance methods of the class. This is a way to add functionality to instances of a class.
Extend: When a module is extended using extend, its methods become class methods. This is a way to add functionality that is generally invoked directly on the class, rather than on instances.

Why is it Important?

Code Reusability: Both include and extend allow for sharing methods across multiple classes.
Separation of Concerns: Using modules makes it easier to maintain and update code.
DRY Principle: Helps in keeping the code DRY (Don’t Repeat Yourself).

Example Code

Ruby with Include

Here’s how you can use include to add instance methods to a class:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
module Greeter
  def say_hello
    puts "Hello!"
  end
end

class Person
  include Greeter
end

person = Person.new
person.say_hello  # Output will be "Hello!"

Ruby with Extend

Here’s how you can use extend to add class methods to a class:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
module Greeter
  def say_hello
    puts "Hello!"
  end
end

class Person
  extend Greeter
end

Person.say_hello  # Output will be "Hello!"

Key Takeaways

include is used to add instance methods to a class, making the module’s methods available to instances of the class.
extend is used to add class methods, making the module’s methods available at the class level.
Both are tools for achieving code reusability and modularity in Ruby.

The load and require methods in Ruby are used to import and load Ruby source files.

require imports and runs another Ruby source file once. Further requires of the same file will not reload it.

For example:

1
2
3
4
# math.rb
def multiply(a, b)
  a * b
end

1
2
3
4
# main.rb
require './math' 

multiply(2, 3) # => 6

Here require runs math.rb only once, adding the multiply method.

load imports and evaluates a Ruby source file every time it is called.

For example:

1
2
# message.rb
print "Hello World!"

1
2
3
4
# main.rb

load './message.rb' # Prints "Hello World!"
load './message.rb' # Prints again

load runs the file each time, repeating the effects.

The main differences are:

require runs a file once and caches it. load re-runs it each time.
require returns true/false if loading succeeded. load returns the executed code.

So in general, require is used more commonly for importing reusable code, while load explicitly re-executes code.

Load and Require in Ruby

Concept

load and require are both methods in Ruby used to include external files into the current program. They allow you to reuse code by importing it from other Ruby files.

Load: The load method reads and parses an external Ruby file every time it is called, even if that file has been loaded before. This is useful if the external file is being updated frequently during development.
Require: The require method reads and parses an external Ruby file only once, storing the parsed code for future use. This means that subsequent calls to require with the same file will have no effect, making require more efficient for libraries or other code that won’t change.

Why is it Important?

Code Organization: Allows for separation of concerns by dividing code into smaller, manageable files.
Code Reusability: Enables sharing of functionality between different parts of an application or between different applications.

Example Code

Using Load

1
2
3
# If example.rb contains: puts "Hello from example.rb"
load 'example.rb'  # Output: "Hello from example.rb"
load 'example.rb'  # Output: "Hello from example.rb" (file is reloaded)

Using Require

1
2
3
# If example.rb contains: puts "Hello from example.rb"
require './example'  # Output: "Hello from example.rb"
require './example'  # No output (file is not reloaded)

Note: For require, you don’t include the .rb file extension and you need to specify relative paths if the file isn’t in Ruby’s load path.

Key Takeaways

load is useful for reloading files that change often during development.
require is more efficient for loading libraries or code that won’t change, as it loads a file only once.
Both methods are essential for code organization and reusability in Ruby.

Explain private, protected and public in Ruby

In Ruby, methods and attributes can have different visibility levels - private, protected, or public. This controls where and how they can be accessed.

Public methods can be called from anywhere - the default visibility.
Private methods can only be used within the defining class itself.
Protected methods can be invoked only by objects of the defining class and its subclasses.

For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
class MyClass
  def public_method
    # ...
  end
  
  private 

  def private_method
    # ... 
  end
  
  protected

  def protected_method
    # ...
  end
end

Here:

public_method is public - it can be called from anywhere
private_method is private - it can only be used within MyClass
protected_method is protected - it can be used within MyClass and subclasses.

This controls encapsulation and restricts external access. Private prevents external use while protected allows subclasses to reuse parent behavior.

Visibility applies to both methods and attributes. Private and protected prevent accidental external visibility into class internals.

Private, Protected, and Public in Ruby

Concept

In Ruby, private, protected, and public are access control mechanisms for methods. They define who can call a method and establish boundaries for object interaction.

Private: A private method can only be called by an instance of the class within which it is defined. It cannot be accessed from outside the class.
Protected: A protected method can be called by an instance of the defining class or its subclasses. It can also be called by other instances of the same class.
Public: A public method can be called by any object that can access the class. By default, all methods (except for initialize) are public.

Why is it Important?

Encapsulation: Helps in hiding the internal structure and state of objects.
Security: Provides control over who can modify or access an object’s data.
Maintainability: Easier to update or refactor code that adheres to access controls.

Example Code

Ruby

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Animal
  def public_method
    puts "I'm public!"
  end

  private

  def private_method
    puts "I'm private!"
  end

  protected

  def protected_method
    puts "I'm protected!"
  end
end

class Dog < Animal
  def show_protected
    protected_method
  end
end

animal = Animal.new
animal.public_method      # Output: "I'm public!"

dog = Dog.new
dog.show_protected        # Output: "I'm protected!"

# animal.private_method   # Raises an error
# animal.protected_method # Raises an error

Key Takeaways

private methods can only be called from within the same instance and are used to encapsulate logic that should not be exposed.
protected methods can be called from the same class or subclasses and are useful for comparisons between instances.
public methods are openly accessible and form the object’s API.
Use these access controls judiciously to design robust and secure classes.

Explain closure in Ruby

Closure in Ruby

A closure in Ruby is a block of code that can be stored and executed later, while still retaining access to the lexical scope in which it was defined.

For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
def creator
  x = 0
  
  lambda { x += 1 }
end

fn = creator()

fn.call # x is 1
fn.call # x is 2 

Here the lambda function closes over the local variable x, and can still access and modify it when called later outside creator. The lambda essentially encapsulates the surrounding context.

Some key properties of closures in Ruby:

They enclose the surrounding context like local variables and methods.
The enclosed context is tied to the lifespan of the closure itself.
They provide data hiding and encapsulation - hiding implementation while exposing behavior.
Closures are commonly created using lambdas or Proc objects.
When closures are called later, they retain access to the context in which they were defined.

Closures are very useful in Ruby for encapsulating state and behavior together and retaining access to the enclosing lexical scope. They are a powerful technique for abstraction.

Concept

A closure in Ruby is a block of code that can be stored in a variable. It carries with it its own context, meaning it has access to variables that existed in the scope where the closure was created. In Ruby, closures are implemented through blocks, procs, and lambdas.

Block: An anonymous piece of code that can accept input and is executed when called within a function. Blocks are the most common form of closures in Ruby.
Proc: Similar to a block but can be stored in a variable, allowing it to be reused. Procs don’t enforce the number of arguments.
Lambda: Like a Proc but stricter about the number of arguments passed to it.

Why is it Important?

Flexibility: Closures allow you to pass around behavior, not just data.
Context Preservation: They capture and remember the surrounding context where they were defined.
Functional Programming: Closures are essential for functional programming paradigms in Ruby.

Example Code

Using Blocks

1
2
3
4
5
def greet
  yield "Hello"
end

greet { |word| puts "#{word}, Block!" }

Using Procs

1
2
say_hello = Proc.new { |name| puts "Hello, #{name}" }
say_hello.call("John")  # Output: "Hello, John"

Using Lambdas

1
2
say_hello = lambda { |name| puts "Hello, #{name}" }
say_hello.call("John")  # Output: "Hello, John"

Key Takeaways

Blocks, Procs, and Lambdas are different types of closures in Ruby.
Closures encapsulate code and context, making them portable and reusable.
They enable more dynamic and flexible programming styles.

What is lexical scope in Ruby?

Lexical scope in Ruby refers to the visibility and accessibility of variables and methods based on their physical location in the source code. It determines where variables, methods, and classes can be referenced from.

The key principles of lexical scope in Ruby are:

Inner scopes have access to outer scope variables and methods. So a method can access variables initialized in the class.
Outer scopes do not have access to inner scope variables and methods. So class methods cannot access local variables inside other methods directly.
Scope is determined at runtime based on where code is defined, not where it is called from.
Scope lookup starts in the immediate scope and works outwards.
Variables and methods in outer scopes are hidden by any inner declarations of the same name.

Some examples:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
x = 10 # available everywhere 

class MyClass
  y = 20 # available in MyClass and subclasses
  
  def print_x
    puts x # prints 10 - lexical scope
  end
end

def my_method
  z = 30 # only available in my_method
  
  puts y # Error - y not visible here 
end

So in summary, lexical scope in Ruby allows inner scopes access to outer scopes following the location of code definitions at runtime.

Lexical Scope in Ruby

Concept

Lexical scope refers to the region of code where a variable is accessible. In Ruby, variables have scope based on where they are defined, not where they are used. Lexical scope is determined at the time the code is written (i.e., lexically), not when it is run.

Types of Variables

Local Variable: Accessible only within the block or method where it is defined.
Instance Variable: Accessible throughout the instance of a class where it is defined.
Class Variable: Accessible within the class and its instances, as well as subclasses.
Global Variable: Accessible throughout the entire program.

Why is it Important?

Code Organization: Helps in structuring code in a way that limits the reach of variables, reducing potential errors.
Readability: Makes it easier to understand where a variable can be used or modified.
Encapsulation: Enables better data hiding and encapsulation practices.

Example Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# Local Variable Scope
def method_one
  x = 10  # local variable
end

def method_two
  puts x  # Raises an error, x is not in scope
end

# Instance Variable Scope
class MyClass
  def initialize
    @x = 10  # instance variable
  end
  
  def show
    puts @x  # Outputs 10, @x is in scope
  end
end

# Global Variable Scope
$y = 20  # global variable

def method_three
  puts $y  # Outputs 20, $y is in scope
end

Key Takeaways

Lexical scope is determined at the time the code is written.
It’s crucial for understanding where variables can be accessed or modified.
Different types of variables have different scope rules. Understanding these rules is key to effective Ruby programming.

What is self in Ruby?

In Ruby, self is a special variable that refers to the current object context. It can be used to access methods and attributes of the current object.

Some key points about self in Ruby:

In instance methods, self refers to the instance the method was called on.

1
2
3
4
5
class MyClass 
  def my_method
    puts self # self is the MyClass instance
  end
end

In class methods, self refers to the class itself.

1
2
3
4
5
class MyClass
  def self.class_method
    puts self # self is MyClass here
  end
end

The value of self changes depending on scope and context. It can refer to different objects and classes.
self can be used explicitly to distinguish between local variables and attributes. For example:

1
2
3
4
5
6
7
@x = 10

def print_x
  x = 20
  puts @x # attribute
  puts self.x # local variable x
end 

The value of self is determined when a method is called, not when it is defined.
self lets objects and classes access their own properties conveniently.

So in summary, self refers to the current object, gives access to its attributes, and changes based on context. It is a powerful way to access object state.

Self in Ruby

Concept

self is a special variable in Ruby that refers to the object that is currently receiving a message (i.e., the object the method is being called on). Depending on the context, self can refer to different types of objects:

Within an instance method, self refers to the instance of the class.
Within a class definition but outside any method, self refers to the class itself.
Within a class method, self refers to the class.

Why is it Important?

Method Dispatch: Helps in determining which method to call when there are methods with the same name in both instance and class scope.
Variable Access: Enables access to instance variables through self.
Class-level Operations: Used in class methods for operations that should affect the class itself, not instances.

Example Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Person
  def initialize(name)
    @name = name
  end

  def greet
    puts "Hello, my name is #{@name}."
    puts "Self is: #{self}"
  end

  def self.describe
    puts "This is the Person class."
    puts "Self is: #{self}"
  end
end

# Instance method context
john = Person.new("John")
john.greet
# Output: "Hello, my name is John."
# Self is: #<Person:0x...>

# Class method context
Person.describe
# Output: "This is the Person class."
# Self is: Person

Key Takeaways

self varies depending on the context in which it is used.
It’s crucial for disambiguating method and variable scope.
Understanding self is essential for object-oriented programming in Ruby.

What is super in Ruby?

The super keyword in Ruby is used to call methods on the parent class from within a child class that inherits from it. It allows accessing overridden methods of the parent class.

For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Parent
  def print
    puts "Parent print"
  end
end

class Child < Parent
  def print
    super
    puts "Child print" 
  end
end

Child.new.print

This outputs:

Parent print
Child print

Some key points about super in Ruby:

super calls the parent class method with the same name as the calling method.
It allows overriding a method while still accessing the parent version.
super can also pass arguments to the parent method.
When used with no arguments, it calls the parent method with the same arguments passed to the child method.
super can only be used within instance methods, and cannot be used to call parent class methods from class methods.
Using super improves code reuse by avoiding reimplementing parent class functionality.

So in summary, super provides a way to invoke parent class functionality in child classes, enabling code reuse and extension.

Super in Ruby

Concept

The super keyword in Ruby is used to call a method of the same name in the superclass of the current class. This allows you to reuse and extend the functionality of the inherited method without completely overriding it.

No Arguments: Using super with no arguments passes all arguments of the current method to the superclass method.
With Arguments: You can specify which arguments to pass by using super(arg1, arg2, ...).
Empty Parentheses: Using super() calls the superclass method with no arguments, regardless of the arguments passed to the current method.

Why is it Important?

DRY (Don’t Repeat Yourself): Reduces code duplication by leveraging existing functionality from the superclass.
Extensibility: Allows for easy modifications to inherited methods without altering the original implementation.
Polymorphism: Enables dynamic method dispatch, one of the pillars of Object-Oriented Programming.

Example Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Animal
  def make_sound
    puts "Some generic animal sound"
  end
end

class Dog < Animal
  def make_sound
    super
    puts "Woof woof!"
  end
end

class SilentDog < Animal
  def make_sound
    super()
  end
end

# Using super
dog = Dog.new
dog.make_sound
# Output: 
# Some generic animal sound
# Woof woof!

# Using super()
silent_dog = SilentDog.new
silent_dog.make_sound
# Output: 
# Some generic animal sound

Key Takeaways

super calls a method of the same name in the superclass.
You have control over which arguments get passed to the superclass method.
It’s a crucial tool for effective code reuse and object-oriented design.

What is binding in Ruby?

Binding in Ruby refers to the execution context or environment associated with some code. It consists of the self reference, variables, methods, class, blocks etc. that are available at a particular place in the code.

Some key points about bindings in Ruby:

A binding encapsulates the context or environment in which some code executes.
It allows accessing variables and methods available in that context from outside.
The Binding class can capture a binding for any context.
Common ways to capture bindings are using Binding.new or Kernel#binding.
Bindings can be evaluated in other contexts using Binding#eval.

For example:

1
2
3
4
5
6
7
8
9
def my_method
  x = 10
  
  binding
end

b = my_method() # Get binding

b.eval('puts x') # Prints 10

Here the binding b gives access to the context within my_method, allowing printing x.

Bindings are useful for introspection, debugging, interacting with new contexts, and implementing DSLs.
They allow bridging different environments by propagating bindings.

So in summary, bindings capture contextual environments in Ruby, allowing evaluation in new contexts.

Binding in Ruby

Concept

In Ruby, a binding is a whole environment in which code is evaluated. It encapsulates the scope, local variables, constants, and methods that are available at a particular point in the code. The binding object serves as a bridge allowing you to access variables from different scopes.

Why is it Important?

Scope Access: Allows you to capture the local scope and reuse it elsewhere.
Dynamic Evaluation: Enables the dynamic evaluation of code in different scopes using methods like eval.
Debugging: Helpful for inspecting the environment at a particular point in the program for debugging purposes.

Example Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
def get_binding(param)
  local_var = "local variable"
  return binding
end

# Create a binding object
sample_binding = get_binding("sample_param")

# Evaluate code in the context of the binding
puts eval("local_var", sample_binding)  # Output: "local variable"
puts eval("param", sample_binding)  # Output: "sample_param"

In this example, the get_binding method returns a binding object that captures the local variable local_var and the method argument param. We can then use eval to evaluate code in the context of that binding.

Key Takeaways

binding captures the complete execution context at a specific point in a Ruby program.
It allows for advanced features like dynamic evaluation and scope manipulation.
Although powerful, it should be used cautiously to maintain code readability and prevent potential security risks.

What is Ruby Object Model?

The Ruby Object Model refers to how objects, classes, and inheritance are represented and interact in Ruby. Some key aspects:

Everything is an object - integers, strings, methods, classes are objects that inherit from Object.
Classes are objects too - They are instances of the Class class. Classes can be dynamically modified.
Single inheritance - Classes can only inherit from one parent class using <. Mixins provide shared behavior via modules.
Methods calls use dynamic dispatch - Methods are called based on the runtime class of the receiver object. Allows polymorphism.
Open classes - Classes are never closed to modification. Existing classes can be reopened and modified.
Singleton methods - Methods can be defined on individual object instances outside the class definition.
Pure OO - No primitives. Operators like +, - are actually method calls that can be redefined.
Duck typing - Interfaces are implicit. Objects are used if they respond to the right methods, not based on static types.

So in summary, Ruby follows a fully flexible dynamic object oriented model that promotes develop-time modification, polymorphism, and duck typing through its design. Everything revolves around modifiable object interactions.

Ruby Object Model

Concept

The Ruby Object Model is a conceptual framework that describes how objects, classes, and modules interact in Ruby. It explains how methods are looked up, how inheritance works, and how modules are included or extended. In Ruby, almost everything is an object, and classes themselves are instances of the Class class.

Why is it Important?

Method Lookup: Understanding the model helps in tracing how Ruby looks up methods when invoked on an object.
Extensibility: It provides the flexibility to dynamically modify classes and objects, facilitating meta-programming.
Clarity: Having a solid understanding of the Object Model can clarify how modules are mixed in, and how singleton methods work.

Key Components

Objects: Instances of classes. They have instance variables and a reference to their class.
Classes: Define the blueprint for objects. They contain instance methods and have a link to a superclass.
Modules: Like classes but can’t be instantiated. Mainly used for namespacing and mixin functionalities.
Singleton Classes: Anonymous classes attached to a single object, allowing per-object behavior.

Example Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Animal
  def make_sound
    "Some generic sound"
  end
end

module Swimmer
  def swim
    "I can swim"
  end
end

class Dog < Animal
  include Swimmer
  
  def make_sound
    "Woof!"
  end
end

# Create an object
dog = Dog.new

# Method lookup
puts dog.make_sound  # Output: "Woof!"
puts dog.swim  # Output: "I can swim"

In this example, when make_sound is called on the dog object, Ruby first looks in the Dog class, finds the method, and executes it. When swim is called, Ruby looks into the included module Swimmer to find the method.

Key Takeaways

The Ruby Object Model is fundamental to understanding object-oriented features in Ruby.
Classes in Ruby are themselves objects, making the language highly dynamic.
The model explains how methods are looked up, starting from the object’s class, going up the ancestors chain.
Understanding the model is essential for effective Ruby programming, especially for metaprogramming and module mixing.

What is symbol in Ruby?

Symbol in Ruby

Concept

A Symbol in Ruby is an immutable, lightweight string-like object that is often used as an identifier or a key. Unlike strings, symbols with the same value are stored in memory only once, making them more efficient for certain operations.

Symbols are defined using a colon (:) followed by the name of the symbol. For example, :name and :age are symbols.

Why is it Important?

Efficiency: Since they’re stored in memory only once, symbols are more memory-efficient compared to strings.
Immutability: Symbols are immutable, meaning they cannot be altered once created.
Fast Comparison: Symbols are compared using their object ID, which is faster than string comparison.

Example Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
# Using symbol as hash keys
person = {
  :name => "John",
  :age => 30
}

# New syntax for the same hash
person = {
  name: "John",
  age: 30
}

# Accessing hash values
puts person[:name]  # Output: "John"

# Comparing symbol and string
puts :name == "name"  # Output: false

# Converting string to symbol and vice versa
puts :name.to_s  # Output: "name"
puts "name".to_sym  # Output: :name

Key Takeaways

Symbols are immutable and more memory-efficient than strings.
Commonly used for hash keys, method names, or any form of identifiers.
Despite the similarities, symbols and strings are different types and are not directly comparable.
Symbols are often favored for performance-sensitive operations like hash key lookup.

A symbol in Ruby is a literal constant identifier. Some key properties of symbols:

Symbols begin with a colon : followed by a name (:my_symbol).
They serve as immutable string-like constants. Once created, a symbol’s value can’t be changed.
Symbols are internally represented by integer IDs. Two symbols with the same name share the same ID.
Lookup of symbols is faster than strings since they are interned.
Symbols do not have string methods. They serve as names only.

Symbols are commonly used:

As hash keys since they are fast to look up.
For referencing method names (:"+" calls the + method).
As constant identifiers for values, akin to enums in other languages.
For naming method parameters as keyword arguments.
As a performance optimization over strings when immutable names are needed.

For example:

1
2
3
4
5
6
7
KEY = :my_key

h = { KEY => "value" } 

h[KEY] # fast lookup

KEY.size # error - no .size method

So in summary, symbols act as fast, immutable string-like identifiers in Ruby. They are heavily used for naming in hashes, methods, and as constants.

What is a class variable in Ruby? When it is used?

A class variable in Ruby is a variable that is shared among all objects of a class. It is prefixed with two @ symbols (@@).

Class variables are used when objects of a class need to access a common value or share state. Some examples:

To represent a common default value for all instances:

1
2
3
4
5
6
class Player
  @@lives = 3 # Default lives for all players
end

p1 = Player.new # p1.lives = 3
p2 = Player.new # p2.lives = 3

To keep track of class-level summary values like total count:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Order
  @@order_count = 0

  def initialize
    @@order_count += 1
  end

  def total_orders
    @@order_count
  end
end

To cache shared expensive resources at the class level:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
class ImageProcessor
  @@image_cache = {}

  def load_image(name)
    if @@image_cache.key?(name)
      @@image_cache[name]
    else
      image = # load image
      @@image_cache[name] = image
    end
  end
end

So in summary, class variables provide shared state across instances of a class. They are helpful for class-wide constants, summaries, and caches.

Class Variable in Ruby

Concept

A class variable in Ruby is a variable that is shared across all instances of a class, as well as the class itself. Class variables are prefixed with @@, such as @@count or @@instances.

Why is it Important?

Shared State: Provides a way to maintain a state that is shared across all instances of a class.
Resource Optimization: Useful when you want to cache or store data that doesn’t need to be replicated for each instance.
Consistency: Ensures that all instances and subclasses see the same variable value unless explicitly overridden.

When is it Used?

Tracking the number of instances created from a class.
Caching values that are expensive to calculate.
Storing configuration settings that apply to all instances.

Example Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Person
  @@count = 0  # Class variable

  def initialize(name)
    @name = name  # Instance variable
    @@count += 1  # Increment the class variable
  end

  def self.total_count  # Class method
    @@count
  end

  def name  # Instance method
    @name
  end
end

# Create instances
p1 = Person.new("Alice")
p2 = Person.new("Bob")

# Access class variable via a class method
puts Person.total_count  # Output: 2

In this example, the class variable @@count is used to keep track of the number of instances of the Person class. The class method self.total_count returns the value of @@count.

Key Takeaways

Class variables are shared across all instances and the class itself.
They are useful for storing shared state or caching.
Care should be taken when using class variables in subclasses, as they share the same value with the parent class.

What is autoload in Ruby?

Autoload in Ruby

Concept

autoload is a method in Ruby that allows you to defer the loading of a file until a constant defined in that file is actually used. It helps in improving the performance of your application by reducing the initial startup time.

Why is it Important?

Lazy Loading: Helps to load files only when necessary, improving initial load time.
Memory Efficiency: Consumes less memory since unused files aren’t loaded into memory.
Organized Code: Facilitates better code organization by loading modules or classes only when they’re required.

When is it Used?

Large codebases where not all modules are needed right away.
Libraries that have multiple optional components.
Applications with a long startup time that can benefit from lazy loading.

Example Code

Assume you have a file math_operations.rb with the following content:

1
2
3
4
5
6
# math_operations.rb
class MathOperations
  def self.square(x)
    x * x
  end
end

You can use autoload like this:

1
2
3
4
5
6
7
8
# main.rb
autoload :MathOperations, 'math_operations'

puts "Before autoload"

result = MathOperations.square(4)  # The file is loaded here

puts "Result: #{result}"

In this example, math_operations.rb won’t be loaded until you actually use MathOperations. When you call MathOperations.square(4), Ruby will autoload math_operations.rb and then proceed with the method call.

Key Takeaways

autoload is a mechanism for deferred loading of constants.
Useful for improving performance by reducing startup time.
Suitable for large codebases or applications with optional modules.
While autoload is convenient, it’s not thread-safe in versions prior to Ruby 2.0. Use with caution in multi-threaded environments.

Autoload in Ruby provides a way to load Ruby classes and modules automatically only when they are used for the first time. This avoids loading all classes upfront even if they are not needed.

The Module#autoload method is used to setup autoloading. For example:

1
2
3
4
5
6
7
# main.rb
autoload :MyClass, 'my_class'

# my_class.rb
class MyClass
  # ...
end

Here, the MyClass constant will only be loaded from my_class.rb when the MyClass name is referenced for the first time:

1
obj = MyClass.new # Loads my_class.rb

Some key points about autoload in Ruby:

It lazy-loads classes to reduce memory usage.
The second argument specifies the file path to autoload from.
It only runs the first time a constant is accessed. Subsequent access uses the loaded reference.
Any Ruby file that defines the right class or module can be autoloaded.
autoload?(name) checks if a constant is set to be autoloaded.

So in summary, autoload provides a lazy-loading mechanism to avoid unnecessary upfront loading of Ruby classes and modules.

Here are some key concepts to review for a Ruby developer interview:

Ruby programming fundamentals - data types, control structures, OOP basics
Ruby object model - objects, classes, inheritance, duck typing, polymorphism
Blocks, procs, and lambdas - for encapsulating behavior
Modules and mixins - for encapsulation and namespacing
Metaprogramming - hooks like method_missing, define_method, instance_eval etc.
Variable scope - constants, class, instance, local, blocks, lexical scope
Ruby Gems - using and creating gems
Popular frameworks like Rails, Sinatra - MVC patterns
Common standard libraries and their usage - e.g. hashes, arrays, enums
Testing - RSpec, Minitest, Test::Unit, mocks, stubs, etc.
Tooling - Bundler, Rake, RubyGems
Ruby idioms and best practices - common conventions
Basic concurrency primitives - Threads, mutexes
Performance and optimization techniques
Debugging, profiling, and benchmarking
Object relational mapping (ORM) basics

Focus on demonstrating idiomatic Ruby knowledge, problem solving, and debugging skills. Show enthusiasm and ability to quickly learn new libraries and techniques.

Concepts for a Ruby Developer Interview

Basics

Syntax and Structure: Understanding of basic syntax, variables, and data types.
Control Flow: if, unless, while, for loops, and iterators.

Object-Oriented Programming

Classes and Objects: Creating classes, instantiating objects, and understanding instance variables.
Inheritance and Polymorphism: How inheritance works, method overriding, and super.
Modules and Mixins: How to create modules and include them in classes.

Core Ruby Features

Blocks, Procs, and Lambdas: Understanding of code blocks and how they differ from procs and lambdas.
Exception Handling: begin, rescue, ensure, and custom exception classes.

Meta-Programming

Dynamic Method Creation: Use of method_missing and define_method.
Reflection: Methods like send, respond_to?, and instance_variable_get.

Standard Libraries

File I/O: Reading and writing files.
Networking: Understanding of libraries like Net::HTTP or Socket.

Ruby on Rails

MVC Architecture: Understanding of Model, View, Controller pattern.
ActiveRecord: CRUD operations, validations, and associations.
RESTful APIs: Knowing how to build and consume APIs using Rails.

Testing

RSpec: Basics of writing unit tests with RSpec.
Factories: Use of factory bots for creating test data.

Other Tools

Bundler: Dependency management.
Rake: Writing custom rake tasks.

Advanced Topics

Concurrency: Familiarity with threads and how Ruby handles concurrency.
Garbage Collection: Basic understanding of Ruby’s garbage collection mechanism.

Soft Skills

Problem-Solving: Ability to solve coding problems efficiently.
Communication: Explain code and logic clearly.

Key Takeaways

A strong grasp of Object-Oriented Programming and Ruby basics is essential.
Familiarity with Ruby on Rails can be a plus, especially for full-stack positions.
Knowing how to write tests will set you apart from other candidates.
Soft skills like problem-solving and communication are just as important as technical skills.

Concepts for a Rails Developer Interview

Basics

Rails CLI: Familiarity with commands like rails new, rails generate, and rails console.
Directory Structure: Understanding of the Rails app folder structure and what each folder is for.

MVC Architecture

Models: How to define models, validations, and database migrations.
Views: Understanding ERB templates, partials, and helpers.
Controllers: How to define actions, filters, and routing.

ActiveRecord

CRUD Operations: Create, read, update, and delete records.
Associations: has_many, belongs_to, has_one, and has_and_belongs_to_many.
Query Interface: Methods like where, order, and group.

Routing

RESTful Routing: Understanding resourceful routes.
Nested Routing: How to define and use nested routes.
Custom Routes: Adding non-RESTful routes.

Asset Pipeline

Sprockets: How assets are compiled.
Webpack: If using Rails 6 and above, familiarity with Webpacker.

Testing

RSpec: Writing unit tests and feature specs.
Capybara: Writing integration tests that simulate user interaction.

Security

CSRF Protection: Understanding CSRF tokens and how Rails protects against CSRF attacks.
Sanitization: How Rails escapes HTML and JavaScript content.

Deployment

Environment Variables: Use of .env files and Rails credentials.
Servers: Familiarity with Puma, Unicorn, or other application servers.
Hosting: Basic understanding of deployment on Heroku, AWS, or other platforms.

APIs

API Versioning: How to version your APIs.
JWT: Use of JSON Web Tokens for authentication in APIs.

Performance Optimization

Caching: Use of fragment and page caching.
Database Indexing: When and how to add database indexes for performance.

Other Concepts

Background Jobs: Understanding of Sidekiq or Resque for background processing.
Real-Time Features: Basics of Action Cable for WebSockets.

Soft Skills

Problem-Solving: Ability to troubleshoot issues and optimize performance.
Communication: Ability to articulate your thoughts, code, and design decisions.

Key Takeaways

A comprehensive understanding of MVC and ActiveRecord is essential.
Knowledge of RESTful principles and routing is crucial for building scalable applications.
Familiarity with testing, security, and deployment will make you a well-rounded candidate.
Soft skills are also vital for team collaboration and problem-solving.

Here are some key concepts to review for a Ruby on Rails developer interview:

MVC architecture - Models, views, controllers
RESTful design and routing
Active Record - Models, associations, validations, queries
Views - ERb, partials, helpers
Controllers - Actions, filters,Strong params
Rails generators for scaffolding code
Asset pipeline - Manifests, compiling assets
Databases - Migrations, schema design
Rake tasks - Creating custom tasks
Rails configs - Environments, initializer files
Routing - Resources, custom routes
Testing - Fixtures, factories, RSpec, Capybara
Debugging - Logger, debugging in dev environment
Security - SQL injection, XSS, CSRF, authentication
Deployment - Environments, Heroku, AWS
Performance - Caching, eager loading, profiling
APIs and services - Building APIs, integrating external services
Gems - Choosing and using both rails gems and custom gems

Focus on demonstrating familiarity with the Rails framework, MVC patterns, debugging, and building applications end-to-end.

SQL Concepts for a Web Developer Interview

Basics

SQL Syntax: Familiarity with basic SQL syntax like SELECT, FROM, and WHERE.
Data Types: Understanding of common SQL data types like VARCHAR, INT, and DATE.

Querying Data

Select Queries: How to retrieve data using SELECT.
Filters: Using WHERE, AND, OR to filter data.
Sorting: Sorting data using the ORDER BY clause.
Functions: Usage of functions like COUNT, SUM, AVG, MIN, MAX.

Data Manipulation

Inserting Data: Using INSERT INTO to add new records.
Updating Data: Modifying existing records using UPDATE.
Deleting Data: Removing records using DELETE.

Joins

Inner Joins: Combining rows from two or more tables.
Outer Joins: Understanding of LEFT, RIGHT, and FULL OUTER JOIN.
Self Joins: Joining a table with itself.

Subqueries

In SELECT: Use of subqueries to retrieve a single scalar value.
In WHERE: Use of subqueries to filter data based on conditions.

Grouping and Aggregation

Group By: How to group data.
Having: Filtering grouped data.

Indexes

Creating Indexes: Use of CREATE INDEX to improve query performance.
Types of Indexes: Understanding of unique, composite, and full-text indexes.

Transactions

ACID Properties: Understanding of Atomicity, Consistency, Isolation, Durability.
Commit and Rollback: How to use COMMIT and ROLLBACK to control transactions.

Data Modeling

Normalization: The process of organizing data to reduce redundancy.
Relationships: Understanding of one-to-one, one-to-many, and many-to-many relationships.

Security

Authentication: Basic understanding of user roles and permissions.
SQL Injection: Awareness of SQL injection attacks and how to prevent them.

Views and Stored Procedures

Views: Use of views for encapsulating complex queries.
Stored Procedures: Writing and using stored procedures for common tasks.

Key Takeaways

A good understanding of SQL querying is foundational.
Data manipulation and joins are crucial for more complex operations.
Knowledge of indexes and transactions can distinguish you as a more advanced candidate.
Awareness of security risks like SQL injection is critical in web development contexts.

Here are some key SQL concepts that are useful to review for a web developer interview:

Basic SQL syntax - SELECT, INSERT, UPDATE, DELETE statements
Table design - Creating tables, data types, primary keys, foreign keys
Querying - Joining tables, aggregate functions, GROUP BY, HAVING
Subqueries - Queries within another query
Database normalization - 1NF, 2NF, 3NF for optimized database design
Indexing - Improving query performance with database indexes
Views - Creating virtual tables by querying from other tables
Stored procedures - Writing reusable SQL procedures for common operations
Triggers - Executing logic on data changes
Transactions - Grouping SQL operations into atomic transactions
NoSQL systems - Key-value stores, document databases, graph databases
ORMs - Object-relational mapping frameworks like ActiveRecord, Hibernate
Scaling databases - Data partitioning, replication, read replicas
Debugging queries - Explain plans, slow query logs, missing indexes

Focus on demonstrating both breadth across SQL concepts as well as hands-on experience with database operations, optimization, and troubleshooting.

ACID

Here is an explanation of the ACID properties of databases in simple terms:

Atomicity - This means that database transactions are all-or-nothing. If any part of a transaction fails, the entire transaction is rolled back and database is left unchanged. It ensures transaction integrity.

Consistency - The database will remain in a consistent state when transactions are completed. All data written will be valid according to constraints. Consistency ensures database correctness.

Isolation - Concurrent transactions will be isolated from each other. Transactions executing at the same time will not interfere with each other. Changes by one transaction are invisible to others until committed.

Durability - Once a transaction is committed, it will remain committed even in case of system failure. The data persistence is durable and permanent.

In simple terms:

Atomicity - All or nothing. No partial transactions.
Consistency - Valid data written. Constraints satisfied.
Isolation - No interference between transactions.
Durability - Once committed, permanent.

These ACID properties ensure the integrity, correctness, consistency and persistence of database transactions and data.

How is Redis used in a Rails project?

Here are some common ways Redis is used in Ruby on Rails projects:

Caching - Redis is used as a fast in-memory cache for fragments, pages, or query results to reduce load on the database. The Rails cache store can be set to Redis.
Background jobs - Redis can be used with Sidekiq or Resque for queuing background jobs and tasks in Rails.
Session store - The Rails session store can be set to use Redis to store session data instead of the cookie store.
Real-time features - Redis pub/sub and channels enable real-time communication between Rails processes and servers. Useful for notifications, chat etc.
Rate limiting - Redis counters and expiration provide a way to implement rate limiting of requests in Rails APIs.
Storing ephemeral data - Redis provides fast key-value storage for ephemeral data like visits, page views, temporary data etc. that expires.
Leaderboards/rankings - Sorted sets in Redis can efficiently store rankings, scores for gaming apps.
Caching responses - Redis can be used to cache API responses and scale Rails APIs.

So in summary, Redis provides Rails apps fast memory storage, background processing, real-time features, rate limiting, ephemeral data, and is a preferred cache + session store. It’s a versatile tool for Rails.

Redis is often used in Rails projects for several purposes:

Caching

Concept: Store frequently accessed data in Redis to reduce database queries.
Example: Cache user profiles so that each time a profile is viewed, the system doesn’t have to query the database.
Rails Code: Rails.cache.fetch("user_#{user.id}") { user.to_json }

Queues and Background Jobs

Concept: Offload tasks from the main thread to be processed later.
Example: Email sending can be done in the background.
Rails Code: Using Sidekiq, which relies on Redis, to handle background jobs.

Real-Time Features

Concept: Use Redis as a Pub/Sub server for real-time updates.
Example: In a chat application, when a user sends a message, publish it to a Redis channel. Subscribed clients will receive the message.
Rails Code: Redis instance can be set up to publish and subscribe to channels.

Session Store

Concept: Store user session data.
Example: Keep track of authenticated users.
Rails Code: config/initializers/session_store.rb can be configured to use Redis.

Rate Limiting

Concept: Limit the number of requests to an API.
Example: Only allow 100 requests per user per hour.
Rails Code: Custom middleware can utilize Redis to keep track of request counts.

Key Takeaways

Redis serves multiple functions in a Rails system.
It is effective for caching, queuing, real-time features, sessions, and rate-limiting.
Incorporating Redis often involves changes to Rails configuration and utilizing specific gems like Sidekiq for background jobs.

By understanding each use-case, you can make informed decisions on how to integrate Redis into your Rails project.

Explain lazy loading in Rails

Lazy loading in Ruby on Rails refers to the technique of delaying the loading of associated records from the database until they are actually needed. This avoids unnecessary queries and improves performance.

For example, consider a Book model that has_many Chapters. Without lazy loading:

1
2
book = Book.find(1)
book.chapters # Fetches chapters from DB

With lazy loading:

1
2
3
4
5
6
7
book = Book.find(1) 
book.chapters # Does NOT fetch chapters yet

# ...later in code when needed...

user.chapters.each do |chapter| # Now fetches chapters
end

Lazy loading is implemented in Rails using ActiveRecord associations with the :lazy option:

1
2
3
class Book < ApplicationRecord
  has_many :chapters, lazy: true 
end

The chapters won’t be loaded until they are referenced, avoiding unnecessary queries.

Rails can also eagerly load associations with .includes to avoid the N+1 queries problem. Lazy loading complements eager loading to only load data when absolutely required.

So in summary, lazy loading delays loading associated records until needed to avoid unnecessary queries in Rails.

What is Lazy Loading?

Concept: Lazy loading delays the loading of associated data until it’s actually needed.
Why: To improve performance by reducing initial data load time.

How It Works

Example: Let’s say you have a User model that has many Posts.
Initial Query: When you fetch a user, Rails won’t load the posts for that user immediately.
Rails Code: user = User.find(1)
Deferred Execution: When you call user.posts, only then will Rails fetch the posts.
Rails Code: user.posts

ActiveRecord Relations

Concept: ActiveRecord returns a Relation object, not actual records, for queries.
Example: User.where(active: true) returns a Relation.
Rails Code: You can chain methods onto this Relation without hitting the database.
Execution: The query fires when you perform an action that needs the data, like each or first.

N+1 Problem

Concept: Lazy loading can lead to inefficient queries when looping through associations.
Example: Looping through users and their posts can result in one query for users and N queries for their posts, where N is the number of users.

Rails Code:

1
2
3
4
users = User.all
users.each do |user|
  puts user.posts.count
end

Solution: Use eager loading to solve this, which loads all the needed data in one go.
Rails Code: User.includes(:posts)

Key Takeaways

Lazy loading helps by deferring data loading until necessary, which can improve initial page load times.
It comes with its own set of problems, like the N+1 queries issue, which you can solve through techniques like eager loading.

Understanding lazy loading helps you write more efficient Rails applications by being mindful of when database queries are executed.

Explain N+1 queries problem

The N+1 queries problem describes a common performance issue that arises from inefficient querying in ORMs like ActiveRecord.

The issue occurs when:

You fetch a number of records (N records)
Then for each record, you fetch its associated records (1 query per record)

This results in N+1 total queries - N for fetching the records, plus 1 per record to fetch its associations.

For example:

# Fetch 10 books 
books = Book.limit(10) 

books.each do |book|
  # Fetch chapters for each book (10 more queries!)
  book.chapters 
end

This issue can greatly increase response times. The solution is to eager load the associations:

# Eager load chapters
books = Book.includes(:chapters).limit(10)

books.each do |book|
  # Chapters already loaded!
  book.chapters
end

Rails also allows lazy loading to only load when needed.

The N+1 problem can cause major slowdowns in Rails and should be avoided via eager loading, lazy loading, or query optimizations.

Explain eager loading in Rails

What is Eager Loading?

Concept: Eager loading fetches associated records in advance to eliminate unnecessary database queries.
Why: To address performance issues like the N+1 problem.

How It Works

Example: You have a User model and each user has multiple Posts.
Initial Query: Fetching all users along with their posts in one query.
Rails Code: User.includes(:posts)

SQL Queries

Without Eager Loading: Multiple queries are made.
- One to fetch users: SELECT * FROM users
- N queries to fetch posts for each user: SELECT * FROM posts WHERE user_id = ?
With Eager Loading: One or two queries, depending on the relationship.
- One to fetch users: SELECT * FROM users
- One to fetch all related posts: SELECT * FROM posts WHERE user_id IN (...)

When to Use

Lists: Use eager loading when iterating over lists that require data from associated records.
Nested Associations: Can also eager load nested associations.
Rails Code: User.includes(posts: :comments)

Syntax Variations

includes: General purpose, lets Rails decide how to fetch the data.
joins: Executes a SQL JOIN operation but doesn’t load the related data into memory.
preload: Similar to includes but ensures separate queries for each table.
Rails Code:
- User.includes(:posts)
- User.joins(:posts)
- User.preload(:posts)

Key Takeaways

Eager loading minimizes the number of database queries, improving performance.
It’s especially beneficial when dealing with lists of records and their associations.
Syntax matters. Each method (includes, joins, preload) has its own use-case and behavior.

By knowing when and how to use eager loading, you can optimize your Rails application for better performance.

Eager loading in Rails refers to the practice of fetching associated records in the same query as the parent records. This avoids the N+1 queries problem.

For example, consider posts and comments models with a 1:M relationship:

1
2
3
4
5
6
7
class Post < ApplicationRecord
  has_many :comments
end

class Comment < ApplicationRecord
  belongs_to :post
end

To fetch posts with their comments:

Without eager loading

posts = Post.all posts.each do |post| post.comments.each do |comment| # N+1 queries end end

With eager loading

posts = Post.includes(:comments).all posts.each do |post| post.comments.each do |comment| # Comments already loaded! end
end


The .includes() specifies to eager load the comments for the posts.

This avoids the N+1 query problem of fetching comments separately per post.

Eager loading significantly speeds up many-to-many and complex associations in Rails. It trades off some memory for better performance.

In SQL does group by clause always go with having clause?

No, the `GROUP BY` and `HAVING` clauses in SQL don't always have to go together. They serve distinct purposes and can exist independently.

### GROUP BY

1. **Concept**: `GROUP BY` is used to group rows with the same value in specified columns.
2. **Example**: Grouping sales data by year.
3. **SQL Code**: 
    ```sql
    SELECT year, COUNT(*) 
    FROM sales 
    GROUP BY year;
    ```
   
### HAVING

1. **Concept**: `HAVING` is used to filter groups created by `GROUP BY`.
2. **Example**: Finding years where the total sales exceeded a certain amount.
3. **SQL Code**:
    ```sql
    SELECT year, COUNT(*) 
    FROM sales 
    GROUP BY year 
    HAVING COUNT(*) > 100;
    ```

### Separately

1. **GROUP BY Alone**: You can use `GROUP BY` without `HAVING` to simply group records.
2. **HAVING Alone**: Technically, `HAVING` is generally used after `GROUP BY`. However, some databases let you use `HAVING` without `GROUP BY` to filter aggregated data, although this is less common and not standard SQL.

### Key Takeaways

- `GROUP BY` is for creating groups based on column values.
- `HAVING` is for filtering those groups.
- They can exist independently, but `HAVING` is most effective when used with `GROUP BY`.

Understanding the independence and functionality of each clause allows you to write more precise and efficient SQL queries.

What is a composite database index?



### What is a Composite Index?

1. **Concept**: A composite index is a database index on multiple columns.
2. **Why**: To improve query performance for queries filtering or sorting by those columns.

### Structure

1. **Example**: An e-commerce database with a `orders` table containing `customer_id` and `order_date`.
2. **SQL Code**: 
    ```sql
    CREATE INDEX idx_composite ON orders (customer_id, order_date);
    ```

### How It Works

1. **Query Optimization**: A composite index can be used in queries that involve all the columns in the index or just the first column.
2. **SQL Code**: 
    ```sql
    SELECT * FROM orders WHERE customer_id = 1 AND order_date = '2023-01-01';
    ```

### Limitations

1. **Order Matters**: The sequence of columns is crucial. An index on `(customer_id, order_date)` won't optimize a query filtering just by `order_date`.
2. **Size**: Composite indexes consume more storage and can slow down insert, update, or delete operations.
3. **Overhead**: Maintenance and complexity increase with the number of composite indexes.

### When to Use

1. **Common Queries**: Use when you frequently query using multiple columns.
2. **Sort Operations**: Helpful for queries that need to sort by multiple columns.
3. **Join Operations**: Can improve performance of JOINs on multiple columns.

### Key Takeaways

- A composite index is an index on multiple columns.
- It can speed up queries involving those columns but comes with limitations like increased size and complexity.
  
Understanding the benefits and drawbacks of composite indexes can help you make informed decisions when designing your database schema.

What are the most important functional programming concepts?

Here are some of the most important concepts in functional programming:

- Pure Functions - Functions that always return the same output for the same input and have no side-effects. They promote referential transparency.

- First-class Functions - Treating functions as first-class citizens that can be assigned to variables, passed as parameters, and returned from other functions. Enables higher-order functions.

- Higher-order Functions - Functions that take other functions as arguments or return functions as output. This enables abstraction and composition.

- Immutability - Data is immutable and cannot be changed in-place. Mutations are performed by returning new copies. Minimizes side-effects.

- Declarative Programming - Focuses on describing what the program should accomplish without explicit step-by-step control flow. More abstract.

- Recursion - Used to iterate rather than traditional loops. Recursive functions require recursive data types to operate on.

- Lambda Calculus - A formal system forming the core concept of functional programming. Helps reason about computation through functions.

- Type Systems - Static type checking is preferred. Type inference reduces verbosity while retaining checking.

These core concepts enable building robust programs from simple, reusable functions free of side-effects. They provide the foundation for functional programming.

### First-Class and Higher-Order Functions

1. **Concept**: Functions are first-class citizens, meaning they can be passed as arguments, returned, or assigned to variables.
2. **Example**: Using map or filter methods, which take functions as arguments.

### Pure Functions

1. **Concept**: A function is pure if its output is solely determined by its input and it has no side-effects.
2. **Example**: A function to square a number is pure; it always returns the same output for the same input.

### Immutability

1. **Concept**: Once a data structure is created, it cannot be changed.
2. **Example**: Instead of altering an array, create a new array with the desired changes.

### Recursion

1. **Concept**: Functions can call themselves to solve problems in smaller pieces.
2. **Example**: Calculating factorial using recursion.

### Closures

1. **Concept**: Functions can capture and remember the environment in which they were created.
2. **Example**: A factory function that returns a function customized with variables from its scope.

### Function Composition

1. **Concept**: The process of combining two or more functions to produce a new function.
2. **Example**: Using `compose(f, g)` to create a new function `h(x) = f(g(x))`.

### Monads

1. **Concept**: A design pattern used for program-wide concerns, like state or I/O.
2. **Example**: The `Maybe` monad in Haskell handles optional values.

### Referential Transparency

1. **Concept**: An expression is referentially transparent if it can be replaced with its value without affecting the program's behavior.
2. **Example**: Pure functions are referentially transparent.

### Lazy Evaluation

1. **Concept**: Delaying the evaluation of an expression until its value is actually needed.
2. **Example**: Infinite lists in Haskell are possible due to lazy evaluation.

### Key Takeaways

- Functional programming focuses on immutability, pure functions, and function composition.
- These concepts lead to easier reasoning, testing, and debugging of code.
  
Understanding these core concepts can help you write cleaner, more maintainable, and more testable code.

Explain map, reduce, filter in Ruby

Here's an explanation of map, reduce and filter in Ruby:

- map transforms an array by applying a block to each element and returning a new array with the transformed elements.

For example: 

```ruby
numbers = [1, 2, 3]
doubled = numbers.map { |n| n * 2 } # [2, 4, 6]

reduce collapses an array into a single value by repeatedly combining elements. A function is applied between elements and the initial value.

For example:

1
sum = [1, 2, 3].reduce(0) { |acc, n| acc + n } # 6

filter creates a new array containing elements that pass a criteria given by the block.

For example:

1
evens = [1, 2, 3, 4].filter { |n| n.even? } # [2, 4]

These methods are very common in functional programming languages and allow manipulating arrays in a declarative way.

map abstracts looping and transformation. reduce abstracts iteration and aggregation. filter abstracts conditional filtering.

Together they enable a functional, non-mutative style of array processing.

Map

Concept: The map method transforms an array by applying a function to each of its elements and returns a new array.
Example: Double each element in an array.

Ruby Code:

1
2
[1, 2, 3].map { |n| n * 2 }
# Output: [2, 4, 6]

Filter (Select)

Concept: The select method filters an array based on a condition and returns a new array containing elements that satisfy the condition.
Example: Find even numbers in an array.

Ruby Code:

1
2
[1, 2, 3, 4].select { |n| n.even? }
# Output: [2, 4]

Reduce

Concept: The reduce method reduces an array to a single value by applying a function to its elements in an accumulative manner.
Example: Calculate the sum of an array of numbers.

Ruby Code:

1
2
[1, 2, 3].reduce(0) { |sum, n| sum + n }
# Output: 6

Key Takeaways

map transforms an array by applying a function to each of its elements.
select filters an array based on a condition.
reduce reduces an array to a single value by accumulating elements based on a function.

Understanding map, select, and reduce can help you manipulate arrays efficiently and elegantly in Ruby.