BRonen

(defmacro infix-math-dsl [form]
  (letfn [(parse [x]
            (cond
              (number? x)
              {:node :number :value x}

              (symbol? x)
              (let [s (str x)]
                (if (contains? #{"+" "-" "*" "/"} s)
                  {:node :op :value x}

BRonen

def tokens:
  split(" ") | map(select(length > 0));

def isnum:
  test("^-?([0-9]+(\\.[0-9]+)?)$");

def evaluate:
  def eval($tokens):
    if ($tokens | length) == 0 then
      error("ending unexpected")

BRonen

(defmacro cond-as->
  [value sym & clauses]
  (when (odd? (count clauses))
    (throw (IllegalArgumentException. "cond-as-> requires an even number of clauses")))

  (let [steps (partition 2 clauses)]
    (loop [val value, steps steps]
      (if (empty? steps)
        val
        (let [[test expr] (first steps)

BRonen

var isValidSudoku = function(board) {
    const rows = new Array(9).fill(0).map(() => new Set());
    const cols = new Array(9).fill(0).map(() => new Set());
    const boxes = new Array(9).fill(0).map(() => new Set());

    for (let i = 0; i < 9; i++) {
        for (let j = 0; j < 9; j++) {
            const num = board[i][j];
            if (num === '.') continue;

BRonen

const example = "1 - 1 + 3 + 44 / 2";

const lexer = (source: string): string[] => {
  const tokens: string[] = [];
  
  let currentToken = "";
  
  for (const char of source) {
    if ([" ", "+", "-", "*", "/"].includes(char)) {
      if (currentToken) tokens.push(currentToken);

BRonen

module MathInterpreter (mathInterpreter) where

import Data.Char

data Token = Number Integer
           | Plus
           | Dash
           | Star
           | Slash
           deriving Show

BRonen

+-assoc-proof : ∀ (x y z : ℕ) → x + (y + z) ≡ (x + y) + z
+-assoc-proof zero y z = refl
+-assoc-proof (suc x) y z = cong suc (+-assoc-proof x y z)

BRonen

with recursive fib as (
  select 0 as a, 1 as b
  union
  select b, a + b from fib
) select a from fib limit 5;

BRonen

type Iter<A> = () => A | null;

const array_to_iter = <A>(arr: A[]): Iter<A> => {
    let index = 0;

    return () => {
        const el = arr[index];
        index += 1;
        return el;
    }

BRonen

Thinking About Database Anomalies

When working on relational databases there are some guarantees called ACID, but these guarantees are not as safe as we usually think.

Let's start with a simple situation, imagine that you have a system that holds a balance of each user in some SQL database.

user A	user B
id: 1	id: 2
balance: 100	balance: 50