Today I Learned

We can use the following method to ensure a variable value is between a specific range

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

Min, max validation

Ruby

We can use the following methods to ensure a variable is always min or max value:

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

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

docker system prune

Docker

The docker system prune command is a shortcut that prunes images, containers, and networks.

docker system prune

Function Composition

Javascript

It is an approach where the result of one function is passed on to the next function, which is passed to another until the final function is executed for the final result.

//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);

Lambdas

Python

Lambdas in Python are a concise way to define anonymous functions. They are useful for short, inline functions that are used only once or in situations where a full function definition would be cumbersome.

# 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

Splat operator for keyword and positional arguments in Ruby

Ruby

Recently, I became interested in Rails' Action Mailbox, and I read several articles including the official documentation. One article from Prograils (https://prograils.com/real-life-examples-adding-action-mailbox-to-a-rails-6-app) particularly caught my attention due to its discussion on using the simple_command gem (https://github.com/nebulab/simple_command). This article shows how the gem can help you avoid repeating the way you invoke your services or classes. It allows you to structure classes like this:

# 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

So you can invoke it like this

AuthenticateUser.call(session_params[:email], session_params[:password])

And I wondered how the SimpleCommand module might be structured. Additionally, I considered how it could support keyword arguments in the form of:

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

In fact, it is quite simple. Let’s define it in two different ways without using any additional dependencies:

Using class_eval and self for defining a class method

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

Using extend to define the methods as class methods

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

And here is how you can use it after that

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

NamedArguments.call(value: 'the value', second: 'from second')

Or using positional arguments

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

SimpleArguments.call('arg one', 'arg two')

There you have it!

Using lru_cache in python to allow memoization

Python

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)

Different ways to execute a lambda/proc

Ruby

lambda = lambda {|value| value ** value }

lambda.(10)
lambda.call(10)
lambda === 10
lambda[10]

proc = Proc.new {|value| value ** value }

proc.(10)
proc.call(10)
proc === 10
proc[10]

How to force the early return in the each loop

Ruby

You can use a break

(1..10).to_a.each.with_index do |element, index|
  puts "element #{element}, index: #{index}"
  break if index == 3
end

Using catch and throw

Following a syntax like this

catch :label do
  (1..10).to_a.each.with_index do |e, index|
    throw :label if condition
  end
end

Practical example

def my_method
  result = []
  catch :completed do
    (1..10).to_a.each.with_index do |element, index|
      result << element
      throw :completed if index == 3
    end
  end
  result
end
my_method
=> [1, 2, 3, 4]

Using Return

If you want to use return, it will stop the iterations but also the method itself, so be aware of that, and that remember that the return clause only works if it is contained in a method

def return_example
  values = []
  (1..10).to_a.each_with_index do |element, index|
    values << element
    return values if index == 3
  end
end

return_example
=> [1, 2, 3, 4]

Public, Protected and Private methods

Python

There is not something like a keyword to user encapsulation but you can address the same behavior by using Python convention "_" and "__"

class Example:
    def __init__(self):
        self.public_var = "public"
        self._protected_var = "protected"
        self.__private_var = "private"

    def public_method(self):
        print("This is a public method")

    def _protected_method(self):
        print("This is a protected method")

    def __private_method(self):
        print("This is a private method")

# Creating an instance of the class
example_instance = Example()

# Accessing public method and variable
example_instance.public_method()
print(example_instance.public_var)

# Accessing protected method and variable
example_instance._protected_method()
print(example_instance._protected_var)

# Trying to access private method and variable (will raise AttributeError)
# example_instance.__private_method()
# print(example_instance.__private_var)

The class Example has three types of methods and variables:

Public methods and variables are accessible from outside the class.
Protected methods and variables have a single underscore _ prefix and are typically considered non-public, although Python does not enforce this.
Private methods and variables have a double underscore __ prefix and are only accessible within the class itself.

In the example code:

public_var, public_method(), _protected_var, and _protected_method() are respectively public and protected variables and methods.
_protected_var and _protected_method() can be accessed from outside the class but are typically considered non-public.
__private_var and __private_method() are private variables and methods and can only be accessed within the class itself. Trying to access them from outside the class will raise an AttributeError.

Capitalize only the first word of a text

CSS

If you need to capitalize only the first word of a sentence use the first-letter property for that.

.your_class_name::first-letter{
  text-transform: capitalize;
}

This was useful to me to capitalize data from an API and can't handle it on the base app.

Type method

Python

You can use the method type() to know the type of a variable for example:

type(123) # <class 'int'>

Separe big numbers with underscore

Python

Using Python you can separate numbers with "_" value for example:
123_145_877
This does not affect the value or type of the number, it is only for improving human reading!

Command to distinguish a table from a view

Postgres

The following will show a table of information about all tables available, including which are views and which are tables:

SELECT * FROM information_schema.tables

See Information Schema for more details.

HATEOAS - Hypermedia as the Engine of Application State

Api Design

HATEOAS (Hypermedia as the Engine of Application State) is a design principle within RESTful APIs. It dictates that the server dynamically informs the client of available actions and related resources through hypermedia elements embedded within the response.

Imagine you're exploring a choose-your-own-adventure storybook. HATEOAS (Hypermedia as the Engine of Application State) is like the book itself guiding you through the adventure.

How it works:

You reach a point in the story (like a new level in a game).
The book (the application) presents you with the available options for what you can do next (like fight a monster or solve a puzzle). These are the hypermedia elements.
You choose an option by following the provided link or instructions.
The story then unfolds based on your choice, revealing new options and progressing the state of the application.

{
  "orderID":3,
  "productID":2,
  "quantity":4,
  "orderValue":16.60,
  "links":[
    {
      "rel":"customer",
      "href":"https://adventure-works.com/customers/3",
      "action":"GET",
      "types":["text/xml","application/json"]
    },
    {
      "rel":"customer",
      "href":"https://adventure-works.com/customers/3",
      "action":"PUT",
      "types":["application/x-www-form-urlencoded"]
    },
    {
      "rel":"customer",
      "href":"https://adventure-works.com/customers/3",
      "action":"DELETE",
      "types":[]
    },
    {
      "rel":"self",
      "href":"https://adventure-works.com/orders/3",
      "action":"GET",
      "types":["text/xml","application/json"]
    },
    {
      "rel":"self",
      "href":"https://adventure-works.com/orders/3",
      "action":"PUT",
      "types":["application/x-www-form-urlencoded"]
    },
    {
      "rel":"self",
      "href":"https://adventure-works.com/orders/3",
      "action":"DELETE",
      "types":[]
    }]
}