renatoargh

import { randomBytes } from 'crypto'

const initCircularBuffer = (buffer: Buffer) => {
  let index = 0;
  
  return (): number => {
    if (index >= buffer.length) {
      index = 0;
    }

renatoargh

┌──────────────┬────────────────────────────────────────┐
│   (index)    │                 Values                 │
├──────────────┼────────────────────────────────────────┤
│  timestamp   │             1678742260622              │
│     uuid     │ 'f0df59ea-bfe2-43a8-98d4-8213348daeb6' │
│     ulid     │      '01GVEDC2WE8EM9HN422CT8VBNP'      │
│ decodedTime  │             1678742260622              │
│ originalUuid │ '0186DCD6-0B8E-43A8-98D4-8213348DAEB6' │
└──────────────┴────────────────────────────────────────┘

renatoargh

import { DateTime, DateTimeUnit, DurationLike } from "luxon";
import { deburr, kebabCase } from "lodash";
import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
import { 
  ConditionalCheckFailedException,
  DynamoDBClient,
  UpdateItemCommand,
} from "@aws-sdk/client-dynamodb";

const client = new DynamoDBClient({ region: 'sa-east-1' })

renatoargh

version: '3'

services:
  flink-jobmanager:
    image: flink:1.7
    platform: linux/x86_64
    container_name: flink-jobmanager
    command: 
      - "jobmanager"
    ports:

renatoargh

//valor:
//	string contendo os números a terem seu mod11 calculado.

//restornarResto:
//	boleano indicando se deve ser retornado o apenas o resto do multiplicatório ou o resultado da subtração por 11.

//multiplicadores:
//	conjunto de números que multiplicarão ciclicamente o valor de entrada.

function mod11(valor, retornarResto, multiplicadores){

renatoargh

General

• chrome
• 1pass
• intelliJ COMMUNITY (ou Ultimate)
• vscode
  • enable settings sync with github
• dropbox
• spectable
• skype
• teamviewer

renatoargh

const sleep = async (timeout: number = 1000) =>
  // tslint:disable-next-line:no-string-based-set-timeout
  new Promise((res) => setTimeout(res, timeout));

/**
 * A test-only utility that executes a function until a given condition is met.
 * Useful to wait for asynchronous operations to complete on integration tests.
 * If the condition is never met (`condition` never returns `true`) then tests will eventually timeout accordin to
 * the test framework timeout settings.
 * @param task Asynchronous function that will be repeatedly executed until the the desired `condition` is met.

renatoargh

import { isUndefined } from "lodash";

export abstract class Cloneable<T> {
  public clone(newValues: Partial<T> = {}): T {
    const clone = new (this.constructor as new () => T)();
    const newValuesWithNestedClones = Object.getOwnPropertyNames(clone)
      .reduce((partial, propertyName) => {
        const property = Object.getOwnPropertyDescriptor(clone, propertyName) as PropertyDescriptor;
        const isCloneable = property.value instanceof Cloneable;
        const isNotProvided = isUndefined(

renatoargh

version: 2

jobs:
  validate_terraform:
    docker:
      - image: hashicorp/terraform
    steps:
      - checkout
      - run:
          name: Validate Terraform Formatting

renatoargh

var valorFinanciado = 100,
    parcelas = 10,
    juros = 0.1, //ao mês
    cf = juros/(1 - (1 / Math.pow(1 + juros, parcelas))),
    valorDaParcela = cf * valorFinanciado;

console.log(valorDaParcela);