Monday, February 23, 2015

Creating a Reference Letter Writing App with LiveCode

Somewhat on a dare, I've created a prototype of a reference letter writing app with LiveCode. I say "on a dare" because I was eavesdropping on a conversation of a few of my faculty colleagues at the University of Georgia before a faculty meeting last week. They were talking about the number of reference letters they were having to write. One colleague remarked that she had promised letters to about 30 very deserving undergraduate students who needed the letters as part of their application to graduate school. As happy as she was to write these letters for them, the task was really taking its tolI in terms of the time she needed to do it. I casually remarked that I thought it wouldn't be too hard to create a simple app with LiveCode that would construct at least a respectable first draft. Everyone thought this would be a fantastic idea for an app though I thought I sensed a hint of doubt in their enthusiastic voices that I could pull something like this off.

So, naturally I dropped everything else I was doing and created a prototype of just such an app. (As I like to say, I'm not a competitive guy, but "I'm more competitive than you.") Seriously, though, it did sound like an interesting and worthwhile project and one that I sincerely thought wouldn't be that hard to build. I even mentioned to my colleagues that it should be very easy to create a simple student rating system, say by using a scale such as from 1 to 3 (outstanding, very good, fair) which could be used to automatically generate a suitable draft letter.

I've spent about 3 hours on this project and it was about as challenging as I suspected. However, I don't think the prototype I built is the way to approach this problem. But, I think that is an important principle of design -- one cannot fully anticipate the design specifications, or even the best approach to identifying those specifications, for a project until one begins building it. I'll return later to discuss what I think would be a better way, but let's take a look at the current prototype:

Allow me to emphasize that I and my colleagues at the University of Georgia take the task of writing reference letters very seriously. All letters require much care and attention. So, don't get the impression that I'm making this app with the intent to trivialize or cheapen the reference letter writing process. My goal was only only to explore how to make an app that would help someone write at least a simple first draft. The letter should then be customized as needed for the particular student.

As mentioned in the video, it would be very easy to have LiveCode choose a phrase from the menu choice fields at random, though this would require that the user code each phrase as being acceptable within the excellent, very good, or fair rating categories. This would allow the app to create a full draft of the letter with just two clicks (one to select the rating and the other to generate the letter). That feature obviously has some appeal.

A Better Design Approach

To be honest, I feel there are all sorts of problems with the design approach I took with this prototype, with the main one being that the user is "locked in" to the basic format of the letter. The only way to change the format is by me going in and changing it within LiveCode. For the app to be useful, the user would need to have complete freedom to change the format and contents of the letter at will. Another obvious feature that is needed is the ability to save as many letter templates as one wishes.

In hindsight, I think a better approach would be to use something called "piped text" within a simple text letter template. The idea is that as one writes the letter, one could decide on those locations in the text where dynamic text should be used. The user could then insert the dynamic text by denoting it with special characters, such as start and end braces. The dynamic elements could likewise be edited at will also. If I continue developing this app in any serious way, I'll most likely redesign it completely with this strategy in mind.


  1. If you use [[ and ]] as your markers for text insertion, and designate a variable that will contain the data to be inserted with a matching name then you can use merge() to do your form letter insertions.
    so if you have a variable you're going to use called firstName and a string "My name is [[firstName]]" if you: put merge(field "myformletterfield") out will pop "my name is Mike" or whatever the current value of the variable firstName is.

    Not sure if this would fit in with the design and behavior you wish to end up with, but thought I'd mention it. merge() is pretty handy. (you can also use it with properties, or even functions I think... [[ the short name of this stack ]] will show up as just that.)

  2. Thank you, Willy, for this suggestion. I did not know about the merge function, so I really appreciate you alerting me to its availability. Interestingly, I just created a second revision of the app that successfully uses replaceable text without knowing about this function. My approach used more of a brute force method. In the future, I'll definitely use the merge function instead. Best wishes.

  3. This is a really good idea and very similar to the process that I use at work. I spent an entire weekend creating a variety of reference letter templates. I, like your fellow colleagues, was sick of rewriting the same thing over and over. They are all pretty much the same just plug in different wording here or there. This has cut back on the leg work for sure.

    Nathan @ Emyoli