After the Deadline

After the Deadline for Comments – So Many Ways, So Much Fun

Posted in Talking to myself by rsmudge on July 30, 2010

There’s another way to make After the Deadline available on your blog. Now you can use it with comments thanks to the After the Deadline for Comments plugin by Otto42. You can see it in action on the world-famous ma.tt blog. If you have feedback on this plugin, there is a thread on the WPTavern.com forum.

Here is a screenshot:

If you’re an IntenseDebate user, don’t forget that After the Deadline is available as an IntenseDebate plugin too. It works pretty seamlessly as well.

Finally, the commercial (but GPL) AJAX Edit Comments plugin integrates After the Deadline too.

Credit: ajaxeditcomments.com

So, if you’re looking for spelling and grammar checking for your blog comments, After the Deadline can help. If you just want this checking capability for yourself, we offer plugins for Google Chrome and Firefox as well.

Let’s Make More Proofreaders Available in More Places

Posted in Talking to myself by rsmudge on July 1, 2010

When After the Deadline started out, its greatest weakness was the lack of places one could use it. Originally it was available on PolishMyWriting.com, then WordPress and TinyMCE, and now many more applications. Making After the Deadline available in many places has allowed many of you to use it.

After the Deadline isn’t the only proofreading game in town though. Language Tool, An Gramadóir, and CoGROO are among many existing projects to make proofreading technologies available under an open source license. The challenge for these tools is they can’t be used in many places. The three I mentioned are available for OpenOffice.org and maybe a few other places.

Make Your Proofreading Technology Available in More Places

So, imagine that you want to make your proofreading technology available in more places, what would you do? One solution: implement the After the Deadline protocol.

After the Deadline is available for Firefox, Google Chrome, bbPress, WordPress, TinyMCE, jQuery, and even OpenOffice.org (beta). We have pretty solid extensions for each of these. Each of these extensions communicates with an After the Deadline server using a simple XML protocol.

If your proofreading technology spoke the After the Deadline protocol, then in theory, you could point one of our many extensions to your software and voilà, you’ll have a full user-experience for your technology.

Check Your Esperanto Grammar in Firefox

The developer of Esperantilo, a grammar checker for Esperanto, realized this and modified AtD/Firefox to talk to his program when it’s running. The result? Speakers of Esperanto now have an option to check their Esperanto writing from Firefox.

Here is a screenshot of it in action:

Esperanto in AtD/Firefox

Yes, I like this…

Right now it’s easy to configure AtD for WordPress.org, bbPress, TinyMCE, jQuery, and OpenOffice.org to talk to another server. That’s a lot of ways for users to use your proofreading technology. Artur, the developer of Esperantilo, had to use an older (non-SSL) version of AtD/Firefox to point it to his software. If other proofreading packages choose to support the After the Deadline protocol and API, I’m happy to add an option to After the Deadline for Firefox and Google Chrome to support custom end-points.

If more developers implement the AtD protocol in their proofreading software, then users can benefit from using the best proofreading technology for their needs in many more applications.

OpenOffice.org Grammar Checkers

Posted in Talking to myself by rsmudge on June 14, 2010

OpenOffice.org 3.2.1 was released a few weeks ago. To commemorate this, I’d like to write about the different proofreading tools available for this platform. It’s a common misconception that OpenOffice.org checks grammar out of the box. It doesn’t. OpenOffice.org does, however, have an API that lets developers add a grammar checker via an extension.

There are proofreading tools / grammar checkers for OpenOffice.org. A few that you may want to look at include:

Language Tool

Language Tool is a rule-based grammar checker with an impressive community developing rules for 18 languages. The inner-workings of this system were a heavy inspiration to AtD’s grammar checker implementation. We use Language Tool to check grammar for our French and German offerings of After the Deadline.

Readability Report

I saw Neil Newbold of the University of Surrey, the scientist developer of Readability Report, speak recently. I felt like I was listening to my proofreading brother from another mother. After the Deadline started life as a style checker hosted at PolishMyWriting.com. The AtD style checker uses best practices and suggestions from the Plain English movement to help you clean up your writing. Readability Report does the same thing for OpenOffice.org. It’s a style checker (rooted in Plain English) AND it’s a readability checker.

Some of the readability heuristics are incredible. Neil does some neat NLP work to decide which sentence is your simplest sentence and which sentences are your weirdest sentences. If you want to learn more about how these work, I recommend reading Neil’s paper The Linguistics of Readability: The Next Step for Word Processing that was presented at the  NAACL Computational Linguistics and Writing Workshop in Los Angeles, CA.

Coming Soon: After the Deadline for OpenOffice.org

Since you’re here, I presume you know about After the Deadline. It’s a proofreading software service. After the Deadline uses statistical language models to offer smarter grammar and style recommendations. It also uses the same language models to detect over 1,500 misused words. If you write weather when you mean whether, After the Deadline can help you.

Recently, I started developing an After the Deadline extension for OpenOffice.org. I was so excited when I started this, I couldn’t stop until I had a beta ready for you to try (yes, you can download and install it now). It’s really cool to use After the Deadline in a word processor, like OpenOffice.org Writer.

Because After the Deadline is a software service, this extension requires an internet connection to check your grammar, style, and misused words. If you’re not connected, it will silently do nothing. Rest assured, we’re not keeping your data and this extension communicates with our service over SSL.

The code is available in a public subversion repository and there is a category in the AtD ticket tracker for this OpenOffice.org extension.

One year of After the Deadline

Posted in Talking to myself by rsmudge on June 4, 2010

Wow, I almost missed it. On 1 Jun 09, I launched After the Deadline. The first review of After the Deadline (AtD) came from w-shadow.com. There were also discussions on CMSReport.com and Hacker News.

Acquisition

It’s been an exciting year. On 21 Jul 09, I started with Automattic. Matt and I had worked out the deal several weeks earlier. We announced the acquisition of After the Deadline in Sept 09 and also made AtD available on WordPress.com.

I remember I was a little nervous about going live on WordPress.com. AtD is written in my language Sleep. I’ve used Sleep for a lot of things but not for the back-end of a web-scale project before. I was afraid of a memory leak or a freak concurrency issue. Fortunately, neither of these issues came up.

Open Source NLP R&D

Shortly after that, we open sourced the After the Deadline service. This is something that will take time to have its impact, but make no mistake, it’s significant.

Using statistics to provide better proofreading is nothing new. Researchers pursued the topic in the 90s and during the earlier part of the last decade. Production tools are starting to use statistical language models to provide smarter suggestions and even correct harder errors like misused homophones. Microsoft Word 2007 has a contextual spell checker that looks for misused words. Microsoft Research is developing ESL Assistant, a tool that uses a statistical language model to filter incorrect grammar suggestions. There are also new tools like Ginger and Ghotit that use statistical techniques to deliver smarter results for writers with learning disabilities. I believe cheap and powerful hardware, lots of available data, and persistent internet connectivity made these smarter, data driven, writing tools practical for production use. We’re riding the same wave of “now possible”.

I’m excited about After the Deadline’s place in this period of change. After the Deadline is simultaneously a production system and a research system. The code is available for researchers and students to tinker with and learn from. Let’s not forget, this also means that you can run your own AtD server and add AtD to your application.

Recently, this project produced its first academic paper. Sunday (6 Jun 10), I will present After the Deadline at the Workshop on Computational Linguistics and Writing taking place at the 2010 North American Association of Computational Linguistics Human Language Technologies Conference.

More Languages

After the Deadline went from one to five languages in the past year. We’ve released preliminary support for French, German, Portuguese, and Spanish. We offer contextual spell checking in these languages. We also use our language model to make the Language Tool grammar checker smarter. There is still much work to be done to bring our misused word detection to more languages.

Community Contributions

At WordCamp NYC, someone approached me with “I love After the Deadline but I always forget to run it”. He suggested we add a feature to automatically proofread posts on submit. No good idea should get lost, so I posted this to the ideas page. Later, I received an email from Mohammad Jangda, who offered to implement this feature. I first made his patch live on WordPress.com. Without an announcement, 500 people were enabling it each day. Over time, auto-proofread doubled the use of After the Deadline on WordPress.com. This same feature has made it into our other platforms as well.

Our wish is to see AtD help people write better in as many places as possible. We put a lot of effort into making high quality plugins, it’s nice when we get help. Gautam Gupta is a great example of such help. He created After the Deadline for bbPress. He and I release updates around the same time and he usually beats me to the punch. My favorite is when he announced AtD/bbPress with support for French, German, Portuguese, and Spanish before I had an updated WordPress plugin out the door.

More Places

As I mentioned in the last paragraph, After the Deadline is now available in a lot more places. We have stable plugins for jQuery and TinyMCE. The AtD Core library has allowed us to reuse the protocol parsing and error highlighting logic in many projects.

We now have After the Deadline for Firefox and Google Chrome. I’m amazed at how well these add-ons work. I didn’t believe they were possible. Mitcho Erlewine took on the initial challenge and worked with us to make After the Deadline for Firefox a reality.

We continue to experiment with other applications too. Who knows where you might see AtD next.

Lots of Proofreading

Last month, our AtD servers processed 3.5 million blog posts, emails, tweets, status updates, and who knows what else.

That’s a lot of proofreading. Not bad for a first year.

Can we use crowd sourcing to improve AtD?

Posted in Talking to myself by rsmudge on May 27, 2010

I’ve written about learning from AtD use in the past. The main ideas I had back then were to bring more data into AtD’s corpus and analyze ignored phrases to find gaps in AtD’s dictionary. I put some time into these ideas but the initial results didn’t look too promising, so I backed off.

Recently, the operator of Online Rechtschreibprüfung 24/7 contacted me. His website offers German spell and grammar checking services (with a beta version using AtD). Neat stuff. Being the nice guy that he is, he is also giving back. His users have the option of marking a spelling mistake as false. He has collected this data and made it available to improve the German After the Deadline dictionary.

This got me to thinking. What could I do to PolishMyWriting.com to help you, help me, improve After the Deadline‘s English checking.

Here are some ideas:

  1. Add a “Not Misspelled?” menu item for spelling errors. This could collect a list of words that are candidates to be added to AtD’s dictionary, similar to what Online Rechtschreibprüfung 24/7 does.
  2. Add a “Not an error?” menu item for grammar and style errors. This could collect the error and the context around it.
  3. Add a “Better suggestion?” menu item for grammar, style, and misused word errors. Here you could input a better suggestion for an error.

These three things are pretty trivial to do. I’d also like to find a way to let users highlight errors that aren’t caught. I don’t have any ideas for magically learning from these suggestions. Right now I’d have to analyze each of them and develop rules to catch these errors.

Maybe an option to highlight some text, click Suggest an Error, and complete a short survey about what type of error the text contains.

What are your thoughts?

How to Jump Through Hoops and Make a Chrome Extension

Posted in Talking to myself by rsmudge on May 14, 2010

Last week, we released After the Deadline for Google Chrome. I like Chrome. It’s low on UI clutter and it’s very fast.

Chrome for the extension developer is a rapidly changing world. I wanted After the Deadline for Google Chrome to match our Firefox add-on feature for feature. I hit and overcame a few road blocks meeting this goal.

This blog post is highly technical and deals with some of the innards of writing Chrome extensions. If you’re not interested in this kind of stuff, then take note that I like Chrome, it’s not done yet, and this makes things hard at times. I’m working to bring the best possible proofreading experience to Google Chrome. You may stop reading now.

If you’re still here, that means you’re a developer. I hope this information helps you in your Chrome extension development adventure.

How to refer to internal images in CSS

Google Chrome, like Firefox, makes extension resources available via a special URL. In Firefox, you set the identifier for your extension and can reference images and other resources using this URL. In Google Chrome this  URL depends on your extension’s ID. This extension ID changes depending on whether the extension is loaded as loose files or packaged. Because of this, you should not hard code the URL to an extension resource in your CSS file.

So how can one refer to internal images or other resources in a CSS file?

One option is to avoid referring to internal images or resources at all. You can set CSS properties using JavaScript and chrome.extension.getUrl(‘resource.ext’). This is kind of hacky and I didn’t want to set and unset hover listeners just to do something CSS already gives me for free.

Another option, discovered in this thread, is to convert your images to base64 and embed them as data URLs in your CSS file. It’s an extra step in the beginning but it solves the problem of referring to internal images.

div.afterthedeadline-button
{
background: url(data:image/png;base64,data goes here) transparent no-repeat top left !important;

Once this hack is in place, you won’t have to worry about extension IDs in your CSS files again.

Good luck with those IFRAMEs

Content scripts (Chrome JS extensions) run in a sandbox separate of the environment scripts attached to a page see. This is good as it reduces the possibility of extensions conflicting with web applications. Content scripts see the same DOM that user scripts see. It is possible to make changes to the DOM and inspect it. I recommend that you read the Chrome extension tutorial and watch Google’s video to understand content scripts.

Unfortunately, Google left a few toys out of the sandbox. It’s nearly impossible to work with an IFRAME. The contentWindow property of any IFRAME DOM element is null. Also window.frames is empty. This is a known bug.

Thankfully, the contentDocument.documentElement property does exist. Through this I can set and get the contents of an IFRAME. That’s close to what I want, but not exact. To proofread an editor, After the Deadline creates an editable DIV and copies style information from the editor to this new DIV. To make this convincing for IFRAMES, I have a need to access style information from the contentWindow property.

I tried to make a content script that figures out if it’s attached to an IFRAME. If it is, the script could communicate the needed information to the extension background script via Chrome’s message passing mechanism.

Unfortunately this didn’t work because Chrome only allows scripts to attach to URLs that have an http:// or https:// scheme. Dynamically generated IFRAMEs used by WYSIWYG editors usually have an empty source attribute which does not match an http:// or https:// scheme.

This thread suggests adding a SCRIPT tag to the DOM to execute a script outside the Chrome extension sandbox. However this isn’t necessarily a straight forward process either.

Execute a Script Outside the Chrome Sandbox

The Chrome extension sandbox exists to protect user scripts from extension scripts and vice versa. It would also be dangerous if a malicious user-land script could get into the Chrome sandbox and manipulate the Chrome extension APIs. For these reasons, it’s natural that Google Chrome would discourage extensions from running scripts outside the sandbox. I tried to insert a SCRIPT tag with a SRC attribute into the site’s DOM using jQuery. This didn’t work.

What did work was injecting inline JavaScript that constructs a SCRIPT tag with a SRC attribute from the site’s DOM. Here is the code:

jQuery('body').append('<script type="text/javascript">(function(l) { 
   var res = document.createElement('SCRIPT'); 
   res.type = 'text/javascript'; 
   res.src = l; 
   document.getElementsByTagName('head')[0].appendChild(res); 
})('"+chrome.extension.getURL("scripts/inherit-style.js");</script>');

You’ll want to replace chrome.extension.getURL('scripts/inherit-style.js') with your resource. This is a convenient way to execute code outside of the extension sandbox.

Beware of WebKit Specific Styles

To make my proofreader look pretty, I inherit as many style properties as I can from the original editor. Mitcho showed me this great trick to copy the styles of one element to another:

var css = node.defaultView.getComputedStyle(node, null);
for (var i = 0; i < css.length; i++) {
    var property = css.item(i);
    /* note that I'm assuming jQuery here, proofreader is the note inheriting the property */
    proofreader.css(property, css.getPropertyValue(property));
}

This trick works fine in Chrome, except I found myself scratching my head when some DIVs were editable even though their contentEditable attribute was undefined. The opposite also held true, sometimes my DIV was not editable even though I defined the contentEditable attribute as true. I learned that WebKit has a CSS property -webkit-user-modify that trumps this attribute.

It’s unlikely you’ll ever encounter this, but one day, someone will do a google search, find this post, and I’ll have given them three hours of life they would have lost otherwise.

Final Thoughts

I like Chrome. It’s a good browser. The world of Chrome extensions is changing and expanding rapidly. On one hand, extensions can’t do simple stuff yet, like add items to the context menu. On the other hand, this is being worked on.

Now for the final hoop. There are three distributions of Google Chrome. These are the stable channel, beta channel, and the developer channel. I started out developing in the developer channel and later downgraded to the beta channel as I continued my development. This was a mistake. There are big differences between the stable channel and beta channels. For example, browser actions (toolbar buttons) are allowed to have popup menus. These popups work in the beta channel (5.x) but not in the stable channel (4.x).

Before you release, be aware of these differences. I recommend developing against the stable channel. If you rely on features from a new version, implement them and then verify that your extension degrades nicely on the old version of Chrome. That’s it.

If you’re willing to jump through some hoops you can make a great Chrome extension. I found the Chrome extension mailing list very helpful.

Thanks to Google and the Chromium community for developing a great browser. I’m ok with jumping through a few hoops.

Two Resources on Innovation

Posted in Talking to myself by rsmudge on April 3, 2010

I’m a firm believer that the opportunity for innovation happens when suddenly the right pieces become available and someone puts them together.

If you consider AtD innovative, know that I didn’t invent anything crazy and new with After the Deadline. I applied simple algorithms to a lot of data and achieved good results. The availability of data, cheap CPU power, and a cultural readiness to accept a software feature that depends on a remote server made After the Deadline possible. I simply put the pieces together (and spent some sweat trying lots of simple algorithm/data combinations that didn’t work) and voilà, a proofreading system.

I’d like to share with you two resources that helped me appreciate the innovation process.

The first is the Myths of Innovation by Scott Berkun. Scott talked to the Automattic crew during our October meetup and I really enjoyed the time we had with him. I read his book and found the historical examples relevant. It’s easy for us to think that innovation happens in a vacuüm with one lone hero pulling it all together at the magic moment. Innovation is a lot of iteration and only becomes a magical moment when enough iteration has happened that others notice.

The other resource is the Connections documentary series by James Burke. I’m on my third time watching. It’s an amazing journey through history. The series is from the 70s and has a lot of speculation about the future and where technology may take us. James Burke speculates about the threat computers present to privacy and how technology might connect us in a way that folks couldn’t even imagine then. The series discusses history in terms of problems and the inventions they led to that later led to other problems and inventions. For example, the Faith in Numbers episode charts a historical journey from the Jacquard Loom, to the United States census, and finally to computers programmed with punch cards.

The message in Scott’s book and Burke’s series are the same. If you look at them, you won’t think about innovation the same way again.

Tagged with: ,

A Guide to the AtD Project(s)

Posted in Talking to myself by rsmudge on March 25, 2010

I was cleaning up tickets on the AtD TRAC today and noticed a lot of sub-projects. If I were new, I’d be a little confused. I’m writing this post to clarify what projects exist under the AtD umbrella and how they fit together. I’ll end this post with resources related to these projects and let you know how you can get involved.

This diagram shows some of the projects and how they relate:

The Server Side

The heart of AtD is the server software. This is where the proofreading happens. The software is written in a mix of Sleep and Java. Applications are welcome to communicate with it through an XML protocol. It’s released under the GNU General Public License. There is a treasure trove of natural language processing [1, 2, 3, 4] code here.

Front-End Plugins

Of course a server is no good without a client. After writing a plugin for TinyMCE and later jQuery, I noticed duplicate functionality. To ease my burden fixing bugs in both and make it easier to port AtD to other applications, the AtD core library was born. This library has functions to parse the AtD XML protocol into a data structure that it uses to highlight errors in a DOM. It’s also capable of resolving the correct suggestions for an error (given its context). This library is the foundation of AtD’s front-end. One change to it immediately benefits the WordPress plugin, the Firefox add-on, the TinyMCE plugin, and the jQuery plugin. This is why you will often see me announce multiple things at once.

TinyMCE is a WYSIWYG editor used in many applications including WordPress. It was the first editor I supported with After the Deadline. This plugin makes it possible to add AtD to any application that already has TinyMCE installed. Some things like persisting settings for “Ignore Always” are left to the developer. For the most part though, this is a complete package.

jQuery is a JavaScript library that makes life easier in so many ways. Our jQuery plugin makes it easy to add After the Deadline functionality to any DIV (and TEXTAREA). I first wrote this to offer After the Deadline as a plugin for the IntenseDebate comment system.

Missing from this diagram is the CKEditor plugin. I made an After the Deadline CKEditor plugin in 8 hours to prove the utility of the AtD Core library. It’s missing some of the polished functionality that the TinyMCE and jQuery plugins have. As none of our projects use CKEditor I haven’t had a need to update it. It’s looking for a maintainer.

These building blocks are released under the GNU LGPL license.

Applications

The pieces I’ve written about so far are merely building blocks. They’re useless unless they’re applied somewhere. The WordPress plugin is built on the TinyMCE and jQuery plugins. Through these plugins I’m able to offer AtD support in both the visual and HTML editor. Thanks to AtD core, I’m able to make sure both editors (mis)behave in the same way.

The Firefox add-on was the first Automattic project to use the AtD core library directly. With it, Mitcho was able to talk to start highlighting errors as soon as he got the add-on talking to the AtD server. This was pretty exciting as it meant we had a lot of functionality right away.

The building blocks are nice as they also make it possible for others to contribute plugins for other applications. For example, Gautam maintains a bbPress plugin using these building blocks.

And of course having these building blocks also means you’re able to add After the Deadline to your application.

Project Resources

And finally, there are the project resources. As much as it seems like things are scattered around, it’s not really that bad.

We use a single TRAC instance for all AtD projects maintained by Automattic. You can report any issues there directly, you just need a WordPress.org account to login.

Most of the AtD code maintained by Automattic is maintained in a common subversion repository as well.

This is the official After the Deadline blog for all the AtD projects maintained by Automattic.

Anything related to the front-end is hosted on the AtD developer’s page.

Information about the NLP research and the proofreading software service are kept at: http://open.afterthedeadline.com

It’s not very active, but there is a mailing list on Google Groups for all AtD related projects.

And we’re using GlotPress to make it easy to translate the AtD projects to other languages.

Getting Involved

That’s it, don’t forget to read our getting involved guide. One of the easiest ways to contribute is to file bugs in TRAC or contribute translations.

If you develop an After the Deadline plugin for an application, let me know. I’ll gladly link to it.

Hopefully this post helps lay out the landscape of the AtD project and some of the sub-projects involved with it.

Humble Origins: PolishMyWriting.com

Posted in NLP Research, Talking to myself by rsmudge on March 19, 2010

I found an old screenshot today and thought I’d share it to give you an idea of (1) how bad my design eye is and (2) some history of After the Deadline. After the Deadline started life as a web-based style checker hosted at PolishMyWriting.com. My goal? Convince people to paste in their documents to receive feedback on the fly, while I made tons of money from ad revenue. It seemed like a good idea at the time.

PolishMyWriting.com Screenshot

The Original PolishMyWriting.com

PolishMyWriting.com did not check spelling, misused words, or grammar. It relied on 2,283 rules to look for phrases to avoid, jargon terms, biased phrases, clichés, complex phrases, foreign words, and redundant phrases. The most sophisticated natural language processing in the system detected passive voice and hidden verbs.I wouldn’t call it sophisticated though. I referenced a chart and wrote simple heuristics to capture the different forms of passive voice. Funny, it’s the same passive voice detector used in After the Deadline today.

This rule-based system presents all of its suggestions (with no filtering or reordering) to the end-user. A hacker news user agreed with 50% of what it had to say and that’s not too bad. After the Deadline today looks at the context of any phrase it flags and tries to decide whether a suggestion is appropriate or not. A recent reviewer of After the Deadline says he agrees with 75% of what it says. An improvement!

How PolishMyWriting.com Worked

My favorite part of PolishMyWriting.com was how it stored rules. All the rules were collapsed into a tree. From each word position in the document, the system would the tree looking for the deepest match. In this way PolishMyWriting.com only had to evaluate rules that were relevant to a given position in the text. It was also easy for the match to fail right away (hey, the current word doesn’t match any of the possible starting words for a rule). With this I was able to create as many rules as I liked without impacting the performance of the system.  The rule-tree in After the Deadline today has 33,331 end-states. Not too bad.

PolishMyWriting.com Rule Tree

PolishMyWriting.com Rule Tree

The rule-tree above matches six rules. If I were to give it a sentence: I did not remember to write a lot of posts. The system would start with I and realize there is nowhere to go. The next word is did. It would look at did and check if any children from did in the tree match the word after did in the sentence. In this case not matches. The system repeats this process from not. The next word that matches is succeed. Here PolishMyWriting.com would present the suggestions for did not succeed to the user. If the search would have failed to turn up an end state for did not succeed, the system would advance to not and repeat the process from the beginning. Since it found a match, the process would start again from to write a lot of posts. The result I [forgot] to write [many, much] blog posts.

What happened to PolishMyWriting.com?

I eventually dumped the PolishMyWriting.com name. Mainly because I kept hearing jokes from people online (and in person) about how great it was that I developed a writing resource for the Polish people. It stills exists, mainly as a place to demonstrate After the Deadline.

And don’t forget, if PolishMyWriting.com helps you out.. you can link to it using our nifty banner graphic. 😉

Rethink Your Relationship with Your Spell Checker

Posted in Talking to myself by rsmudge on March 8, 2010

Last week, switched.com reviewed several grammar checkers to celebrate National Grammar Day. The tested text was interesting to me and it inspired this post.

Its common for users to rely entirely on the in built proofreading capabilities of a word processor. Since the technology became standard in Microsofts Word in the 90’s countless cubicle dwellers and students have stopped carefully proofreading they’re own writing they have instead trust the automated spellcheck and grammar correcting features of their office product of choice to identify errors. We have carefully crafted this text to test the accuracy of these features, there are roughly 10 common grammatical mistakes in this paragraph. No matter good these tools perform there no replacement for carefully rereading you’re writing.

I agree and I think it’s time people rethink their relationship with their spell checker.

My friend Karen once told me a story about giving her husband feedback on a school paper. She noticed that he really liked semicolons. She confronted him on this and he said that Microsoft Word kept suggesting them and he kept accepting them. This is not a good situation.

Many writers rely on their spell checker to a fault. They see their spell checker as a tool to verify that a document is correct and ready to go with no effort on their part. If you want to verify that a document is correct, you need to reread it and look for errors. A great technique is to read the document backwards. Purdue’s Online Writing Lab has more tips like this.

If writers need to reread their documents, then what is the use of tools like After the Deadline? I look at After the Deadline as a tool that teaches users about writing. When asked what I do, I sometimes reply that I’m an English teacher with many thousands of students. No one gets the joke. It’s ok.

After the Deadline does a good job of finding its/it’s errors. It does not find all of them. I think this is OK. If a user checks their document and has a habit of misusing its/it’s, they’ll probably see a lot of errors. If this user is inquisitive, they may quick click explain. By doing this they’ll learn why the error is an error. By reading the feedback during the writing process, the lesson has the most potential to sink in.
Feedback is most valuable when it’s immediate. After the Deadline makes you a better writer through immediate feedback.