charles-l

def kalman_predict(x_hat, u, P, wheel_slip_std):
    # non-linear state transition
    def f(p, u):
        x, y, θ = p
        dΦ_l, dΦ_r = u
        return v(
            x + (((WHEEL_R * dΦ_l) / 2) +
                 ((WHEEL_R * dΦ_r) / 2)) * DT * cos(θ),
            y + (((WHEEL_R * dΦ_l) / 2) +
                 ((WHEEL_R * dΦ_r) / 2)) * DT * sin(θ),

charles-l

#lang racket

(require racket/draw)


(define string-dist 15)
(define fret-dist 20)
(define strings 6)

(define (draw-gstring dc frets x h)

charles-l

GSoC 2017 Project

This summer, I worked on adding more attributes to ThinLTO's index to allow for more optimizations.

Background

LTO (Link-time optimization) combines the bitcode of every module in a project into a monolithic bitcode file during linking, so IPO (interprocedural optimizations) can be applied throughout a whole program. This improves the quality and the speed of the executables generated. However, LTO consumes a large amount of memory, so it isn't viable on many larger C/C++ codebases.

ThinLTO addresses this problem by introducing a light-weight in-memory index, that tracks attributes for relevant global values in a program. The index can be used to propagate information across a whole program, import and internalize functions, and apply whole program optimizations without having to store all the bitcode in memory.

charles-l

;; metacircular evaluator from sicp
(define apply-in-underlying-scheme apply)
(define (list-of-values exps env)
  (if (no-operands? exps)
    '()
    (cons (eval (first-operand exps) env)
          (list-of-values (rest-operands exps) env))))

(define (eval-if exp env)
  (if (true? (eval (if-predicate exp) env))

charles-l

// a simple notification daemon that sits on a fifo and calls a popup commend when new lines appear
// to use:
// cc -o notifyd notifyd.c
// ./notifyd
// <in a different terminal>
// echo 'a wild notification appears!' > /etc/notidsock
// <bask in the glory of a simple notification service that's less than 100 lines of code>

#include <stdio.h>
#include <unistd.h>

charles-l

bump = require 'bump'

local world = bump.newWorld()

local level = {elems = {}}

function level:addElem(x, y, w, h, drawLambda)
  local t = {draw = drawLambda}
  world:add(t, x, y, w, h)
  table.insert(self.elems, t)

charles-l

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
//                              p        pp
// (input - sent to first pipe) | tr a b | (output - read back in)


int main (void) {
  int p[2];

charles-l

#include <stdio.h>

// TO RUN EXPLOIT (this file just generates the junk needed to overflow to the return address):
// cc exploit.c; ./a.out | nc problems2.2016q1.sctf.io 1337

int main() {
    // EIP points to the current stack frame (so we want it to point at get_flag)
    //
    // We can do this by overwriting the old return address with the address for get_flag
    // (which you can get by running `pd 1 @ sym.get_flag` in radare)

charles-l

#!/usr/bin/env python

import gdb

class ListPrintCommand(gdb.Command):
    """print atoms"""

    def __init__(self):
        super(ListPrintCommand, self).__init__("print-atom",
                gdb.COMMAND_DATA, gdb.COMPLETE_SYMBOL)

charles-l

hi clear
set background=dark
if exists("syntax_on")
  syntax reset
endif
let g:colors_name = "bwop"

hi Normal         ctermfg=7 ctermbg=0
hi Directory      ctermfg=gray
hi Search         ctermfg=white ctermbg=blue