Take Notes Electronically with a Tablet and Stylus

I’m an advocate of taking notes electronically on a tablet, with a stylus.  I’m often asked why.  Here’s my argument.

Why Take Notes Electronically?

• Electronic notes are searchable
• Electronic notes can be accessed remotely
• Electronic notes require no significant physical storage space
• Electronic notes are more likely to be retained over time
• Your electronic device is probably able to contain books and other reference materials, making it so you have less to carry in general, and convenient to quickly switch between your notes and other documents.
• There are several great pieces of software for taking notes (OneNote [my preference], EverNote, and Keep).

Why Use a Tablet?

• If you’re taking notes on a notebook PC, others who can’t see your screen may assume you’re doing something other than taking notes.
  • I know that in certain environments (e.g. a lecture hall), this isn’t a concern.  But in many contexts, like business meetings, it is.
• Because others can’t see your screen, you may be tempted to do something other than take notes.
• Smart phones are too small to key data into quickly (for me, at least).
• When you’re keying data into a smart phone, others can’t see the screen and may (with good reason) assume you’re texting, posting stuff to Facebook, etc.
• Notebooks aren’t as portable as tablets.
• Notebooks generally don’t boot up as quickly as tablets.
• Notebooks require a surface to rest on, which may not be available in every situation.  A tablet can be held with one hand and used with the other hand.
• Many notebooks don’t have a battery life as good as the battery life of tablets, which is generally 6+ hours.
• A tablet is inconspicuous and will work in just about any situation that a pen and paper will work in.

Why Use a Stylus?

• If you’re using a physical keyboard with a tablet, items #1 and #2 in the previous section would apply.
• On-screen keyboards have no tactile feedback, and require a surface to rest on if you want to use both hands.  If you’re only using one hand, a stylus will be faster.
• It’s very similar to taking notes on paper, which most people are comfortable with.
  • When we write on paper, the paper is flat on the table. With typing, the keyboard is usually at an angle.  And even when the keyboard is relatively flat, like with a notebook PC, the screen is roughly perpendicular to the keyboard.  So to be keying on a flat surface, with the display also flat, is not something most people are used to and not comfortable (for me).

Demo

So, that’s my argument.  You may be thinking, “that sounds all well and good, but how easy is it to do?”  Truth is, there is a learning curve, and it’s not for everyone.  But I find that it’s worth it, particularly since I have many occasions to take notes at this point in my life.

Recognizing your handwriting and converting it to text is not an exact science, and the computer will make mistakes.  I can’t speak for other tablets, but the Microsoft Surface has a few simple correction gestures that makes is easy to correct errors.  I’ve included a demo video below.

Taking Notes on Microsoft Surface RT Demo from Osborne Supremacy on Vimeo.

NerdDinner Tutorial in Visual Studio 2012

I’ve been going through Scott Guthrie’s NerdDinner Tutorial.  It’s been very educational for me.  However, it’s written in Visual Studio 2010 with C# and .aspx pages.  As I’ve been going through it, I’ve been using Visual Studio 2012, Visual Basic, and Razor.  During the process, I’ve occasionally had to wrestle to get things working right.  The most challenging has been step 10, AJAX Enabling RSVPs Accepts.

There’s nothing particularly complicated in this step, but I had to do a lot of dancing to get it to work right.  When I did I found myself thinking, “why exactly did that take so long?”  In any case, I thought I’d mention the major obstacle I encountered and what I did to get around it, in case anyone else is struggling with the same thing.

Here’s the code that was the problem:

 <%= Ajax.ActionLink( "RSVP for this event",  
 "Register", "RSVP",  
 new { id=Model.DinnerID },  
 new AjaxOptions { UpdateTargetId="rsvpmsg"}) %>      

In order to get the AJAX to work, Guthrie says to include these libraries:

 <script src="/Scripts/MicrosoftAjax.js" type="text/javascript"></script>  
 <script src="/Scripts/MicrosoftMvcAjax.js" type="text/javascript"></script>   

My first question was, if these libraries should be included to get Ajax.ActionLinks to work, why aren’t they included in the Scripts folder by default?  The answer is, they’re not needed in VS 2012 (at least for this application), since jquery.unobtrusive-ajax, will handle it, and that library is included in web projects by default, and is included in the jqueryval bundle in the BundleConfig file.

So, those Microsoft AJAX libraries don’t need to be included.  Instead, the Details view needs this:

 @Section Scripts  
   @Scripts.Render("~/bundles/jqueryui")  
   @Scripts.Render("~/bundles/jqueryval")  
 End Section  

But even with that change, the Ajax.ActionLink was not working.  It was doing a GET rather than a POST.  So, I had to change it to this:

       @Ajax.ActionLink("RSVP for this event - AJAX",  
                "Register",  
                "RSVP",  
                New With {.id = Model.DinnerId},  
                New AjaxOptions With {.UpdateTargetId = "rsvpmsg", .HttpMethod= "Post"})   

With that, the Ajax.Actionlink works as expected.

Here’s a stray observation.  When the code was not working, clicking the “Register” link was behaving differently between Chrome and IE.  Chrome would give me a “resource not found” error page, while in IE nothing would happen.  I wonder if it’s not a good idea to always create a view to handle an ActionLink, for cases when there’s a JavaScript issue, even one that’s not the developer’s fault (e.g. a user’s machine having a cached .js file that’s out-of-date or not compatible with other .js files).