The paperCrane’s view from the reverseFold

Update 4: Huzzah! My username is back! Or at least the URL works properly again. Internal Facebook links still use the profile id URL. I suspect it has to do with my account settings still showing that I have not selected a username. Still, it’s nice to have this finally resolved. Thanks to Paper Crane for releasing my username.

Update 3: The username “papercrane” was released by “Paper Crane” more than a day ago but is not available for me to choose. Hopefully Facebook will get this resolved soon.

My Facebook username and URL were stolen by a new company in Texas. While using Facebook for my job at Idle Games, a company that makes games for Facebook, I was forced to logout of Facebook and upon logging back in was shown a page saying that my username had been removed because it had no relevance to my profile. There was no direct messaging or e-mail, only this one ephemeral page. I’ve had the username “papercerane” on Facebook since the username feature was introduced 3+ years ago, have used it online for 10+ years, and my e-mail and profile picture on Facebook and other sites both feature papercrane prominently.

My profile is now only at http://www.facebook.com/profile.php?id=658423354. I used to have the URL http://www.facebook.com/papercrane but now it redirects to http://www.facebook.com/PaperCrane, which is a Facebook profile for a stationery company in Texas. This account was created on Tuesday, Oct. 30, 2012, which is now 3 days ago. According to their page, the business opened in August 2012, which makes my use of the name precede theirs by many years.

I posted on this company’s Facebook wall about the issue but they removed the post from their wall before responding with a comment to the effect that they had requested the username from Facebook and that Facebook had granted them the username because they were a company. Until today the conversation was still available at http://www.facebook.com/PaperCrane/posts/452337791472324?notif_t=feed_comment but now that page says “The page you requested was not found” which I take to mean that the post has been deleted entirely or hidden from public view. I subsequently then them a direct message but today when I checked I had not received a response and had been blocked from posting on their wall, commenting on their posts, and sending them messages.

This is an abuse of Facebook’s policies and means that anyone could have their username taken if a company claims the name as their own. You may ask yourself why this matters so much; It’s just a name, after all. Consider that a Facebook username is what creates an easy-to-remeber URL to your profile. This URL may have been used to link to your profile on any number of webpages, not only those controlled by you, but those controlled by any number of third parties. Now those links are, in essence, broken, as they no longer point to the same content that they were intended to point to. This leads to confusion and possible disassociation or even reduction of your credibility as a URL that was previously in your control is now in the control of another person. This is a de facto violation of the W3C’s standards regarding changing URIs. Originally that standard was meant to avoid “linkrot“, a situation that frequently occurs when a website changes the format of its URLs, moving content to new places and causing previously working URLs to now display an error. Changing the content that a URL links to leads to a more insidious version of the same issue. Now a person following the URL is misled into thinking that the content now served at that URL is the intended content when it is, in fact, unrelated. I am again, here, respectfully requesting that the business “Paper Crane” relinquish the Facebook username papercrane, which was in use by me long before their business was formed.

Update 1: Since they blocked my personal account from messaging them I used another account to send them a followup message asking for more explanation.

12:37pm
Me

It looks like you’ve blocked my personal account from messaging you without even responding to me. Be an adult and let’s talk about this. Did you request that facebook take the username, papercrane, away from me?

2:11pm
Paper Crane

Justin, as we have already disclosed to you when setting up our Facebook page we saw that the username was already taken. With that being the case all we did was send a request to Facebook asking if we could be granted the username which reflects our company and which is stated in the guidelines for Facebook. Facebook was the decision maker in giving us the username. With that being said if you have an issue with this you should be contacting Facebook, not harassing us. We in no way shape or form STOLE your username. Simply we put in a request for the name and Facebook was the one to make the change.

We are sorry for the inconvenience but this is our legal company name, and we ask that you please stop posting on our page. Again, if you have an issue with this please contact Facebook.

2:39pm
Me

You can’t simply abdicate responsibility for this. You knew that the name was being used by me and, instead of contacting me and asking you just assumed it was ok to take the name away from me. That’s just not ok, regardless of Facebook’s terms and conditions. Unfortunately, I can find no formal way for me to appeal this decision to facebook. I have sent messages via the channels I could find but have not received a response.

Since you are now the “owner” (for lack of a better word) of this facebook username I’m asking you to be a good citizen and tell facebook you wish to give the name back to me. You could easily use a name like “Paper.Crane”, “PaperCranePlano”, “PaperCraneTexas”, or “PaperCraneAtWillowBend” instead of taking what I have been using for more than 3 years now on facebook.

Update 2: Now that the issue is public they’re “willing to work with me”. They think I have the power to unring the bell, but nobody has that power.

2:11pm
Paper Crane

Justin, we do not appreciate that you have publicly displayed this issue. This is a matter between you and our company which we are willing to work with you on. If you would like to receive your name back we ask that you please remove any and all comments or post about this. Your friends have crossed a line with the comments that have been posted on our page. Please let us know how you would like to proceed.

2:39pm
Me

I tried to work with you when I first noticed that this had happened. Instead of taking responsibility you just deleted posts, disabled my ability to communicate with you, and claimed that you weren’t responsible for your own actions. This is when I started “publicly displaying this issue”.

Additionally, I have no control over the actions of other people or what content appears on Facebook under their names. I’m as surprised as you are by the size and speed of the response but it appears that it is this response which has brought you to the point where you are willing to start working with me.

Your credibility and reputation are in your own hands, not mine. So far people have assumed the worst because you haven’t given any indication to the contrary. Do the right thing and you’ll restore your own reputation.

[Disclaimer]
This is a personal posting and does not reflect the views of my employer in any way. I merely mention Idle Games as I work for them and use Facebook every day in my work, making applications which make Facebook money.
[/Disclaimer]

I just stumbled upon a fun little snippet for shell scripting and thought I’d share. You can comment out a block of shell commands in a shell script with an anonymous heredoc.

#!/bin/bash
echo "hello" | grep -q "world" || exit $?
for f in $(ls /tmp); do
    echo $f
done
echo "ok"

To comment out multiple lines, use an anonymous heredoc:

#!/bin/bash
: <<'EOF'
echo "hello" | grep -q "world" || exit $?
for f in $(ls /tmp); do
    echo $f
done
EOF
echo "ok"

Sean Cooper recently ran a challenge at Lolapps to create the fastest version of Conway’s game of life in Flash that we could. Of course, he first showed us his version which uses a convolution filter, but that’s not what this challenge was about. The idea was to figure out how to make AS3 both perform and display as fast as possible. Of course I immediately found someone else’s Pixel Bender version but after playing with that I went my own route to see what I could do in pure AS3.

For the impatient, you can view an animation which helps to explain the concept or jump straight to the result.

Pretty quickly, the discussion I was a part of moved towards the possibility of caching. After getting the initial naive version of Life finished, I let the caching idea bounce around in my head and finally came up with an idea. Since (basic) life has only two states per pixel, alive or dead, these map trivially to bits. Taking an arbitrary rectangle of the map and reducing it to a simple integer then is easy. Additionally, operations on this section can be done via bitshifting and bitwise operations, which tend to be extremely fast. Unfortunately, the uint in AS3 is only 32 bits long, so this limits the size of the “chunk” we can put into a single uint, but then again 2^32 would be a lot of states to possibly store and/or calculate. I also found that if I try to make a Vector.<uint> 2^30 long, Flash hangs, then crashes.

Let’s assume for now that we’re going to deal with Life in 3×3 cell chunks. I’ll explain why later on. We’ll start with a 9×9 set of cells:

A 9x9 section of cells

Then break that up into 3×3 chunks of cells.

3x3 chunks

Let’s look at the center chunk:

The center chunk

The simple life rules make each cell depend on its immediate neighbors in every direction.

• If a cell has less than 2 live neighbors it dies (or stays dead) due to loneliness.
• If a cell has 2 live neighbors it stays as it is, dead or alive.
• If a cell has 3 live neighbors it is alive in the next iteration (dead cells come alive, live cells stay alive).
• If a cell has 4 or more live neighbors it dies of overcrowding.

To run these rules for a single cell we need the ring of cells around it to calculate its next state. In the same way, to calculate the next state of a 3×3 set of cells we need the ring around it, making the chunk we need to look at a 5×5 chunk of cells.

5x5

This is what ultimately limits the size of the chunks we can easily cache. 5×5 cells mean we need 25 bits to make them into a uint. 5×6 would make 30 bits and a simple array that big crashes Flash.

Now that we’ve established the basics of what we need it’s just a matter of figuring out how to efficiently calculate, store, and retrieve the values.

We’ll store the state transitions in a simple vector of uints. The index will be the current state and the value is the next state. For the current state we take the 5×5 chunk, turn the pixels into bits, then put them together to make a uint.

5x5 as bits, the top-left is the least significant bit (2^0)

= 9870129

Now we have the center chunk’s current 5×5 state as a uint. 9870129 will be the index into the state transition map. Now we need the state that this will become after the rules are applied.

The next state

Note that the ring around the 3×3 chunk is all empty. Since what we’re calculating for is the 3×3, that’s all we care about. We needed the 5×5 to be able to say what the 3×3 became and in the result we store the uint with only the 3×3 chunk filled out.

Result bits

= 4194688

Once this is done for all of the 3×3 chunks, you run it all over again. In order to get the 5×5 you can mask out the bits needed in the neighbors, bitshift them, and bitwise-or them together to get the 5×5 uint to index back into the state transition map. To speed things up even more you can store those masked and bitshifted parts separately so all you need to do is bitwise-or them together to find out what the next state is.

If you made it this far, thanks for reading. Here again is a link to the explanatory demo, which is where the screenshots above came from.

And, finally, the result. The fastest Life implementation I’ve made thus far. :-) You can press ‘r’ to switch to another pattern (try resizing to 1440×599) and then again to get a random start state. ‘p’ pauses the animation. Enjoy!

Click to view the completed application

Update: I’ve posted my code for this on Github.

If you ever have the need to use non-standard logging levels with Python’s logging module, seeing the level names output as ‘Level #’ can be frustrating. Luckily there’s a simple fix. Just add 2 lines of code to “monkeypatch” your own level names into the logging module:

import logging
 
logging._levelNames[42] = 'MYLEVEL'
logging._levelNames['MYLEVEL'] = 42

After creating my first Enum class for AS3 I found out that Flash was behaving unexpectedly when running the static initializations. Unfortunately, the order of the static declarations isn’t always the order in which Flash runs them. In a simple example with just a few classes I found that the initialization order was the same as the order of the declarations in the file, hence causing the generated ordinal values to be in the defined order, just like in Java. However, in a more complicated application the order became somewhat random, causing the ordinal values to not match what they might be in Java. In the case where you don’t care what the ordinal values are, (i.e. you use the names for storage or network communication or are only using the static vars directly in code) you don’t need to worry about this. However, if you want to use the ordinal values then you’ll have to go back to specifying the ordinal values manually. However, this Enum class still gets you a lot more than just static ints. The type safety alone is worth it in my opinion. Without further ado, the updated class:

package com.reversefold.util {
	import flash.errors.IllegalOperationError;
	import flash.utils.Dictionary;
	import flash.utils.describeType;
	import flash.utils.getQualifiedClassName;
 
	/**
	 * An abstract class to emulate Enum type.
	 * 
	 * Subclasses should follow this pattern:
	 * 
	 * package com.example {
	 * 	public class TestEnum extends Enum {
	 * 		public static const ONE : TestEnum = new TestEnum(1);
	 * 		public static const TWO : TestEnum = new TestEnum(2);
	 * 		public static const THREE : TestEnum = new TestEnum(3);
	 * 		
	 * 		public static function get values() : Vector.<testenum> {
	 * 			return Vector.</testenum><testenum>(Enum.getValues(TestEnum));
	 * 		}
	 * 		
	 * 		{
	 * 			initEnumConstant(TestEnum);
	 * 		}
	 * 	}
	 * }
	 */
	public class Enum {
		protected static var sequence : Dictionary = new Dictionary();
 
		/**
		 * To protect from instantiation after static initializing.
		 */
		private static var values : Dictionary = new Dictionary();//.<vector .<Enum>>
 
		private static var valuesByName : Dictionary = new Dictionary();//.<object>
 
		/**
		 * Function to call for each enum type declared and in static init.
		 */
		protected static function initEnumConstant(inType : Class) : void {
			var className : String = getQualifiedClassName(inType);
			var typeXML : XML = describeType(inType);
			var newValues : Vector.<enum> = new Vector.</enum><enum>();
			var newValuesByName : Object = {};
			for each (var constantXML : XML in typeXML.constant) {
				var name : String = constantXML.@name;
				var constant : Enum = inType[name];
				constant._label = name;
				newValues.push(constant);
				newValuesByName[name.toUpperCase()] = constant;
			}
			//sort by ordinal
			values[className] = newValues.sort(
				function(lhs : Enum, rhs : Enum) : Number {
					return lhs._ordinal > rhs._ordinal ? 1 : (lhs._ordinal < rhs._ordinal ? -1 : 0);
				}
			);
			valuesByName[className] = newValuesByName;
		}
 
		protected static function getValues(inType : Class) : Vector.<Enum> {
			return Vector.</enum><enum>(values[getQualifiedClassName(inType)]);
		}
 
		protected static function getByName(inType : Class, inName : String) : Enum {
			return Enum(valuesByName[getQualifiedClassName(inType)][inName.toUpperCase()]);
		}
 
		protected static function getByOrdinal(inType : Class, inOrdinal : int) : Enum {
			var values : Vector.</enum><enum> = getValues(inType);
			if (inOrdinal >= values.length) {
				throw new Error("There is no enum value for ordinal " + inOrdinal + " in class " + getQualifiedClassName(inType));
			}
			return values[inOrdinal];
		}
 
		/**
		 * Enum label.
		 */
		private var _label : String;
		public function get label() : String {
			return _label;
		}
 
		private var _ordinal : uint;
		public function get ordinal() : uint {
			return _ordinal;
		}
 
		public function Enum(inOrdinal : int = -1) {
			var className : String = getQualifiedClassName(this);
			if (values[className]) {
				throw new IllegalOperationError("Cannot instantiate anymore: " + className);
			}
			if (inOrdinal == -1) {
				var seq : uint;
				if (!sequence[className]) {
					seq = 0;
				} else {
					seq = sequence[className] + 1;
				}
				_ordinal = seq;
				sequence[className] = seq;
			} else {
				_ordinal = inOrdinal;
			}
		}
 
		public function toString() : String {
			return ordinal + " " + label;
		} 
	}
}
</enum></object></vector></testenum>

UPDATE: There is a new version of the Enum class in the next post.

Enumerations are one of the major language features that I miss in AS3, especially when writing client-side versions of Java code which use Java’s robust enumerations. This has been discussed elsewhere quite a bit so I’ll just do a quick recap and then give my new updated version.

The simplest version of an enumeration you can do in AS3, of course (and the one most people use) are static const String values that are set in a class which is meant not to be instantiated.

package com.example {
	public class SimpleEnum {
		public static const ONE : String = "One";
		public static const TWO : String = "Two";
		public static const THREE : String = "Three";
	}
}

This works for the simplest cases but doesn’t come near to having the features of Java’s enumerations. One alternate version uses int values to make the conversion from Java to AS3 easier (Java uses int values to identify each enumeration value which is called an ordinal).

package com.example {
	public class SimpleEnum {
		public static const ONE : uint = 1;
		public static const TWO : uint = 2;
		public static const THREE : uint = 3;
	}
}

The main problem with both of the above is that any time you use one of your SimpleEnum values, you are using a simple type (String or uint) which allows any random value to be passed in, not just those that you have defined.

The next step is to use instances of the Enum class for each one of the constants. This makes your enumerations typesafe and allows you to have your enum values be real objects with member functions and variables.

package com.example {
	public class SimpleEnum {
		public static const ONE : SimpleEnum = new SimpleEnum("One");
		public static const TWO : SimpleEnum = new SimpleEnum("One");
		public static const THREE : SimpleEnum = new SimpleEnum("One");
 
		private var _name : String;
		public function get name() : String {
			return _name;
		}
 
		public SimpleEnum(inName : String) {
			_name = inName;
		}
	}
}

This is great as it enforces that any time you want to use a value from SimpleEnum you can ensure that it’s the right type, but this has a different form of the same issue above. Other code can happily create new versions of SimpleEnum and use them wherever.

It is at this point that some of the more esoteric bits of AS3 coding can be helpful. Private constructors would fix this problem right away but AS3 also lacks this language feature. For Singletons, most developers use a private class which is appended to the same file, after the package block ends. Unfortunately, this doesn’t work as the “private” class is not yet loaded when the static const variables are being created. Luckily, static initializers fix this problem.

package com.example {
	public class SimpleEnum {
		public static const ONE : SimpleEnum = new SimpleEnum("One");
		public static const TWO : SimpleEnum = new SimpleEnum("One");
		public static const THREE : SimpleEnum = new SimpleEnum("One");
 
		private var _name : String;
		public function get name() : String {
			return _name;
		}
 
		private static var _created : Boolean = false;
 
		//This code is run statically after the const vars above are created, closing off the constructor
		{
			_created = true;
		}
 
		public SimpleEnum(inName : String) {
			if (_created) {
				throw new Error("SimpleEnum is an enumeration, use the class constants instead.");
			}
			_name = inName;
		}
	}
}

I can see only two downsides to this pattern. Any function parameter or variable which is of the SimpleEnum type could be set to null. This is a common issue with Object Oriented programming, though, and can happen with Java’s enum type as well, so this is minimal. The larger possible issue is that the error for trying to use new SimpleEnum() happens at run-time and not compile-time. This could bite users who mistakenly try to instantiate the SimpleEnum class in their code and could potentially not be found right away, since a specific set of run-time conditions may have to be satisfied to call the offending code. However, with a helpful enough error message and documentation I think that this is a small issue.

This is essentially the pattern that I have adopted but I’ve added a few more features. Specifically, I’ve implemented an ordinal value which can be used for interaction with Java enum values or for advanced serialization or hashing and have added a function to get all of the possible values for use in iteration (or enumeration of the values….;-) ). The creation checking is also done in the base class so that a minimum of extra work needs to be done in the concrete enum classes.

package com.reversefold.util {
	import flash.errors.IllegalOperationError;
	import flash.utils.Dictionary;
	import flash.utils.describeType;
	import flash.utils.getQualifiedClassName;
 
	/**
	 * An abstract class to emulate Enum type.
	 * 
	 * Subclasses should follow this pattern:
	 * 
	 * package com.example {
	 * 	public class TestEnum extends Enum {
	 * 		public static const ONE : TestEnum = new TestEnum();
	 * 		public static const TWO : TestEnum = new TestEnum();
	 * 		public static const THREE : TestEnum = new TestEnum();
	 * 		
	 * 		public static function get values() : Vector.<testenum> {
	 * 			return Vector.</testenum><testenum>(Enum.getValues(TestEnum));
	 * 		}
	 * 		
	 * 		{
	 * 			initEnumConstant(TestEnum);
	 * 		}
	 * 	}
	 * }
	 */
	public class Enum {
		protected static var sequence : Dictionary = new Dictionary();
 
		/**
		 * To protect from instantiation after static initializing.
		 */
		protected static var values : Dictionary = new Dictionary();//.<vector .<Enum>>
 
		/**
		 * Function to call for each enum type declared and in static init.
		 */
		protected static function initEnumConstant(inType : Class) : void {
			var className : String = getQualifiedClassName(inType);
			var typeXML : XML = describeType(inType);
			var newValues : Vector.<enum> = new Vector.</enum><enum>();
			for each (var constantXML : XML in typeXML.constant) {
				var name : String = constantXML.@name;
				var constant : Enum = inType[name];
				constant._label = name;
				newValues.push(constant);
			}
			//sort by ordinal (instantiation order)
			values[className] = newValues.sort(
				function(lhs : Enum, rhs : Enum) : Number {
					return lhs._ordinal > rhs._ordinal ? 1 : (lhs._ordinal < rhs._ordinal ? -1 : 0);
				}
			);
		}
 
		protected static function getValues(inType : Class) : Vector.<Enum> {
			return Vector.</enum><enum>(values[getQualifiedClassName(inType)]);
		}
 
		/**
		 * Enum label.
		 */
		private var _label : String;
		public function get label() : String {
			return _label;
		}
 
		private var _ordinal : uint;
		public function get ordinal() : uint {
			return _ordinal;
		}
 
		public function Enum() {
			var className : String = getQualifiedClassName(this);
			if (values[className]) {
				throw new IllegalOperationError("Cannot instantiate anymore: " + className);
			}
			var seq : uint;
			if (sequence[className] == null) {
				seq = 0;
			} else {
				seq = sequence[className] + 1;
			}
			_ordinal = seq;
			sequence[className] = seq;
		}
 
		public function toString() : String {
			return ordinal + " " + label;
		} 
	}
}
</enum></vector></testenum>

And here is an example use:

package com.reversefold.shop.model {
	public class TestEnum extends Enum {
		public static const ONE : TestEnum = new TestEnum("One");
		public static const TWO : TestEnum = new TestEnum("Two");
		public static const THREE : TestEnum = new TestEnum("Three");
 
		//This function gives typesafe access to the list of constants that Enum.getValue() gives
		public static function get values() : Vector.<testenum> {
			return Vector.</testenum><testenum>(Enum.getValues(TestEnum));
		}
 
		//static initializer, make sure to pass in the current class as a parameter
		{
			initEnumConstant(TestEnum);
		}
 
		//read-only getter of the name value
		private var _name : String;
		public function get name() : String {
			return _name;
		}
 
		public function TestEnum(inName : String) : void {
			super();
			_name = inName;
		}
 
		override public function toString() : String {
			return super.toString() + " " + _name;
		}
	}
}
</testenum>

Thanks to all of the linked blog postings for their ideas. I only found Scott Bilas’ post after I’d finished writing my own extension of Peter Moelgaard’s version. Scott’s does nearly the same things mine does, but in a more C#-like way.

I’ve continued adding bits to my fractal letters over the past few weeks and have finally finished everything to print out my full e-mail address. The @ symbol was particularly interesting and I think it turned out pretty nice.

Fractal Email - first iteration

Fractal Email - third iteration

Fractal Email - fifth iteration

The pictures link to the updated app. Enjoy, and as usual, don’t slide the slider up to the max unless you’re willing to wait while your entire browser hangs for several minutes.

I’ve updated my ASCIIMathML plugin so that it doesn’t have quite so many security holes and abuse vectors. I’ve put it up for download at http://www.reversefold.com/blog/asciimathml_0.2.tgz. Please note that this requires command-line access to run, requires python and inkscape to be installed, and has been tested only on linux. There may also be security problems and bugs. I take no responsibility for anything that may happen if you should use this. The code is released under the LGPL for now.

With the disclaimers out of the way, I hope this is useful to you. Let me know if you have any issues with it or any suggestions for improvements.

This is an update of a previous post.

On the way home last Thursday I decided to try creating fractal letters. The idea was to replace each “line” in a simple version of a letter with a copy of itself but allow for the aspect ratio of its dimensions to change so that the result is still recognizable as a letter. This is something like an L-system, of which the Dragon curve is one. After a weekend’s worth of work I have what amounts to thirteen different fractal letter algorithms for six different letters. 1 P, 3 A, 2 E, 2 R, 2 C, 3 N. Yes, those spell PAPERCRANE. Here is the first iteration (just the letters).

Fractal Letters, iteration 1

And here is the fifth iteration:

Fractal Letters, iteration 5

Some letters have variations in how they are drawn or how they repeat, or both (hence the 2 lines). The bottom N uses an algorithm I worked out which didn’t change the aspect ratio and had only one repetition per line. Both of the N variants in the words use two repetitions per line and constrict the width faster than the height, which leaves the N recognizable. The idea here, after all, was to make letters which had a cool fractal look but could still be read.

Click either of the pictures to view the flex app and play with the iterations yourself. Just drag (or click on) the slider on the bottom of the app to change the iteration.

Stay tuned, I have another blog post coming up soon specifically about that N on the bottom, the math required to create the algorithm, and some interesting (and beautiful) results I got when implementing a test program.

Over the Christmas break I went to Chinatown in San Francisco and got some new origami paper which is smaller than any of my other paper. I quickly decided to make one of my signature reversefolds with the new paper. I started creasing the paper and got to the sane point, which would have given me 4 rows of reversefolds. This would have been small, but not small enough for me. I like my folds to be more complicated.

Finished creases, back side

Finished creases, front side

Yes, that paper is less than 2 quarters wide. Of course, going one more level took a lot of careful and precise folding which took the rest of the night. The next day I started the accordion folds which are the base of the final product.

Accordion halfway done

Accordion finished

That took several hours. The last step is to pop in the reverse folds, one row at a time. This is the most time consuming part of the process and for this fold it took me several nights with a small crafting tool. Here it is with five rows finished.

Five rows finished

And after many painstaking hours of work, here is the finished product:

Finished fold

Finished fold, side view

Finished fold, 3/4 view

And for a little perspective here is a shot of the finished fold compared to the original paper:

Finished fold vs. unfolded paper

And just in case the quarter wasn’t enough, here’s the finished fold in my palm. Yes, it is that small. No, I won’t make you one. ;-)

Finished fold in the palm of my hand

All of these photos link to my newly created flickr account. The entire set is up there along with higher quality versions.