Cerrisian Blog

This is like the best user of Twitter, ever. An autogenerated poem based on tweets.

So, I absolutely love the pocketmod versions of microlite20 rules. But, I don’t like how the margins end up when you print them out and fold them, and I’d like to be able to make my own pocket mods without using their software.

I found this example of using postscript tools to make a pocket mod from a full size document. This is great if you’re converting something existing, but I used Lyx/LaTeX to create a pocket book of rules on tiny pages (one eighth the size of letter).

So, here’s my example of how to make a pocket mod:

pdf2ps microlite20.pdf microlite20.ps
pstops -w8.5in -h11in 8:0L(1w,0.75h)+1R(0,1h)+2R(0,0.75h)+3R(0,0.5h)+4R(0,0.25h)+5L(1w,0)+6L(1w,0.25h)+7L(1w,0.5h) microlite20.ps microlite20_pocket.ps
ps2pdf microlite20_pocket.ps

This will work for any document that’s already properly scaled. However there are some issues with margins.

• Page 1 left margin too small
• Page 2 right margin too small
• Page 3 right margin too small
• Page 4 good margins
• Page 5 slightly too small on right (alright though)
• Page 6 slightly too small on left (alright though)
• Page 7 good margins
• Page 8 good margins

These are probably artifacts of how I folded it. But I probably should just make the left/right margins 3 ems instead of only 2.

After play testing microlite20 last night and looking through some of the house rules I thought of a really cool idea. A web page that keeps track of house rules numbered akin to Nomic.

The basic idea would be to start with the core microlite 20 rules and amend/append rules that get proven after X number of rounds of playtesting and Y votes. It would also keep a record of all the rules and only allow amendments Nomic style. That way people can create there own custom rulesets using previously created rules.

I guess a slightly more workable way would be a “rule database” for microlite20 that just has the rules as worded and a few examples of each rules use.

I just finished working with some incoming freshmen to university. All of them are going into either engineering or science and a lot of them complained about not liking math. The absolutely floors me, to have any chance at engineering you have to like math.

I don’t know what causes this, but they have this hatred of math combined with a need for heuristics and “tricks” to do even simple factoring. These heuristics replace their intuitive understanding of algebra and use of the “standard” rules of algebra to solve problems. I can definitely see where this use of heuristics and “tricks” prevents them from properly understanding axiomatic math.

It just floors me. They’d be better off just doing speed drills of basic operations of math then learning all these tricks.

So, I’ve basically finished my refactor/resuscitation of PyGP (except for the part where I actually package it and release it). So it’s time to select my next victim.

Since I mostly do Java at work, I thought I’d select a Java project. I’ve found such a project in YAJII, a java implementation for an IRC client. It doesn’t appear to have any unit tests (or a build system) but it does have some documentation. The author’s current webpage is here.

My real goal would be to use this as a project for a coding Kata, potentially to be presented at the OSUG, depending on the interest I get, I could then spin off a sub-group or another meetup for code Katas in general.

Before I’m able to do a Kata I’ll have to do the following:

1. Get it to build with ant or some other build tool (ant + ivy, maven, buildr, scons…)
2. Run the “testbed” application through it’s paces.
   • This would follow the context driven testing methodology, maybe a 1/2 hour session to find a big problem to fix. “Go through all the menus to get a feel, read the user manual create a test outline.”
3. After the problem the big problems from the testing perspective have been found, I’ll use the saff squeeze to isolate it with a unit test. This will be an iterative process of getting the program into a test framework, starting with a “smoke test” covering much of the stack and iterating towards the point that the saff squeeze will lead me to. These will use various techniques from Working Effectively With Legacy Code to get the code unter test.
4. Finally, use techniques from WEWLC to fix the problem/add the feature found in exploratory testing.

Since this is a Kata, it will mostly focus on getting good technique. It’s okay to go down false allies to figure out what’s happening. The techniques that will be covered are:

1. Dealing with build systems, especially of code that isn’t under one yet.
2. Exploratory testing (Context-driven school). A very different skill that most developers don’t have.
3. Getting code under automated tests.
4. Converting a exploratory test into a fully automated test. Both acceptance level and unit level.
   1. This includes dependency breaking, the saff squeeze and test doubles.
5. Fixing code based on automated tests.
6. Verifying a code fix manually after automated tests.

I think this would hit a lot of the skills needed for software maintenance. This seems to be large enough to break into multiple Katas.

My concern is that it may be too big to do as an introductory Kata, maybe something else would be better? Bowling scores, or maybe one of the problems from S.Lott’s blog?

A lot of small businesses basically just need a “brochure” website, multiple pages consisting of contact information, advertising copy, testimonials, schedules, maps, etc. Currently I don’t know of any specific django app to easily do this (that meets the following requirements)

• Easy for endusers to update and edit (CMS with WYSIWYG editor, preferably usable with MS Word)
• Easy for endusers or developer to change templates (dbTemplates, good presets such as YUI or blueprint)?
• Easy to deploy on cheap shared hosting (Django already meets this requirement with flup and its FastCGI interface).

A simple brochure site using Django could probably be created using the following:

• Django Page CMS for the CMS part
• A Django Admin Widget like this one for editing pages
• And finally dbTemplates to allow for client-editable templates

This was from August 2008, just found it now…

It’s amazing how just being exposed to people arguing can tire you out. Maybe it has something to do with the topics being important being argued about. In any case, all my reserves of energy were totally shot today.

I just did my mnemosyne cards, an extremely small amount on OS, uploaded my latest drawing, drew a bit (that was really relaxing.) Looked up how to mock datetime in python, did some research on the newforms admin in Django, and…that’s it, I guess. Huh, I did a lot for someone who’s nerves were totally fried.

When I draw on the picture plane now I’m developing some spatial memory. This really helps with dealing with the slight changes in position of my viewpoint as I draw. It’s interesting, just be repeating the exercise over and over, I’m able to gain just new skills and understanding. It’s really interesting how we are able to learn new things, repetition is reinforcement and discovery, or at least that’s how I perceive it.

I notice the same thing with my mnemosyne cards, when I forget something, I think about how it fits in with my other knowledge, which is usually a discovery process, at the same time, the repetition of learned cards reinforces the memories. The same type of thing happens with drawing, but each “atom” of knowledge can’t be separated like it can be in mnemosyne.

Which reminds me, I still need to add the diagrams to class to mnemosyne for Physics and Operating Systems…

I’ve been talking with my friends about making a RPG website and hosting a Transformers RPG. This brings up what type of gaming system we should use: D20, GURPS, JAGS, etc.

Now, the problem for me is that there isn’t really a lot of Transformers source material that I see kicking around, and a lot of the pre-existing systems are somewhat complicated, and I don’t like spending a lot of time on mechanics. It would also be nice if the system could easily be used on a simple website, where people post actions and discuss.

Then it hit me. Nomic! Nomic is a game of self-amendment and rule changes that serves as an analog to a real legal system. If we have a system of self-amendment to the game rules, in the game itself, it can evolve based on the skills of the players as they play. There are a couple variants that I like, Minic and Pure Nomic are a good start, as is this Nomic RPG ruleset. I also like the feature of Nomopoly where the “Administrator” has veto power over anything that is paradoxical, hard to implement or unfair.

A lot of the ruleset can be implicit in the RPG, because I’m assuming a somewhat cooperative audience. Modifying the RPG rule set to use D20 dice, I come up with something like this as the initial rule set:

1. To make a proposal to change the ruleset, shout “Proposal!” and state your proposal.
2. Unless otherwise stated, a proposal adds a new rule to the end of the rule set.
3. Each player has one vote on any given proposal, which may be AYE, NAY or ABSTAIN. Robert’s rules of order style voice votes will be used unless a contention occurs.
4. Proposals that have a unanimity of AYE votes at any time become part of this rule set.
5. Players may change their votes at any time before a proposal is passed or failed.
6. Each player’s character has six attributes: Strength, Dexterity, Constitution, Intelligence, Wisdom and Charisma.
7. Each time a character does a task that may succeed or fail, they must roll a D20 and add modifiers for the ability used. If the character beats a value determined by the game master, they succeed.

There are probably some big problems with this rule set, but they should be shaken out after some peer review and a few rounds of voting.

I was inspired on my hike through the forest. An ideal ontology based intelligent tutoring system would follow this procedure:

1. Corpus selection
   • A corpus is selected either by hand or through some sort of text search/index. This corpus represents the domain to be learned from the ITS.
2. Ontology Extraction
   • A reliable ontology is extracted from the corpus. Information in this ontology should not be inaccurate, although it is acceptable for it to be shallow, or not complete. Ideally this would be fully automated with the ability to use a semi-automated or other interface to fill in pieces missed.
3. Lesson generation
   • A more or less ’standard’ ITS system that generates questions, lessons, etc. based on the ontology. Would be nice if we could generate a sequence such that the domain can be learned with little effort. May be acceptable to rely on student exploration. The lessons must maximize comprehension and internalization of concepts, not just memory recall.
4. Card generation
   • Generate review cards for memorization based on ontology. These may be abstract or concrete, but would only be available after the student had learned the domain knowledge through the lesson. The assumption being that the lesson gives the student context for the knowledge to allow for easy memorization and understanding.

The cards and lessons may not be differentiated in the user interface, but they should be called out since the required outcomes are different.

This doesn’t really cover procedural skills, although it would be interesting to see if it could be associated with learning types of problem solving.

Yay! I’ve once more bitten off more than I can chew.