Quizmaster is a tool to let people design, publish, and use fun quizzes.

License: This project is free software, available under your choice of the Artistic, GPL, and MIT licenses. If you like this software, you are invited to consider linking to CJSHayward.com.

The Powered Access Bible is a tool to allow free and effective access to the Bible. The Powered Access Bible is especially good at finding which verses contain a given word, and then easily reading those verses in their full context. (The Powered Access Bible is a tool to find what the Bible says about something, and read it in context.) This includes Old Testament, New Testament, and Apocrypha/Deuterocanonical books.

There is also a package available for download and use on Unix-like servers:

If you’re not sure which version to download, I suggest the highest-numbered version.

License: Everything but the Bible versions is available to you under hour choice of the Artistic, GPL, and MIT licenses; the Bible translations are licensed as documented in the distribution. If you like this software, you are invited to consider linking toCJSHayward.com.

When I began using my cell phone’s web browser, it displayed error pages for quite a lot of stuff on the web. Browsing the web from my cell phone was a lot like trying to read a book or a magazine with large chunks simply ripped out. And when I tried troubleshooting, I might have missed something, but it seemed like a big problem without an easily available solution.

So I tried to provide my own solution. I made a free mobile proxy server that would present webpages for the mobile web so that they would display in a way that would work for my cell phone’s web browser and let me access pages I couldn’t access before.

If you would like to download the Mobile Web Proxy server, you are invited to do so. I suggest the most recent-numbered version marked “stable”.

License: This mobile web proxy server is free software, available under your choice of the Artistic, GPL, and MIT licenses. If you like this software, you are invited to consider linking to CJSHayward.com.

The Magic Notebook lets you keep and organize notes. These notes can be almost anything—projects, contact information, to do lists, books to read, and assorted other things—and are available to you anywhere there’s a networked computer. If you use the Magic Notebook, you may find other uses as well. If you would like to use it, the Magic Notebook is available here.

If you would like to install the Magic Notebook on a Unix-like web server, the software to run it is available for download. (If you’re not sure which version of the Magic Notebook to use, I suggest the highest numbered release that is stable instead of development.)

License: This project is free software, available under your choice of the Artistic, GPL, and MIT licenses. If you like this software, you are invited to consider linking to CJSHayward.com.

Hayward’s Free Intranet Employee Photo Directory is the world’s first open source employee photo directory, and is free software, made available to you under your choice of the MIT and GPLv2/v3 licenses. It is an Ajax application powered by Django on the backend and jQuery on the front.

It includes:

Ajax design intended to crowdsource information from within your employees.

Search by name, skill, department, title, and tagging.

Status updates.

Local time clock for people and organizations who are not in the visitor’s time zone.

A simple, powerful, usable, unobtrusive user interface and a good user experience.

The Data Mine is a search engine designed to give users an unusually powerful interface. It is designed around human-computer intelligent interaction (making the computer a tool so humans can use their intelligence). It divides the screen into two halves: one lets you find all the instances of your query’s keywords, and the other lets you look through a highlighted version of the results you choose.

If you’re not sure which version to download, I suggest version 2.0.

License: This project is free software, available under your choice of the Artistic, GPL, and MIT licenses. If you like this software, you are invited to consider linking to CJSHayward.com.

cjsh, developed by CJSH (Christos Jonathan Seth Hayward) is an experimental Unix/Linux command-line shell, designed to search for files for the user instead of making the user search through directory heirarchies manually, and allow much of the power of Python as its command-line scripting language.

It can be downloaded, as in the TL;DR section above, and can be initialized (this takes some time, but it pays off in usage), by running:

dev ~/directory $ cjsh --update
Creating image of file heirarchy; please wait.
This may take some time; it may be worth the wait (but sorry...)
Note that the following works well in nightly crontab:
cjsh --update --silent
The image is complete. You are free to use cjsh.
dev ~/directory $ cjsh
One moment, please; trying to load data...
Loaded.
Welcome to cjsh. Please visit CJSHayward.com! Hit '?' for help.
--
user @ dev.localdomain - Tue Oct 2 17:00:43 2012
/Users/user
cjsh> [TAB] for index in range(10):
----> echo %(index)d
---->
0
1
2
3
4
5
6
7
8
9
user @ dev.localdomain - Tue Oct 2 17:02:24 2012
/Users/user
cjsh>

Those echo statements are not built into the (cjsh) shell. They come from an os.system() statement, and it is possible in this way to interleave shell commands and Python, with Python variables accessible to the shell commands, at least at a basic level.

License: This project is free software, available under your choice of the MIT and GPLv2 licenses. If you like this software, you are invited to consider linking to CJSHayward.com.

You’ve tried CVS, SVN (Subversion), Git, Mercurial, and others. Isn’t it time to try a little more green of a distributed version control system?

CFL is the first green distributed version control system (DVCS). Inspired by “twisted but brilliant” compact fluorescent lights, CFL offers full DVCS services at a download weight of a very green file size of just under 8k.

dev ~/directory $ cfl commit
CFL can be turned off for efficiency purposes, and comes turned off by
default.
Right now CFL is turned off.
To turn it on, type:
cfl on
Thank you for using CFL!
dev ~/directory $ cfl on
You have turned CFL on. Please remember to turn it off when you have finished
using it.
Thank you for using CFL!
dev ~/directory $ cfl commit
CFL needs some time too warm up after you have turned it on. Please try again
in a few seconds.
Thank you for using CFL!
dev ~/directory $ cfl commit
CFL needs some time too warm up after you have turned it on. Please try again
in a few seconds.
Thank you for using CFL!
dev ~/directory $ sleep 5; cfl commit
To encourage efficient use of resources and a green footprint in terms of bytes
taken by commits, CFL has disabled editor-based commit messages in favor of
command-line inline commit messages, e.g.
cfl commit -m 'Last commit before adding experimental feature.'
Please try again using an inline commit message.
Thank you for using CFL!
dev ~/directory $

Testimonials

“Whoa, CVS is so much better than CFL it’s not even funny.” -Jane Q. Hacker

“Every programmer needs time to percolate, and slow down enough to be productive. That is why I consider CFL an essential programmer productivity tool.” -John Q. Hacker

“Every so often you run across a tool that changes the way you think about technology. CFL is that tool.” -A former environmental activist

“How did you get in here? Who let you past security? Guard!” -A Fortune 500 CTO

Models of Computation: The Church-Turing Thesis and Geometric Construction

The Church-Turing Thesis posits that the equivalence class that includes the Turing machine, and is also the basis for modern digital computing, is the most powerful model of computation. And it hasn’t been proven, but when people have checked out other models of computation, every one has turned out to either be equivalent to the Turing machine, or become lesser.

Quite probably it may be impossible to construct some useful computer by this model; quite possibly for that matter its greatest usefulness may come through simulations by digital computer, in which case its simulations will automatically not exceed Turing machines or digital computer by its power. However, even if is a failure at scaling some of the highest peaks, it seems an interesting and provoking possibility to explore.

Standard Euclidean geometric construction is a model of computation. It is not usually presented as such, but you start with a diagram and all that may be inferred from it, and you have two tools, a compass and straightedge, as well as a pen or other implement to draw with. And the solution to a construction is to come back with an algorithm that will go through computational steps that start with its initial state represented in a diagram, and use your three tools to create the desired end result.

Both models figure into the model of computation discussed here, but the model of computation is different.

The model of computation described here is like a blacksmith’s forge. I have read that one of the first things a blacksmith makes, is a pair of real tongs. And a blacksmith is not just turning out nails and other things for other people, but tools used in the forge. The core insight here is that a blacksmith can create tools, much as a computer programmer may make customized tools for their own work. This is at its core a geometric model of computation, with a more obvious debt to geometry, although the tools should be sufficient to implement a Turing machine. One person made the interesting suggestion that it is applying recursion to geometric construction.

The blacksmith’s forge

The main tools the blacksmith’s forge works with are as follows; the first three are taken from geometric computation:

A compass, that can be used to draw circles.

A straightedge.

A marking implement.

A jigsaw. The geometric plane is conceived not to be one point thin, but a uniform distance thick. When the blacksmith’s forge has constructed the closed outline of the shape, the shape can be cut out.

Pins, equal in length to two or more (whole) times the thickness of the plane. If one pin goes between two shapes one on top of the other, and the shapes are not otherwise constrained, they will be able to pivot around the pin with respect to each other. If two or more pins go through, then the two positions will be rigid in how they are joined.

Pieces cut out with the jigsaw, possibly joined by pins.

Idealized Physics in the Blacksmith’s Forge

The blacksmith’s forge has an idealized physics. The pin and jigsaw are parts of this idealized physics, but another part of the physics is that pieces do not tip over: any number of stackings that would immediately fall over in the real world are assumed to simply stand upright, the pieces resting on top of any other piece immediately beneath them for some positive areas. There is friction, and pieces pushed to where one entity crosses another, for instance, will immediately stop moving if they are no longer being pushed. Items touching each other can be pushed past each other, but only so far as they are pushed. This does not exhaust the physics, but if you think of the physics of ordinary geometric construction, you should be close to the mark.

Three Classic Problems

Trisecting an Angle

Consider the following diagram:

That is half of it. Take another one, rotate it by one notch and pin it to the bottom one, and you have forced equality for the angles between adjacent arms:

Take this constructed device, rotate it so point A is at an angle’s vertex, B is in the angle’s clockwise side, and expand or contract the accordion-like device so that C is at the angle’s other side. Angle DAB is now one-third of the (trisected) original angle.

Doubling the Cube

Consider the following modification of the previous diagram:

Take a circle, and draw a concentric circle at twice the radius. Then place the constructive device so point A is at the center, and expand out or collapse in so that B is on the initial circle. Then collapse or expand the device so that it is on the the new “double radius” circle. Point E will have a distance to the center equal to the original radius times the cube root of two.

Squaring the Circle

Cut out two circles, and a tall, thin rectangle. Put the circles snugly and squarely so that the line between them and the rectangles is perpendicular to the rectangles’ long dimension. Put pegs through the circles’ centers through the perpendicular rectangle, and mark (A) both the first circle and the rectangle where they meet. While holding the first circle squarely, push on the outer circle until it wraps the long rectangle around the first circle, and mark on the tall rectangle where it touched the circle’s mark.

You now have a distance marked out on the tall rectangle that is 2π times the radius of your circle. Getting the square root of π is not terribly difficult; you can draw two subsegments of a line segment, one equal to the original circle’s diameter in length and one equal to circle’s circumference, and then draw a long line segment perpendicular to the first segment starting where the two meet. Take one of the corner-like squares above, place it so that it touches both endpoints of the line segment, and while continuing to hold it tight to the ends of the segment, move it so its inner corner lies on the perpendicular line segment. The distance from that point along the line segment to the center is equal to the square root of π times the length of the original circle’s diameter:

(And though this would be laborious, I see no reason why such calculations could not emulate a Turing Machine.)

Foul!
You’re Using Extra Privilege!

I am indeed using extra privilege, but may I point something out?

There is a bit of a historical difference between now and ancient Greece. We now have a number of branches of mathematics, and though there may be likes and dislikes, it is something of an outsider’s question to ask, “Which is right: real analysis or modern algebra?” There is a general sense that as with board games, if you want to play chess you play by the rules of chess and if you want to play go you play by the rules of go.

The three questions neatly and easily answered are the standard three famous problems which it was subsequently proven to be impossible to construct with Euclidean geometry. And these were not simply mathematical chess problems; I don’t know the stories for all of them, but legend has it that there was a plague killing many people and an oracle stated that the plague would be stopped if a cubic altar were built that was twice the volume of an original cubic altar. This was not one where people only used Euclidean construction because they decided they could only play by the rules of Euclidean geometry. This was a “by any means necessary” matter, and it should be understood as much. The attitude of “This is the set of rules for this particular game” is anachronous; people would be very glad to have an extension to Euclidean construction that would allow solution of at least one of these problems.

And it is not clear to me whether this is any sense of useful model of computation. (I personally think, out of my second master’s thesis, that the human brain can do things no Turing-approximant style of computers can do. Some people have said, “A year spent in artificial vision is enough to make one believe in God,” and there are some basic things, like making sense of an I can read book, that most humans do well but are so far insurmountable to computers; one writer wrote of an embodied AI robot “Cog,” “The weakness of Cog at present seems to be that it cannot actually do very much. Even its insect-like computer forebears do not seem to have had the intelligence of insects, and Cog is clearly nowhere near having human intelligence.”

But I think this model of computation is interesting, whether or not it proves useful.

Arbitrary precision arithmetic libraries are old hat. But this is different.

This is a proof of concept, and only a proof of concept, for an approach that will allow exact precision arithmetic for any computable number. Want the square root of three to three decimal places? Realize later-on that the user wants twenty decimal places instead, or that the number of decimal places is dynamic? No need to refactor the original calculation; just ask the stored square root of three for twenty, or a user-supplied number, of decimal places. Have algorithms to calculate e and π? Add e and π together, and don’t worry until later about how many decimal places you want for e + π. Numbers are stored with exact precision and decimal approximations are print-on-demand.

The approach is outlined in the original email:

I was thinking about a way to try to have integer-clean arithmetic on algebraic numbers, and a brief Google search for “integer-clean arithmetic algebraic numbers” did not turn up obvious software tools for integer-clean handling of algebraic numbers.

However, I think I may have found a way to use objects to circumvent the corruption that comes from naive use of floating point numbers, where the corruption can increase exponentially.

Let’s say that every number is an object that is either:

Something that primitively can return an arbitrarily specified number of digits’ accuracy, which includes π and e, eventually, but what I originally have in mind is just integers, which will just return more zeroes after the decimal point if you keep asking for more digits of accuracy. —OR—

An object storing a first number, a second number, and an operation between them (addition, multiplication, and exponentiation, and their inverses).

Let us furthermore suppose that each number object has a method to evaluate its contents to a specified accuracy.

Numbers in class should be calculable by querying both numbers with enough additional places of accuracy that, when the operation is performed on them, the error is orders of magnitude smaller than the requested accuracy. (Note that this leaves the door open to some question of rounding error; but if a certain number of digits’ accuracy has rounding error that overlaps the rounding for the requested accuracy, more digits might be requested. Rounding error may be a fly in the ointment, although it would seem that an epsilon-delta style argument would establish that there are no corner cases that cannot be met by specifying enough digits.)

So if I request (31 / 10 + the square root of 2), accurate to three decimal places, and we say that we are giving two digits of padding, that resolves first to 31.00000 / 10.00000, round to 3.10000, and the second resolves to 2.00000 ^ .500000, which resolves to 1.41421. I add them, getting 3.51421, which I round to three decimal places, getting 3.514. And nothing in this calculation has been integer clean arithmetic in the usual sense, but the number has been evaluated accurately to three places, and it could just as well have been evaluated accurately to twenty places.

Now this abandons one feature that comes with specification floating-point arithmetic, namely that any number takes O(1) memory. This seems like numbers would have something more like O(n log n) memory, maybe more but seems subquadratic at least. And on a machine with 16 gigs of RAM, there may be some calculations where you want and can afford the memory consumption for these objects. For that matter, 16 megs of RAM might still be enough that you don’t absolutely need O(1) floating point numbers.

I think I’ll see about a Python package tomorrow.

Thoughts?

P.S. to [Name]: I’m interviewing with Google.

The proof of concept is only intended as a proof of concept, not a production release and not necessarily something that will handle every corner case. However, it is intended to clearly outline how one would go about such things and what the concept is that’s being proven.

This is implemented in Python that is written to be executable pseudo-code, (perhaps apart from the laborious parser that takes integer, float, string, and Decimal values and converts them to Numbers built from integers). The code is meant to be not-clever, and serve programmers in other languages as pseudocode that demonstrates how one might go about implementing this approach to arithmetic and number in the language of one’s choice.