“The most incompetently advertised open source software product since… that one product!”

—A Developer

“Hey, it works. Kind of.”

—A User (of creative punctuation, on rehabilitation from a marriage-destroying apostrophe dropping habit)

Behind closed doors, everyone is doing it…
Secret vice.
Secret intellectual pleasure.
And now:
Secret suffering of bugs, shared by all in secret.

Crucial details

Conman’s Dictionary is the perfect dictionary application for improving and working with your constructed languages. It offers an easy workflow for both inventing new words, and looking up words when translating text.

Conman’s Dictionary is written in Java, and has been tested in Debian GNU/Linux and Windows 7, the former using OpenJDK and latter using Sun Oracle (with defiant tone) Sun Java. Earlier versions ran with Apple’s JRE on OS X, but I only have a PPC Mac at hand so I haven’t checked up on how it works on recent OS X versions. Also, OpenJDK compatibility has not been ensured yet.

The source code is available under GNU General Public License, Version 3.


There are currently no actual releases of Conman’s Dictionary, because some of the crucial features (even ones hyped below) are in flux and not yet completely trustworthy. Buggy, even. The software is fairly usable for certain kinds of things, however. Gearheads can grab the code from  GitLab.com using git, and can rebuild it pretty darn easy. Bug reports are fully appreciated in Launchpad.

You need the Java Runtime Environment to use the program.

The bleeding-edge source code can be accessed through the  GitLab.com repository, and you need Ant to build it. Full build instructions used to be somewhere.

Currently (October 2013), the master Git branch is under heavy development. Work is under way to remove Swing Application Framework, which was a bloody nice idea back in the day, but ahem no one maintained it, so NetBeans 7 no longer supports it at all – which is to say, I need to go back to plain ol’ Swing. This is harder than it sounds like, because NetBeans refuses to do anything with the appframework code, but doable with patience. Current version does not build, unfortunately.

The netbeans branch has been abandoned – first of all, it used Maven, which is altogether too complicated and slow way to build stuff considering this is such a small application, and it used NetBeans Framework, which turned out to be wayyyyyy too complicated and incomprehensible for such a small application.

Features and workflow

Basic operation

Conman’s Dictionary presents you with two word lists, which are intended for translating words from English to your fanciful language, and your fanciful language to English. Obviously, you can choose to use some another intermediate language as well; just remember that the Tolkien estate may not be particularly happy if you translate inglorious terms in your language to the veritable Proto-Sindarin. Please exercise appropriate reverence.

Basic operations of the word lists is quite self-explanatory. For example, when designing the Pavonian language, the Pavonian list may say “bluznerg: (n.) Hammond organ”, and the English list may then have entries like “Hammond organ: (n.) bluznerg” and “organ: (n.) bluznerg (a Hammond organ)”, for easy cross-reference.

Regrettably, as of current version, Conman’s Dictionary does not support custom characters or fonts, but it does support the full range of Unicode characters as supported by your operating system. You may then introduce fascinating Pavonian vocabulary, such as “omggponiesž: (v.) to post to a website (lit. to surprise people with retarded humour)”.

Both word lists feature separate headword editors, which allow you to add, modify or delete words. The headword lists also include an interactive search feature, allowing you to quickly find the words you are looking for in the dictionaries while translating text.


The trend in modern writing applications – that is to say, software geared toward novelists – is toward simplicity and lack of user interface clutter.

Conman’s Dictionary is in the front trenches of this battle with its revolutionary Notepad feature, which will allow you to make relevant and accurate notes with the rampant one-track-minded ferocity of the dreaded Swampspector himself. The notepad itself consists of an elegantly initialised JEditorPane instance, which also utilises a scrollbar in form of a likewise simply and elegantly initialised JScrollPane instance. Dismissal of the editor is handled through the very latest in button technology, a JButton – pure, simple, standardised, unambiguously labelled as the close button; perhaps a tad bit conservative in its design, but nevertheless exhibiting functionality over form. Text of the editor is practically stored in the most fitting of XML datatypes, an xs:string, one of the most elementary and efficient of XML datatypes in use. When using the Notepad feature in Conman’s Dictionary, you can almost see that you are editing a long litany of characters stored in the file between <notepad> and </notepad> tags as a simple character stream. No formatting, save whitespace; just you, your text, a text editor control and a button to end your ardourous day of work.

…“So this Notepad is just a bloody normal Java plain text editor field”, I hear you say after a pregnant pause. I smile and nod… and you smile and nod in return; we both know how these modern word processors are fundamentally awful and blatantly over-engineered for wrong purposes – they’re all geared toward office peons writing forgettable rubbish paperwork, not true artists working on true literary art.

Seriously, though, the Notepad is highly useful for storing simple notes for work-in-progress stuff, and it’s stored right in the same file with the dictionary itself.

Multiple-document workflow

While Conman’s Dictionary only allows you to edit one document at a time, modern operating system technology allows “multitasking”, an advanced technique whereby multiple programs can be run at the same time. If you feel you’re constrained by the program’s insistence of working on just a single dictionary, you can keep your master dictionary in one program, while working on new words on another window. This allows you to search for existing and well-established words in one program window and simultaneously unleash your creativity and come up with new words in another; go wild, come up with crazy words, and not worry about them until you’ve reviewed them in a more sober state. The words can then be effortlessly merged in your master dictionary. You can even open up your master dictionary and save it as a “template”, so you don’t need to replicate all word classes and categories in the temporary dictionary files you create.

Categorisation features

Currently, the program supports two kinds of word categories: word classes and categories. These two are fairly self-explanatory. Each word class has a name, abbreviation and optional description – say, “Noun”, “n”, and no description, because everyone knows what nouns are, right? The abbreviations then show up in appropriate listings with a trailing period and perhaps even parentheses. Be thou flabbergasted by surprise: (n.) an element which is not found here. Categories are used to put words in bigger groups, like “Body parts”, “Everyday items”, “Music instruments”, um, “Computer terminology”, “Bibliographical jargon”, um… “Food items”… heck, this is tough, I don’t have much stuff in sight right now… “Wolf-related terminology”… all right, this is probably comprehensive enough.


The program reports statistics on number of headwords in the dictionary lists, and breaks them down by word class and category. This allows you to easily see that there are nowhere near enough different words to describe body parts. A constructed language is nothing unless there’s sixteen different synonyms for “finger” – so that the advanced computer-wielding alien race can perform unambiguous calculations. And there’s always a shortage of good words in the wolf-related terminology category. Nothing quite cures depression like coming up with synonyms for “fluffy tail-wagging”!

Flagging words

Certain kinds of words in the dictionary can be flagged, and there is an option to not save the flagged entries to file. This is useful for maintaining two versions of the files – one with stable and established words, another with less established and creative words. You can maintain a master database, and save unflagged words as the “officially published” word list.

Do you have entries that still need work before the next revision of dictionary is published? Perhaps just dubious etymologies? Perhaps even just silly etymologies? Oh, most likely you have just been practising recreational linguistics at 4 o’clock in the morning, and come up with words that you have absolutely no idea what they mean, on the simple and easy-to-explain account that they were written down around 4 o’clock in the morning? Or perhaps it is a question of public image; perhaps the report function shows that the bulk of the sexual terminology vastly overshadows certain more practical categories, and you may want to cull down that particular category of words… purely to avoid enforcing the geek stereotypes, of course. In no way that was an indication of frustrations and you merely came up with all these words at the proverbial 4 o’clock in the morning out of sheer boredom; truth to be told you’re banging hot scientists all the time, of course. Scientists are awesome.

Exporting dictionaries

Currently, Conman’s Dictionary allows you to export your dictionary in the format used by dictd. Thanks to the wonders of the modern software development priorities and general crypticity of setting up dictd locally, it is not, however, actually tested with an actual installation of dictd; all anyone ever needed was the ability to export the bloody things as UTF-8 plain text files. As far as this goal is concerned, the application works perfectly.

Owing to the wonders of the XML file format, writing external exporters and data-massaging thingies should be fairly straightforward: 5 minutes in REXML, 5 days in XSLT, same difference, no sweat.

Technological features

Veritable paradise of Java buzzwords

Over the years, I’ve mostly followed Java with eyes half closed, only doing an odd Java program here and there until Java 1.4, and only got enthusiastic about Java in Java 6. So, here I am, cramming in tons of amazing technological marvels that I hadn’t seen in years gone by! So many options! This project is mostly about me learning about l33t things that can be done in modern Java, like the finally-moderately-debugged Swing (y’see, over the years I used those other GUI toolkits, I came to the realisation that they all suck, and Java’s GUI toolkits suck by far least) and JAXB (I can’t believe people could live before this). The project also uses famous NetBeans-semimandated goodies like Ant, Swing Appframework and jUnit. There’s even an abundance of other design features, like “very damn vaguely MVC-inspired” document-based class design, and best of all, development happens through 100% pure certified git commits.

XML file format

The application has its own XML file format, which is fairly simple, even when the schema file is gigantic. (Then again, that is in XML Schema format. Of course it’s gigantic.) The best thing that can be said about the file format is that it’s… simple?