|
![](/i/fill.gif) |
> 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
|
![](/i/fill.gif) |