vit0rr

Code is clean if it can be understood easily – by everyone on the team. Clean code can be read and enhanced by a developer other than its original author. With understandability comes readability, changeability, extensibility and maintainability.

---

General rules

1. Follow standard conventions.
2. Keep it simple stupid. Simpler is always better. Reduce complexity as much as possible.
3. Boy scout rule. Leave the campground cleaner than you found it.
4. Always find root cause. Always look for the root cause of a problem.

Design rules

vit0rr

Theorem plus_1_n : forall n : nat, n + 1 = S n /\ S n > n.
Proof.
  intros n.
  split.
  - induction n as [| n' IHn'].
    + simpl. reflexivity.
    + simpl. rewrite <- IHn'. reflexivity.
  - induction n as [| n' IHn'].
    + simpl. apply le_n.
    + simpl. apply le_n_S. apply IHn'.

vit0rr

Como Pensar

Ler e entender um pouco desse artigo. https://wiki.c2.com/?FeynmanAlgorithm

• Reconhecer como você pensa
• Descrever métodos que você usa para pensar
• Entender métodos diferentes de pensar
• Fazer perguntas sobre tudo(incluindo sobre perguntas)

Perguntas

vit0rr

YouTube video stream format codes

Comprehensive list of YouTube format code itags

itag Code	Container	Content	Resolution	Bitrate	Range	VR / 3D
5	flv	audio/video	240p	-	-	-
6	flv	audio/video	270p	-	-	-
17	3gp	audio/video	144p	-	-	-
18	mp4	audio/video	360p	-	-	-
22	mp4	audio/video	720p	-	-	-

vit0rr

// computing
C_bool = (A : Type) -> A -> A -> A;
(c_true : C_bool) = A => t => f => t;
(c_false : C_bool) = A => t => f => f;

// induction
I_bool b = (P : C_bool -> Type) -> P c_true -> P c_false -> P b;
i_true : I_bool c_true = P => p_t => p_f => p_t;
i_false : I_bool c_false = P => p_t => p_f => p_f;

vit0rr

let one = (f) => (x) => f(x) // (λf.λx.f x)
let two = (f) => (x) => f(f(x)) // (λf.λx.f (f x))

let _succ = (n) => (f) => (x) => f(n(f)(x)) // (λn.λf.λx.f (n f x))
let _add = (m) => (n) => (f) => (x) => m(f)(n(f)(x)) // (λm.λn.λf.λx.m f (n f x))
let _mult = (m) => (n) => (f) => (x) => m(n(f))(x) // (λm.λn.λf.λx.m (n f) x)
let _exp = (m) => (n) => (f) => (x) => n(m)(f)(x) // (λm.λn.λf.λx.n m f x)
let _pred = (n) => (f) => (x) => n((g) => (h) => h(g(f)))(u => x)(u => u) // (λn.λf.λx.n (λg.λh.h (g f)) (λu.x) (λu.u))
let _sub = (m) => (n) => n(_pred)(m) // (λm.λn.n pred m)

vit0rr

type TRUE = <A>(a: A) => <B>(b: B) => A;
type FALSE = <A>(a: A) => <B>(b: B) => B;
type OR = <A extends TRUE | FALSE>(a: A) => <B extends TRUE | FALSE>(b: B) => TRUE | FALSE;

// (λx.λy.x)
const TRUE: TRUE = a => b => a;
console.log(TRUE(1)(0));

// (λx.λy.y)
const FALSE: FALSE = a => b => b;

vit0rr

type Props = {
  length: number;
  arr: number[];
}

function insertionSort(arr: Props['arr']) {
  for (let i = 1; i < arr.length; i++) {
    let currentVal = arr[i];
    for (var j = i - 1; j >= 0 && arr[j] > currentVal; j--) {
      arr[j + 1] = arr[j];

vit0rr

type Reverse<A> =
  `${A}` extends `${infer AH}${infer AT}`
    ? `${Reverse<AT>}${AH}` : A

type Digs = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
type DigsNext<I = Digs, R = {}> =
  I extends [infer Head, infer Next, ...infer Tail]

vit0rr

/// <reference types="node" />
/// Locale: node_modules/@metaplex-foundation/mpl-token-metadata/dist/src/accounts/Metadata.d.ts


import { Borsh, Account, AnyPublicKey, StringPublicKey } from '@metaplex-foundation/mpl-core';
import { AccountInfo, Connection, PublicKey } from '@solana/web3.js';
import { Buffer } from 'buffer';
import { Edition } from './Edition';
import { MasterEdition } from './MasterEdition';
import { Uses } from './Uses';