And Even More Turtles!

(Wow, two posts in a just a few days! Must be something really exciting to report.)

And yes, it is something really exciting. This Turtle Graphics project has captured my attention, and I can’t help but work on it. Fortunately, there’s been lots of success, so I can write enthusiastically about recent milestones.

The other day (see last post) I got as far as creating a simple LOGO language parser that could move the turtle forward and backward, turn right or left, and loop a number of times. That was cool, but somewhat limited. Based on the various web articles I’ve found (and even some of the comments to my last post), there’s way more potential awaiting. All I need to do is get variables and procedures functioning, because then I can explore recursive algorithms and fractal geometry.

Procedures turned out to be fairly simple; the layout of the parser mechanism I built adapted nicely to interpreting from different “source” arrays. In my design, the LOGO program is parsed into a String array, which is passed to the Parser with an index pointer saying where to translate next. A “pre-parser” would scan for functions (code that begins with “TO” and ends with “END”), and would copy the function to another array before removing it from the program. Thus, when the parser encounters a call to a function, the code merely locates the function “code” in the other array and calls the parser with it.

Variables were initially simple … until they got complicated. Well, okay, things were fine until I got into recursion. Without recursion, the code that handled variables was straightforward: As the parser encounters a variable, it would add the variable to an array. Each time that variable gets referenced elsewhere it gets retrieved from the array. In effect, every variable was global. No problem.

One of the websites I found (www.turtlegraphics.net) shows this lovely fractal tree, and that was what I was using as a guide for my efforts. I quickly found (or should I say, remembered?) that recursive routines don’t work with global variables. Recursive routines need local (i.e., stack based) variables because each iteration of the recursive routine needs its own data. Figuring a solution to this took a day or two of thinking (no coding). Late last night it dawned on me: I store variables in an array, but that array can contain multiple copies of the same variable. So I quickly wrote a “CreateLocalVariable” function that forcibly adds another copy of a variable to the end of the variable storage array. The “variable retrieval” function scans the entire array, looking for the variable in question. If there happens to be multiple copies, it will report the last one it finds, which will in effect be the local variable! (The only caveat is that I need to remember to remove those “local” variables from the array when the procedure is done.)

Moments later, I had my fractal tree:

So now I have a functional Turtle Graphics / LOGO interpreter. There’s still more that could be added (changeable colors, text support, etc.), but that’s only if I want to turn this into a full blown effort. My intention was to provide high school freshmen with a chance to get a computer to “do what they tell it to do”, as a gentle way of introducing the idea of programming. I don’t think they’ll spend more than a day or two at the most on this, which raises the question of why bother with more.

But, yeah, I’ll probably add more later.

It’s Turtles All The Way Down

As a high school computer science teacher, I’m always trying to find ways to increase interest in this rich subject. Of course, there’s the obvious “the more students who take CS courses, the more my school will need my services to teach CS classes” aspect. But aside from that, I have long recognized that CS is a subject that a lot of students shy away from because they don’t know anything about it. I’ve got a growing list of students who, after taking their first programming class, discover a new passion. The unfortunate reality in my school is that the majority of students take just one class, and making matters worse is that it’s Microsoft Office. (Granted, it’s important that students be functional in Word, PowerPoint, and Excel, but this class hardly qualifies as “Computer Science”.) And since my state only requires one semester of CS to graduate high school, this is all the majority of students will ever see of the computer lab.

About two years ago, my fellow teacher and I began to realize that by carefully changing the Office class, we could do something about this. By selectively trimming away some of the less critical parts of the curriculum, we opened up 4 or 5 days in the semester’s schedule that we could use for enrichment, or as I call it, Explorations in Computer Science. Borrowing ideas from CS Unplugged, I used these days in the past few semesters to teach the fundamentals of binary (thus letting the kids figure out for themselves the “There are 10 kinds of people” poster in my lab), sorting algorithms (they sort themselves by their phone numbers without ever letting anyone see theirs!), and data encryption (sending messages using a simplified ASCII), and we ultimately get into a day or two of extremely basic programming in VB. The students find the material fascinating, and we’ve seen an uptick in enrollment in our programming classes.

This year we have a bit of a problem, however. Doing these lessons after the Christmas Holidays makes the most sense, as I don’t have to worry about anyone forgetting anything important that they learned two weeks of vacation earlier, and I can usually count on a week and a half to two weeks before the start of midterm exams. The nature of this year’s calendar means that there’s two and a half weeks between these milestones, which means … I need a couple three more “out of curriculum” lessons.

Think, think … what can I do, what can I add? The only rough spot I’ve noticed in the past year or so was when starting up VB. The students seemed to have a good footing with the “unplugged” concepts I showed them, they just had a mental hurdle when we got to “now let’s add some instructions to this VB Form we created.” And I’d rather NOT pack more VB lessons on the end, because I don’t want to have the students who DO decide to enroll in a VB class to essentially start over too much when they start that class. So I started thinking about the various “gentle introduction to programming” paradigms I’ve seen or heard of over the decades. Alice is an option, but it seems too big an infrastructure to tackle (from my perspective), and I don’t have a good feel for what can be done in 2-3 days. Kodu similarly looks like a lot to add to a computer system (in the lab or at home); but maybe I just don’t understand it well enough. I even thought about ChipWits (see several past blog entries), but neither my (now ancient) version nor the (forever under development) commercial version seemed finished enough; plus, like Alice, I’m not sure how those lessons could be applied in a real programming environment.

Suddenly the words “turtle graphics” popped into my mind. This was something introduced decades ago, intended to be the “gentle introduction to programming” for the world. The theory was you have a canvass (the computer screen), with a “robot” turtle in the middle. You give the turtle simple commands (“forward 100” pixels, “right 90” degrees, etc.), and the turtle moves on the screen. The permitted instructions make up what was called the LOGO language. The turtle has a pen attached to its tail, so lines are drawn as it moves. Without a great deal of effort, you can create some fairly complex drawings with very simple instructions. Obviously, it never went anywhere, but could I find use here, I wondered. A quick web search turned up a number of links to sites describing the various programs available (Wikipedia says nearly 200 implementations over the years), but I couldn’t find any self-standing versions (not that I looked that long). Geek that I am, my first thoughts were, “I wonder if I could write one?”

I must admit, I impressed myself. Starting from scratch, and a few websites to describe the LOGO language, I had a simple Turtle Graphics program with LOGO interpreter written in VB in about 2 hours. An hour later I had looping. Another half hour and I had file capability (to save and restore your creations).And about three hours later (2.5 spent “thinking”, half hour coding) procedures were working. There’s still more to add (variables, and the “turtle” icon itself come to mind), but it’s quite amazing how quickly this came together. (Click on the image to zoom in.)

The pretty pattern of circles was generated from the eight lines of LOGO program on the left side. Aside from knowing that “forward 2” means draw a line two pixels long, and “right 1” means turn one degree to the right, the rest is entirely easy to understand even for non-programmers, which is the whole point!

Now, how will it be received in the classroom …

Still here?

Wow … I’ve been away for a while … again.

I need to get better at writing in this thing.

Windows Phone apps?

It’s been about a year since I wrote here. I can’t say “had anything to write”, because I’m ALWAYS thinking of things to write, but I never seem to get off my duff and write. I suppose I have to chalk it up to laziness.

Anyway, after a fairly successful FIRST Robotics season (lots to write there), and before I sink into the annual hell called Scheduling (see my last post on that one), I think I found something to write about. Every year in my AP Computer Science class I strive to get as many kids as possible as full of CS knowledge as possible so that they can take a three-hour test and get the highest score possible. Since the AP Exam takes place in early May, it means I have to figure out what to do with my students for the 4-6 weeks (depending on if they’re juniors or seniors) between the test and the end of the school year. Every year I try to find some large-scale, challenging, and above all else interesting programming assignment for them. Over the years I’ve tried Pocket PC applications, XBox games, Facebook apps (that didn’t go over too well), and last year I even tried a text-based Adventure style game. This year a new option presented itself: We’re gonna try Windows Phone App Programming.

My friend Alfred Thompson has blogged for ages about cool things to do in Visual Studio, and recently has been describing how to develop apps for Windows Phones in Visual Basic or C#. Having recently acquired a Windows Phone, this seems to be a fortitous alignments of planets.

So over the next few days or weeks, I might just find a reason to write more. (Who knows, it may just become a regular event.) In any event, I’ll be sure to describe the apps that my students create; there’s some good talent there.

My Annual Scheduling Adventure

 Like every year for the past five, May brings the joys of Scheduling. I get to work with the school’s Registrar, and together we sift through all the course requests and teacher assignments and concoct a schedule for next year that is acceptable to parents, students, teachers, and the administration. For a variety of reasons, the process takes a week or more, and can result in more than a few sleepless nights for all involved.

This year started with a bit of a twist: the woman I’ve worked for the past five Mays announced that she would be retiring at the end of the school year. With those simple words, my world was thrown into a tizzy, because an obvious next announcement could very easily be “And Mr. I will be taking over her duties as Registrar.” That would not have gone over well; I like teaching, and I will fight anyone who decides I’d be better elsewhere.

Fortunately, a quick word with the school President put that fear to rest; the school would be hiring a new Registrar. In fact, in all likelihood I would continue to work with the new Registrar on scheduling, unless s/he decides I’m not needed. This meant that this year I’d better take on the role of the Chief Scheduler, and not just the Registrar’s Assistant.

The normal process of scheduling actually begins in March, when the students of the school go through the course selection process. Working with their Guidance Counselors, they pick and choose from the menu of available courses, aiming to fulfill their graduation requirements and take electives that match their interests. In mid-April, the school sends out the Letters of Intent to the teachers, or invitations to return next year. (Yes, on rare occasions, the Letters of Intent could more properly be called Letters of No Thanks.) My peers and I have a few days to respond with “Yes, I’d like to return” or “No, I’m moving on.” This information would be combined with the student course selections by the administration to figure out how many sections of each class are needed next year, and the Department Chairs would then decide which of their teachers would be in each section. By mid-May these issues are ironed out, and Scheduling can begin in earnest. A week or two of effort later, and the students have their new schedules in hand by the first week of June. That’s how things have run in the past, anyway.

This year, the Letters of Intent were several days late in coming. This lead to the return letters being a week behind (we had Spring Break during that time), and the delays just kept cascading. When all was said and done, we started the process the day before Memorial Day weekend, roughly two weeks later than usual, or about the time we typically target for completion.

I mentioned that the process can take a week or more; this is much longer than most schools, because we take a different approach to scheduling. Most schools employ what’s called Arena Scheduling, which means that a schedule is created based primarily on what the teachers want to teach. The school administration decides on how many sections of each course there should be, based on projected enrollments, and teachers are assigned to those sections. Once everything is finalized, the schedule is opened up to the students, who then build their personal class list from the menu available. If a student can’t make their desired classes fit into the published schedule, or if a class is not available in the semester that they need it, they are out of luck. Their only hope would be to swap out one or more other courses until they can make things fit.

At my school, the administration takes a different view of scheduling. Working with their Guidance Counselors, the students pick the courses they want. The counselors help assure that the students meet all prerequisites, and that they are not overloading their courses to the point of failure. Once all course selections are made, it is up to the school to find a way to make a schedule that will meet most if not all of these desires. It means a great deal of work for us, but a lot more success for the students.

Anyway, the Friday before Memorial Day weekend we loaded the 7,738 course requests made by 859 students from a list of 122 courses (with anywhere from 1 to 10 sections apiece, for a total of 416 sections) taught by 68 teachers in 7 periods and 2 semesters into the school’s database system. I also loaded much of the same data into a number of applications that I’ve developed over the past few years to facilitate the process.

Ah, yes, the process. As I said, the goal is to get as many course successes for the students. What this means is that we to try to arrange the courses (all 416 sections of them) in such a way so that as to get as few schedule conflicts as possible. To achieve this result, we start with the courses that have only 1 section apiece (“singletons” in our vernacular). We place each of them in the blank schedule grid so that no student taking Singleton “A”, who is also taking Singleton “B”, finds a conflict because “A” and “B” are in the same time slot. When this is done, we move to the “doubletons”, then “tripletons”, etc., all the way up to the courses with 10 or more sections (we don’t have a word for that, I’m afraid). Doing things in this order means that we have the greatest chance of getting the least conflicts. The downside is that when we get to the last courses (the ones with the most number of sections apiece), we have the hardest time shoe-horning them into place with fairly even enrollments. When the last course is placed, the schedules of all the students are essentially set, and there’s not much room for adjustments. So if one section of the last course has only 3 students and another has 57, we have little recourse but to “unwind” the schedule a dozen or two courses and try a different pattern. (Yes, backups are a critical way of life for us.)

Extreme variations in enrollment is where we found ourselves last Friday, one week into the process. When the last course was placed, we had wild swings in enrollments in a number of courses, and no options appeared open to us. So Sunday afternoon, shortly after graduation ceremonies for the seniors, the Registrar and I sat down and began a long process of restoring from a very early checkpoint (about 25% through the process) and trying again. Fortunately we were able to “fly” through the task, because several of the key decisions that we agonized over during the week (such as seeing the effects of poor choices, and the resulting unwinding and correcting of those choices) followed the same paths. We worked from about 4pm until after 11, and got to within the last four courses when we called it quits because vision was going cross-eyed. Monday morning, things went remarkably well for us, and by noon we were done. In fact, the schedule looked a whole lot better once completed than it was looking the evening before.

A thorough walk-through followed, checking every enrollment in every section, searching for hidden dangers in the tall grass. Fortunately, we didn’t find any. In the end, only about a dozen students couldn’t get everything they wanted. (Typically this is where the guidance counselor calls the student in to say “you have a conflict, you can’t take AP English and underwater basket weaving,” and the student inevitably drops the lesser course.) We threw the schedule up to the administration, and with their approval the students had their schedules delivered this morning.

Next year, things will be different. All I know today is that I can’t imagine how different they will be.

Well, this is interesting …

Okay, not quite 7 years ago I started a blog. Nothing too exciting or Earth-shattering, just the “Random musings from a former PC Software Engineer now High School Computer Teacher”. Considering what and where I was teaching, and based on the recommendations of a friend, I chose to locate it on theSpoke.com. That gave me a relatively interested audience of students, teachers, and others in the high tech field.

About three years into it, a funny thing happened: theSpoke died. Never got the whole story of why, but it started when management stopped, and the various blogs started filling with spam and other annoyances. When it became obvious that there was no hope for recovery, I jumped ship to a new site, Microsoft Live Spaces. My audience, unfortunately, didn’t seem to follow me, and most of my blog posts were, well, to myself. Fortunately, I happened to stumble upon a tool somewhere (not even sure anymore) that allowed me to transfer the dozens of my posts that I thought would simply go poof when the powers that be deleted theSpoke, so I was able to preserve my own past.

The other day, as I was posting a far-too-infrequent tale, I saw a screen that said “Live Spaces is going away.” Sigh … here we go again. Again, fortunately this transition was almost painless, and I was able to trnasfer my posts here. (Not sure if ALL of them got transfered, theSpoke history might be history!)

Anyway, welcome to my new home. Perhaps someone out there will discover my ramblings, and I’ll get an audience again.

Crazy Train – Update

Sometimes I surprise myself with how easy a project comes together. Let me throw this picture at you:

What you see here is my own recreation of the Candy Train game that was available on the web up until a few years ago. My version is an object oriented version written in VB.NET 2005, and is quickly becoming my favorite arcade-style game that I’ve written, even though it’s not even finished! Right now, the grid of track segments is randomly generated, each segment can be rotated right or left (via mouse clicks) to construct a longer continuous track. The “train” starts off as a red square (actually just a Label object, nothing fancy yet), and it follows the path that you arrange. You can control the speed using the speed adjustment (right now just two speeds, perhaps the finished version will have more?), and your score goes up faster as your train goes faster. Periodically (about 5 seconds) a new “rail car” will appear (shown as the purple square in the middle tile in the bottom row), and you have to flip track segments until your train travels through that tile. When it does, your train gets one car longer, and play continues. About every 10 seconds, one of the tiles starts flashing (the white bordered tile) for a few seconds, and then that tile gets replaced with a new randomly selected tile. This is to prevent you from just arranging a closed circle and racking up points! In fact, when I took the screen shot above, the tile flipped a split second and caused my train to crash.

Okay, I still have much more to go. Most importantly, I want to add better graphic images than just square labels. (Presumably, the code won’t need much modification with this change.) Then there’s all sorts of little things, like level control (have a “station” appear when the train reaches a predetermined length; bringing the train to the station completes the level), better score keeping, and perhaps even sound effects.

Not bad for a week’s worth of coding. This is fun.

Crazy Train

It dawned on me a week or two ago that I hadn’t written any new games in a long time. A bunch of years ago I started periodically to sit down and write a game, usually a recreation of something I had seen before; all of them get written in Visual Basic .NET (which is my favorite language). I’ve written card games (Four Corners, Nickles), board games (Othello, Sorry), puzzle games (Traffic, Sokoban, MasterMind, 3D Maze), and arcade games (Stacker, Klax, Bejeweled); some are one player, some two or more. Some even got ported to my PocketPC. I do it to keep my programming skills sharp, or to learn new skills (like PocketPC programming), but I guess mostly so I can have my own copy of the game. (I once saw a student playing the same game every day in homeroom, and wrote an equivalent on a dare.)

 

Anyway, as I said I realized recently that it’s been a while (a few years!) since I’ve done this, so I started looking around for a challenge. Going through my list of favorites from various gaming sites, I found that one particular favorite seems to be gone. If you search for a game called Candy Train, you’ll see lots of hits, but it’s been taken off PopCap.com where I originally found it. This tells me I found my target!

 

Candy Train (or my version, Crazy Train) has a 7×7 grid of tiles, and each tile has a random train track segments: straights, curves, etc. Clicking on any tile rotates it 90 degrees right or left (based on the mouse button used). A train engine starts in the center tile, and your mission is to keep switching the track tiles to keep the train on the tracks. Periodically a new train car will appear somewhere on the grid, and you have to manuver the train to that tile to pick up the car. The new car will be added to the end of the train, which of course makes it harder to keep a clear path open for the train. After the train reaches a predetermined number of cars, a train station tile appears, and you have to bring the train to the station to go to the next level. Failing to get a tile aligned before the train reaches it will naturally cause the train to crash. Here’s what it used to look like:

 

So a week ago I started writing the game (actually, modifying my Bejewled equivalent, since it already works with an array of picture box tiles). After a little bit I had the grid of tiles, and got them to rotate right or left. (I even got a few of my FIRST students interested, as they would occasionally walk into the lab and see me working on the game. But alas, none of them are in my programming classes right now.) So it got to the point where I rearrange the tiles to make the track any way I wanted … and then it hit me: I needed to get the tiles to know about the track beyond just the image! Each tile needed to know its track’s shape, so that the train (however that would be programmed) could tell if it was entering from the North, South, East or West, and what side it would exit from.

 

After pondering this a bit, I came to the conclusion that I needed to rethink my approach. I needed to NOT use an array of PictureBoxes, but an array of TrackSegment objects that were based on PictureBoxes. Each TrackSegment would know internally what its track looked like (straight, curved, etc.), and would also be able to tell the train object (again, however it would be programmed) where it was on the tile as the train moved along.

 

Tonight, after a few days of start and stop programming (anywhere from five minutes to an hour at a time), I got it working. My train right now is a small red box (just something easily seen), but it will run around the track designed with mouse clicks. (Can’t wait to show the students!) Hopefully there will be more entries in the future to describe my progress.

NH to NYC by bike

I like to ride my bicycle. I’m not a fitness nazi by any stretch of the imagination, but I enjoy getting on my bike and riding for miles at a time. I suppose it started when I was a kid in New York City, and would ride by bike (single speed complete with the sissy-bars and the banana seat) around the block over and over, dozens of times at a shot, because my mother didn’t like us riding in the streets of Queens. As a teen I would ride a salvaged 10-speed bike (which was a lot back then), gradually expanding my range. I brought a bike to college, and during the summers I rode 9+ miles each way to get to my job. After graduating I rode to my job when I lived nearby, or during lunch just for exercise when I didn’t. A dozen years ago I started riding in the Tour de Cure bike-a-thon, raising money for diabetes research 25-100 miles at a time. Riding just seems to always have been part of my life.

 

A bunch of years ago, I started to dream of really long bike rides. Could ride from home to my fraternity house (150 miles); to my parents’ house (240 miles); to Ohio (700 miles)? What would be involved in shipping a bike to the Pacific Ocean (San Francisco, Seattle, etc.) and riding back? How long would it take? I’ve looked into various websites describing cross country bike tours, mused about going it alone, and even started mapping out potential routes. In the past year or two my now teenage daughter Michelle would muse with me, and we’d imagine where we’d go and what we’d see, just for the fun of it. This past winter I started seriously thinking about biking to New York City, aided by the fact that Google Maps recently added the ability to map a bike route. Entering my address and my parents’ address in Queens instantly produced a tour plan … that turned out to be completely useless. You see, Google Maps is now linked with the Rails to Trails Conservancy, who develops and charts bike paths that used to be abandoned train tracks. And, unfortunately, there’s no standard on the quality of the routes: Some are nicely paved and marked, while others barely have the tracks removed! Google Maps for Bikes, which knows to favor bike paths, doesn’t know the difference, and the first route it provided took me to the intersection of Massachusetts, Connecticut, and Rhode Island, and then directed me down a rail trail to Hartford that is little more than a path through the woods. (Yeah, that’s worth going out of my way for!)

 

Anyway, I figured out how to tailor the route to my own liking, and eventually found a route that started at my house, cut through Mass just west of Worcester, went through Conn to Hartford, took a (paved) rail trail to New Haven, and followed the coast of Long Island Sound to The Bronx. From there I figured I could jump the Triboro Bridge to Queens, and in around 250 miles get to my parents’ house. I figured I could ride about 150 miles the first day, get a hotel near Hartford, and complete the last 100 miles on the second day. Michelle and I even started planning on making this trek over Spring Break, biking Saturday and Sunday, resting a few days, and returning before the next weekend.

 

Fortunately, the weather didn’t play nice for us, as it rained both weekends of Spring Break. I say “fortunately” because we really weren’t prepared physically for such a ride, not covering many miles before the end of April. But schedules opened up for us at the start of August, and we decided to give it a shot. We even got an 80 mile practice ride in a few days before hand, to prove to ourselves that we could do it. At my parents’ request, we changed the route a bit, heading for the Bridgeport – Port Jefferson ferry instead of going through The Bronx; this cut the distance to 240 miles or so, making it even more feasible.

 

With bikes loaded with energy bars, twelve pages of maps, and the complete turn-by-turn Google directions, we headed out bright and early (7am) on Wednesday morning, and for the first half of the day things went great. Heading south through Hollis, we jumped on the Nashua River Rail Trail, a dozen miles of paved path that we know well. Skirting around the former Fort Devens Army Base, we hit our first snag: signs that read “Bridge Closed – Detour”. Opting to ignore the barricades, we found a bridge under repair but otherwise passable, so we stuck to the plan. A few miles later, at the end of a long downhill section, we found another set of signs for another bridge closed. Again we went around the barricades, and while this bridge had people working on the bridge, they didn’t mind as we road on the sidewalk. A dozen miles further on, just past the Wachusett Reservoir, we were directed onto River Road. This seemed at first to be a nice, quiet and level road; a quarter mile later we came upon signs saying “Road Closed Ahead”, followed by more barricades. Asking a cyclist coming the other way, we found that the road was closed because it was significantly deteriorating, but was otherwise passable. We also found that it had some significant hills in its two miles; this would be an omen of what was to come. Returning to “real” roads, we found ourselves in an area of Central Mass that consists of very tall, very long hills. And while rolling hills can be pleasant (using the downhill portion to gain speed to carry you over the following uphill portion), these hills were just obnoxious. You couldn’t go fast enough downhill, due to traffic lights, road conditions, or just wind drag, and the uphill climbs were brutal. (We joked that one hill was best climbed with a ladder.) After several hours and far too many miles of these hills, we turned onto Route 9; while a much busier road, it was also smoother and less hilly, so we could try to make up some lost time.

 

Unfortunately, after leaving Rt. 9, a missed instruction put us miles off course. When we passed under the Mass Pike (very near to Six Flags), we found we were not where we thought we were, and had difficulty with our limited maps determining where we wanted to be. A passing cyclist helped us out with directions (and even refilled our water supplies!) but we realized that we were not going to make it to Hartford by evening. Crossing into Connecticut, we found a place to eat in the town of Stafford, as well as the only place to stay (Angelina’s Inn Keeper’s Place Bed & Breakfast) within 20 miles.

 

The next morning we were met with the first rain storm seen in the area in weeks. While this put us about 2½ hours behind schedule, we used the delay to ask the inn keepers about road conditions in the area. They advised strongly to NOT take the roads we were planning, as they had steep hills and numerous switchbacks. Instead they directed us to other roads that began with gentle hills and ended with long stretches of smooth, flat travel; in short, some of these roads qualified as the find of the trip. Heading out at 9:30, we were in Hartford by noon, and a few hours (and a brief rain storm) later we arrived at the Farmington Canal Heritage Trail. This well-maintained, paved trail carries you nearly 30 miles from south-east of Hartford to New Haven … except for a 7 mile stretch in the middle! (Aw, come on guys, you couldn’t connect the pieces?) Arriving in New Haven for dinner, we found a hotel in Milford, and called it a day.

 

On the last morning of ride, we covered the dozen miles and just missed the 10:30 ferry, so by 1pm we were on Long Island. A slow leak in my front tire and a persistent head wind greeted us, but we pushed through the last 45 miles, arriving at my parents’ home in time for dinner. We stayed there for a couple of days, and then my wife drove down with the van and “rescued” us. (Had we not several other appointments in the following week, we would have ridden back as well.) In any event, 243 miles, three days, and a whole bunch of memories!

 

Virtual Bicycling Across the USA

I like to ride bicycle; I’ve done it forever, gone thousands of miles, and have ridden at least a few miles in 11 states (and the Caymen Islands). One eternal life dream is to one day pack up my bike and assorted gear, fly to the west coast, and ride back. I know, it takes tons of planning and practice, but hey, it’s a dream.

Recently I’ve found that a friend from my early years (high school and prior) has a son who’s blogging as he rides from San Francisco to New Jersey. As he tells of his trials and tribulations, he also mentions other riders he encounters and their blogs. So now I’m riding vicariously through three people as they tackle the Sierra Nevada mountains, Utah desserts, and relentless winds. Okay, maybe not the same as actually riding, but its cool to consider how the world has indeed gotten smaller, even if it is still 4500 miles from Pacific to Atlantic via bike.