Gatlin Johnson gatlin

## write_to_fd.c
/* Helper function which writes a string to a file descriptor.
*/
static gboolean
write_to_fd (int fd, const gchar *message) {
  gsize bw;
  GIOChannel *channel = g_io_channel_unix_new (fd);
  GString *message_str = g_string_new (message);
  g_string_append (message_str, "\n");
  g_io_channel_write_chars (channel,
                            message_str->str,

## cast.sh
#!/bin/bash

MEDIA_FILE="$1"

if [ -z "$1" ]; then
    echo "Please specify a media file as the first argument."
    exit 1
fi

CHROMECAST_IP4_ADDRESS="$2"

## gist:d89ee5442c10ca59ac9a8b621392ed10
; Composable syntax-rules macros via the CK abstract machine
;
; We demonstrate (mutually-) recursive, higher-order applicative
; macros with clausal definitions, defined in the style that looks very
; much like that of ML or (strict) Haskell.
; We write composable, call-by-value--like macros without
; resorting to the continuation-passing-style and thus requiring no
; macro-level lambda. The syntax remains direct-style, with
; nested applications.

## psilo-typeclass.sl
;; Hask-- I mean, psilo with no real typeclasses and one virtual typeclass.
;  Inspired by [1], this is an exploration of representing all typeclasses
;  through one distinguished class.
;
;  This version of psilo does not have "real" typeclasses. However faking them
;  with explicit dictionary passing does seem to correctly infer and check the
;  constraints.
;
;  The goal then is to figure out how best to represent "real" typeclasses as a
;  distinguished feature in the language implementation given that we are

## io.hs
{-# LANGUAGE RankNTypes #-}

import Prelude hiding (IO, getLine)
import qualified Prelude as P
import System.IO.Unsafe

-- * The Foreign Function Interface

-- | FFI values permit interfacing with foreign functions, such as low-level IO
-- operations, memory management operations, or bindings to other user-level

## install-arch-linux-rpi-zero-w.sh
#!/bin/sh -exu
dev=$1
cd $(mktemp -d)

function umountboot {
    umount boot || true
    umount root || true
}

# RPi1/Zero (armv6h):

## free-compiler.hs
{-|
 - Example of using free constructions to build a flexible little compiler.
 -
 - The goal here is not necessarily efficiency but readability and flexibility.
 -
 - The language grammar is represented by an ADT; however, instead of
 - recursively referring to itself it instead references a type variable.
 -
 - We derive instances of 'Functor' and 'Traversable' for this type.
 -

## index.html
<!DOCTYPE html>
<html>
    <head>
        <title>Large Type</title>
        <link rel="stylesheet/less" type="text/css" href="style.less">
        <script type="text/javascript" src="lib/jquery-2.1.4.min.js"></script>
        <script type="text/javascript" src="lib/less.min.js"></script>
    </head>
    <body>
        <div class="out"><span contenteditable autofocus>*hello*</span></div>

## yet-another-conway.hs
{-# LANGUAGE DeriveFunctor #-}

import Control.Applicative
import Control.Comonad

import Control.Monad (forM_)

-- These two typeclasses probably make some people groan.
class LeftRight t where
    left :: t a -> t a

## markov.py
###
# Markov models!
#
# A Markov model of some process is a model of different states you can be in,
# where each state links to other states. These links are weighted by some
# probability score. Markov models are designed to model systems where future
# states depend only on the present state.
#
# In the case of words you may define "present state" to be "the current word,"
# or perhaps "the last 3 words."