function calculatePrice(total) {
  if (total > 1000) {
    return total * 0.9; // 0.9 is a magic number
  } else {
    return total * 0.95; // 0.95 is another magic number
  }
}

function getErrorMessage(code) {
  switch (code) {
    case "ERR001":
      return "Connection Error"; // "ERR001" is a magic string
    case "ERR002":
      return "Authentication Error"; // "ERR002" is another magic string
    default:
      return "Unknown Error";
  }
}

<%= button_to "Delete", [quote, line_item_date] %>
<%= button_to "Delete", quote_line_item_date_path(quote, line_item_date) %>

redirect_to @quote
redirect_to quote_path(@quote)

• Large and General: These models are typically very large, containing billions or even trillions of parameters. This allows them to learn complex patterns and relationships within the data.
• Broadly Applicable: Foundation models are trained in a way that allows them to be applied to a wide range of tasks. They can be fine-tuned for specific purposes like generating text, translating languages, or recognizing objects in images.
• Platform for AI Applications: They act as a foundation upon which other AI applications can be built. By fine-tuning a foundation model for a specific task, developers can create powerful AI tools without needing to train a massive model from scratch.

• Imagine a child learning from a vast amount of information (books, videos, experiences). Foundation models are like these "child brains" in the AI world, having learned from a huge dataset.
• While the child might not be an expert in any specific field, it can use this knowledge as a base to learn new things quickly. Similarly, foundation models can be adapted (fine-tuned) to perform various tasks effectively.

def double(x):
  """Doubles a number."""
  return x * 2

result = double(5)
print(result)  # Output: 10

# Lambda function to double a number
double_lambda = lambda x: x * 2

result = double_lambda(5)
print(result)  # Output: 10

• Passing small functions as arguments to other functions.
• Sorting or filtering data based on a simple criterion.
• Creating throwaway functions used only once.

array = [1, 2, 3, 4]
new_array = []
array.each do |element|
  new_array << element * 2
end
new_array
# => [2, 4, 6, 8]

array = [1, 2, 3, 4]
array.map do |element|
  element * 2
end
# => [2, 4, 6, 8]

data = "  Hello, world!   "  # String with leading and trailing spaces

stripped_data = data.strip()

print(stripped_data)  # Output: "Hello, world!" (whitespace removed)

data = "**Hello, world!**"  # String with leading and trailing asterisks

stripped_data = data.strip("*")

print(stripped_data)  # Output: "Hello, world!" (asterisks removed)

h: help
w: where
n: next
s: step (steps into function)
c: continue
p: print
l: list
q: quit

# Ensure between 1 and 100
111.clamp(1, 100)
# => 100
-1.clamp(1, 100)

# Ensure the value is one or more
[value, 1].min

# Ensure the value is 100 or less
[value, 100].max

docker system prune

//example
const double = (x) => x * 2;
const square = (x) => x * x;

var output1 = double(2);
var output2 = square(output1);
console.log(output2);

var output_final = square(double(2));
console.log(output_final);

# Syntax
lambda arguments: expression

# Example of use
add = lambda x, y: x + y  # Defines a lambda function that adds two numbers
result = add(5, 3)  # Calls the lambda function with arguments 5 and 3
print(result)  # Output: 8

# define a command class
class AuthenticateUser
  prepend SimpleCommand

  # optional, initialize the command with some arguments
  def initialize(email, password)
    @email = email
    @password = password
  end

  # mandatory: define a #call method. its return value will be available
  #            through #result
  def call
    if user = User.find_by(email: @email)&.authenticate(@password)
    ...
end

def my_method(value:, second_value:)
  puts "value #{value}, second_value #{second_value}"
end
my_method(value: 'value one', second_value: 'value two')

module SimpleCommand
  def self.included(klass)
    klass.class_eval do 
      def self.call(*args, **kwargs)
        puts "args #{args}"
        new(*args, **kwargs).call
      end
    end
  end
end

module SimpleCommand
  def self.included(klass)
    klass.extend(ClassMethods)
  end
  
  module ClassMethods
    def call(*args, **kwargs)
      new(*args, **kwargs).call
    end
  end
end

class NamedArguments
  include SimpleCommand
  def initialize(value: , second:)
    @value = value
    @second = second
  end

  def call
    puts "the method in myClass @value: #{@value}, @second #{@second}"
  end
end

class SimpleArguments
  include SimpleCommand
  def initialize(valueOne, valueTwo)
    @valueOne = valueOne
    @valueTwo = valueTwo
  end

  def call
    puts "the method in myClass @value: #{@valueOne}, @second #{@valueTwo}"
  end
end

from functools import lru_cache
@lru_cache(maxsize= 128) #cache can save up to 128 entries and optimize execution
def fib_with_cache(n): 
   if n < 2: 
       return n 
   return fib_with_cache(n-1)+ fib_with_cache(n-2)