leandronsp

# ruby 3+
# gem install test-unit
require 'test/unit/assertions'
include Test::Unit::Assertions

def balanced?(input)
  delimiters = { 
    "(" => ")", 
    "{" => "}", 
    "[" => "]" 

leandronsp

FROM --platform=linux/amd64 ubuntu
RUN apt-get update
RUN apt-get install make binutils build-essential -y
RUN apt-get install nasm gdb strace -y
WORKDIR /app

leandronsp

require 'faker'
require 'benchmark'

def generate_groups
  (1..1_000).map do |id|
    { id: id, name: Faker::Educator.primary_school }
  end
end

def generate_users(groups_ids)

leandronsp

#!/bin/bash

## Create the response FIFO
rm -f response
mkfifo response

function handle_GET_home() {
  RESPONSE=$(cat home.html | \
    sed "s/{{$COOKIE_NAME}}/$COOKIE_VALUE/")
}

leandronsp

OOP in Bash script

Wait, what?

Inspired by this awesome article.

Prelude about OOP

According to wikipedia, OOP is a programming paradigm or technique based on the concept of "objects". The object structure contain data and behaviour.

Data is the object's state, which should be isolated and must be private.

leandronsp

use std::{thread, sync::{Arc, Mutex, Condvar}};

struct BlockingQueue<T> {
    store: Mutex<Vec<T>>,
    emitter: Condvar,
}

impl<T> BlockingQueue<T> {
    fn new() -> BlockingQueue<T> {
        Self {

leandronsp

fn main() {
    // 1. Singly Linked List (using Box)
    {
        println!("1. Singly Linked List (using Box)");
        struct Node<T> {
            value: T,
            next: Option<Box<Node<T>>>,
        }

        let mut head = Box::new(Node { value: 1, next: None });

leandronsp

fn main() {
    println!("This is a demonstration of ownership, borrowing and smart pointers in Rust.");

    // 1. Data on the stack (fixed size)
    {
        println!("Data on the stack (fixed size):");
        let age: i32 = 42;
        println!("Age: {}", age);

        // Transfer ownership: Copy

leandronsp

$ docker build -t localhost:5000/myapp . --push

leandronsp

use std::sync::{Arc, Mutex};
use std::sync::Condvar;
use std::thread;
use std::collections::HashMap;
use std::time::Duration;

struct Node<T> {
    value: T,
    next: Option<Arc<Mutex<Node<T>>>>,
    previous: Option<Arc<Mutex<Node<T>>>>,