alpicola

Writing style

This applies to everything you write for me: chat replies, reports, documents, PR bodies, and commit messages.

• Use plain, simple English. I am not a native speaker. Pick the common word over the rare one (write "leftover", not "vestigial"). If a term has no simple substitute, explain it in a few words right after.
• Write short sentences and short paragraphs. One idea per sentence. Use active voice.
• Lead with the highlights: what you did, whether it worked, and what I should do next. Cut everything I do not need to act on.
• If some detail is worth keeping but not needed to act, move it to an "Appendix" section at the bottom.
• Keep file paths, commands, and identifiers exact.

alpicola

Require Import Coq.Unicode.Utf8 Arith FunctionalExtensionality String Coq.Program.Equality.

Set Implicit Arguments.

Ltac invert H := inversion H; clear H; subst.
Ltac invert1 H := invert H; [].

Inductive star A (R : A -> A -> Prop) : A -> A -> Prop :=
| StarRefl : forall x,
  star R x x

alpicola

require 'fileutils'

Dir.glob('*_assignsubmission_file_*').each do |filename|
  if m = /(.+)_\d+_assignsubmission_file_(.+)/.match(filename)
    _, username, orig_filename = *m
    FileUtils.mkdir_p(username) # if it exists, do nothing
    FileUtils.mv(filename, username + '/' + orig_filename)
  end
end

alpicola

// inspired: http://journal.stuffwithstuff.com/2013/04/23/playing-with-generics-in-typescript-0.9.0/

class Base {
	foo() : void {}
}
// If `Derived' has no addional method, we'll get different results
class Derived extends Base {
	bar() : void {}
}

alpicola

// X. Yan, J. Guo, Y. Lan, and X. Cheng, A Biterm Topic Model for Short Texts,
// in WWW. ACM, 2013, pp. 1445–145

import scala.collection._
import scala.io.Source
import scala.util.Random
import java.io._

class BTM(val alpha:Double, val beta:Double, val k:Int, val iterN:Int) {
    private var words:Array[String] = null

alpicola

Definition id {A} : A -> A := fun x => x.

Arguments id {A} / x.

Definition compose {A B C} :  (B -> C) -> (A -> B) -> (A -> C)
    := fun g f x => g (f x).

Notation "g 'o' f" := (compose g f) (left associativity, at level 37).

Arguments compose {A B C} f g x /.

alpicola

(test (match {4 2 1 9} (List Integer)
        {[(foldr (lambda [$i $l]
                     <cons $a_i l>)
                 <nil>
                 (between 1 4))
          [a_1 a_2 a_3 a_4]]}))

alpicola

#!/usr/bin/env ruby

require 'thor'
require 'mechanize'

USER = ''
PASS = ''

class Report < Thor
  desc 'submit src1 src2 ...', 'Submit code'

alpicola

#sideNavi,
.leafThemeTitle,
.leafThemeTitleMap,
.themeTopic {
    display: none !important;
}

.topTitleBar,
#kijiBox,
.kijiTitle,

alpicola

#!/usr/bin/env ruby

require 'optparse'
require 'pathname'
require 'tmpdir'

libraries = %w|/Applications/Processing.app/Contents/Resources/Java/core.jar|
compiler = 'scalac'
OptionParser.new {|opt|
  opt.on('-w', '--watch') { compiler = 'fsc' }