Kevin Reid's blog

GSoC update: Hurry up and procrastinate.

kpreid@mac.com — Mon, 13 Jul 2009 13:33:56 GMT

I'm having severe getting-around-to-actually-doing-the-work problems; I am far behind schedule. I think the problem is framing this as “work” rather than just another of the projects that I've found interesting and tinkered with. (I also blame Team Fortress 2 and Rosetta Code for providing attractive distractions...)

I've ported the “Ref” facility from E; this is necessary as CapTP is built on Ref semantics (promises, proxies, broken refs). I hope to very soon get the actual CapTP connection module up, then (as I wrote before) “define, document and implement a CapTP-over-HTTP protocol”.

(I previously mentioned implementing the Surgeon (serialization tool) but I then remembered that that's actually irrelevant to CapTP.)

Also: working without Internet access removes a whole lot of potential distractions — and one’s access to online documentation. Luckily I had some source code around which provided examples.

Common Lisp hackery: writing fasls from non-file input

kpreid@mac.com — Mon, 13 Jul 2009 13:09:44 GMT

Common Lisp provides compile-file whose purposes is to convert a CL source file into an (implementation-defined) format which usually has precompiled code and is designed for faster loading into a lisp system.

compile-file takes the pathname of a textual lisp source file. But what if you want to compile some Lisp code that's not in a file already, perhaps because you translated/compiled it from some not-amenable-to-the-Lisp-reader input syntax, or because it contains unREADable literals? You can use a "universal Lisp file", which I know two ways to create (use whichever you find cleaner):

(cl:in-package :mypackage)
#.mypackage::*program*

(cl:in-package :mypackage)
(macrolet ((it () *program*))
  (it))

Suppose this is in "universal.lisp". Then to use it:

(defvar *program*)

(defun compile-to-file (form output-file)
  (let ((*program* form))
    (compile-file #p"universal.lisp"
                  :output-file output-file)))

This is just a minimal example; you'll also want to appropriately handle the return value from compile-file, provide an appropriate pathname to the universal file, etc. For example, here's an excerpt of the relevant code from E-on-CL, where I have used this technique to compile non-CL sources (emakers) into fasls:

(defparameter +the-asdf-system+ (asdf:find-system :e-on-cl))
(defvar *efasl-program*)
(defvar *efasl-result*)
...
(defun compile-e-to-file (expr output-file fqn-prefix opt-scope)
  ...
  (let* (...
         (*efasl-program*
           `(setf *efasl-result*
                  (lambda (...) ...))))
    (multiple-value-bind (truename warnings-p failure-p)
        (compile-file (merge-pathnames
                        #p"lisp/universal.lisp"
                        (asdf:component-pathname +the-asdf-system+))
                      :output-file output-file
                      :verbose nil
                      :print nil)
      (declare (ignore truename warnings-p))
      (assert (not failure-p) () "Compilation for ~A failed." output-file))))

(defun load-compiled-e (file env)
  (let ((*efasl-result* nil)
        ...)
    (load file :verbose nil :print nil)
    (funcall *efasl-result* env)))

Note that the pathname is computed relative to the ASDF system containing the universal file; also note the use of a variable *efasl-result* to simulate a "return value" from the compiled file, and the use of a lambda to provide a nonempty lexical environment, both of which are features not directly provided by the CL compiled file facility.

Web site moved; feedback wanted

kpreid@mac.com — Sun, 14 Jun 2009 04:37:10 GMT

I have moved my web site to a new location: http://switchb.org/kpreid/.

I have done this because Apple has announced they are shutting down homepage.mac.com. While they offer a replacement, I do not want to have to change my URLs ever again, so I bought a domain name.

As well as moving the files I have updated my picture, changed some of the URL layout, updated some miscellaneous information, added an “About me” section for the front page, and fixed broken external links. Please let me know if I missed anything...

or even just critique it without respect to what's new.

GSoC update: Going both ways.

kpreid@mac.com — Tue, 02 Jun 2009 18:52:11 GMT

I'm not making progress as fast as I would like; mostly due to assorted distractions rather than Doing The Work.

That said, I've gotten both ends of serialization implemented, at least for non-circular cases: the deJSONTreeKit and deSubgraphKit have both builder and recognizer implementations. (For a terminology introduction, see the serialization paper.)

Next up is the surgeon (high-level serialization interface), and designing uncallers suitable for JavaScript. I definitely need to increase my rate of progress to get this done on schedule.

GSoC update: It runs!

kpreid@mac.com — Sat, 30 May 2009 03:58:06 GMT

I completed enough of the E-on-JavaScript improvements, and wrote the beginnings of one Data-E kit in Cajita, together with the Updoc tests for it, and a Makefile to cajole the JavaScript and "animate" the Updoc - convert it into a HTML page that actually runs the tests.

I also improved various readme files and pages, hopefully such that someone else can get it all installed on their own system starting from my project page without too much prior knowledge.

Near-term plan: Put aside the EoJS, and get the Data-E kits working; then the surgeon; then the CapTPConnection; then define, document and implement a CapTP-over-HTTP protocol.

GSoC project update

kpreid@mac.com — Thu, 28 May 2009 14:39:43 GMT

I have begun the work on my GSoC project, Caja-CapTP.

I am currently working on improving E-on-JavaScript in order to be able to use its Updoc facility as the test framework for the Caja-CapTP code.

(If you don't know, Updoc is a test system which works by rerunning a recorded or made-up interactive session and confirming that the output is the same as before. The advantage of this system is that you can write test cases very simply as sequential code without gobs of assertFoo() for every particular attribute you think of testing.)

You can see my commits to EoJS at CIA.vc.

I am also learning more about exactly how Cajita works in areas such as library loading; the documentation in this area needs improvement, which I am going to work on myself and/or ask the Caja developers to clarify.

The overstuffed ballot box

kpreid@mac.com — Wed, 13 May 2009 17:54:36 GMT

I get the feeling the textbook writers had a list of everyday objects which they randomly picked from to avoid saying “an object” in each exercise. The results are mostly just distracting or mildly amusing, but sometimes they're a bit too much:

— Halliday, Resnick, Walker, Fundamentals of Physics, 8th ed., page 215

Spot the bogus proof [updated]

kpreid@mac.com — Tue, 12 May 2009 12:06:42 GMT

(This is (finally, now that the semester is over and I have some free time, heh) one of those posts-related-to-schoolwork I mentioned before.)

Does the infinite series converge?

First, rewrite it to have n = 1 as , and discard the constant term since it does not affect convergence. The terms of this series are strictly less than those of ; therefore, there is some x such that

Let k be the upper bound of the sum as we take the limit: .

Since is a continuous function of p, for any k there is some p greater than 1 such that

Since is a p-series which converges, i.e. has a finite sum, and the series under consideration has a lesser sum by the above inequality, it converges.

Furthermore, the above may be generalized to a proof that any series whose terms are eventually less than those of the harmonic series converges.

However, it is invalid, and in fact diverges.

I managed to convince myself and my calculus teacher with it, but we realized it must be invalid after he presented a counterexample to the general case. I then realized which step was invalid.

You can't use the same k for all three series in the second inequality; each infinite sum has its own independent limit, and what this proof is doing is along the lines of ∞ - ∞ = 0 — assuming that “two infinities are the same size”. Or rather, the inequality itself (among partial sums) is true, but that fact has nothing to do with the properties of the true infinite series.

I would be mildly interested in a more formal description of this sort of failure: how the k inequality is true yet the independent series do not have the same relation.

Update: I have received many informative comments and replied to some; one pointed out an earlier mistake: is bogus because we can't compare the series until we know they converge.

Whee, G-S-o-C

kpreid@mac.com — Tue, 21 Apr 2009 11:09:25 GMT

I have been accepted to Google Summer of Code 2009!

kpreid@mac.com — Thu, 26 Mar 2009 04:05:41 GMT

I just recently found out that LJ is displaying ads on my journal-or-blog-whichever — I hadn't previously noticed as it doesn't when I'm logged in (which seems a bit deceptive). I had previously understood that with a basic account there would be no ads.

Your opinion on the matter? Have the ads bothered you? Is there actually a way to turn them off that I haven't noticed? Should I find other hosting for my blog?

(I expect most of my readers are actually via feeds and don't see them...)

Confused yet?

kpreid@mac.com — Sat, 21 Mar 2009 15:46:39 GMT

While setting up my new laptop, I found this situation:

Decloaking, part 1: stage of life

kpreid@mac.com — Tue, 10 Mar 2009 10:49:19 GMT

Up until now, I've pretty much had an Online Life and an Offline Life (not much of one), and not made any connections between them. It's time to change that.

I'm 25, and my current phase of the Standard Life Plan, in which I am running a bit late, is “college”. I am currently attending Mohawk Valley Community College in New York, and planning to transfer to a four-year school, with the goal of a bachelor's degree in computer science.

It's taken me far too long to get around to posting this. A short todo list of further items:

Update my web site.
Post about transfer.
Post about employment.

(One of the reasons for this post is to provide context for if I later post something related to schoolwork; another is getting around to the third item on this list.)

A note on JavaScript method call semantics

kpreid@mac.com — Sat, 03 Jan 2009 19:40:21 GMT

So. In JavaScript, an “object” is a set of “properties”: associations from strings to values. A method is just a property whose value is a function. Functions are called like “foo()”, properties are accessed like “bar.foo”, and methods are called like “bar.foo()”. Looks straightforward enough, right?

Now, how does a method access the state of its object? Without inheritance, you could just have the method functions of a given object all close over some variables; but JavaScript does have prototype inheritance, so the necessary access is provided by binding the variable “this”, in the method body, to the object the method was invoked on.

And when does this happen? When you use the method call syntax. bar.foo() is not the same as

var m = bar.foo;
m();

(It is the same as m.call(bar) — call is a method on function objects which invokes them with this bound — but that's beside the point.)

So, the syntax is non-compositional.

Not only that, but it is enthusiastically so: bar.foo() is the same as (bar.foo)() — the parentheses do not break up the method call construct!

Database document software?

kpreid@mac.com — Thu, 30 Oct 2008 20:44:46 GMT

Something I've wished for several times recently is a database-document program.

By "document" I mean that the database is a single file, which I can move, copy, etc., as opposed to living in a database server which has to stay up, uses accounts and ACLs, needs special backup procedures, and so on. It doesn't need to support humongous data sets — fits-in-memory and even linear searches are fine.

I am aware that people use spreadsheets for such purposes, but I would like to have named, typed, and homogeneous columns, easy sorting/filtering/querying, etc. which I assume I'm not going to find there. Relational would be nice too.

It must be GUI, and run on Mac OS X, but it doesn't have to be thoroughly native — I can stand the better sort of Java or perhaps even X11 app.

And finally, it should have a file format that either is obvious how to parse, or has a specification, or is supported by many other programs.

Does such a thing exist?

(If not, I might write it.)

A dreadful thing

kpreid@mac.com — Sat, 04 Oct 2008 14:36:57 GMT

some type *foo;
size_t count = ...;

...

foo = malloc(count * sizeof * foo);

Getting started with AVR microcontrollers (using C, free tools and no IDE)

kpreid@mac.com — Wed, 01 Oct 2008 21:28:41 GMT

This is not a complete tutorial; it is intended to collect the information that I needed to get started and didn't find obvious, particularly explaining the operations needed to compile a program, and the most basic of syntax, operators, and IO operations to use microcontroller-specific operations from C/avr-gcc/avr-libc. It does not cover designing circuits or choosing a programmer.

Needed software

Get avr-gcc, avr-binutils, avr-libc, and avrdude. If you're on Mac OS X, all three are available through MacPorts.

Setup

Create ~/.avrduderc to specify what kind of programmer you have and where it's connected. Mine looks like this:

  default_serial = "/dev/cu.KeySerial1";
  default_programmer = "stk500v1";

default_serial is the device for the serial port the programmer is attached to; default_programmer is the type of programmer; see the manual section on command line options for programmer type names. You can also specify these on the command line, but I figure since these are specific to your computer it's better to leave them unspecified in makefiles.

Writing code

char is 8 bits and int is 16.
The entry point is the normal int main(void); you don't have to do any special initialization.
Special registers are exposed as variables — e.g. PORTD = 0 to do output.
All normal variables take up scarce RAM — for constant data, use the facilities in <avr/pgmspace.h> to store it in program space.
Basic IO: Each port has three registers. For some port x, DDRx specifies direction: a 1 bit makes the corresponding pin an output, whereas 0 makes it an input. Reading PINx takes input from the pins; writing PORTx sets output. If DDRx has a 1 bit, then PORTx controls internal pullups on those pins.
For further info on the functions of the chip, read the datasheet for it; the translation into C is mostly straightforward.
The avr-libc manual contains info on its avr-specific features.
The avr-libc demo projects are informative and well-explained.

Compiling

  avr-gcc -mmcu=at90s8515 -Werror foo.c bar.c -o foo.elf

Substitute the part number of your target chip for at90s8515. I use -Werror to reduce the chances I'll run broken code on real hardware.

  avr-objcopy -O ihex foo.elf foo.hex

This step discards the metadata the .elf file contains, leaving just the code, suitable for programming.

Programming (downloading)

avrdude -p 8515 -U flash:w:foo.hex

Substitute the part number of your target chip for 8515.

Why you should idly browse Wikipedia

kpreid@mac.com — Mon, 22 Sep 2008 23:34:31 GMT

I've seen it said that one should not use Wikipedia because at any given moment, a page might be wrong. But what's that error rate, versus the error rate of your own memory of miscellaneous not-significant-to-you-at-the-time information?

If the latter is ≥ the former, then even if Wikipedia is worthless for reliable information, it is still then useful to browse it randomly, or in a topic area of slight interest, because afterward you have increased your total knowledge while not increasing your error rate per fact.

kpreid@mac.com — Sun, 31 Aug 2008 17:14:00 GMT

“Language-independent” just means they invented a new language.

Apple's Sampler file format, and SBCL SB-SPROF report generation

kpreid@mac.com — Thu, 19 Jun 2008 14:09:03 GMT

Apple's Sampler is a profiler based on the principle of periodically collecting the entire call stack of the executing threads, then summarizing these stacks to show what occurs frequently; primarily, as a tree, rooted at the bottom of the stack, where each node shows the number of times that call sequence was found on the stack.

SBCL's sb-sprof is a profiler which also collects call stacks, but its summary report is much less useful to me as it does not provide the per-branch counting; just top-of-stack frequencies and a caller/callee graph.

Therefore, I examined Sampler's file format and wrote code to generate it from sb-sprof's record.

The file is mixed text/binary, LF line endings. The grammar, as far as I've determined it, is:

  "@supersamplerV1.0" LF
  "@symboltableV1.1" LF
  (TAB int32<id> TAB int32<unknown> 
   TAB text<symbol> 
   TAB text<library-path> TAB text<library-path> LF)*
  "@end" LF
  (
    "@threadV1.0" TAB int16Hex<thread-id> LF
    (
      TAB int32<1> int32<0> int32<1> int32<count of stack-frame> (int32<stack-frame>)* LF
    )*
  )*
  "@end" LF

where by "int32" I mean a big-endian 32-bit (unsigned?) integer (i.e. four not-necessarily-ASCII bytes), and by "int16Hex" I mean a 16-bit integer in hexadecimal (i.e. four ASCII bytes).

"id" is an arbitrary identifier for this symbol. "unknown" is occasionally nonzero, but I don't know what it means. "symbol" is the name of a function/method found on the stack. "library-path" is the pathname to the object file it was loaded from (relative in the case of a standard framework, e.g. "Carbon.framework/HIToolbox.framework/HIToolbox").

"thread-id" is an identifier for the thread, which should occur as an "id" in the symbol table; the upper 16 bits evidently must be 0. Thread symbol table entries have a name and library path which is the string ("Thread_" int16<thread-id>); I have not confirmed whether this is necessary.

Each entry in a @thread block is one sampling of the whole stack of that thread. I do not know what the 1, 0, and 1 mean, but the fourth integer is the number of frames on the stack; immediately after are that many integers, each of which is an id from the symbol table.

Files generated from this structure are accepted by Sampler, but not always by Shark; I don't know why, and my attempt at tracking it down made it seem to depend on the size of the trace file.

Here is code to generate such a file from sb-sprof data; it should be loaded in the SB-SPROF package:

  (defun write-32 (index stream)
    (write-byte (ldb (byte 8 24) index) stream)
    (write-byte (ldb (byte 8 16) index) stream)
    (write-byte (ldb (byte 8 8) index) stream)
    (write-byte (ldb (byte 8 0) index) stream))

  (defun write-sampler-data (stream)
    (format stream "~&@supersamplerV1.0~%")
    (format stream "~&@symboltableV1.1~%")
    (let ((symbols (make-hash-table :test 'equal))
          (buffer))
      (loop with gen = #x00002121
            for i below (- (samples-index *samples*) 2) by 2
            for debug-info = (aref (samples-vector *samples*) i)
            do (unless (or (member debug-info '(trace-start))
                           (gethash debug-info symbols))
                 (let ((index (incf gen)))
                   (setf (gethash debug-info symbols) index)
                   (write-char #\Tab stream)
                   (write-32 index stream)
                   (write-char #\Tab stream)
                   (write-32 0 stream)
                   (let* ((*print-right-margin* nil)
                          (*print-miser-width* nil)
                          (name (princ-to-string 
                                  (if debug-info
                                    (node-name (make-node debug-info))
                                    (format nil "Thread"))))
                          (real-info
                           (when (typep debug-info 'sb-di::compiled-debug-fun)
                             (sb-di::compiled-debug-fun-debug-info debug-info)))
                          (source
                           (when real-info
                             (sb-c::debug-info-source real-info)))
                          (pathname
                            (when (and source
                                       (eql (sb-c::debug-source-from source) :file))
                              (sb-c::debug-source-name source))))
                     (nsubstitute #\/ #\Newline name)
                     (format stream "~C~A~C~A~C~A~%"
                             #\Tab name
                             #\Tab pathname
                             #\Tab pathname)))))
      (format stream "~&@threadV1.0~C~4,'0X~%" #\Tab (gethash nil symbols))
      (flet ((out ()
               (when buffer
                 (write-char #\Tab stream)
                 (write-32 1 stream)
                 (write-32 0 stream)
                 (write-32 1 stream)
                 (write-32 (length buffer) stream)
                 (dolist (sym buffer)
                   (write-32 sym stream))
                 (terpri stream)
                 (setf buffer nil))))
        (loop for i downfrom (- (samples-index *samples*) 2) to 0 by 2
              for debug-info = (aref (samples-vector *samples*) i)
              do (cond
                   ((eql debug-info 'trace-start)
                    (out))
                   (t
                    (push (or (gethash debug-info symbols)
                              (error "No symbol assigned to ~S" debug-info))
                          buffer))))
        (out)))
    (format stream "~&@end~%"))

Usage:

(with-open-file (s "sampler.trace" :direction :output 
                                   :element-type :default
                                   :if-exists :supersede)
  (sb-sprof::write-sampler-data s))

This code generates a noninteractive Sampler-style tree report from SB-SPROF data.

  (defun make-bucket ()
    (list 0 (make-hash-table :test 'equal)))

  (defun put (bucket name)
    (let ((h (second bucket)))
      (or (gethash name h)
          (setf (gethash name h) (make-bucket)))))

  (defun build-tree ()
    (loop with root = (make-bucket)
          with current = (list root)
          for i downfrom (- (samples-index *samples*) 2) to 0 by 2
          for debug-info = (aref (samples-vector *samples*) i)
          do (cond
               ((eql debug-info 'trace-start)
                (dolist (bucket current)
                  (incf (first bucket)))
                (setf current (list root)))
               (t
                (let ((name (node-name (make-node debug-info)) #|kludge|#))
                  (push (put (first current) name) current))))
          finally (return root)))

  (defun twiddle-tree (bucket)
    (let (entries)
      (maphash (lambda (k v) (push (list* :i k (twiddle-tree v)) entries))
               (second bucket))
      (list (first bucket) entries)))

(Usage for printing a report: (twiddle-tree (build-tree)).)

Re: Zippers

kpreid@mac.com — Fri, 30 May 2008 03:05:13 GMT

For those wondering about the problem I was trying to solve with a zipper: After all the advice and some consideration, I decided to go with “option #2”: a whole-tree processing step which adds equal labels to corresponding variable uses and bindings. I’ve implemented all of the analysis I described in the original post using this system.

(However, the code isn't quite finished (as I discovered some problems with a different aspect of it) so it's not in any public repository yet.)

Zippers for evaluation and program analysis

kpreid@mac.com — Sun, 04 May 2008 14:02:52 GMT

It occurs to me that there is a similarity between a zipper and the combination of an expression and an environment, as for evaluation. I've got a problem that seems almost solvable by use of this, and I would especially like to hear Planet Haskell readers' thoughts on the matter.

(The expressions given here are in E syntax.)

For example, let's start with the expression

  def x := 74
  x + 1

For those unfamiliar with E, the tree this expression parses into has structure like this (ignoring some extra features and names):

  sequence(define(var("x"), literal(74)),
           call(var("x"), "add", literal(1)))

If we move “down” zipperwise into the second subexpression of the sequence, then we get the expression “x + 1” with the context “def x := 74 before this in a sequence”. Similarly, an interpreter uses an intermediate result of “x + 1”, “x is bound to 74”.

With a slightly extended context, I'm trying to use this to express program analysis in an auditor. The zipper context now tracks a small amount of information about variables, as well as the enclosing expressions.

The first problem is to determine that all occurrences of a given variable are used in a particular fashion: e.g. for f, permitting “f(1)” but not “f("foo")” or “somethingElse(f)” (where the third case would permit f to be used arbitrarily since the auditor doesn't get to see somethingElse’s code). This is easily accomplished by walking the entire expression looking for occurrences of var("f"), and walking “up” from each of those occurrences to check that the enclosing expressions form a permitted usage.

The second problem is to determine that the variable in a particular position is a free variable, and that its guard is of a particular form. This can be done by extending the context objects to record what variable names are bound by any expression preceding the current location (that is not inside its own block); thus walking up the contexts to the top-level determines whether the variable is free.

The third problem, I'm not sure what to do about. I have a situation roughly like this:

  def foo {
    method a() {
      def bar {
        method b() { foo }
      }
    }
  }

  object(var("foo"),
         method("a", object(var("bar"), 
                            method("b", var("foo")))))

As part of the first problem, I have found the object “bar”; I then walk upward to determine that it is generated by a method of the object “foo”. (There are additional constraints on the structure that I haven't mentioned.) I need to determine that the reference to “foo” in “b” is in fact to the outer object, and not to some other intervening lexical binding.

I've thought of two possible solutions so far:

Starting from method("a", ...), scan its children for occurrences of var("foo") and reject any which bind it. This would reject more than it needs to.
Switch to a pre-processing stage (instead of the incremental operation of a zipper) to assign an identity (or a mutable analysis-information field, equivalently) to each variable binding and all of its uses, and add upward references (like in the zipper) to each node; this would make the is-this-foo-that-foo test a simple comparison.

At the moment, the second option seems attractive; tying uses to definitions of variables in a generic fashion should be useful for other types of analysis. And since this is strictly analysis, not transformation, I don't need the modify-without-mutation function of a zipper. The only reason I haven't done that yet is I think zippers are neat (and there might be other uses for an established zipper over E ASTs).

What do you think I should do?

Portal (on a Mac)

kpreid@mac.com — Tue, 05 Feb 2008 15:19:11 GMT

I found out that you can play Portal on a Mac without installing Windows using CrossOver Mac. Yay.

It works fine with minor glitches, except that on the MacBook I have access to, level 19 (the last main-sequence level) appears nearly completely obscured by blue fog. I have not found any solution for this yet, though I've seen a report of success. (The launch option -dxlevel 70 works for Half-Life 2 (which uses the same engine), but is incompatible with Portal.) Level 19 works fine on an iMac.

The worst of the minor glitches was that the first time, it started up in full-screen with the image shifted down and right by half the screen size.

Changing the display options to some other resolution will straighten it out, but the glitch put the Options menu item off-screen. I found that the menu could be accessed by keyboard, and guessed correctly that Options would be the second-from-last option. So, highlight the first option, up arrow twice, return. Then drag the options subwindow by its edge to get to the controls.

Oh, and the game?

Portal is great.

I especially liked the moments of stare at layout baffled ... OH! ... portal-portal-portal-ding!

A bit of advice: Don't go on YouTube and watch a bunch of videos. There are only 19 levels (25 if you count the advanced maps, which are modifications of 6 of the regular ones), and having several of them spoiled was a bit disappointing.

I haven't tried any third-party maps. (Got recommendations?)

Oh, and one tip: when bouncing through a pair of floor portals and trying to aim at something, be looking straight up or down when you pass through the portal — that way, the game won't reorient you while you're trying to aim.

The Electronic Goldmine

kpreid@mac.com — Sat, 08 Dec 2007 21:40:46 GMT

I recently purchased some items from The Electronic Goldmine. I placed the order on December 2 (Sunday); it arrived at my post office box December 7 (Friday). The box was large and the contents were well-padded; I think it could safely have been smaller.

On the quality and details of the contents:

G15698 “5.5" x 12" Scissor Cut SS Copper Clad” $1.75

Looks like it got kicked around a bit: scratches, scuffs, grunge, and dark spots that might be dirt or pits; I haven't unbagged it yet.

GP59 “Small Mono Capacitors” $2.49

Not quite as described and depicted. The leads are 1" rather than 1⁄2" long. All have leads exiting with .1" spacing, but most of them are bent into .2" spacing.

G16567 “EIC-801 Solderless Breadboard 400 Contact” $4.49

No surprises, but note that the "distribution strip" is at a half-step offset from the "terminal strip" grid. The spacing between the distribution strip and the terminal strip sockets is an even .3" (two empty rows), however. The strips appear to be separable and interlocked, and are joined on the bottom with a pad of what appears to be double-sided foam tape.

G8534 “Large Universal Breadboard” $6.75

The design is almost identical to the G16567, and they came in similar packaging (EIC branded); however, the attachment pegs/notches on the sides are not compatible. Unlike the photo, the distribution strips are marked in red and blue.

G16562 “Microtips Technology MTC-S16204A LCD Display w/Backlight” $3.95

Looks new; haven't tested it yet. The pins fit into a breadboard as expected.

G2200 “Electronic Surprise Box” $3.25

I haven't unpacked this, as I do not yet have containers to sort it into. The box is about a 4" cube (inside), and reasonably well filled. The items I've spotted on top are:

3 × 6.5V 8800µF electrolytic capacitors
1 × large non-electrolytic capacitor
2 × rectangular-ceramic-cased power resistors
many resistors, on tapes
many small glass diodes, loose
3 × not-yet-identified TO-92-package device
1 × not-yet-identified IC (bent leads)
1 × LED
3 × paired "N/R" 14V indicator lamps, incandescent, panel-mount
4 × 125V indicator lights
3 × thermal cutout fuses
3 × headers, 2×?? pins
4 × stick-on rubber feet
2 × stick-on cable clips

GP27 “LED Mixture 1” $2.49

All the non-surface-mount ones are working and in good condition. 5 were surface mount, packed in a plastic strip; I did not open it to test them. 3 are in plastic right-angle frames like in the photo of GP43; 10 are in frames which have the leads folded back underneath as if for surface mount or plug-in use. These frames could probably be removed by straightening the leads. 9 are rectangular, and 23 are round (various sizes, mostly 5mm).

G1498 “Test Clips With Wire” $1.99

All tested and working; however, removing one of the insulating sleeves shows that the wires are attached merely by folding the conductor back over the insulation and crimping the clip on. No idea whether this is adequate in the long term. Some of the sleeves are quite slippery (fresh plastic), such that squeezing the clip fully open tends to result in it slipping out of the sleeve; shouldn't be a problem for normal use. The wires are quite flexible; nearly limp. Package branding is "SE".

If your MacBook's nonexistent Num Lock is stuck, check Mouse Keys

kpreid@mac.com — Thu, 29 Nov 2007 04:57:15 GMT

Bought a new MacBook with Leopard installed and used Migration Assistant (transferring from an iBook G3). Upon logging in to the primary account, the letter and number keys, Return, and some others stopped working. Returning to the login window, they continued to not work (as tested in the password-entry field) except for the Num-lock number pad region (which seemed strange, since this keyboard doesn't have a num-lock key or keypad markings). An external full USB keyboard worked normally.

The fix that worked (found in a web search) was to disable Mouse Keys (in Universal Access preferences).

Timer project: sound generation

kpreid@mac.com — Sun, 07 Oct 2007 16:34:26 GMT

One of the requirements for the timer project is that the alarm sound be not too unpleasant.

So: What can I do with the current prototype hardware, a piezo element taken from a watch connected directly to a (digital) output pin on the PIC?

Trivially, fixed-volume square waves, by either toggling the output pin in software or setting up the PIC's PWM feature to drive it automatically. (Note that the PWM produces a minimum frequency of 1/16384 of the main oscillator.)

(I've moved the piezo output on the prototype to the RC2/CCP1 pin. This change is not yet reflected in the published circuit and program.)

However, I want software volume control, so I tried something more elaborate. I set the PWM to a very high frequency, and produce the audio-frequency signal by varying the PWM's duty cycle parameter. The characteristics of the piezo crystal filter out the high frequency, producing an effectively analog output.

After much twiddling getting this to work (CCPR1L is not the least-significant bits of the duty cycle), I found that square waves work well, sine waves are very quiet, and changing the amplitude has the expected effect. So while it won't sound great, I can at least program it to increase the volume gradually.

I haven't yet integrated this into the main timer program, so I don't know whether I'll be able to produce decent tones despite (or making use of) the timer program's counting interrupt.