A fun way to learn the basics of Ruby on Rails:
For more information check out http://railsforzombies.org/
A fun way to learn the basics of Ruby on Rails:
For more information check out http://railsforzombies.org/
Recently, I've been thinking about teaching my 5 year old son to ride a bike without training wheels. We tried to do this a couple of weeks ago and I experienced probably what every parent teaching their child goes through. I spent most of the time holding the bike and running behind him. And by the end of the day, he wanted to put his training wheels back on and I had a sore back.
Yesterday, I watched this video about an organization called Bike New York, a non profit whose mission is "to promote and encourage bicycling and bicycle safety through education, public events, and collaboration with community and government organizations". They run "Teach Your Child to Ride" clinics at parks around New York city and apparently have a very high level of success. After learning about their unconventional training technique, I felt inspired to teach my son to ride again, but this time with a very different approach.
The result — in 24 hours with about 60 minutes of practice, he was riding a bike all by himself. I shot some footage with my iPhone 4 and edited with iMovie 11. Here's the result:
It’s amazing what you can do with an iPhone and a $1.99 app. I’ve been using the Camera+ app on my iPhone 4 for a couple of months. It has a one touch clarity feature that transforms your photos and also provides the capability to add beautiful effects. I’ve been on a couple of recent trips where I also took my digital SLR with me but never used it once. I managed to get all the shots that I needed with my iPhone.
Here are some shots I took in Lake Wenatchee and Issaquah…
For most of my 10+ year’s career at Microsoft, I’ve been in program management roles — from being a program manager responsible for a specific product feature to becoming a group program manager leading a team of program managers. It’s a role that I really enjoy doing and over the years I have learned a lot about the program management discipline from a lot of smart people at Microsoft. This post focuses on the ‘what’ i.e. what do program managers do.
The first thing to note about the program manager role is that it’s an unfortunate job title. As Steven Sinofsky wrote in his blog post PM at Microsoft back in 2005 “program managers do not program, nor do they manage”. Well that isn’t completely true – there are some PMs that write code (although that’s not usually part of a PM’s job) and there are PMs that manage other PMs (but not development and test teams). Also PMs play an important role in not only defining the software product, but also doing the project management.
I like to describe the PM role at Microsoft using the ’3 Ds’ – discover, design and deliver:

In order to understand and frame the landscape, the PM needs to gather as much data as possible about the market, customers, competitors, technology trends etc. There are lots of ways to accomplish this – market research reports, customer feedback, user surveys, usability studies, competitor product reviews, industry reports etc. The goal at this stage is to just gather data and start making some sense of the landscape.
The next step is to analyze this data and identify opportunities, gaps, trends in the market. One useful tool for distilling this data into key information is a SWOT analysis (strengths, weaknesses, opportunities & threats). In simplest terms you identify the strengths and weaknesses of your business/product (internal) and then identify the opportunities and threats in the market (external). Whatever tool you use, the goal at this stage is to develop a deeper understanding of the landscape.
Once the PM understands the landscape, it’s time to clearly define the opportunity. Usually this doesn’t just emerge once you’ve understood the landscape – it takes a little more work. One useful way to develop those ideas is to start discussing your findings with other members of the team i.e. other PMs, developers, testers, product planners, marketing, partners etc. This will eventually get you to a point where you feel good about a particular opportunity and are ready to tell a story.
Telling the story is really about answering the what, who & why questions i.e. what problem are you going to solve, who are you going to solve it for, why does this problem need to be solved etc. By now the PM can clearly describe the landscape and use data to backup key points. You’ll know when you’re onto something when people clearly understand what you’re proposing and why. And when your story not only resonates with them but starts to get people excited.
Once the landscape has been framed, the PM must help define what to build. A good place to start is by clarifying the value proposition i.e. what problems will you solve for your customers. The PM will then work with the team to establish SMART goals including the non-goals i.e. what you will not try to do (in order to manage the project scope). And then work with key stakeholders to define and prioritize the requirements — which will eventually get translated into scenarios.
There’s no silver-bullet for figuring out what to build — as they say, the best way to have great ideas is to have lots of ideas (good or bad). The PM must help foster the right environment for idea generation e.g. establishing brainstorming ‘ground rules’, involving the right people etc. Then these ideas need to be validated using relevant data, evaluating the trade-offs and by continuously asking ‘will this solve our customers’ problem?’. And then the PM must help the team get closure by selecting a concept or idea.
Getting to the right design takes multiple iterations and feedback loops. The PM needs to clearly communicate the early ideas (whiteboards, sketches, emails etc.) and gather lots of feedback on the proposed design. Both functionality and user experience (UX) need to be considered at this stage, so it’s critical to involve UX designers early in the process. After several iterations, the PM should have enough information to start producing the detailed specifications (spec).
The spec is typically a document that provides very detailed information on how the final product should look and function. But in an agile world, it’s sometimes more effective to write a shorter spec and communicate the details of the design with a prototype. In some cases, this could be a set of design comps and in other cases it could be a working mockup of the final product. There are lots of great prototyping tools available — a couple of my favorites are Balsamiq and iMockups for iPad.
In this phase, the PM’s job is to ensure that the product team ships the right product on time. This means working with the rest of the product team (development and test) to understand work item estimates, develop a schedule and make the right trade-offs e.g. cutting features if necessary. The PM must take on a leadership role in developing a solid plan with the rest of the product team and effectively anticipating and identifying potential issues.
The PM also spends a lot of time refining the plan during this phase e.g. clarifying requirements, working with developers to resolve feature design challenges etc. And with so much focus at this stage on how to build the product, it can be easy to sometimes forget why you’re building it. So ensuring that everyone keeps the big picture in mind is critical. The PM needs to continuously remind the rest of the team about the value proposition and ensure that the final product will actually solve the customer’s problems.
As early versions of the product become available, the PM can start to get real user feedback e.g. is the product intuitive to use, does it address the real world scenarios, do customers actually like what they see etc. This provides the product team with incredibly value information about the product they’re building and it’s an opportunity to refine the design and make additional improvements to ensure that the team ships the right product. It can also help to identify major customer issues that may require the team to go back to the drawing board.
And finally, the PM needs to provide effective communication across the board. There are always a lot of moving parts on any software development project and the PM is the key person to ensure that everyone on the team knows what’s going on i.e. status of the project, issues, risks, dependencies, early customer feedback etc.
Here’s a demo of Windows 8 that was previewed at the D9 Conference earlier this month.
I’ve been thinking of about a fun technology project that I could work on with Dany (my 5 year old son) this summer. We’ve been talking about robots for a while and I’ve been looking for a good excuse to start playing around with Arduino – an open source electronics prototyping platform. So I was pretty excited to discover DinoFab’s tutorial on hacking a Rumble Robot toy and turning into your very own Arduino robot.

I bought a used Rumble Robot Me-Fisto! from eBay for $15. Now I just need to get an Arduino micro-controller, a Ping ultrasonic sensor and a few other items and we’ll be all set for this project. More updates on this later…
Let’s say we have a simple to-do list application in ASP.NET MVC which displays a table of open tasks. And below that table, we display a list of completed tasks.

The scenario is pretty straight forward – when a user clicks on an open task check box (to mark it complete) we need to update the database record for that task and then move it to the completed tasks list below. And vice versa – if a user changes their mind and unchecks the completed task, then we need to update the database record again and move that task back up to the open task table. There’s no submit button or form here – it’s going to be something we’ll handle dynamically with one click of a checkbox.
Here’s part of the HTML generated by our Razor view. Each task has a unique ID e.g. ‘checkbox1′ based on the task ID in the database i.e. 1. I just added the ‘checkbox’ prefix to avoid confusion with lots of ‘vague’ numbered IDs all over the place in the HTML.
First, we need to get our jQuery code working to handle the check and uncheck events for any of these tasks. All we’re doing here is getting the ID of the task that’s being checked (stripping out the ‘checkbox’ prefix), determining if a checkbox was checked or unchecked and then then passing that ID to the relevant action method in the Item controller i.e. “Complete” or “Incomplete” action method:
The “Complete” action method finds the record in the database using the ID that was passed to it from the jQuery function, updates the “Completed” column to “Y”, saves the database changes and then redirects to the “Index” action method (which displays the Razor view shown above).
The “Incomplete” action method basically does the same thing as the “Complete” action method above, but changes the “Completed” column value to “N” i.e. marks the task as open again.
I’m not sure if doing a redirect from the jQuery function to the relevant action method is the best way to handle this (versus a Post), but it seems to work okay. The next step will be to use some Ajax to just update the table & list without reloading the entire page, but I’ll leave that for another day.
Using jQuery with ASP.NET MVC3 is pretty simple, especially now that it comes pre-installed with VS 2010. However, to set it up in a more scalable way with your project takes a little bit of work upfront but is definitely worth the extra effort in the long run.
1. Create a New Razor Helper
Let’s start by creating a new Razor helper in the App_Code folder (you may need to create this folder if it doesn’t already exist in your project). Add a new Razor view called Content.cshtml and replace the entire contents of that file with the following helper code:
2. Add Script References to Layout Master
Add the following code to the end of _layout.cshtml (before the closing body tag).
3. Adding New Script References
Adding any new script references is now easy. We can just add them to _layout.cshtml. Just be sure to add those references before the RenderSection line to ensure that the scripts load in the correct order.
4. Adding Script References For Specific Pages
The RenderSection helper is used to call any page specific script references in the correct order i.e. after the main jQuery files have been loaded. The page specific script references can now be called in the same way i.e. simply add the required references to the relevant Razor view:
Voila! Now we’re ready to start having some fun with jQuery.