Background

Anyone who uses Outlook tasks and notes and an iPhone knows the pain of not being able to sync tasks and notes over-the-air from Exchange to the iPhone. I was surprised when I first realized that the Exchange client oin the iPhone only syncs email, calendar and contacts and does not sync notes and tasks. I was surprised because I assumed it would be like any other Exchange client and sync tasks and notes as well. Initially, not being able to sync notes did not seem like a showstopper. But over time it became more and more problematic as I was unable to access notes from Outlook that I have become dependent upon.

Evernote

A colleague introduced me to Evernote (see evernote.com). Evernote is a service that allows you to save notes containing various types of media to a central, cloud-based service. The notes are available for viewing and editing using a variety of applications including: traditional web, iPhone, Windows dand Mac. Best of all, the service and clients are free if you do not exceed a (fairly generous) disk space allotment. Notes that are created or edited on any platform are quickly and efficiently replicated to all clients.

Moving Existing Notes

Evernote has two built-in mechanisms to import data:

1. Import Evernote import/export files
2. Extract notes from Microsoft OneNote

I found myself in a bind. I had over 125 notes in Outlook 2007 (I was not using OneNote) and could not find an existing way to import these Outlook notes other than to copy and paste each note, one-by-one, into my Windows Evernote application. So I wrote a program to convert the Outlook notes into a format that can be imported into the Evernote Windows client (Note: as of this writing, the Mac Evernote client does not support this import feature).

My Outlook to Evernote (OL2EN) program takes an exported Outlook 2007 Notes file in Windows CSV format as input and creates an Evernote compatible import/export XML file as output. The Evernote import/export file can then be imported into the Evernote Windows client.

The complete steps to get started and import your Outlook 2007 notes are detailed:

1. Download Evernote iphone client from the Apple App Store (the app is free)
2. Download and install the Evernote Windows client from the evernote.com site (the app is free)
3. Create a free account on evernote.com. You can do this from iPhone application or on evernote.com website.
4. Export notes from outlook in windows CSV using the following steps:
   a. Click on Notes in Microsoft Outlook 2007
   b. Select File | Import and Export…
   c. Select ‘Export to a File’ in the resulting Import and Export dialog and click Next
   d. Select ‘Comma Separated Values (Windows)’ and click Next
   e. Make sure that ‘Notes’ is selected in the hierarchy and click Next
   f. Type in a location and filename (ending in .CSV) for your Outlook notes export CSV file and click Next
   g. Leave the default mappings on the final dialog and click Finish (your file will be created)
5. Create an Evernote XML import/export file using my tool using the following steps:
   a. Download the OL2EN application and run it (note that it requires the Microsoft .NET runtime)
   b. Run the program and select the CSV file you created in step 4 in the ‘Outlook Export File’ field
   c. Type in the name of the Evernote XML file you want to generate in ‘Evernote Import File’ field
   d. Leave ‘Ignore header row (first CSV row)’ checked as the first CSV entry from the Outlook 2007 export is a header row
   e. Click ‘Generate’. A success dialog should indicate how many notes were converted.
6. Import the Evernote import/export XML file using the Evernote Windows client application using the following steps
   a. Start the Evernote Windows application
   b. Select File | Import | Evernote Export Files…
   c. In the resulting File Open dialog, browser for and select the Evernote import/export file created in step 5 and click open. If the import is successful, you will see a success dialog indicating the notes were imported into a separate notebook inside Evernote. Contratulations! In the event of a failure to import, your import notebook will be empty and you will not see a success message. Unfortunately, there doesn’t appear to be any information provided by Evernote, but is is likely that the XML file is malformed.

OL2EN is free to use for commercial or non-commercial purposes. If you find OL2EN useful or want me to add any additional features, or run into any errors, please post a comment. OL2EN saved me from a lot of typing. I hope someone else can make use of it as well…

Who doesn’t have clothes in their closet that they never wear? It is hard to decide what I will not wear and therefore should donate, but fortunately, I learned a trick that I can turn hangers backwards for all clothing for which I don’t think I will wear. If I end up wearing any of this questionable clothing, when it is returned to the closet, I will hang it with the hanger positioned normally (i.e. not backwards).

After a few months (or however long I want to wait) I can determine what clothing I did not wear because their hangers are still backwards. Clothes that are left on a backward hanger can safely be donated/given away because they are definitely not being worn. This approach allows even a pack-rats the peace of mind to get rid of any unnecessary clothing. The benefit is that I can get rid of clothing that takes up valuable space in my closet, but more importantly, it makes dealing with my closet easier because I don’t have excess clothes to pick through.

I’ve found that my brain is most at ease when my GTD lists of next actions (ToDos) and projects are most abundant because that means (or at least has the feeling) that everything is out of my head and in my system. This allows my brain to stop thinking about what I need to do and allows me to focus on getting things done. However, as my GTD system grows (i.e. more projects and ToDos are added to my system), it seems as if it becomes exponential difficulty to simply scan my context-specific list of ToDos when trying to determine the most appropriate next action.

During the course of my day, my ToDo list is constantly changing. I’m adding items that I’ve identified and removing items that I’ve completed. With just over 350 tasks in my GTD system, it can take several minutes to scan a list of @Computer-Broadband related next actions when the list has over 50 items. Just the thought of scanning through 350 next actions is painful!

In order to keep my GTD system complete, but not bloated, I need to prune my list of next actions and projects from time to time. GTD suggests moving unnecessary next actions and projects to the Someday Maybe list/category. My problem, like with clothes in my closet, is that it is very difficult to make the mental leap that an item is not needed and should be moved to the Someday maybe list.

To combat this resistance to prune an item, I use a similar technique to the backward hangers in the closet for my GTD lists. Although there are many ways you can approach it, during a special, monthly review, I put a trailing asterisk on next actions and projects for which I have not acted upon in at least a month. If, at some point, I act upon the action or project, I remove the asterisk (similar to returning clothing to the closet with the hanger oriented normally).

Once a month, during my weekly review, I review the items with asterisks (see example above). If it has been at least a month since I dealt with the project or next action, I move it to the someday maybe category.

The beauty of this technique is that it helps me be aggressive at keeping my next action list to a minimum. (GTD practitioners will understand that we ignore the someday maybe list except during our weekly reviews). Minimizing the clutter and bloat in my lists allows me to more quickly understand what is truly important. By using this technique, my GTD system is much less bloated and I enjoy scanning my shorter lists easily throughout my day.

At Adobe MAX last month, Adobe announced the Mosaic alpha release (to a beta community). It is a composite rich internet application product that allows organizations to integrate and mash up their Flash/Flex, HTML and 3rd party web applications. Mosaic is part of Adobe’s approach to building next generation rich internet application (RIA) applications in the enterprise. Using Mosaic, you can create task-centric applications (i.e. mashups) that are context aware and are composed of other applications.

From the glimpse of what I saw in my hands-on session, the alpha version of Mosaic includes a subset of what you’d expect from a portal. But Adobe was very careful not to call Mosaic a portal. It provides the UI layout and inter-application communication that you’d want from a portal-like technology, but it is intended to be more of a mashup container. As a result, Mosaic is intentionally missing many portal features such as user management.

Tiles and Views
Each application that is contained in Mosaic is referred to as a tile. Tiles are made available to Mosaic through the catalog. The catalog contains all the information about a tile including its location, category, description, tags and other information about its layout. Any tile from the catalog is available to be injected into Mosaic. At the moment, Mosaic stores the tiles in an XML-based catalog. It seems likely to assume that Adobe will ultimately provide a management facility to allow non-programmers to manage the catalog and tile information.

An interesting aspect of the Mosaic UI is its support for up to 3 views. A view allows end-users to create a collection of related applications in single context. For example, within Mosaic you might have a view that contains your financial tiles, another view that contains your HR-related tiles and a third view that contains CRM-related tiles. You can think of views along the lines of multiple desktops or workspaces supported in Windows or Spaces on a Mac. As you would expect, the views can be saved from session to session and support the task-centric focus of Mosaic. As you would expect from a RIA application, Mosaic allows tiles to be rearranged within the view and also to run normalized or maximized.

Inter-Tile Communication
Ultimately, Mosaic allows Flash/Flex, HTML and 3rd party applications (where source code is not available) to be integrated.  Flash/Flex tiles interact by modifying the application source to allow the resulting tile to send and receive messages and to take advantage of a global or view-based context. HTML applications (where source is available and can be edited) can make use of a JavaScript library to communicate. And finally, 3rd party HTML application (for which the source code is not available) can use URL Bridging to pass URL parameters. For example, you can include a tile in your application that calls google news to retrieve any recent news regarding Adobe by using the URL “http://news.google.com/news/search?q={global.sym}” where global.sym resolves to “adobe”.

Although details are not available, Adobe plans to provide tight integration with Mosaic and LiveCycle ES2.

Extreme Programming (XP) defines a concept called a spike. A spike is an activity to find out answers to a touch technical or design problem. Extremeprogramming.org defines a spike as:

Create spike solutions to figure out answers to tough technical or design problems. A spike solution is a very simple program to explore potential solutions. Build a system which only addresses the problem under examination and ignore all other concerns. Most spikes are not good enough to keep, so expect to throw it away. The goal is reducing the risk of a technical problem or increase the reliability of a user story’s estimate.

When a technical difficulty threatens to hold up the system’s development put a pair of developers on the problem for a week or two and reduce the potential risk.

So a spike should be the minimum work required to demonstrate the suitability of the solution, reduce the risk and help estimate the overall effort. Now to a problem outside of programming…

I’ve been meaning to replace the battered wooden lattice around the base of my deck that is attached to my house for several years. I was planning to use a plastic material (plastic lattice sheet and accompanying edging with a pre-cut channel) rather than wood so it is maintenance free and doesn’t rot. I used this plastic lattice and edging the previous year on a project, but was not happy with the way I assembled the lattice to the frame to form a panel.

I realized I was procrastinating on the deck lattice replacement project because of my previous mediocre experience with the plastic material coupled with the fact that I was not sure how long it would take, how much material I needed, what it would cost, and most importantly how I would anchor the finished panels to the base of the deck.

Furthermore, underneath the deck there are no vertical supports on the edge of the deck to which I could screw the panels. As a result, I was not sure how to fabricate and install the appropriate vertical supports without making this a huge production. And I also wanted to make sure the decorative panels were built to last and didn’t fall because they are not secured properly.

Then it occurred to me, I really needed to do a spike to better understand what I was up against. To remove the unknown, determine the effort involved and material needed. I had some scrap lattice and frame left over from my previous project, so I assembled a small panel the way I thought I wanted to do the whole deck. Given that it was a spike, I was prepared and expecting to throw out the panels I was building, just like I would do with code on an agile development project.

When I positioned my first panel in place below the deck, it fit beautifully and I was able to find two excellent and easy locations to secure vertical posts to which the panel was screwed. I was feeling good, but realized that the panel I installed was different from all the other locations and that it was likely easier to install. So, just like with software, if you find your spike does not represent the true unknown, you need to continue the spike. So I decided to continue building a second panel that would be installed in a more typical and potentially more difficult location.

After building the second panel, I held it in position and pondered how the heck to install it without any vertical supports. At this point, it would have been extremely helpful to have a pair carpenter to collaborate with on ideas, but I was out of luck, I was alone. After inspecting the way the panel met the bottom of the deck I realized an easy and hidden way to use metal strapping to secure a post just about anywhere I needed a post. Using this technique, I was able to successfully and easily screw the second panel to its supports. At this point I felt I learned enough and brought the spike to an end.

Photo of one installed panel that was built during the spike

With the information I learned from the spike, I was able to estimate the materials needed, the cutting I had to do and the time to cut, assemble and install. Given these discoveries I knew how much it was going to cost and roughly how long it would take to build and install the remaining panels for the deck.

Just like with code built in a spike, I ended up discarding the first two panels I built during the spike because I built them with an emphasis on experimentation and was not concentrating on quality.

The most significant benefit from the spike was the pressure lifted from my shoulders by just committing to do a single panel in a spike and letting go of the complexities for the remainder of the deck skirt. Just like in a software spike, I only addressed the problem under examination and ignored all other concerns. That shift in mindset was freeing!

There are differences in evaluating and comparing open source software (OSS) products, as opposed to commercial packages. A number of key OSS criteria are also described. This information is based on years of experience at Redpoint , using OSS and evaluating both open source and commercial software for clients.

Evaluating OSS effectively requires different criteria than the ones used for commercial software. Commercial software selection techniques and tools are inadequate in making informed choices about OSS. Different OSS products will have strengths in different functional and technical areas. Some are growing and vibrant with strong growth in the developer and end-user community, others may be stagnant.

The traditional commercial software evaluation process involves establishing software requirements/functionality evaluation criteria, reading industry analyst reports, meeting with sales and technical pre-sales teams and negotiating licensing and support costs. An in-depth evaluation of commercial software will involve talking to a few reference customers and reviewing the financial stability of the software vendor and the longevity of their product.

Much of the information that is used for the commercial software evaluation is obtained from the software vendor’s sales team. When evaluating OSS, there typically aren’t any sales teams, no on-site demos by the sales team, no glossy sales brochures that highlight product advantages, no advertising and, as a result, the process needs to be different. Also, unlike commercial software, it is not always easy to determine who else is using an OSS product.

Industry analyst reports on OSS are scarce and the information is usually limited. Typically, OSS evaluations focus on the few leading OSS initiatives such as Apache, Linux, MySQL, etc. When evaluating an open source software package, it is important to focus on the following categories:

• Product Capabilities
• Quality
• Integration and Dependencies
• OSS Community
• Support

Product Capabilities

It is usually easy to identify and verify the capabilities of an OSS product. Most groups clearly document their features and exaggerations of their capabilities are not typical as they will generate support email and unfavorable discussions in their community. Also, these groups are typically looking for developers to implement their missing feature so they have an incentive to be honest about the capabilities.

Open source products many times have a different focus because of their origins or because of the influence of the developers that initially developed it. Also, OSS tends to evolve and sometimes take on different focus. It is important to consider the focus of a product and how it has evolved to get an indication of where the product may evolve in the future.

Although all OSS can be modified, it is important to understand what modifications are in-line with the product direction so they are within the upgrade path in the future. Most CRM OSS provides a mechanism to customize the software. However, the technique and range of customization that is allowed varies greatly among the products.

Quality

In addition to inspecting the code, development approach, documentation, build environment, testing strategy and general product literature, inspecting the bug database, which is usually public, is a good way to understand the number of bugs in a system. This will indicate the number of high-visibility bugs outstanding and the length of time it takes for typical bugs to get fixed.

Integration and Dependencies

Most OSS list the other OSS or commercial products with which they integrate. The products with which they integrate and the way in which the OSS integrates often says a lot about the general integration mechanism that is available in the product.

Product dependencies also give an indicator of how the product is intended to be integrated. Many times the dependencies are available explicitly from the OSS literature, other times it must be inferred by reviewing the installation and support documentation.

OSS Community

OSS projects can vary from a single developer to a distributed, world-wide, company-backed team. It is important to understand the project structure, its backing and its motivation. Some products are developed by commercial companies attempting to make their money from the customization, support and training. Other projects are only supported by key alliance partners that are a result of the OSS community.

Ideally the team is more than a single developer, but sometimes a very large, distributed team can hinder the ability for the product to have a clear, concise vision and to make targeted release dates.

The strength of the community is best gauged by the support and activity of the OSS wikis, forums and mailing lists. Typically, there are two mailing lists – one for users that includes help installing, upgrading, etc. and another list for the developers to discuss bugs, the roadmap, new features, etc.

Development Process and Source Code Control

The quality and development process is another important consideration for OSS that is not typically available for commercial software. The code can be reviewed and checked for adherence to general product and industry best practices and coding style.

The testing techniques used are also very important. Even if it is not documented, a quick check of the build script will typically reveal whether any unit testing is incorporated into the project. Overall, the software should have some documentation – both from an architectural and code-level perspective.

Even if you don’t plan to alter the OSS source code, it is important that the system can be built (i.e. compiled). Even if you don’t intend to contribute back to the OSS community, it is important to be able to rebuild the system if a show-stopper bug were encountered.

The release management techniques employed by the OSS development group is important. A quality product does not necessarily have a robust release process and does not necessarily have any easy upgrade path. A feel for the release process can be determined by reviewing the release notes with previous builds and determining whether frequent bug releases are distributed shortly after major product releases.

Support

The first level of support for typical OSS is by the community having access to the source. Many OSS bugs are identified and fixed by developers that use the product. Some fix and contribute back the fix to help ensure it is fixed in a future release, not because they feel they have to contribute to the community.

In order to perform fixes on the OSS source code, it must be logical, easy to understand and proper documentation must exist. Some documentation may be in-line in the source code and other documentation will vary from on-line to PDF format.

Most major OSS products have paid support options. This support can range from first-tier support, where the vendor will act as your first-line help desk, to second- and third-tier support where internal support will first attempt to identify and fix a problem before it is escalated to the paid support. The cost of the support decreases as the company takes on more initial support roles (e.g. help desk).

Paid support can range from typical commercial-style maintenance contracts to per-incident agreements. It is important to understand the typical turn-around time for support under the various support agreements.

At Redpoint Technologies, we’ve been evaluating many of the services offered by leading cloud vendors in order to better understand where various cloud offerings are most appropriate. Like any technology, it is important to understand each offering’s strengths and weaknesses.

Today I executed some crude performance tests against the Rack Space Mosso Cloud Files offering. This is very similar to the Amazon S3 storage offering. It allows files to be uploaded to the Mosso cloud server where they can be later retrieved. The service offers no minimum or maximum in overall storage, but does limit individual files to 5GBs or smaller, and utilizes utility-style pricing.

Cloud Files optionally allows you to store your content on a content delivery network (CDN). A CDN is an infrastructure of servers located in different geographic locations that work together to rapidly deliver web content to users based on their geographic location. As a result, a CDN can dramatically increase the speed with which content is delivered/retrieved.

Major Considerations

Depending on your needs for uptime, Mosso offers what I’d consider the minimum availability with a 99.9% uptime guarantee for Cloud Files. This means the service may be down about 10 minutes per week or roughly 40.5 minutes per month. For many applications, that is acceptable, but for mission critical situations, this may not be enough.

The following table summarizes many of the considerations and the description for how these considerations are addressed by Mosso.

Performance

For an upcoming distributed, grid-based project, I’m interested in the speed with which I can upload gigabytes of data to a temporary storage location.

The performance of Mosso was decent when using their API, but dreadful when uploading via their web-based interface (but to be fair, the web interface is more for account management and less about use in a production system). The overhead of SSL was surprisingly minimal (as compared to raw FTP - see below as this was not an exact comparison).

I used a 24.9 MB bitmap file as my test file to measure performance for uploading files to Mosso (additional tests around downloading would be worth while testing as well). I tested uploading the test file via the Mosso web interface, using the Mosso API from a .NET application (see the c# console application code below) and to this blog site via FTP to have a non SSL benchmark.

I ran each test several times and throughout the day from my cable modem (which scores between 712 to 2550 Kbps in a browser-based connection speed tests). The results from each run were pretty consistent. On average, it took about 6.25 minutes to upload the 24.9 MB test file to Mosso via the Mosso web interface (control panel), about 3.5 minutes to upload the 24.9 MB test file to Mosso via the Mosso API using the below application and about 3.25 minutes uploading to this (shared .NET hosting) blog site using Filezilla.

The results were satisfying in that my raw FTP upload (to a non-Mosso server) were just a bit faster than the Mosso upload that uses SSL. In my brief testing the service was reliable and I like that the Mosso session could be cached indefinitely in a custom application (unlike the web interface that timed out my session after about 20 to 30 minutes of inactivity).

.NET Test Application

You can use the code below to create a C# console application that will upload a file to Mosso’s Cloud Files service. (Please note that you will need to purchase an account at Mosso prior to being able to run this code.) Prior to building/running the application, you need to add a reference to the com.mosso.cloudfiles .NET assembly that is included in the lib directory of the free download that includes the Mosso .NET sample code. And don’t forget to provide meaningful values for the string values in lines 16, 18, 20 and 22.

Although it would be easy to add an upload timer to the code below, I used a physical stopwatch to capture the time for my upload tests.

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:  using com.mosso.cloudfiles.services;

   6:  using com.mosso.cloudfiles.domain;

   7:  

   8:  namespace MossoPerfTest

   9:  {

  10:      class Program

  11:      {

  12:          static void Main(string[] args)

  13:          {

  14:              Connection connection;

  15:              // get your user name from mosso at sign-up

  16:              string username = "your-user-name-here";

  17:              // get this from mosso console once you have an account

  18:              string api_access_key = "your-key-here";

  19:              // containers are top-level "folders" for your data files

  20:              string container = "your-container-name-here";

  21:              // fully-qualified filename you want to upload 

  22:              string fileName = @"C:\your-filename-here.txt";

  23:              try

  24:              {

  25:                  connection = new Connection(

  26:                          new UserCredentials(username, api_access_key));

  27:                  connection.PutStorageItem(container, fileName);

  28:              }

  29:              catch

  30:              {

  31:                  Console.WriteLine(

  32:                          "Authentication failed or file upload failed");

  33:              }

  34:          }

  35:      }

  36:  }

Conclusion

In conclusion, you need to be strategic in thinking where you’d use a service like Cloud Files from RackSpace’s Mosso. We would use a service like Cloud Files for storing large files if we could queue them up and upload them asynchronously from our system. Or, perform a synchronous upload if the file was small enough.

From the Mosso’s marketing material, they state that Cloud Files is good for:

• Backups/archives of your data
• Serving images/videos (streaming data to the user’s browser)
• Secondary/tertiary, web-accessible storage for your data
• Well suited when amount of storage is difficult to predict
• Simple point-and-click interface via Mosso Control Panel

But that it is not so good for:

• Native support within your Operating System. It is not yet possible to “mount” or “map” the Cloud Files storage system as a virtual hard-disk on your computer.
• Disk mirroring or backup solutions that require byte/block level differences. There are no concepts of “append” or “file locking” operations within Cloud Files.
• Data can be organized into storage compartments called “Containers”, but they cannot be nested. Since there is only one top-level of Containers, you will not be able to upload a nested directory/folder structures into Cloud Files unless a transformation is performed to flatten the structure.

Some of you are blessed with the ability to drink coffee or tea at temperatures that seem to be approaching the temperature of lava. Unfortunately, I’m always trying to find ice or cold water to cool down my drink whether I just brewed it at home or bought coffee from a cafe.

So it is not surprising that a Smart Coaster Popular Science Build It project by Dave Prochnow caught my eye. This is a pretty simple circuit that uses a thermistor to measure the temperature of your hot drink. You calibrate your coaster to illuminate an LED while the temperature of the drink is too hot and to turn off the LED once the temperature reaches the point where it is cool enough to drink. I like the author’s use of a shoe polish container, but all I could get my hands on was an ever-so-versitile Altoids container.

Like the author explains, once you have your circuit built and tested, you need to calibrate your potentiometer to turn off your LED just when the temperature of your drink is ready to drink. I taped my thermistor to the underside of the top of the metal enclosure, but still found it a bit tricky to get the potentiometer set properly. When you are calibrating, you need to make sure you use the same type of coffee cup or else you will get very inconsistent results.

My finished product is below. As you can see, the LED sticks out the front and I also have my potentiometer sticking out the side of the enclosure. With the Altoids box, it is easy to have wires hang outside, but be careful as repeated open and closing quickly wears away the insulation on the wires!

I initially prototyped the circuit on a breadboard, like I do for any new circuit I’m building or experimenting with, and used a plastic (note metal would not be good here given that it would conduct and cause your battery to get extremely hot!) chip clip to hold the positive and negative leads onto each side of the flat, disc-shaped battery. In the enclosure I built a home made 3.7V battery holder by putting the battery in the top of an old 35mm camera film case and used hard plastic to cover the bottom. I cut a small hole in the top and bottom to route a wire with a long, uninsulated lead (that was swirled into a spring-like shape) into each side of the battery enclosure. Finally, I taped the home made battery enclosure with electrical tape to keep the positive and negative wires snug against each side of the battery. It looks pretty ugly, but works great.

Below is a picture of the inside of the enclosure where you will see the battery holder on right side, the tangled mess of wires and the thermistor taped with electrical tape to the bottom of the lid:

And I used the dead bug method to solder the LM324N Integrated Circuit (IC) into the circuit. This is a technique that is popular in robotics where space is limited. This technique is nothing more than turning the IC upside down, with the legs sticking up (so it looks like a dead bug on its back with its legs up in the air) and soldering your connections directly to the legs of the integrated circuit chip. If I had an IC socket handy I would have used the dead bug technique to solder directly to the empty socket and would have avoided the risk of damaging the circuit by soldering it directly. Fortunately, I did not damage the IC by soldering directly to it. By clipping the unused legs of the IC, it made it a bit easier to solder directly to the IC legs.

Finally, I’d highly recommend that you use a stripboard or create a printed circuit board for this circuit. The article does not advocate the use of a board and in the excitement to build the smart coaster I did not use a board…but shortly into the project remembered how frustrating it can be to solder everything together and then struggle to get the circuit into its enclosure without breaking any solder joint. With a strip or circuit board the circuit would easily sit in the enclosure with the LED, thermistor and potentiometer connected via lead wires.

In retrospect, I also recommend that you use very light gauge wire for any wires that will require flexibility and that you intend to move around. Otherwise, you end up breaking solder joints as you move the components around.

A few items worth noting if you are building this project:

• You can always identify leg 1 of an IC by finding the dimple in side of Integrated Circuit (IC) and then finding the first leg that is counter clockwise to the dimple. Sometimes, leg 1 also has a dot of paint near it. My LM324N IC had the dimple, but not paint. Below is the block diagram that displays the dimple at the top and leg 1 on the top left.
• 

• I recommend that you purchase a battery holder for your 3.7v battery. Here is a battery holder available from SparkFun.com. You will still need to wrap your battery and holder in lots of electrical tape to make sure a metal holder does not conduct against the side of the smart coaster (assuming your enclosure is metal).
• I would highly recommend that you use a heat sink if you are soldering your IC using the dead bug technique. This will draw heat from the leg and minimize the chance of damaging your IC.
• Whether you use a board or not, you should make sure you have a helping hands or other desktop vice to hold your parts in place while you are soldering.
• Get some heat shrinking insulator material and slip the heat shrink tubes on your wires prior to soldering. This way you can easily cover your soldering joints and exposed metal inside your crowded, metal enclosure. And for places where you cannot easily use heat shrink tubing, use plenty of electrical tape.

For Christmas my wife and kids bought me an iHome iPhone alarm clock. My first impression was good, I thought it would be nice to have a home for my phone at night and be able to listen to music in our bedroom.

iHome Alarm Clock

But, what I didn’t realize was that it would be incredibly convenient to capture todos/thoughts while lying in bed prior to falling asleep. I’m not sure if this is common, but all sorts of things fly though my head when I’m relaxing at the end of the day. I think of things I didn’t get completed (not too many!), but also have many creative thoughts.

Prior to my cool new iHome alarm clock, I kept a notepad and pen in my nightstand to capture thoughts, but it requires the light to be turned on to see what I was writing. With the backlit iPhone right by the bed, I can capture notes in the dark and, best of all, my GTD next actions are already in my official GTD system and don’t require any further thought.

Aside from GTD, it would be a shame if I didn’t mention how great this iHome alarm clock really is. Like the iPhone’s visual voicemail, which is easy to maneuver and use, the iHome has a visual display for setting the alarm…and the alarm time is always visible on the display, so I always know whether the alarm is set and if the alarm time is correct.

Regards,
Matt

Late last month (November 18, 2008), Amazon Web Services (AWS) announced the public beta of a new service for content delivery. The new Cloud Computing service, CloudFront, provides developers an easy way to distribute HTTP content to end users with minimal latency delays and provides high data transfer speeds.

CloudFront integrates with other AWS services and, like the other AWS services, does not require any long-term commitment or expensive upfront cost, has the self-service account interface and utility pay-as-you-go payment model.

CloudFront is exciting because it provides a mechanism to deliver HTTP content throughout the world by leveraging the Amazon network of edge servers. These edge servers are distributed throughout the world in order for the content cached at these servers to be physically closer to the end users in order to lower the latency in delivering the content.

CloudFront integrates with AWS S3 by allowing you to store the original versions of your data in an AWS S3 bucket (S3 is Amazon’s Simple Storage Service, which is a web service that allows any size chunk of data to easily be stored and retrieved). The beauty is that the original data objects can be stored in S3 and, after a simple registration process, are seamlessly accessible through the AWS edge servers throughout the world.

At the moment, the dominant players in the Content Delivery Network or Content Distribution Network (CDN) space are Limelight, Akamai and CDNetworks. CDNs are used by most high-scaling websites including, for example, MySpace.com and the National Basketball Association (NBA). The CloudFront offering in this space provides a lower-cost alternative to the existing players.

It seems the excitement and use of Class, Responsibility, Collaboration (CRC) cards has diminished over the years. But with an emphasis on agile development approaches, it seems there is a rise in simple, yet powerful approaches that are low tech. The barrier to entry for CRC cards is pretty low…you just need a pile of 3″x5″ or 4″x6″ index cards and a pen.

Are CRC big upfront design? I don’t think so, but it is a potentially conflicting with Test Driven Development (TDD). I see the greatest value of CRC cards as a way to get a sense for the initial high-level design and not a way to work through the design of every low-level class in a system. This may be most useful in the case of a service oriented system, for example, where you may desire a bit of focus up front on the exposed external interface. Or better yet, a way to talk through a design if you get “stuck”. The downside of CRC cards is that you are not keeping a client-oriented view like you do when using TDD. A client-oriented view is critical to good design and is one of the natural advantages to TDD.

Back to CRC cards…The idea is that each physical index card represents a single class or interface. Each card should have the name of the class at the top, the class responsibility (note that conscious choice to make this singular) on the bottom left and the classes with which the given class collaborates on the bottom right.

CRC Card

I like the smaller 3″x5″ cards because you want to be constrained by space. If you write your class responsibility (typically captured as bullets) and you find that you are running out of room on your card because it is requiring too many bullets, you have already identified that you are likely violating the SRP and you need to break the class up into separate classes or at least rethink your design. If you run out of space for your collaborations, you also likely have an issue.

I like to arrange the cards physically on a table so they are arranged close to their collaborators. The process is typically done with a pair or group of developers and involves a lot of discussion as the cards are created and modified. The cards are a jumpstart mechaims, and like many other artifacts in an agile project, they will be discarded and the software will take on a life of its own.