JoshCheek

def json_parse(json)
  success, index, _ws   = json_parse_optional_whitespace(0, json)
  success, index, value = json_parse_value(index, json)
  raise "Could not parse" unless success
  value
end

def json_parse_value(index, json)
  %I[
    json_parse_null

JoshCheek

module Consistency
  original = Enumerable.instance_method :reduce
  refine Enumerable do
    # I didn't actually check it against the real impl or docs or anything, but its something like this
    alias_method :inject, define_method(:reduce) { |*args, &block|
      block = args.pop if args.size == 2
      Enumerator.new do |y|
        original.bind(self).call(*args) { |l, r| y.yield r, l }
      end.each &block
    }

JoshCheek

def rot13(ascii_char)
  ascii_offset  = 65
  alphabet_size = 26
  full_index    = ascii_char.ord - ascii_offset
  cap_bit       = full_index & 0b100000
  half_index    = full_index & 0b011111
  rotated       = (half_index + alphabet_size/2) % alphabet_size
  (rotated + cap_bit + ascii_offset).chr
end

JoshCheek

require 'grape'
require 'logger'
require 'json'

class MyApi < Grape::API
  version 'v1', :using => :path
  format :json

  desc "Returns first / last name"
  get '/:first/:last' do

JoshCheek

Trunk Based Development
=======================

Disclaimer:
  I've never done this on a deployed flagship app at a job.
Words:
  Continuous integration: all code is merged frequently (perhaps several times per day to once every few days)
  Continuous delivery:    the integrated code is delivered (tested and deployable)
  Continuous deployment:  the deliverable code is deployed (shipped)
  Release:                feature is available to users

JoshCheek

#!/usr/bin/env ruby
require 'io/console'

class Grid
  def self.from_str(str, color:)
    rows = str.lines.map do |line|
      line.chomp.chars.map do |c|
        color if c != " ".freeze
      end
    end

JoshCheek

class Piece
  def self.from_strs(*strs, **opts)
    new strs.map { |s| s.chars.map { |c| c == "*" } }, **opts
  end

  attr_reader :rows, :graphic

  def initialize(rows, graphic:)
    @graphic, @rows = graphic, rows.map do |row|
      row.map { |cell| cell == true ?  graphic : (cell || nil) }

JoshCheek

require 'minitest/autorun'

module DotIs
  # Track the current test so that we can run assertions in its context
  def self.current_test=(test)
    Thread.current[:dot_is_current_test] = test
  end

  def self.current_test
    Thread.current.fetch :dot_is_current_test

JoshCheek

class Query
  def initialize(table, db)
    @db, @table, @cols, @rest = db, table.downcase, '*', ''
  end
  def method_missing(clause, *args)
    clause == :select \
      ? @cols = args.join(', ') \
      : @rest << ' ' << [clause, *args].join(' ')
    self
  end

JoshCheek

($true => $false => $if => y => succ => zero => toJs =>
(one => two => three => add => nil => cons =>
(multiply => map => reduce =>
  console.log(reduce(arr => n => [...arr, toJs(n)])(

    // Translation of this program into lambda calculus
    // https://dev.to/laurieontech/human-readable-javascript-337o
    //
    // const arr = [1,2,3]
    // const timesTwoPlusIndex = (el, index) => (el*2) + index