Quizmaster is a tool to let people design, publish, and use fun quizzes.
|Version||RedHat RPM||Unix/Linux .tar.bz2||Unix/Linux .tar.gz|
Quizmaster is a tool to let people design, publish, and use fun quizzes.
|Version||RedHat RPM||Unix/Linux .tar.bz2||Unix/Linux .tar.gz|
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.
|Version||Unix/Linux tar.bz2||Unix/Linux tar.gz||RedHat RPM|
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.
|Version||Unix/Linux tar.gz||Unix/Linux tar.bz2|
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.)
|Version||Unix/Linux Tarball||RedHat RPM|
You are invited to download the Django project:
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.
|Version||RedHat RPM||Unix/Linux tar.gz||Unix/Linux tar.bz2|
|0.0 beta, development||datamine-0.0b-1.i386.rpm||datamine0_0b.tar.gz||datamine0_0b.tar.bz2|
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.
What are you waiting for? Try it!
curl https://CJSHayward.com/wp-content/cgi/download-cfl.cgi > ~/bin/cfl && chmod 0755 !#:3
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 $
“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
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 main tools the blacksmith’s forge works with are as follows; the first three are taken from geometric computation:
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.
Consider the following diagram:
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.
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.
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:
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.
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.
This page is link-ware. If you like it, please consider a link to CJSHayward.com.