Narrow fixed-width fonts for coding

October 21st, 2015 No comments

I code a lot, and so I like having good monospaced / fixed-width fonts for doing so. Lately I think I prefer narrow coding fonts because they give me more characters per line that I can see at once. So I did a web dive to find some good narrow coding fonts online. Here are some I liked. I’m currently using M+1M as my main code font in Eclipse, Qt Creator, and other IDEs.

Categories: Uncategorized Tags:

MVC Podcast

September 5th, 2015 No comments

So, my good friend Victoria​ and I made a podcast. We call it “MVC” (Marty and Victoria Conversations). We wanted an excuse to talk once a week about various tech news for nerds. In this one, we talk about topics like:

  • Do you need to be good at math to learn to code?
  • the Ashley Madison hack
  • removal of Flash from web browsers
  • a few other things.

    It’s pretty “version 1.0”: not perfect audio, kind of long and rambly (around an hour), more than a few “ums” and “uhs.” We’ll try to do shorter ones in the future. But we thought we’d post it anyway in case anybody enjoys it. We fully expect this to be one of those “only our moms and S.O.s listen to it” podcasts, but we’ll see. :-)

Categories: Uncategorized Tags:

There’s something about YAML

August 16th, 2015 No comments

When you’re developing an app, you often run into the problem of needing to store structured data in some format. The crucial thing is that you absolutely cannot just make up some dumb format of your own, like:

# marty's homemade file format
# (now I get to write code to parse it from scratch; yay!)
server = "localhost"
email = ""
buddies = {

Many years ago I settled on XML as a nice standard file format. XML is basically HTML except that you can use any tags or attributes you want. It’s easy to understand if you know HTML; it’s nicely rigidly structured and can be validated if you create an XML schema specifying which tags/attributes are allowed where.

<?xml version="1.0" encoding="UTF-8"?>
    <!-- Marty's data in XML -->

XML has served me well for many years, but it’s a bit cumbersome. To pull the data out of the XML file, you need to use the XML document-object model (DOM), a set of classes and methods for talking to XML data. The good news is that the XML DOM is mostly available and standardized across lots of programming languages. The bad news is the the XML DOM is verbose and kind of clunky to use. To pull the buddies out of the above stuff, you’d have to write code like:

// this is mostly Java
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
try {
    DocumentBuilder builder = factory.newDocumentBuilder();
    InputSource source = new InputSource(IOUtils.toInputStream(xmlFileText));
    Document doc = builder.parse(source);
    Node settingsNode = doc.getElementsByTagName("settings").getChildNodes().item(0);            // ...
    Node buddiesNode = settingsNode.getElementsByTagName("settings").getChildNodes().item(0);    // ...
    NodeList buddies = buddiesNode.getElementsByTagName("buddy");
    for (int i = 0; i < buddies.getLength(); i++) {
        Node buddyNode = buddies.item(i);                                                        // ...
        String arrrrrrrrrrgh = buddyNode.getTextContent();                                       // "Allison"  (finally!!)
} catch (Exception e) {

So, that all works, but it can be kind of a pain. A lot of folks using web apps have switched their data into JavaScript object notation (JSON) format. JSON is the cute idea that you should just declare your data as a JavaScript object literal, as a map from property/field names into values.

// Marty's data in JSON (a comment isn't legal here but oh well)
    "server": "localhost",
    "email": "",
    "buddies": {
        {"name": "Allison"},
        {"name": "Helene"},
        {"name": "Katlyn"},
        {"name": "Mariana"},
        {"name": "Zorah"}

JSON is a nice format because if your language knows how to parse JSON, you can usually just turn the data into a nice nested object and access each property directly, something like:

myJsonData["buddies"][3]["name"]   // "Mariana"

In some recent work on my Practice-It web app I was getting sick of a glut of XML data the app uses. One annoying thing about this particular data was that a lot of it was HTML snippets. The app uses XML files to describe programming exercises, each with an HTML description and a Java code solution. So I had things like:

<?xml version="1.0" encoding="UTF-8"?>
        &lt;p&gt;Write a method named "max" that accepts two integers and returns which one is greater.&lt;/p&gt;
        &lt;p&gt;For example, the call of &lt;code&gt;max(12, 47)&lt;/code&gt; returns &lt;code&gt;47&lt;/code&gt;.&lt;/p&gt;
        public int max(int a, int b) {
            if (a &gt; b) {
                return a;
            } else {
                return b;

Notice how I have to HTML-encode the description and solution because you can’t have the < > characters inside a tag in XML. It’s just a pain to have to HTML-encode everything and carefully nest all of it inside the XML.

JSON wouldn’t be much better; all the property names/values have to be quoted and JavaScript-string-encoded, and multi-line values are crappy, so if I were to convert the above to JSON, I’d get muck like:


Write a method named \"max\" that accepts two ints and returns which one is greater.


For example, the call of max(12, 47) returns 47.

" "solution":"public int max(int a, int b) {\n if (a > b) {\n return a;\n } else {\n return b;\n }\n }" }

Doesn’t seem much better to me.

ENTER YAML. YAML is a data markup language commonly used with Ruby on Rails apps for config files and things of that nature. I’ve seen it called “the Python of markup languages”, which is a great description. Its syntax is brief and bare, using name: value pairs along with spaced indentation to indicate nesting. You can indicate a multi-line value with a | or > character. Look at this loveliness:

# This is YAML, MFers, awwwwww yeah
    description: |
        <p>Write a method named max that accepts
        two ints and returns which one is greater.</p>
        <p>For example, the call of <code>max(12, 47)</code>
        returns <code>47</code>.</p>
    solution: |
        public int max(int a, int b) {
            if (a > b) {
                return a;
            } else {
                return b;

Not all languages include a YAML parser, but I found a small Java library that turns the YAML data into a nested Map<String, String>, which is fine for my purposes:

Map<String, String> yamlData = FileReader("mydata.yaml"));
String solutionCode = yamlData.get("problem").get("solution");

It’s just so clean and simple and nice. I’m in love. I’m planning to create most of my new problem data files in YAML rather than XML from now on; it’s just so much faster and cleaner for me to author the files.

YAML isn’t perfect. One issue is that it can be tougher to verify that a given YAML file matches some exact schema. So I think YAML is currently best suited to data that comes from a trusted source; in this case, the data is authored by me, and I trust me.

Categories: Uncategorized Tags: , , , , ,