>     Probably all of these are good enough for the resume. Some may need 
> rephrasing or more details.

Really? They're all pretty tiny little things that took me a day or two. 
They specifically said "large projects".

>> - Built a recursive Turtle-style fractal plotter.
> 
>     What the heck is this? You mean similar to Logo? You may want to add 
> a line beneath it (indented a bit) that has a one line explanation of 
> what this is (but don't change the above description if it's accurate).

Imagine Logo, but with a command and re-executes the entire program, but 
with all the lengths scaled down. (And starting from the Turtle's 
current position. And restoring that position when the sub-program 
ends.) Makes it very easy to draw ferns, the Kock snowflake curve, etc.

It's more or less equivilent to an L-system. But I'd never heard of those.

>> - Built a Lambda calculus interpretter.
> 
>     Put this in. Specify what language you used, though (and spell it 
> properly!)

*cough* Haskell.

Actually, a Lambda calculus interpretter is fairly trivial. What I wrote 
was a CGI script which shows a complete reduction sequence, and can also 
"compile" an extended Lambda calculus expression into plain Lambda 
calculus, and then into SKI combinator calculus, and finally into Iota 
calculus. It accepts any of these 4 languages as input. Simultaneously.

This is not as trivial as it sounds. (!!)

>> - Built a mini-Mathematica engine.
> 
>     Give more details - perhaps as bullets beneath it. What were its 
> capabilities and in which language?

Borland TurboPascal 5.5 for DOS. And I basically implemented 
Mathematica's pattern-matching and expression transformation language. 
Of course, the thing that makes Mathematica so powerful is the 
stupendously *vast* library of transformation rules it comes with. It's 
the culmination of many man-centuries of R&D. Not something I could 
duplicate in a hurry - especially since I don't know, for example, what 
"hypergeometric functions" even *are*, never mind how to implement them.

>> - Built a modular software sound synthesizer.
> 
>     Good. Again, perhaps some bullets describing features.

TurboPascal again. Each "module" is an MS-DOS program that takes a bunch 
of CLI args and maybe some input files, and dumps some sound data into 
an output file. By writing batch files, you can design complex synthesis 
algorithms. I've got modules for generating envelopes of various kinds, 
an oscilator for generating any Fourier series, a variable amplifier, 
and an FM operator. Any questions?

(If only I'd known DSP back then... I could have added a digital filter!)

>> - Built a collection of data compression modules.
>     
>     What language and which data compression formats (you could just put 
> the latter in parentheses).

Haskell. Again.

It doesn't handle any well-known formats such as RAR or ZIP. Rather, the 
modules implement basic algorithms such as LZW, Huffman, BWT, etc.

>> - Built a Mandelbrot generator with multiple colouring options.
> 
>     Good enough. Language?

Originally BASIC. Then assembly. Then Pascal. Then Smalltalk. Then Java. 
Then PostScript. Then Eiffel. Then Haskell...

Special features include inversion of the complex plane, colouring by 
the final value of Z, or the weighted average of the whole orbit, the 
option of adding "orbit traps" (e.g., the well-known "epsilon cross" 
option of FractInt). Special mention goes to the built-in 
Floyd-Steinburg error distribution dithering built into the Pascal 
version to enable psuedo-truecolour display on a 16-colour VGA monitor. 
Also the special RLE file format for storing and retrieving the images.

>> - Built a mini-Prolog interpretter.
> 
>     Good enough. Language? You could give more details as above (what 
> features did you implement, etc).

Haskell. I believe I may even have posted the source code (or at least 
its derivation here). I *definitely* posted the Windows CLI binary. It's 
basically straight out of a book, with a few Andrewisms added. (E.g., 
VGA colour text!)

Give it a predicate involving some variables. It will attempt to assign 
values to the variables in such a way that the predicate is satisfied. 
There may be zero, one, or multiple ways this can be done...

>> - Built a simple ray tracer.
> 
>     Language? Remove "simple" and put something like "prototype". Maybe 
> list some basic features.

It traced spheres and planes. It had CSG though, so that means it 
basically traces any polyhedron. In fact, there was a nonlinear scaling 
operation which means you could turn a sphere into a cylinder, and then 
a cylinder into a cone, so you actually have quite a few options there. 
There's no particular reason for not adding other quadratics too; I just 
never got round to it. I was too busy playing with texturing.

It had a texturing system based on several different kinds of "maps". A 
scalar map assigns a value to each point in space. By using a [piecewise 
linear] colour map, you could then assign a colour to every point in 
space. You can also apply multilayer textures, where lower ones "show 
through" upper ones. And each element of a CSG operation can be textured 
seperately. (As you can see... it's basically a blatent rip of POV-Ray.)

But there were also "vector maps", which you could use to displace other 
map types. So you could assign a red/green Y-gradient to an object, and 
then sine-displace it in the Y direction, and then again at a different 
frequency in the Z direction. In this way, you could make some pretty 
complex textures. (Not to mention that you can checkerboard textures, or 
have "texture maps" by applying a texture blend to a scalar map... As 
you can see, I kinda went overboard on generality. It's probably 
Turing-complete!)

>> ...should I continue?
> 
>     Sure.

Numerical intergration for physical motion simulations?

CPU emulators?

That grainular synthesis thing I played with?

Fractal image compression? (Maybe not include that one; it ever actually 
worked!)

The graphing tool I never finished?

OK, I'm starting to run out now...

>     There's a danger of your resume becoming too long. In which case 
> you'll want a short version (2 pages) which have only the ones that you 
> think are really prominent or interesting to the job. Then, separately, 
> you can have a CV that has all of the above, with details on most as 
> bullets.

Well, this is specifically for Wolfram Alpha. Check out the application 
form. There's only space for, like, 300 words, and they specifically 
want one "large project". I have many, many, MANY tiny projects.

>> Every single one of these has been a small one-man project totalling
>> less than 1,000 lines of code, I would estimate.
> 
>     Doesn't matter. Most of these are non-trivial.

You think??

Sure, *I* was impressed that I wrote a raytracer and it worked. But from 
what I can gather, *everybody* writes raytracers. Hell, Warp wrote a 
raytracer *inside* a raytracer!! Using a damned macro language. :-P

>     Definitely put the recovery plan in there.

Done.

-- 
http://blog.orphi.me.uk/
http://www.zazzle.com/MathematicalOrchid*

Post a reply to this message