<p>After several false starts, the convention for how to organize a solution seems to have come together. This also includes how to change the default project settings, and how to keep everything tidy as the software grows.</p>
<h3>Vigil.Data Solution</h3>
<p>This solution will contain all projects in the Vigil.Data namespace. This includes the central collection of Entity Framework data models, projects for DDD Bounded Contexts, and each project needed for services. There will be future solutions for the web projects, automated routine projects, importing pipelines, export processes, etc.</p>
<ul>
<li>Vigil.Data.Code: where the Entity Framework Code First data models exist, including necessary abstract classes, interfaces, and extension methods.</li>
<li>Vigil.Data.Modeling: contains all of the Entity Framework specific code that pertains to modelling the data into the data store (database), including the DbContext, Database Migrations, DbInitializers, and interfaces. This does not include any bounded contexts that may exist in the future.</li>
<li>Vigil.Data.Services: services (which handle the business rules and workflows), specific-use data models, data mappers, validation, and supporting interfaces will all reside in this project.</li>
<li>Vigil.Testing.Data: all unit tests will be rooted in the namespace Vigil.Testing, with the sub-namespaces reflecting the project(s) they are testing. Thus, this will have all of the tests for the Data projects.</li>
</ul>
<p>Once these projects are created, there are three property pages that I immediately change from the defaults.</p>
<h3>Assembly Information</h3>
<ul>
<li>Check the Company and Copyright information to make sure they reflect the project that I am creating (and not the computer's defaults).</li>
<li>Set the Assembly Version to 0.1.* (default the Build and Revision Numbers)</li>
<li>Set the File version to 0.1.0.0</li>
</ul>
<p>Later, as the project grows and meaningful features are added, I will manually increase the minor version number as appropriate. Maybe even increase the Major Version, too!</p>
<h3>Signing</h3>
<blockquote>
<p>Benefits of strong naming your assembly first:</p>
<ul>
<li>Strong naming your assembly allows you to include your assembly into the Global Assembly Cache (GAC). Thus it allows you to share it among multiple applications.</li>
<li>Strong naming guarantees a unique name for that assembly. Thus no one else can use the same assembly name.</li>
<li>Strong name protect the version lineage of an assembly. A strong name can ensure that no one is able to produce a subsequent version of your assembly. Application users are ensured that a version of the assembly they are loading come from the same publisher that created the version the application was built with.</li>
<li>Strong named assemblies are signed with a digital signature. This protects the assembly from modification. Any tampering causes the verification process that occurs at assembly load time to fail. An exception is generated and the assembly is not loaded.</li>
</ul>
<p>—Why use strong named assemblies? answer by Kyle Rozendo</p>
</blockquote>
<h3>Code Contracts</h3>
<ul>
<li>Set the Assembly Mode to "Standard Contract Requires"</li>
<li>Enable Runtime Checking at "Full"</li>
<li>Set the <a href="http://stackoverflow.com/a/17892803/28310">Contract Reference Assembly</a> to "Build"</li>
</ul>
<blockquote>
<p>Initial projects for the Core data models, data modeling objects, data services, and data testing.</p>
<p>Added public assembly signing, code contracts, application versioning, and copyright notifications.</p>
<p>—<a href="https://github.com/drovani/Vigil/commit/527fabb81ff6383f8ece46848feb2e329c131201">Commit 527fabb81ff6383f8ece46848feb2e329c131201</a></p>
</blockquote>


Vigil.Data Solution and Initial Projects

<p>There are many posts out there for how to configure a database schema to handle scheduling events. The part that I found difficult to find was an algorithm for calculating future dates for each type of recurring schedule. I have started this series on Recurring Gifts as a way to document the process I went through to build the current system. Some features include:</p>
<ul>
<li>Ability to scheduled gifts by daily intervals, weekly intervals, monthly (by date) intervals, and monthly intervals by relative point. From there, it is simple math to do Quarterly, Yearly, or any other multiple.</li>
<li>Ability to place gift generation On Hold until a certain date.</li>
<li>Ability to Cancel gift generation on or after a certain date.</li>
<li>Ability to makes changes that apply on a certain date.</li>
<li>Easy to answer the question of "why was this gift created" because all gifts are linked to the schedule that generated it.</li>
</ul>
<p>A few limitations that may constraint its universe utility:</p>
<ul>
<li>Only one active schedule can be created. Can only do "first Friday of every Month", not "first Friday of every Month, and third Tuesday of every other Month."</li>
<li>Cannot schedule by the phase of the moon (not even joking ? this was an actual request) ? though it could be fudged by using a Daily schedule.</li>
<li>Cannot schedule based on National Holidays (also an actual request).</li>
<li>Schedules can only pause and restart once (via the Header.HoldUntilDate).</li>
</ul>
<h2>Database Schema</h2>
<p>Instead of inventing a database schema from nothing, I did what I do best — stand on the shoulders of giants, and Microsoft's SQL Server team is a pretty huge giant. Turning to their documentation on the <a href="https://msdn.microsoft.com/en-us/library/ms178644.aspx">SQL Server Agent job schedules</a>, I opened up the msdb.dbo.sysschedules table. I adjusted some of the definitions to fit my need and built my schema from there.</p>
<h2>Schedules Data Schema</h2>
<p>There were three major changes that I made to the SQL schedule.</p>
<ol>
<li>Frequency Interval, for weekly recurrences, is a bit flag in the SQL Agent schema. Since there is already an enum in the mscorlib, I changed the schema to use the System.DayOfWeek enum values.</li>
<li>Frequency Interval, for monthly relative recurrences, uses 1-7 for Sunday-Saturday, 8 = Day, 9 = Weekday, 10 = Weekend day. I only need the days of the week, so it made sense to also adjust this to use the System.DayOfWeek enum values.</li>
<li>I dropped all notion of "sub day" scheduling. There is no need to have gifts created at multiple points in a day.</li>
</ol>
<p>A common approach to handling querying the event dates is to store a list of all future dates. I can also use this to determine when
the gift was actually created, and use this as an audit for gift creation. By tying the Audit to the Schedule, it is very easy to find
out exactly why an Audit was created.</p>
<p><img src="/images/recurring-schema.png" alt="Recurring Schema"></p>
<h2>Evolution Path</h2>
<p>There were two mistakes I made in the original implementation of this schema. First, I had the End conditions on the Schedule. The thought was that this would be mildly helpful with knowing why the generation of gifts might have started and stopped. Potentially, a termination point would be reached, gifts would stop being generated, then a new schedule would be added, thus resuming creation. However, the actual hit rate for this situation was zero. All it did was ridiculously complicate the algorithm for parsing the schedules.</p>
<p>Additionally, I previously had the Start Date on the Schedule. This also was confusing, as two schedules could be created and cause a gap in the timeline. It is much more easier to implement one "pause until" setting than try and handle skips. My use case was exactly zero for needing multiple start and stops, which is why I have pulled back on the complexity a bit for this second round.</p>
<h2>Up Next</h2>
<p>The next post is going to start to demonstrate how I implemented various parts of the C♯ algorithm to generate the dates in a schedule. These collections then are combined to provide for a final list of all dates.</p>


Recurring Gifts — Part 1: Database Schema

<blockquote>
<p>There are only two hard things in Computer Science: cache invalidation and naming things.</p>
<p>-Phil Karlton</p>
</blockquote>
<p>To any seasoned developer, this is entirely too true, and <a href="http://www.quora.com/Why-is-naming-things-hard-in-computer-science-and-how-can-it-can-be-made-easier">many</a>
<a href="http://blog.stackoverflow.com/2009/03/it-stack-overflow-update-naming-is-hard/">people</a> have <a href="http://seesparkbox.com/foundry/naming_css_stuff_is_really_hard">written</a>
extensively on why this is so hard. For this particular exercise, I have to decide what to the call the core object that represents a (potentially) giving unit in Vigil. Trolling through existing applications, here some options I have come across, and why I rejected them:</p>
<ul>
<li>Client - feels too impersonal for a DRM, though I know there are non-profits that use this as their preferred term.</li>
<li>Constituent - the term is mostly used with voting system. Also, I am really loathe to type out "Constituent" thousands of times.</li>
<li>Customer - this term is associated more with a point-of-sale system than a donation tracking system.</li>
<li>Donor - not all names in the database are going to be actual donors. Some will just be people that purchased something, many will not even have given (in a system I recent worked on, around 55% of the names were non-donors).</li>
<li>Entity - this conflicts heavily with Entity Framework, where the Entity object is used everywhere.</li>
<li>Patron - this is a compelling term, since it has the dual definition of being both a person who gives financially, and a customer to a store.</li>
</ul>
<p>The other part of the name is that it needs to pair with all of the auxilary tables that will be prefixed with:</p>
<ul>
<li>______Address</li>
<li>______Attachment</li>
<li>______BankAccount</li>
<li>______Code</li>
<li>______ContactBase</li>
<li>______CreditCard</li>
<li>______Date</li>
<li>______Email</li>
<li>______Identifier</li>
<li>______Note</li>
<li>______Number</li>
<li>______Payment</li>
<li>______Person</li>
<li>______Phone</li>
<li>______Relationship</li>
</ul>
<p>And that's just the preliminary list!</p>
<p>I had initially gone with Entity, since that it is what our current system uses. However, I quickly tired of running into the namespace conflicts with EF, and thus went searching for alternatives. I had almost settled on Constituent, until I went to start the re-factoring and after the twelfth time of typing it, realized it was going to cause <a href="http://www.ninds.nih.gov/disorders/carpal_tunnel/detail_carpal_tunnel.htm">CTS</a>. Patron was a late find that I stumbled upon. Thesauruses are my friends. So far, I am really digging it. I figure I get one re-factoring before I hit the point of no return. I am hoping this is the right one.</p>


Naming the Patron Object

<p>I am not sure why I started using <a href="http://knockoutjs.com/">Knockout</a>, but I have had an overall positive experience with the framework.  I was very intrigued with their hands-on tutorials built into the site, which made getting started fairly easy.  I walked through them step-by-step, writing out all of the code examples by hand, and diligently debugging typos when the example would not execute as expected.  From there, I took the simple step of starting a small side-project just to see how it would all interact.  At that point, it became quickly obvious that the tutorials suck and are missing large pieces of information that are vital to get just a basic application going.  I also found that there are two tutorials that are completely worthless in terms of getting start - they are advanced topics that I still have not found an applicable usage.</p>
<p>However, the tutorials were just an hour or two of my time, and at least got me started.  The most bothersome part is the official documentation on the website.  It is terribly incomplete, and just leads to frustration.  There are lots of hidden features and unexplained function arguments that force me to take trips through search engines, which inevitably lead to a question that someone else posted on <a href="http://stackoverflow.com/questions/tagged/knockout.js">Stack Overflow</a>, which might hint at the answer to my problem.  It has been frustrating to have to wade through the tangled mess of tangential questions and obscure answers to maybe find something similar to my problem.  However, it has also been immensely rewarding to discover new methods of working with JavaScript, better tools for debugging, and simpler ways to manage my code.</p>
<p>The <a href="https://github.com/knockout/knockout/wiki">GitHub wiki</a> is sparse and filled with many empty templates.  The information is not reliable - I am not sure how much of is it accurate as of Knockout 3.1.  So, I am working on slowly putting together better documentation.  As I discover something new or expand on something I already know, I am adding it all to a little sidebar of notes that I keep.  My hope is that I will get enough information that I can meaningfully contribute to the wiki.  I like this project, and it is clear that plenty of other people like it.  I just wish the difficulty to realistically get started was a little lower.</p>
<p>I am trying - this is going to be my <a href="http://opensource.com/life/14/1/get-involved-open-source-2014">first little tiny toe dipping</a> in the big ocean of open source development.  We shall see how it goes.</p>


KnockoutJS Tutorials Suck (But Not As Much As the Documentation)

<blockquote>
<p>The <a href="http://www.asp.net/identity">ASP.NET Identity</a> system is designed to replace the previous ASP.NET Membership and Simple Membership systems. It includes profile support, OAuth integration, works with OWIN, and is included with the ASP.NET templates shipped with Visual Studio 2013.</p>
</blockquote>
<p>In and of itself, it is a very nice and pleasant library that really does integrate nicely into a WebAPI or MVC project.  The template project that comes with VS2013 spins up very quickly and provides the illusion of something that the developer can just forget about.  Were that the case, I would not have this post.</p>
<p>All I wanted was to change the default primary key from a <code>GUID</code> to an int.  My initial thought was to change the default <code>ApplicationUser</code> from inheriting from the non-generic IdentityUser to the generic <code>IdentityUser&#x3C;int, VigilUserLogin, VigilUserRole, VigilUserClaim></code>.  Compiling worked just fine, running caused all kinds of type casting problems.  Why?  Because all of the other classes surrounding the <code>IdentityUser</code> were all coded to the <code>string</code> type (which internally is a <code>GUID</code>).</p>
<p>Thus began the big hunt to find out all of the places where I needed to override, inherit, or otherwise manipulate the library to get the primary key to be an integer. This meant replacing the five main classes that create the authentication and authorization schema:</p>
<ul>
<li>IdentityUser</li>
<li>IdentityRole</li>
<li>IdentityUserRole</li>
<li>IdentityUserClaim</li>
<li>IdentityUserLogin</li>
</ul>
<p>Then I had to create a new <code>UserStore</code> and <code>UserManager</code> to utilize these new classes, and create a new <code>ClaimsPrincipal</code> to store and retrieve the new security identifier (Sid) for the user. Finally, a new <code>BaseController</code> class was created that all other controllers must inherit from, in order to utilize all of this new code.</p>
<pre><code>using System;
using System.Security.Claims;
using System.Web.Mvc;
using Vigil.Data;

namespace Vigil.Web.Controllers
{
    public abstract class BaseController : Controller, IDisposable
    {
        public VigilClaimsPrincipal CurrentUser
        {
            get { return new VigilClaimsPrincipal((ClaimsPrincipal)this.User); }
        }
        protected readonly IVigilContext VigilContext = new VigilContext();

        public BaseController() { }

        protected override void Dispose(bool disposing)
        {
            if (disposing &#x26;&#x26; VigilContext != null)
                VigilContext.Dispose();
            base.Dispose(disposing);
        }
    }
}
</code></pre>
<pre><code>using System.Data.Entity;
using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.EntityFramework;
using Vigil.Data;
using Vigil.Data.System;

namespace Vigil.Web
{
    public interface IVigilUserStore : IUserStore&#x3C;VigilUser, int> { }

    public class VigilUserStore : UserStore&#x3C;VigilUser, VigilRole, int, VigilUserLogin, VigilUserRole, VigilUserClaim>, IVigilUserStore
    {
        public VigilUserStore() : base(new VigilContext()) { }
        public VigilUserStore(DbContext context) : base(context) { }
    }

    public class VigilUserManager : UserManager&#x3C;VigilUser, int>
    {
        public VigilUserManager() : this(new VigilUserStore(new VigilContext())) { }
        public VigilUserManager(IVigilUserStore store) : base(store) { }
    }
}
</code></pre>
<pre><code>using System;
using System.Security.Claims;
using Vigil.Data;
using Vigil.Data.System;

namespace Vigil.Web
{
    public class VigilClaimsPrincipal : ClaimsPrincipal
    {
        public VigilClaimsPrincipal(ClaimsPrincipal principal) : base(principal) { }

        public int UserId
        {
            get { return Int32.Parse(this.FindFirst(ClaimTypes.Sid).Value); }
        }

        public VigilUser VigilUser
        {
            get { return (new VigilContext()).Set&#x3C;VigilUser>().Find(UserId); }
        }
    }
}
</code></pre>
<pre><code>using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Data.Entity.ModelConfiguration.Conventions;
using System.Data.Entity.Validation;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNet.Identity.EntityFramework;
using Vigil.Data.System;

namespace Vigil.Data
{
    public interface IVigilContext : IDisposable
    {
        DbChangeTracker ChangeTracker { get; }
        DbContextConfiguration Configuration { get; }
        Database Database { get; }
        DbEntityEntry Entry(object entity);
        DbEntityEntry&#x3C;TEntity> Entry&#x3C;TEntity>(TEntity entity) where TEntity : class;
        IEnumerable&#x3C;DbEntityValidationResult> GetValidationErrors();
        int SaveChanges();
        Task&#x3C;int> SaveChangesAsync();
        Task&#x3C;int> SaveChangesAsync(CancellationToken cancellationToken);
        DbSet&#x3C;TEntity> Set&#x3C;TEntity>() where TEntity : class;
        DbSet Set(Type entityType);
    }
    public class VigilContext : IdentityDbContext&#x3C;VigilUser, VigilRole, int, VigilUserLogin, VigilUserRole, VigilUserClaim>, IVigilContext
    {
        public VigilContext()
            : base("VigilDb")
        {
            Database.SetInitializer&#x3C;VigilContext>(new VigilDbInitializer());
        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.HasDefaultSchema("vigil");
            modelBuilder.Conventions.Remove&#x3C;OneToManyCascadeDeleteConvention>();
        }
    }
}
</code></pre>
<pre><code>using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.EntityFramework;

namespace Vigil.Data.System
{
    public class VigilUser : IdentityUser&#x3C;int, VigilUserLogin, VigilUserRole, VigilUserClaim>, IUser&#x3C;int>
    {
    }
    public class VigilRole : IdentityRole&#x3C;int, VigilUserRole>, IRole&#x3C;int>
    {
    }
    public class VigilUserRole : IdentityUserRole&#x3C;int>
    {
    }
    public class VigilUserLogin : IdentityUserLogin&#x3C;int>
    {
    }
    public class VigilUserClaim : IdentityUserClaim&#x3C;int>
    {
    }
}
</code></pre>
<p>At this point, I am wrestling with the fact that now my domain model has a hard requirement on the <code>Microsoft.AspNet.Identity</code> library. I had initially hoped to have my <code>User</code> and <code>Role</code> domain models be completely separated from the actual authentication/authorization system. This creates a hard link that is going to be the death of me unless I can find a way to isolate the framework and run unit tests without requiring the database. For now, though, I am going to continue in this direction, and turn a blind eye to the technical debt accruing from this decision. Maybe before I ship this, I will find a better way to do it all, but for now at least I have my integers.</p>


All I Wanted Was an Integer Primary Key

<p>For any serious runner, looking through training plans inevitably leads to the discovery that they all want you to do hill repeats.  Hal Higdon (basically the godfather of running in Chicago), recommends that <a href="http://www.halhigdon.com/training/51142/Marathon-Advanced-2-Training-Program">hills be a quarter-mile</a> or longer.  If you have never been to Chicago, allow me to clue you in - the city is flat.  The largest and longest "hills" we have are the on and off ramps for the expressways.  Finding long stretches of elevation are difficult, and I cannot think of any that are a full quarter-mile long.  However, here are a couple of spots that I have found that make for at least a somewhat noticeable incline.</p>
<ul>
<li><a href="https://goo.gl/maps/j2txxh9e2oK2">Lincoln Park</a>, just north of North Pond, near the entrance to the Diversey Yacht Club.  It is long enough to at least make you feel it, though it is not very steep.  There are lots of trees around, so it is nice and shaded during hot days.</li>
<li><a href="https://goo.gl/maps/xVUTgSYVe3y">Cricket Hill</a>, between Lake Shore Drive and Montrose Beach.  This staple of the Montrose Beach area has a gentle incline for the first half, and then a steep incline for the last half, rising about 45 feet from the base.  The north west side of the hill is currently <a href="https://www.dnainfo.com/chicago/20140514/uptown/playing-fields-by-cricket-hill-getting-2-million-upgrade">under construction</a> while the city puts in a new turf field and an <a href="http://james46.org/wp-content/uploads/2014/04/Lincoln-Park-Wilson-Field-and-Track-Site-Plan.pdf">8-lane running track</a>.  This is going to get a lot of runner attention once it is finished.</li>
<li><a href="https://goo.gl/maps/ZiogKX4rLK72">Solder Field South Lot</a>, south of Burnham Harbor and Solder field, accessible via the Lakefront Trail, this sledding hill is a short but steep incline.  I would estimate that it is about 200 meters from bottom to top, and probably a 30 foot rise.  Nothing spectacular, but we take what we can get.</li>
<li><a href="https://goo.gl/maps/WtgmjEG9AWE2">Horner Park</a>, bounded by Montrose, Irving Park, California, and the river.  The incline is not very steep, and I would be surprised if the hill crested at more than 15 feet.  However, it is about the longest stretch of incline you will find in a city park.</li>
<li><a href="https://goo.gl/maps/Lw5HyrTCFMK2">Humboldt Park</a>, next to Little Cubs Field - more of a grassy knoll than a hill, at least it is something.  Also, there are lots of paths all around Humboldt Park, making for a nice run.  While there, check out the gorgeous field house.</li>
<li>Parking garages - these are spread throughout the city, with lots of them being downtown or at movie theaters.  I have used the one at the <a href="https://goo.gl/maps/Pz3JLRM45SU2">Regal City North</a> a couple of times.  It is not as fulfilling as running on the grass hills, but I find the concrete and cars are still better than trying to run on a treadmill.</li>
<li>Treadmills - the ugliest of the suggestions, but sometimes it is the only way.  Set the thing to the steepest it will go, and start out slow.</li>
</ul>
<p>If I find any others, I will update the list.  My runs are almost exclusively on the Lakefront Path and on the north side of the city, but if I hear of anything elsewhere in the city, I will gladly share it.</p>


Hills In Chicago

<p>It has been almost over ten years since I last bought a backpack, and now I need a new one.  My three primary use cases are while commuting on a Divvy bike, riding on my motorcycle, and generally walking around.  It needs to be comfortable and secure in all three scenarios. Other requirements (in no particular order):</p>
<p>| Requirements | Nice To Haves |
|-|-|
| Padding and ventilation on my back | Separate laptop sleeve/compartment |
| Enough space to hold 15" laptop | Two separate large compartments |
| Pocket with partitions for pens, cables and other small stuff | Exterior side pockets for waterbottle |
| Compression straps for lighter loads | High and low compression straps |
| Sternum strap | Waist strap |
| Rain proof | Built-in Backpack rain cover |
| Secure fit with heavy and/or bulky loads | Harness pocket for Divvy key, hip pocket for phone |
| Ability to secure all loose straps[^2] | Reflective portions for night riding |</p>
<p>After searching around the internet and asking a few friends, I have narrowed it down to three different brands - based on quality, price, reputation, and what I have seen on the backs of other riders. Timbuk2, Chrome, and Osprey.  In alphabetical order, these are the leading contenders right now.</p>
<ul>
<li><a href="http://www.chromeindustries.com/us/en/bags/backpacks/bravo-night">Chrome Bravo Night</a> - the cross compression straps on this back are extremely inviting, though its large roll-top opening is a turn-off.</li>
<li><a href="http://www.chromeindustries.com/us/en/bags/backpacks/cardiel-fortnight">Chrome Cardiel Fortnight</a> - I like the profession look of this bag, and the pockets seem well organized.  One of the pictures shows a pair of shoes in the bag, but something tells me that my colossal size 15 running shoes will not fit quite as well.  The bag certainly does not look as large as other 40 liter packs.</li>
<li><a href="http://www.chromeindustries.com/us/en/bags/backpacks/citadel">Chrome Citadel</a> - I really like the "large zip-around main compartment", in theory it makes getting items out of the bag easier.  I am not sure about having straps that wide on the harness, though.  Another point where I am going to have to try it on it determine if it is a pro or a con.</li>
<li><a href="http://www.ospreypacks.com/en/product/commute_1/momentum_30">Osprey Momentum 30</a> - same as the Radial, no pictures of the backing, though it seems to have a low profile on the back - good for unobstructed views over my shoulder</li>
<li><a href="http://www.ospreypacks.com/en/product/city__trail/quasar">Osprey Quasar</a> - This would not have even made the list if they did not happen to have it in stock for me to try at a store I went to.  However, it was very comfortable with lots of pockets and secure fitting.</li>
<li><a href="http://www.ospreypacks.com/en/product/commute_1/radial_34">Osprey Radial 34</a> - the website does not show what the back padding/ventilation is, so this might get written off quickly once I get my hands on it.</li>
<li><a href="http://www.timbuk2.com/especial-medio-cycling-backpack/435-3-2001.html">Timbuk2 Especial Medio</a> - the entire Especial line looks really nice, and this is my favorite of the three. The feature list is extensive (the video shows them off), though I wonder if the accessory pocket is going to open enough to get to the bottom of the pocket without having to blindly dig around.  Overall, this seems to be the <strong>just right</strong> in sizes between the Tres and Vuelo.</li>
<li><a href="http://www.timbuk2.com/tb2/products/especial-tres-waterproof-cycling-laptop-backpack">Timbuk2 Especial Tres</a> - the roll-top of the backpack could be too much of an inconvenience for me.  With a 40.0 liter capacity, it may be too large for what I need.</li>
<li><a href="http://www.timbuk2.com/especial-vuelo-cycling-laptop-backpack/458-3-2182.html">Timbuk2 Especial Vuelo</a> - the smallest of the Especial line, I think its lack of features and smaller size might not suit my needs.  I want to get a hold of it though, to find out if it is larger than it appears.</li>
</ul>
<h2>Late Additions</h2>
<p>Two different sources suggested that I take a look at Deuter, a company that I had never heard of before.</p>
<ul>
<li><a href="http://www.deuter.com/us/us/hiking/futura-28-34214-119.html">Deuter Futura 28</a> - A friend went through a similar exercise, settled on this, and has been gracious enough to let me borrow it for a little bit to see how it fits. Unfortunately, it turned out have a frame too high to comfortably wear on a bicycle.</li>
</ul>
<h2>Rejects</h2>
<p>While most of these are not inherently bad backpacks, they just do not fit my purpose.</p>
<ul>
<li><a href="http://www.ospreypacks.com/en/product/tech/pixel">Osprey Pixel</a> - main compartment is too small for my needs.</li>
</ul>
<h2>Honorable Mentions</h2>
<p>There were some bags that I came across that had neat little features that are of no use to me, but I thought I would give them a little credit for creativity.</p>
<ul>
<li><a href="http://www.ospreypacks.com/en/product/tech/pixel_port">Osprey Pixel Port</a> - contains a clear plastic pocket under the main flap to hold a 10" tablet (read: iPad), which allows use without removing it from the bag.</li>
</ul>
<p>Some points of interest that I have found in my research.  Osprey's website is tolerable, Chrome's is acceptable, and Timbuk2 blows them both out of the water.  For no other reason than each of Timbuk2's bags include a video showing all of the different pockets, which is as close as I can get to touching and feeling the bag without it being in my hands.  Before I went to a store to actually see how they felt on my back, I had ruled out all of the Osprey offerings.  They would are only still on my list because a sales associate at the first place I went to suggested I try the Osprey Quasar bag. Furthermore, all of the sites need to show what the back looks like on tall models.  <a href="http://www.cdc.gov/nchs/data/nhsr/nhsr010.pdf">5'9' may be average</a>, but their consumers are not going to all be average.</p>
<p>I will be updating these bags as I get some hands-on time with them, and then I will eventually post about which bag I chose and periodic updates.</p>


Rovani's Sandbox

Blog Posts - Page 12