As it turns out Dumbledore is in reality Nicholas Flamel who creates Dark wizards like Grindlewald, Voldemort and Harry so he can defeat them. The story is available as PDF.

Building an adaptive dictionary

This first step is quite easy and is the basis for later operations. Parse all filename for words and make up a dictionary. The important part is that you keep track of the number of occurrences. The more often a word occurs the more probable it is, that the word is correct.The basic assumption is, that errors occur occasionally. For example sometimes I mistype ‘the’ as ‘teh’, but if I were to mistype it every time it could not be recognized.  In the end you will have a bunch of words that occurred only once, these might be misspelled or only be used once. There is no way to distinguish them, but these are the words you have to look at. Another group of misspelled words to look out for is the group with multiple occurrence which is very similar to another word with an even higher occurrence count. For example you mistyped ‘teh’ four times but did it correctly 10 times.

String similarity

Investigating methods to find similar strings I stumbled on Ralph Allan Rice string-similarity library. He uses the Dice and Jaro-Winkler algorithm to compute the similarity. I checked them out and only found Jaro-Winkler of any use. This algo has some deficits, most notable its focus on matching beginnings of words: Fed is not very similar to Ned

Eliminating related words

This aspect I did not investigate further. The basic gist is that want to bring similar word together that are related like ‘see’ and ‘sees’ or ‘get’ and ‘got’. This would best be done with JAWS and WordNet.

Some further theoretical thoughts

These are things that I did not fully implement, the the theory seems sound, however there are probably some problems with suitable abort criteria for efficient computation. First some definitions:

• Operation: An operation transforms string A into string B. Operations can be queued/concatenated (°). An operation is a simple action. Each operation has its complexity. Concatenated operations are not necessary commutative, meaning executing a°b on A does not result in the same string as b°a.

• Complexity: The operation with the complexity 0 is the Identity. The complexity is a floating point value. The complexity is measured against the length of the string.

• Minimal length: The only operation executable on a string of length 2 is a Transposition. Therefore the minimal length of a String is considered 2 characters.

• Similarity of order: String A and B are similar if there exists a sequence of Operation that transforms String A into String B and there combined (added up) complexity is below the specified order.

• Success: To measure if an operation leads to a more similar result, the similarity computed with one of the above algorythms must be greater.

• Upper-Lower-Case: Most languages do not distinguish upper and lower case words. To my knowledge the is only a link between upper-lower case in the grammatical sense but not the semantical. Therefore this can be ignored as a no-issue.

Many of the operations will use common sub sequences to limit their range (already common sequences must not be transformed). Identifying the common causes for errors helps defining operators:

• Transposition: swapping two characters in the string. The closer the characters the lesser the complexity.

• Replacement: change a single character with another.

• Misstyped: During spelling out the word the key besides the intended was hit. Different complexity for the direction of the two keys.

• MissingCharacter: character is missing. Higher complexity within the word (when typing rapidly, it may happen that the first letter of the second string is the last letter of the first, this would be a transposition of the space and the letter, spaces however were removed during parsing)

• Duplication: Duplication of an existing character

• Reducing: Reduce double characters

• Removal: Remove a character. Higher complexity within the word. Reverse of MissingCharacter.

The code is part of my utilities project, but not yet part of the latest released version (1.2.3)

Available as PDF or online.

• Pettigrew is caught during the summer, freeing Sirius
• Riddle is defeated more easily, though with a greater trauma to Ginny, who repeats her first year and is sorted into Ravenclaw
• Courch Jr. escapes prematurely and helps Voldemort embody himself a year earlier
• Voldemort is killed at the end of the Triwizard turnament

On the side line there are other changes. Harry and Hermione come together and include Luna. Pansy strikes Hermione with a poisoned dagger almost killing her. As the Brotherhood all have Horocruxes, Harry and Hermione join them.

There is a PDF available.

The first step in such things is always to search the net, where I found some few hints. Some brought me a step further. The first realisation I had was that though the software is OpenSource the way into a repository is not. But it is not that complicated. You have to decide on a repository where you want to deploy your release into. Most repositories are interconnected, meaning they synchronize new artefacts, so your stuff should be promoted through the whole Maven ecosystem within some days. For OpenSource software the obvious choice seems to be the OSS repository of Sonatype. Whatever repository you choose the first step is an administrative one: Create an account and state your intentions on adding a project.

The following links helped enormously in the process to get my artefact into the repository:

• Description of the Maven Release Cycle
• How To Generate PGP Signatures With Maven
• Sonatype OSS Repository User Guide

Normally the repository has some policies as to the minimal requirements of your pom file. I figure the ones of Sonatype to be reasonable. In the case of the sahitsUtils project this resulted in the following pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>ch.sahits</groupId>
	<artifactId>sahitsUtil</artifactId>
	<version>1.2.4-SNAPSHOT</version>
	<name>sahitsUtil</name>
	<description>Utilities used in different projects of Sahits GmbH</description>
	<parent>
		<groupId>org.sonatype.oss</groupId>
		<artifactId>oss-parent</artifactId>
		<version>7</version>
	</parent>
	<developers>
		<developer>
			<id>hotzst</id>
			<name>Andi Hotz</name>
			<organization>Sahits GmbH</organization>
		</developer>
	</developers>
	<licenses>
		<license>
			<name>GNU Library General Public License (GPL), Version 2.0</name>
			<url>http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt</url>
			<distribution>repo</distribution>
		</license>
		<license>
			<name>Lesser General Public License (LGPL)), Version 2.0</name>
			<url>http://www.gnu.org/licenses/old-licenses/lgpl-2.0.txt</url>
			<distribution>repo</distribution>
		</license>
	</licenses>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.5</source>
					<target>1.5</target>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-javadoc-plugin</artifactId>
				<configuration>
					<show>private</show>
					<nohelp>true</nohelp>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-release-plugin</artifactId>
				<configuration>
					<tagBase>https://sahitsutil.svn.sourceforge.net/svnroot/sahitsutil/tags</tagBase>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-gpg-plugin</artifactId>
				<executions>
					<execution>
						<id>sign-artifacts</id>
						<phase>verify</phase>
						<goals>
							<goal>sign</goal>
						</goals>
					</execution>
				</executions>
			</plugin>

		</plugins>
	</build>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.8.1</version>
		</dependency>
	</dependencies>
	<organization>
		<name>Sahits GmbH</name>
	</organization>
	<scm>
		<url>https://sahitsutil.svn.sourceforge.net/svnroot/sahitsutil/trunk</url>
		<connection>scm:svn:https://sahitsutil.svn.sourceforge.net/svnroot/sahitsutil/trunk</connection>
		<developerConnection>scm:svn:https://sahitsutil.svn.sourceforge.net/svnroot/sahitsutil/trunk</developerConnection>
	</scm>
	<distributionManagement>
		<repository>
			<id>sonatype-nexus-staging</id>
			<url>https://oss.sonatype.org/service/local/staging/deploy/maven2</url>
		</repository>
		<snapshotRepository>
			<id>sonatype-nexus-snapshots</id>
			<url>https://oss.sonatype.org/content/repositories/snapshots</url>
		</snapshotRepository>
	</distributionManagement>
</project>

For details on the working of the maven-gpg-plugin see How To Generate PGP Signatures With Maven.

The standard procedure for releasing an artefact would be:

mvn release:clean release:prepare release:perform

The prepare goal checks your project and prepares it for releasing:

• Check that all the local resources are committed
• Check that all dependencies have a defined version (no SNAPSHOTs allowed)
• If your version is a SNAPSHOT version, remove the SNAPSHOT part
• Execute the tests against the changed pom.
• Commit the modified POM
• Create a tag using the configuration specified in scm (Note that tagBase was supplied in the configuration of maven-release-plugin)
• Increase the version
• Commit the modified POM

If you do not run mvn release:prepare with the batch option -B, you are asked for:

• release version
• SCM release tag or label
• new development version

The proposed values most often are good defaults, so you can run this in batch mode. However if you have specified a passphrase for your private key, you cannot use batch mode, unless you specify it with -Dgpg.passphrase=thephrase. The prepare step produces the artefacts for the pom, binary, source and javadoc along with the signature files.

Since this project was converted, the checkout in mvn release:perform produces a non-default layout so this step fails. I therefore found it easier to bundle the artefacts in a jar and upload them manually to the repository. This worked perfectly as described.