summaryrefslogtreecommitdiffstats
path: root/software
diff options
context:
space:
mode:
Diffstat (limited to 'software')
-rw-r--r--software/functional programming52
-rw-r--r--software/git7
-rw-r--r--software/ruby67
-rw-r--r--software/scheme67
4 files changed, 193 insertions, 0 deletions
diff --git a/software/functional programming b/software/functional programming
new file mode 100644
index 0000000..4720280
--- /dev/null
+++ b/software/functional programming
@@ -0,0 +1,52 @@
+===================================
+Functional Programming
+===================================
+
+Recursion
+--------------
+**Partial** functions can recurse endlessly over a finite input. **Total**
+functions will terminate/halt over a finite input. (TODO: check this
+definition)
+
+Collectors
+--------------
+The collector concept/pattern/paradigm is the one I am least familiar with
+in functional programming.
+
+My current understanding is that they essentially allow allow recursive
+functions to maintain something like state by wrapping immutable functions
+or variables in layer after layer of functions and just holding on to
+the outermost layer. For instance, the typical way to write a ``length``
+function in python would be::
+
+>>> def how-long(x):
+>>> l = 0
+>>> while x.has_next()
+>>> l = l+1;
+>>> x.pop()
+>>> return l
+
+Using recursion, we could do::
+
+>>> def how-long-recurse(x):
+>>> if x.has_next()
+>>> x.pop()
+>>> return how-long-recurse(x) + 1
+>>> else
+>>> return 0
+
+Using the collector paradigm, we could do::
+
+>>> def add1(x): return a+1;
+>>> def how-long-col(x, col):
+>>> if x.has_next()
+>>> return col(0)
+>>> else
+>>> x.pop()
+>>> return how-long-col(x, lambda a: col(add1(a)))
+
+The first two ways, the plus one operation is actually executed at any given
+time, while with the collector implementation we're really creating a
+function step by step which will give the answer at the end when it is all
+executed.
+
diff --git a/software/git b/software/git
new file mode 100644
index 0000000..cd0da69
--- /dev/null
+++ b/software/git
@@ -0,0 +1,7 @@
+=======================
+Git
+=======================
+
+Quick tip: when you have ``.gitignore`` ignoring everything (with a ``*``
+entry), you need to use ``git-update-index --add FILE`` to actually add the
+file, instead of just ``git-add FILE``.
diff --git a/software/ruby b/software/ruby
new file mode 100644
index 0000000..e64f73e
--- /dev/null
+++ b/software/ruby
@@ -0,0 +1,67 @@
+==================
+Ruby
+==================
+
+.. note:: This information is very rough, it's mostly my notes about what is
+ different about Ruby syntax compared to similar modern interpreted
+ pan-paradigm languages like Python.
+
+A unique intro to ruby is `"Why's Poignant Guide to Ruby"`__, a web-comic-y
+short free online book by why the luck stiff. The more serious reference is
+the "pickax" book.
+
+__ http://poignantguide.net/
+
+Blocks
+---------
+Blocks of code can be passed to functions, making ruby code more of a first
+order data type.
+
+Ranges
+----------
+
+>>> 2..7 # => 2..7
+>>> (2..7).to_a # => [2, 3, 4, 5, 6, 7]
+>>> (2...7).to_a # => [2, 3, 4, 5, 6]
+>>> ('e'..'h').to_a # => ["e", "f", "g", "h"]
+
+Control Structures
+--------------------
+Can use ``if`` after a statement::
+
+>>> a = c if c > b
+
+Along with the usual ``break`` and ``next``, there is ``redo`` which redoes
+the current loop (initial conditions may have been changed).
+
+
+Boolean Operators
+--------------------
+Anything that is not ``nill`` or ``false`` is true. To force interpretation
+as boolean, use ``!!`` (not not)::
+
+>>> !!(nil) # => false
+>>> !!(true) # => true
+>>> !!('') # => true
+>>> !!(0) # => true
+>>> !!({}) # => true
+
+
+Misc
+----------------
+Can use nasty Perl style regular expression stuff::
+
+>>> re1 = /\d+/
+>>> "There are 5 kilos of chunky bacon on the table!" =~ re1 # => 10, the index
+>>> $~ # => #<MatchData:0xb7c36754>
+>>> $~.pre_hash # => "There are "
+
+Also $1, $2, etc.
+
+The "splat operator", '*', either collects or expands extra arguments depending
+on syntax (I think this is kind of icky)::
+
+>>> a, b = 1, 2, 3, 4 # a=1, b=2
+>>> a, *b = 1, 2, 3, 4 # a=1, b=[2,3,4]
+>>> c, d = 5, [6, 7, 8] # c=5, d=[6,7,8]
+>>> c, d = 5, *[6, 7, 8] # c=5, b=6
diff --git a/software/scheme b/software/scheme
new file mode 100644
index 0000000..258343b
--- /dev/null
+++ b/software/scheme
@@ -0,0 +1,67 @@
+==================
+Scheme
+==================
+
+``mit-scheme`` with the ``scmutils`` package is assumed; the command
+``mechanics`` starts in interactive edwin prompt.
+
+See also notes on `The Little Schemer </k/books/littleschemer/>`__.
+
+Scheme Implementations
+-----------------------
+
+Very partial list, mostly just the ones which are interesting to me.
+
+MIT/GNU Scheme
+ The 7.9.0 release (last stable as of 01/01/2009) is not R5RS compatible,
+ and is generally a pain in the ass to compile on new systems. The 9.0
+ release should be easier to compile and distribute because it will use
+ a C compiler to bootstrap (true?).
+
+SCM
+ SCM is a fairly minimal, very small footprint R5RS-compatible
+ implementation. Apparently very portable and easy to compile. Includes
+ the Hobbit compiler. Part of the GNU project, maintained at MIT?
+
+SIOD
+ SIOD (scheme in one day) is a super small (75k binary?) Scheme
+ implementation.
+
+Coding in ``edwin``
+-----------------------
+
+..note: this section should be spun off as emacs. edwin is essentially a
+ scheme version of emacs. See this
+ `http://static.bryannewbold.com/mirror/sheets/emacs.pdf`:emacs cheatsheet:
+
+Common keyboard commands (usually 'M' is alt button, 'C' is ctrl, and 'S' is
+meta/super/"windows"):
+
+========= ====================================================================
+C-x C-f Open a file, or create a new one
+C-x C-s Save the file
+C-x k Kill (close) a buffer
+C-x C-c Exit the editor
+C-g Abort a command
+C-x C-e Evaluate the previous expression
+M-z Evaluate the surrounding expression
+M-o Evaluate the entire buffer (everything)
+C-c C-c Kill evaluation after an error
+C-y Paste (yank)
+C-x 2 Split screen vertically
+C-x 5 Split screen horizontally
+C-x o Switch to next buffer window
+C-x 1 Return to non-split screen
+M-x Enter a command by name in minibuffer (use tab to complete)
+C-x C-b Show buffer menu
+C-x b Select buffer
+C-x u Undo
+C-y Paste
+========= ====================================================================
+
+Scope
+--------------
+
+``set!`` looks up a symbol name and permanently changes the first value it comes
+across. ``let`` (and ``letrec``) create a new symbol with the given value.
+But wait, you need a ``lambda`` block to make everything work?