## Saturday, December 31, 2011

### Picomath

The Picomath project holds some reusable math functions inspired by John D. Cook's Stand-alone code for numerical computing, including:

• Error function
• Phi (standard normal CDF)
• Phi inverse
• Gamma
• Log Gamma
• exp(x) - 1 (for small x)
• log(n!)

These functions are implemented in an impressive list of languages: Ada, C++, C#, D, Erlang, Go, Haskell, Java, Javascript, Lua, Pascal, Perl, PHP, Python (2.x and 3.x), Ruby, Scheme, and Tcl.

And now Factor!

You can find the code (and a bunch of tests) for this on my Github.

## Friday, December 30, 2011

### Slot Machines

Playing slot machines can be pretty fun, but don't be fooled by claims that the casino has the "loosest slots", odds are probably still against you. I thought it would be fun (and cheaper!) to build a slot machine simulator using Factor.

Our slot machine is going to be a console application that will look something like this:

## Spinning

Even though our slot machine is text-only, we can still make use of some nice unicode characters to be our symbols:

`CONSTANT: SYMBOLS "☀☁☂☃"`

Each spin chooses a different symbol at random (each being equally likely):

```: spin ( value -- value' )
SYMBOLS remove random ;```

To reproduce the feel of spinning a slot machine, we will introduce a slight delay so that the wheel spins fast at the beginning and then slower and slower until it stops on a symbol:

```: spin-delay ( n -- )
15 * 25 + milliseconds sleep ;```

Spinning the slot machine takes a spin number, delays for a bit, then rotates each wheel (we stop spinning the first column after 10 spins, the second after 15, and the last after 20):

```: spin-slots ( a b c n -- a b c )
{
[ spin-delay ]
[ 10 < [ [ spin ] 2dip ] when ]
[ 15 < [ [ spin ]  dip ] when ]
[ drop spin ]
} cleave ;```

## Display

Each "spin" of the slot machine will be printed out. Using ANSI escape sequences, we move the cursor to the top left ("0,0") of the screen and then issue a clear screen instruction. Then we print out the current display and flush the output to screen:

```: print-spin ( a b c -- a b c )
"\e[0;0H\e[2J" write
"Welcome to the Factor slot machine!" print nl
"  +--------+" print
"  | CASINO |" print
"  |--------| *" print
3dup "  |%c |%c |%c | |\n" printf
"  |--------|/" print
"  |    [_] |" print
"  +--------+" print flush ;```

## Playing

The player will have won if, after all the spins, the "pay line" shows three of the same characters:

```: winner? ( a b c -- )
3array all-equal? nl "You WIN!" "You LOSE!" ? print nl ;```

Playing the slot machine consists of spinning the wheels 20 times, displaying each spin to the user, then checking if the user has won the game.

```: play-slots ( -- )
f f f 20 iota [ spin-slots print-spin ] each winner? ;```

Since our casino wants the user to keep playing, we make it really easy to just hit ENTER to continue:

```: continue? ( -- ? )
"Press ENTER to play again." write flush readln ;```

And, to finish it off, we define a "MAIN" entry point that will be run when the script is executed:

```: main-slots ( -- )
[ play-slots continue? ] loop ;

MAIN: main-slots```

The code for this is on my Github.

## Wednesday, December 28, 2011

### Elementology

Question: What do the words bamboo, crunchy, finance, genius, and tenacious have in common? I'll give you a hint: its the same thing they have in common with the words who, what, when, where, and how?

Stumped? Well, it's not that these are all English words.

Answer: All of these words can be spelled using elements from the periodic table!

I was recently inspired by the Periodic GeNiUS T-shirt from ThinkGeek and a website that can "make any words out of elements in the periodic table". I thought it would be fun to use Factor to see how many other words can be spelled using the symbols for chemical elements.

First, we need a list of elements:

```: elements ( -- assoc )
H{
{ "H" "Hydrogen" }
{ "He" "Helium" }
{ "Li" "Lithium" }
{ "Be" "Beryllium" }
{ "B" "Boron" }
{ "C" "Carbon" }
...
{ "Uut" "Ununtrium" }
{ "Uup" "Ununpentium" }
{ "Uuh" "Ununhexium" }
{ "Uus" "Ununseptium" }
{ "Uuo" "Ununoctium" }
} [ [ >lower ] dip ] assoc-map ;```

Next, a word that checks if a particular substring is the symbol of an element:

```: element? ( from to word -- ? )
2dup length > [ 3drop f ] [ subseq elements key? ] if ;```

We know that symbols are only ever one, two, or three characters. A word is considered "periodic" if it can be composed of any number of (possibly repeating) element symbols. We build a recursive solution that starts with the first character and continues as long as element symbols are a match or until the end of the word is reached:

```: (periodic?) ( word from -- ? )
{
[ swap length = ]
[
{ 1 2 3 } [
dupd + [ pick element? ] keep
'[ dup _ (periodic?) ] [ f ] if
] with any? nip
]
} 2|| ;

: periodic? ( word -- ? )
>lower 0 (periodic?) ;```

It's easy to get a list of dictionary words from most Unix systems:

```: dict-words ( -- words )
"/usr/share/dict/words" ascii file-lines ;```

And then a list of all "periodic words":

```: periodic-words ( -- words )
dict-words [ periodic? ] filter ;```

So, how many words are "periodic words"? About 13.7% of them.

```IN: scratchpad dict-words length .
235886

32407```

The code for this is on my Github.

## Thursday, November 10, 2011

### wc -l

The `wc` program is a utility that can count the number of lines in a file. It has a number of options that are described on its man page that can change its function to count characters or word or produce the length of the longest line.

For the last month, Joe Groff has been improving the performance of Factor's I/O libraries. Yesterday, we were investigating slow performance when doing lots of small reads from a file. Joe was able to make a number of nice speedups, which will be in the next release of Factor.

After suggesting that we use `wc -l` as a benchmark to aspire to, we came up with several approaches with varying performance. I want to demonstrate these, using timing information from running it on my computer. Although the Factor image file is binary data, we are going to count the number of newline characters in it.

Note: some of these require the latest development version of Factor to run.

Our "gold standard" will be `wc -l`, which takes just over 0.1 seconds:

```\$ time wc -l factor.image
6149212 factor.image

real 0m0.111s
user 0m0.090s
sys  0m0.020s```

Our first attempt in Factor is the shortest amount of code but takes 5.8 seconds (you can time this by running "`USE: system [ image wc-file-lines ] time`"):

```: wc-file-lines ( path -- n )
binary file-lines length ;```

We don't really need the lines, just their count, so perhaps just increment `each-line` in a loop. This is an improvement at just over 3 seconds:

```: wc-each-line ( path -- n )
binary [ 0 [ drop 1 + ] each-line ] with-file-reader ;```

Trying to use `read-until` to look for the next newline, is a bit slower at 3.4 seconds:

```: wc-read-until ( path -- n )
binary [
0 [ "\n" read-until [ drop 1 + ] dip ] loop

Instead of reading each line at a time, we can just read 65,536 byte blocks and count the number of newlines. This takes about 1.5 seconds:

```: wc-each-block ( path -- n )
binary [
0 [ [ CHAR: \n = ] count + ] each-block

Since we are only counting characters in each block, we don't need to allocate and copy the bytes out of the I/O buffer. Instead, we can look at a `slice`. This takes about 1 second:

```: wc-each-block-slice ( path -- n )
binary [
0 [ [ CHAR: \n = ] count + ] each-block-slice

The stream functions (such as `read`) operate on an `input-stream` dynamic variable, which introduces some overhead. If we remove that, the compiler can eliminate some of the dynamic dispatches. taking 0.320 seconds:

```: wc-fast ( path -- n )
0 swap [
[ CHAR: \n = ] count +
] each-stream-block-slice
] with-disposal ;```

If we make an assumption that the number of lines in a file will fit into a `fixnum`, then we can get a bit faster at 0.240 seconds:

```: wc-faster ( path -- n )
0 swap [
[ CHAR: \n = ] count + >fixnum
] each-stream-block-slice
] with-disposal ;```

And, if we cheat and just run the `wc -l` process directly, we can get to 0.210 seconds:

```: wc-system ( path -- n )
"wc -l " prepend utf8 [
readln " " split harvest first string>number

Overall, not too bad! Factor is getting within shouting distance of programs written in "faster" languages. Probably with a few more hours, we could close the gap, but thats enough for today.

Update: using SIMD, Joe was able to get the time down to 0.120 seconds!
```: aligned-slices ( seq -- head tail )
dup length 15 bitnot bitand cut-slice ; inline

: wc-simd ( path -- n )
[
0 swap binary <file-reader> &dispose [
aligned-slices [
uchar-16 cast-array swap
[ 10 uchar-16-with v= vcount + >fixnum ] reduce
] [ [ 10 = ] count + >fixnum ] bi*
] each-stream-block-slice
] with-destructors ;```

## Wednesday, October 26, 2011

### Disassemble

A neat trick that Factor provides is the ability to disassemble functions into the machine code that is generated by the compiler. In 2008, Slava Pestov created a disassembler, and has improved it a bit since then (switching to udis86 for its implementation).

## Constant Folding

The compiler performs constant folding, using the compiler.tree.debugger vocabulary, you can output the optimized form of a quotation:

```( scratchpad ) [ 2 2 + ] optimized.
[ 4 ]```

Using the disassembler, you can see the machine code this generates:

```( scratchpad ) [ 2 2 + ] disassemble
011c1a5534: 49c70640000000  mov qword [r14], 0x40
011c1a553b: c3              ret

## Local Variables

One of the questions that comes up sometimes is whether local variables affect performance. We can examine two words that add numbers together, one using locals and one just using the stack:

```( scratchpad ) : foo ( x y -- z ) + ;

( scratchpad ) :: bar ( x y -- z ) x y + ;```

The "optimized output" looks a little different:

```( scratchpad ) \ foo optimized.
[ + ]

( scratchpad ) \ bar optimized.
[ "COMPLEX SHUFFLE" "COMPLEX SHUFFLE" R> + ]```

But, the machine code that is generated is identical:

```( scratchpad ) \ foo disassemble
01115de7b0: 488d1d05000000  lea rbx, [rip+0x5]
01115de7b7: e9e49439ff      jmp 0x110977ca0 (+)

( scratchpad ) \ bar disassemble
01115ef620: 488d1d05000000  lea rbx, [rip+0x5]
01115ef627: e9748638ff      jmp 0x110977ca0 (+)

## Dynamic Variables

Another frequently used feature is dynamic variables, implemented by the `namespaces` vocabulary. For example, the definition of the `print` word looks for the current value of the `output-stream` variable and then calls `stream-print` on it:

```( scratchpad ) \ print see
USING: namespaces ;
IN: io
: print ( str -- ) output-stream get stream-print ; inline```

The optimized output inlines the implementation of get:

```( scratchpad ) [ "Hello, world" print ] optimized.
[
"Hello, world" \ output-stream 0 context-object assoc-stack
stream-print
]```

You can inspect the machine code generated, seeing references to the factor words that are being called:

```( scratchpad ) [ "Hello, world" print ] disassemble
011c0c6c40: 4c8d1df9ffffff        lea r11, [rip-0x7]
011c0c6c47: 6820000000            push dword 0x20
011c0c6c4c: 4153                  push r11
011c0c6c4e: 4883ec08              sub rsp, 0x8
011c0c6c56: 48b8dbc5a31a01000000  mov rax, 0x11aa3c5db
011c0c6c60: 498946f0              mov [r14-0x10], rax
011c0c6c64: 498b4500              mov rax, [r13+0x0]
011c0c6c68: 488b4040              mov rax, [rax+0x40]
011c0c6c6c: 498906                mov [r14], rax
011c0c6c6f: 48b86c91810e01000000  mov rax, 0x10e81916c
011c0c6c79: 498946f8              mov [r14-0x8], rax
011c0c6c7d: e8de4e36ff            call 0x11b42bb60 (assoc-stack)
011c0c6c86: 488d1d05000000        lea rbx, [rip+0x5]
011c0c6c8d: e94e5264ff            jmp 0x11b70bee0 (stream-print)

## Wednesday, October 12, 2011

### Optimizing 2^x

A great little article was posted last year about optimizing 2^x for doubles (by approximation). The author gets 40+% performance improvements in C#. I wondered if we could get similar improvements in Factor.

The basic idea is to use the fact that a number, `ab+c` can be factored into `ab * ac`. If we separate a floating point number into two components: an integer and a fractional part, we can show that:

`2n = 2integer(n) * 2fractional(n)`.

We are going to approximate this value by using a lookup table to compute the fractional part (within a specified precision). For example, to compute within a 0.001 precision, we need 1000 lookup values, essentially performing this calculation:

`2n = ( 1 << Int(n) ) * Table[ (int) ( Frac(n) * 1000 ) ];`

## Implementation

So, we need a word that can split a floating point number into those two values:

```: float>parts ( x -- float int )
dup >integer [ - ] keep ; inline```

Instead of one table with 1000 values, we will copy the original authors decision to use three lookup tables for additional precision. The following code calculates these lookup tables:

```CONSTANT: BITS1 10
CONSTANT: BITS2 \$[ BITS1 2 * ]
CONSTANT: BITS3 \$[ BITS1 3 * ]

CONSTANT: PRECISION1 \$[ 1 BITS1 shift ]
CONSTANT: PRECISION2 \$[ 1 BITS2 shift ]
CONSTANT: PRECISION3 \$[ 1 BITS3 shift ]

CONSTANT: MASK \$[ PRECISION1 1 - ]

CONSTANT: FRAC1 \$[ 2 PRECISION1 iota [ PRECISION1 / ^ ] with map ]
CONSTANT: FRAC2 \$[ 2 PRECISION1 iota [ PRECISION2 / ^ ] with map ]
CONSTANT: FRAC3 \$[ 2 PRECISION1 iota [ PRECISION3 / ^ ] with map ]```

The function `pow2` looks pretty similar to our original mathematical definition:

```: pow2 ( n -- 2^n )
>float 2^int 2^frac * >float ;```

The guts of the implementation is in the `2^int` and `2^frac` words:

```: 2^int ( n -- 2^int frac )
[ float>parts ] keep 0 >= [ 1 swap shift ] [
over 0 < [ [ 1 + ] [ 1 - ] bi* ] when
1 swap neg shift 1.0 swap /
] if swap ; inline

: 2^frac ( frac -- 2^frac )
PRECISION3 * >fixnum
[ BITS2 neg shift FRAC1 nth-unsafe ]
[ BITS1 neg shift MASK bitand FRAC2 nth-unsafe ]
[ MASK bitand FRAC3 nth-unsafe ] tri * * ; inline```

## Testing

Let's try it and see how well it works for small values:

```( scratchpad ) 2 1.5 ^ .
2.82842712474619

( scratchpad ) 1.5 pow2 .
2.82842712474619```

It seem's to work, how about larger values:

```( scratchpad ) 2 16.3 ^ .
80684.28027297248

( scratchpad ) 16.3 pow2 .
80684.28026255539```

The error is clearly detectable, but to test that it really works the way we expect it too, we will need to calculate relative error:

```: relative-error ( approx value -- relative-error )
[ - abs ] keep / ;```

Our test case will generate random values, compute 2x using our approximation and verify the relative error is less than 0.000000001 when compared with the correct result:

```[ t ] [
10000 [ -20 20 uniform-random-float ] replicate
[ [ pow2 ] [ 2 swap ^ ] bi relative-error ] map
supremum 1e-9 <
] unit-test```

And to verify performance, we will benchmark it against the built-in (and more accurate `^` word):

```: pow2-test ( seq -- new old )
[ [ pow2 drop ] [ each ] benchmark ]
[ 2 swap [ ^ drop ] with [ each ] benchmark ] bi ;```

We got almost a 40% performance improvement at the cost of a small loss of precision - not bad!

```( scratchpad ) 10000 [ -20 20 uniform-random-float ] replicate
pow2-test / >float .
0.6293153754782392```

The code for this is on my Github.

## Sunday, September 25, 2011

### Approximating Pi

A few days ago, it was announced on the Wolfram Blog that a 13-year-old had made a record calculating 458 million terms for the continued fraction of `pi`. In the spirit of that, I thought I would show how to solve a question that sometimes gets asked at interviews:

Given that Pi can be estimated using the function 4 * (1 - 1/3 + 1/5 - 1/7 + ...) with more terms giving greater accuracy, write a function that calculates Pi to an accuracy of 5 decimal places.

Using Factor, we can calculate the `nth` approximation of `pi` using vector arithmetic:

```: approximate-pi ( n -- approx )
[1,b] 2 v*n 1 v-n 1 swap n/v
[ odd? [ neg ] when ] map-index sum 4 * ;```

This isn't ideal if we want to try an increasing number of terms (looking for a particularly accuracy), since a lot of the the work would be redone unnecessarily. Instead, we can write a word that adds successive terms until the difference between the previous approximation and the current approximation is less than our requested accuracy.

```: next-term ( approx i -- approx' )
[ 2 * 1 + ] [ odd? [ neg ] when ] bi 4.0 swap / + ; inline

:: find-pi-to ( accuracy -- n approx )
1 4.0 [
dup pick next-term [ - ] keep
swap abs accuracy >= [ 1 + ] 2dip
] loop ;```

To show its performance, we can time it:

```( scratchpad ) [ 0.00001 find-pi-to ] time .
Running time: 0.026030341 seconds

3.141597653564762```

An equivalent function in Python might look like this:

```def find_pi_to(accuracy):
i = 1
approx = 4.0
while 1:
term = (2 * i) + 1
if i % 2 == 1:
term = -term
new = approx + 4.0/term
if abs(new - approx) < accuracy:
approx = new
break
i += 1
approx = new
return approx```

But, if we time this version (not counting startup or compile time), it takes 0.134 seconds. Doing the math shows that Factor is 5 times faster than Python in this case. Not bad.

## Thursday, September 22, 2011

### Really Big Numbers

Factor supports both `fixnum` (fixed size integers, typically 32- or 64-bit values) and `bignum` (arbitrarily large integers). Recently, I discovered that Factor did not have support for calculating the logarithm of really big numbers (those larger than 21024).

You can define a simple factorial function:

```: factorial ( n -- n! )
[ 1 ] [ [1,b] product ] if-zero ;```

But if you tried to calculate the logarithm of `1000 factorial`, it produces the wrong answer.

```( scratchpad ) 1000 factorial log .
1/0.```

The reason for this is that Factor attempts to convert a `bignum` into a double-precision floating point number and take the logarithm of that. Unfortunately, the value in this case is too large. What do other languages do in this case?

We could look at Ruby, but it has the same problem as Factor:

```>> Math::log((1..1000).inject(:*))
(irb):8: warning: Bignum out of Float range
=> Infinity```

However, you can get the right answer in Python:

```>>> def factorial(n):
...    r = 1
...    while n > 0:
...        r *= n
...        n -= 1
...    return r
...
>>> math.log(factorial(1000))
5912.128178488163```

If you look under the covers, you will see that Python handles this case by calling frexp to split a value into a fraction (`x`) and a power of two (`exp`). The original value can be calculated as `x*2exp`. Using this, the logarithm can be computed as `log(x) + log(2) * exp`.

After discussing this on #concatenative, Joe Groff and I came up with a solution for this. I'm not going to go over all the details, but if you're curious, you can look at the discussion.

First, we implemented a cross-platform version of `frexp`:

```GENERIC: frexp ( x -- y exp )

M: float frexp
dup fp-special? [ dup zero? ] unless* [ 0 ] [
double>bits
[
HEX: 800f,ffff,ffff,ffff bitand
0.5 double>bits bitor bits>double
] [ -52 shift HEX: 7ff bitand 1022 - ] bi
] if ; inline

M: integer frexp
[ 0.0 0 ] [
dup 0 > [ 1 ] [ abs -1 ] if swap dup log2 [
52 swap - shift HEX: 000f,ffff,ffff,ffff bitand
0.5 double>bits bitor bits>double
] [ 1 + ] bi [ * ] dip
] if-zero ; inline```

Next, we added support for `log` and `log10` of `bignum`. If the number can be represented as a float, we continue to process it as before, but if it is larger, we calculate it similar to Python (with some caching of the `log(2)` and `log10(2)` values for performance):

```: most-negative-finite-float ( -- x )
HEX: -1.ffff,ffff,ffff,fp1023 >integer ; inline
: most-positive-finite-float ( -- x )
HEX:  1.ffff,ffff,ffff,fp1023 >integer ; inline

CONSTANT: log-2   HEX: 1.62e42fefa39efp-1
CONSTANT: log10-2 HEX: 1.34413509f79ffp-2

: (representable-as-float?) ( x -- ? )
most-negative-finite-float
most-positive-finite-float between? ; inline

: (bignum-log) ( n log-quot: ( x -- y ) log-2 -- log )
[ dup ] dip '[
dup (representable-as-float?)
[ >float @ ] [ frexp [ @ ] [ _ * ] bi* + ] if
] call ; inline

M: bignum log [ log ] log-2 (bignum-log) ;

M: bignum log10 [ log10 ] log10-2 (bignum-log) ;```

And now, in the listener you can get the answer!

```( scratchpad ) 1000 factorial log .
5912.128178488163```

This change is now in the Factor repository (if you'd like to update), and will be in the next release.

## Tuesday, September 20, 2011

### Enigma Machines

I noticed a fun blog post about recreating the Enigma machine in Python. For those who need a refresher, an Enigma machine was an encryption device used before and during World War II. I thought it would be fun to implement this in Factor.

## Build It

Our alphabet will be the 26 letters in the English alphabet, indexed from 0 to 25 ("a" to "z"):

```: <alphabet> ( -- seq )
26 iota >array ;```

The Enigma machine is made up of a number of "cogs", which contain an encoding. We will create a cog using a randomized alphabet:

```: <cog> ( -- cog )
<alphabet> randomize ;```

We need to create a utility function to remove a random element from a sequence:

```: remove-random ( seq -- elt seq' )
[ length random ] keep [ nth ] [ remove-nth ] 2bi ;```

A special rotor called a "reflector" connected pairs of outputs, ensuring that encryption and decryption were the same process. It also gave the Enigma machine the property that no letter encrypted to itself (a flaw which was used to help break the code). We can create a reflector by taking the alphabet, and randomly exchanging pairs of elements:

```: <reflector> ( -- reflector )
<alphabet> dup length iota [ dup empty? ] [
remove-random remove-random [ pick exchange ] dip
] until drop ;```

We can now create an Enigma machine with a number of cogs and a reflector:

```TUPLE: enigma cogs prev-cogs reflector ;

: <enigma> ( num-cogs -- enigma )
[ <cog> ] replicate dup clone <reflector> enigma boa ;```

We need a way to check for special characters (those not in the 26 letter alphabet):

```: special? ( n -- ? )
[ 25 > ] [ 0 < ] bi or ;```

We need a utility function to change several elements of a sequence at the same time:

```: change-nths ( indices seq quot: ( elt -- elt' ) -- )
[ change-nth ] 2curry each ; inline```

Encoding a piece of text is where all the work is performed. The main strategy is to apply each character (that isn't special) through the cogs and then the reflector to find the encoded character, and then cycle the cogs to prepare for the next character.

```:: encode ( text enigma -- cipher-text )
0 :> ln!
enigma cogs>> :> cogs
enigma reflector>> :> reflector
text >lower [
CHAR: a mod dup special? [
ln 1 + ln!
cogs [ nth ] each reflector nth
cogs reverse [ index ] each CHAR: a +
cogs length iota [ 6 * 1 + ln mod zero? ] filter
cogs [ unclip prefix ] change-nths
] unless
] map ;```
Note: this converts the text to lowercase before encoding. The `encode` word could be expanded to support uppercase, but its much simpler this way.

If we make a word to reset the cogs back to the original configuration, we can verify that the encrypted text can be decrypted back to the original.

```: reset-cogs ( enigma -- enigma )
dup prev-cogs>> >>cogs ;```

## Try It

We can experiment with this in the Listener, creating a 4-cog Enigma machine and then encoding, resetting, and encoding again:

```( scratchpad ) 4 <enigma>

( scratchpad ) "hello, world" over encode [ print ] keep
luhhn, xnzha

( scratchpad ) over reset-cogs encode print
hello, world```

The code for this is on my Github.

## Sunday, September 18, 2011

### Most Pressed Keys

Mahdi Yusuf made a fun blog post about which keys get pressed the most in various programming languages. I thought I would generate one for Factor:

This was assembled by taking all the source code (not documentation or tests) from `core/` and `basis/` in the Factor codebase and passing it through heatmap.js.

## Sunday, September 11, 2011

### Manipulating Files

Java has had historically frustrating API's for interacting with files. In Java 7, these API's were cleaned up a little bit. A blog post demonstrates some examples of using these new API's. I would say, though, that Factor demonstrates a much simpler cross-platform API:

## Creating and Deleting Files

To create a file, simply:

`( scratchpad ) "/path/to/file" touch-file`

To update file permissions (on unix systems), you can use the io.files.info.unix vocabulary:

`( scratchpad ) "/path/to/file" OCT: 666 set-file-permissions`
Note: it would be nice to support parsing "rw-rw-rw-" and "g+x" and similar permission strings, and probably not very difficult.

To delete a file, simply:

`( scratchpad ) "/path/to/file" delete-file`

## Copying and Moving Files

To copy a file from one path to another:

`( scratchpad ) "/path/from" "/path/to" copy-file`

To copy a file, and preserve its file permissions:

`( scratchpad ) "/path/from" "/path/to" copy-file-and-info`

To copy a file into a directory:

`( scratchpad ) "/dir1/file" "/dir2" copy-file-into`

To move a file from one path to another:

`( scratchpad ) "/path/from" "/path/to" move-file`

To move a file into a directory:

`( scratchpad ) "/dir1/file" "/dir2" move-file-into`