Kevin McMahon

#holoyolo

2013-05-22T00:00:00-05:00

What started as a tongue-in-cheek reference to the wave of apps finally being updated to align with Android's Holo design guidelines became a rallying cry at Google I/O this year. The #holoyolo hashtag made its way onto more than a few slides during the sessions last week and now it has found its way onto a t-shirt. So any of you Android developers or designers out there looking for a cheeky way to induce a conversation about getting your Android app to adhere to the Holo guidelines look no further. This is the t-shirt for you.

Order at Teespring.com, $15

Google I/O 2013 Recap

2013-05-21T00:00:00-05:00

Last week I had the pleasure of attending this year's Google I/O. Before I got too far removed from the conference I thought I would try to capture my impressions and thoughts about last week.

Keynote

The keynote clearly wasn't as tight as WWDC keynotes and frankly not as cohesive as past I/O conferences. Lots of bits were spilled last week in the aftermath, and I will spare you a retread of the common complaints. I do think though that a majority of the problems stemmed from the lack of a unifying theme or major tent-pole announcement. It is tough to build a substantive keynote around the smaller, more strategic moves Google announced. That being said, I cannot argue with the complaints about the "blocking and tackling" problems Google had during the keynote especially at a conference this big.

Android Announcements

When the keynote came and went without an official Android bump to the API level, many took that as Google wavering on their commitment to the platform. Watching the keynote live I had the opposite impression, and the subsequent Android sessions during the week reaffirmed that.

The Google Play Services and the r13 Android Support Library UI enhancements showed us how Google plans to curb the fragmentation issues which have plagued the platform. By packaging these enhancements in libraries that are compatible back to Froyo and immediately available for integration, Google enabled developers to get these new features and services into the hands of users immediately. This eliminates the dependency Google had previously on hand-set manufactures to integrate new Android releases on their current and older devices.

Many have questioned the long term viability of the Android platform for Google as companies like Amazon and Samsung seek ways to circumvent or minimize Google's influenence on their products. The approach that Google adopted has provided a way forward that serves their needs as well as developers. That is a big deal.

Comparison to WWDC

The content and variety of sessions at both conferences is excellent. On the whole, WWDC's sessions appeared to be more polished and rehearsed when compared to the I/O sessions. I found the I/O sessions tended to be a little more light-hearted and included more variety in the session structure (fireside chats, interactive labs) which added to the enjoyment of the sessions and kept the sessions from becoming monotonous. Both conferences provide a tremendous amount of access to the engineering teams directly working on the frameworks and services developers interact with on a daily basis. These opportunities for interaction are easily the most valuable parts of each conference. While the Apple labs at WWDC predominantly allowed for one-on-one interaction with their engineers, Google made their engineers available in an Office Hours setting that had the engineers holding court for small groups around white boarded areas in the conference hall. If you had very specific questions, the WWDC labs could not be beat for access and personal attention. If you were interested in picking up some tips and inside scoop about your favorite Google developer topics, then the I/O office hours are great.

My biggest gripes about I/O are mainly with the logistics and the infrastructure at the conference. The most popular talks were being held in rooms that could have easily been filled if they were four times the size. The bigger tracks like Android and Chrome could have benefitted from being clustered on one floor near each other instead of being spread over two. That would've made bouncing between sessions easier and eased up the congestion around the escalators and the other traffic hotspots on the floors. The session rooms themselves were stuffy and hot during the talks and especially so in the popular sessions which typically had crowds sitting along the walls and in the aisles. While the range of these complaints range from the minor (too crowded at times) to major (uncomfortably hot rooms) annoyancess they still detract from an otherwise great conference experience. The best thing about these issues are that they fixable. Hopefully Google will make some changes to eliminate these issues from future conferences.

External Conference Activities

The best parts of conferences are social interactions and Google I/O was no different. I kicked off the week at the Meatup.io, made my way out to Twitter for their Mobile Showcase lightning talks and capped the week off by going to a meetup-style talk on Android testing at a local startup. It was great to meet so many great developers and engineers at these events and it was nice to be able to thank so many of the project creators and maintainers in person for their contributions to Android's open-source community.

Summary

I had a fantastic time at Google I/O. I'm still chewing on and trying to process all the great content, conversations, and code that I was exposed to last week. I highly recommend Google I/O, and if you are fortunate to get an opportunity to attend a future event, I strongly urge you to go. Being around 6,000 passionate and excited developers is an amazing way to spend a week learning and exploring new technologies and services.

Favorite Sessions

Android

Non Android

The Freebase APIs: Tapping into Google's Knowledge Graph
Gamestorming
Cognitive Science and Design

That Conference 2013

2013-05-09T00:00:00-05:00

I am excited and honored to be speaking at That Conference again this August in the Wisconsin Dells. That Conference will have multiple tracks for mobile, web and cloud developers as well as an interesting other track this year.

I'll be sharing some of the hard-won Android tips and best-practices that I have collected over the past few years while building and shipping apps for clients. Hope to see you there in August!

Setting Up Motorola ET1 for Android Development

2012-10-12T00:00:00-05:00

Getting ADB to recognize the Motorola ET1 took longer than I'd like so I'm posting this with the hope that it'll help others who find themselves in a similar spot.

Like most Android-based devices, developers need to enable USB debugging on the device by toggling a setting in the developer section of the settings app. However, with the ET1, developers also need to add the device's vendor id (0x05E0) to the ~/.android/adb_usb.ini file or else the device won't be detected or visible to ADB.

Once the vendor id has been added, kill and restart the ADB server. After ADB starts back up, the ET1 should now be listed in the ADB device list and able to be deployed to.

Favorites from August 2012

2012-08-31T00:00:00-05:00

A collection of some of my favorite links, tweets and quotes from August. While these aren't a comprehensive look at or summary of August 2012, they do capture the things that I found interesting, thought provoking, and/or cool over the past month.

Favorite Links

Favorite Quotes

When you say "I seen," I assume you won't finish that sentence with "the inside of a book." -- someecards

Favorites from July 2012

2012-07-31T00:00:00-05:00

A collection of some of my favorite links, tweets and quotes from July. While these aren't a comprehensive look at or summary of July 2012, they do capture the things that I found interesting, thought provoking, and/or cool over the past month.

Favorite Links

Favorite Quotes

"No SciFi author foresaw this: we are building clans around languages we speak to the Machine.” -- @mraleph
"It's important to take a moment to reflect on how fortunate we are that those alien spaceships were compatible with Jeff Goldblum's laptop." -- @gavinspeiller on July 4th

Nexus 7 Quick Thoughts

2012-07-17T00:00:00-05:00

A few quick initial impressions of the Nexus 7.

A legitimate Android tablet has finally been released. It is the best Android tablet on the market.
Jelly Bean is definitely "buttery".
Touch is very responsive in Jelly Bean. Big improvement over previous Android devices/versions.
The Kindle Fire is comically bad and outdated compared to it.
The build quality is ok. Doesn't feel plastic-y like the Samsung products. Not a fan of the faux leather back.
Feels like a big phone.
Seems like resolution/size will require better fluidity from apps. Devs will definitely have to account for more screen real estate.
Not sold on the 7" form factor but I think I'll be in the minority.

Overall I'm pretty impressed with the Nexus 7. Seems like the software finally caught up with the hardware and, judging by the buzz around the product, the affordable price will make this a popular choice for those consumers looking for a tablet.

Core Location : The Missing Details

2012-07-05T00:00:00-05:00

My primary objective at WWDC this year was to find answers to Core Location questions I had and develop some intuition about how the framework works underneath the hood. Armed with some questions and a small sample app illustrating some of the bugs I found, I set out for the one Core Location lab being run during the week. These "office hour" style labs offer developers an opportunity to talk directly with the Apple engineers who work on these frameworks, and after getting paired up with one of the more senior Core Location guys, I was blown away by how valuable these sessions can be. I was able to resolve several issues and had a bunch of questions answered while also picking up a few tips and tricks to use in future apps. The amount of knowledge and insight shared during my relatively short session was invaluable.

While I can't share everything I learned in the lab due to the NDA covering iOS 6 updates and features, I did collect non- iOS 6 specific concepts which I can share with you. Much of the information isn't documented even though it helps paint a fuller picture of how Core Location works. During my time in the lab, two things became clear: quality of the location services can be significantly impacted by variations in environment and hardware and that Apple engineers are still actively iterating and improving Core Location. I didn't get a straight answer as to why they are reluctant to publicly share or document some of this information, but I would not be surprised if these types of things were a factor.

Finally, this information was collected from some notes scribbled on paper during my lab session and a brain dump I did into nvAlt immediately following the meeting to get whatever didn't make it on the page. I am reasonably confident that what I captured in my notes is legit and valid information, but it is entirely likely that I misheard, misinterpreted, or misunderstood something. Caveat Emptor.

Region Monitoring Information:

The minimum region radius size is 100m. Core Location will allow you to set a radius value smaller than 100m for a CLRegion, but internally the framework will treat the region as if its radius was 100m.
The maximum number of regions that can be monitored at one time is 20. This is not documented anywhere, but if you try to register for more than 20 regions, you will get an error indicating that you can't add any more regions. One technique that is used to get around this cap is to load and unload regions based on your current location and using significant location change notifications to evaluate when old regions need to be removed and updated with regions closer to the user's current location. Keep in mind that adding and removing regions does take some power, so it is something that you want to do judiciously.
Regions fall into three categories. Depending on what category the registered region falls into affects the time it takes for Core Location to trigger the delegate callbacks.
- Fine Region (0 - 150m)
  - With the floor of 100m this category's range is effectively 100-150m.
  - For regions this size performance is heavily dependent on the location-related hardware in the devices. The iPhone 4S, unsurprisingly, has the best hardware. Some iPads and all iPod Touches don't have cellular radios. All these types of scenarios should be considered during development.
  - The amount of time that it takes Core Location to detect and call the appropriate delegate method is roughly 2-3 minutes on average after the region boundary has been crossed.
  - Some developers have figured out independently that smaller regions would see quicker callbacks and would cluster smaller regions to cover one large area to improve region crossing notifications. This was frowned upon by the Apple engineer as this type of solution uses more resources/power than monitoring just the single large region, but it is a viable alternative if you need the quickest possible updates. Apple is aware of this, and they are continually trying to minimize the time that elapses until Core Location invokes the delegate methods.
- "Normal" Region (150m - 7km)
  - Core Location can take as long as 15 minutes to invoke the delegate methods, but it is usually less.
  - Response time improves significantly with increased user interaction with the device. Core Location tries to minimize power consumption, so it doesn't accelerate battery drain and tries to piggyback on other activities to check location. A device that is actively being used to browse the web or send text messages is more likely to have Core Location checking for updates than a device that is idle in standby mode.
- "Huge" Region (7km+)
  - This was referred to as the "1/3 of the earth" region. Outside of its mention and confirmation that category of region exists, not much else was said about it.
Regions are not registered for instantaneously. If you register for a region and then immediately enter/exit the region, then it won't get registered properly. The recommended suggested wait time was 10s which is helpful to know when testing.
Bugs prevented the start/stop watching region callbacks from being invoked in iOS 5. The callbacks do not work properly in the simulator and only work correctly on some hardware devices. This appears to be fixed in iOS 6.

Other Core Location Tidbits

Significant location change (SLC) updates will not fire unless 5 minutes elapsed and a change of 500m occurred since the last update.
If you stop and then start registering for SLC notifications, there are no guarantees that it will fire immediately. Apparently enough people thought this worked and/or tried this that Apple changed how Core Location behaves and now a cached value (if Core Location has one) will be returned on the subsequent firing.
You can tell the source of your location information by observing the blue location dot used by MapKit. A pulsing dot means GPS (example) and a static dot means cell/wifi (example). This is not documented anywhere officially and apparently a lot of Apple engineers don't recognize/notice the difference.
Core Location quality/performance varies substantially based on where you are. In a high density area like a city, the device will pull less data and use less resources than if you're in a sparsely populated area.
Core Location piggy backs on other user interactions to do most of its updating. The more opportunities it has to check / update location, the better the response time.
The mocked location data that is provided to the simulator always appears to be coming from GPS. You can't simulate the behavior that the cellular or wifi sources provide or simulate what happens when the GPS source is sketchy. In prior iOS releases, region monitoring relied heavily (exclusively?) on the location data provided by cell towers to operate, but improvements to both the algorithms and simulator should mitigate any of these issues.

Chicago Alt.Net Amazon Web Services

2012-07-04T00:00:00-05:00

In June I had the pleasure to speak at the Chicago Alt.Net meetup about Amazon Web Services. The talk covered the basics of cloud services, provided a high-level overview of how Amazon's web services work and showed how easy it was to integrate AWS into a project via the .Net SDK that Amazon provides. For some of the attendees it was their first technical look at the platform. I hope that they found the talk informative and piqued their interest enough to explore the platform further.

Favorites from June 2012

2012-06-30T00:00:00-05:00

A collection of some of my favorite links, tweets and quotes from June. While these aren't a comprehensive look at or summary of June 2012, they do capture the things that I found interesting, thought provoking, and/or cool over the past month.

Favorite Links

Favorite Quotes

"EC2 comes with a free Chaos Monkey service. It's called EC2." -- pjscott via Hacker News
"Never attribute to stupidity that which is adequately explained by process." -- Paul Ford
"We are cups, constantly and quietly being filled. The trick is, knowing how to tip ourselves over and let the beautiful stuff out." -- Ray Bradbury RIP

Android Crash Course

2012-06-22T00:00:00-05:00

One the main goals of my current client engagement was to help a team of talented developers come up to speed and become proficient with the Android platform. A key component of the approach I employed was to hold a weekly "tech talk" session that focused on basic Android topics. The topics ranged from how do views work to understanding the development tools available and were intended to fill in some of the fundamentals of the platform as the team was starting to develop the project. The scope and the depth of the sessions varied depending on the topic and the relative familiarity that the team already had with it, but ultimately they focused on building solid fundamentals.

After being asked recently by another developer for some tips on getting up to speed with Android, I thought it might be useful to aggregate and cleanup the notes I had from the tech talks with the hope that they might prove useful for someone looking for a crash course in Android development.

The outline is still very rough and definitely needs further refinement, but in the spirit of releasing early and often, I'm making it available today here and in pdf form. I'd love to get feedback or suggestions on this and how it could be more helpful so please feel free to reach out.

Favorites from May 2012

2012-05-31T00:00:00-05:00

A collection of some of my favorite links, tweets and quotes from May. While these aren't a comprehensive look at or summary of May 2012, they do capture the things that I found interesting, thought provoking, and/or cool over the past month.

Favorite Links

Favorite Quotes

"The world is a book and those who do not travel only read one page." -- St. Augustine
"Lighting one candle with another candle-- spring evening" -- Haiku from Buson

That Conference - Summer Camp for Geeks

2012-05-22T00:00:00-05:00

I am excited and honored to be speaking at That Conference this August in the Wisconsin Dells. That Conference is going to have tracks for mobile, web and the cloud and the sessions look outstanding. I'll be doing a session on Core Location which, according to the iOS 6 rumors, may be a hot topic at WWDC this year. Hope to see you there!

Geofencing in iOS - Chicago Code Camp 2012

2012-05-20T00:00:00-05:00

Yesterday I had the pleasure of doing a talk exploring Core Location at the 4th annual Chicago Code Camp. Really enjoyed the audience participation and hopefully everyone left with a better understanding of Core Location.

Code on Github

Favorites from April 2012

2012-04-30T00:00:00-05:00

A collection of some of my favorite links, tweets and quotes from April. While these aren't a comprehensive look at or summary of April 2012, they do capture the things that I found interesting, thought provoking, and/or cool over the past month.

Favorite Links

Favorite Quotes

"If you start with “useful” as a first principle, then you automatically place customer need and experience first." -- Mary Ellen Muckerman

Favorites from March 2012

2012-03-31T00:00:00-05:00

A collection of some of my favorite links, tweets and quotes from March. While these aren't a comprehensive look at or summary of March 2012, they do capture the things that I found interesting, thought provoking, and/or cool over the past month.

Favorite Links

Favorite Quotes

"Papyrus is a classy comic sans." -- @rands
"Time is a created thing. To say "I don't have time" is to say "I don't want to"" - Lao Tzu

Favorites from February 2012

2012-02-29T00:00:00-06:00

A collection of some of my favorite links, tweets and quotes from February. While these aren't a comprehensive look at or summary of February 2012, they do capture the things that I found interesting, thought provoking, and/or cool over the past month.

Favorite Links

Favorite Quotes

“Chaos was the law of nature, order was the dream of man.” – Henry Adams
"All men will benefit, if we can invoke the wonders of science instead of its terrors." – JFK

Favorites from January 2012

2012-01-31T00:00:00-06:00

A collection of some of my favorite links, tweets and quotes from January. While these aren't a comprehensive look at or summary of January 2012, they do capture the things that I found interesting, thought provoking, and/or cool over the past month.

Favorite Links

Favorite Tweets

@dansinker:"The first rule of John Kerry fight club…" contains at least 75 subclauses."
@citizenparker: MUTABILITY! From hell’s heart I stab at thee (until another operation inadvertently changes my state to “not stabbing”)

Quotes

"Data is the new raw material of the 21st century" - Tim Berners Lee & Nigel Shadbolt

Importing CSV data with location information into PostGIS

2012-01-09T00:00:00-06:00

Sometimes location data isn't neatly packaged in a SHP file, and it requires some massaging before it can be used in spatial queries. In this post I'll take a look at importing latitude and longitude data from a CSV file into our PostGIS database and transforming those coordinates into geometry data that can be spatially queried against.

Step 0 - Initial Starting Point

Get a CSV dataset. For this example I'll be using the Individual Landmarks dataset exported as CSV. You can get a copy of the CSV file that I am using for the example here. We already have the latitude and longitude and the extra location field isn't something that we'll use so I removed the location column prior to exporting the dataset. You can hide the column by selecting the arrows on the column heading in the table (shown here) or via the manage screen and deselecting the location column from the list of available columns (shown here).
A PostgreSQL database with PostGIS installed.

Step 1 - Create the table in the database

Use the following SQL to create a table to hold the landmark data.

Step 2 - Copy the CSV data into the database

To run the copy command, login to the database and execute the following command :

There are a couple of things to note with the copy command:

The first argument passed to the copy command specifies the tablename (landmarks) and the columns which the CSV files map to. Our table includes a column gid that is an auto-incremented id which is used as a primary key as well as the_geom geometry column. The CSV does not include either of these columns in the data we are copying. If we don't specify the specific columns that the fields in the CSV map to, errors will occur when attempting to copy the data.
The DELIMITERS argument specifies your delimiter.
The CSV argument at the end lets PostgreSQL know that the file is CSV.
The HEADER argument lets PostgreSQL know that the file includes the headers on the first line.

Here is a look at our data after the import. Note that the_geom has no data. We'll take care of that in the next step.

Step 3 - Translate latitude and longitude into POINT geometry

Now that we have the data imported, we need to convert the latitude and longitude columns to a PostGIS POINT geometry. The following SQL will update the_geom column in the landmarks table with a POINT geometry created from the row's latitude and longitude columns. In order to create the POINT, the ST_GeomFromText method is used. This method allows us to create a POINT, which is a PostGIS geometry type, textually with the latitude and longitude values being specified in the construction of the type.

Here is a look at the data with the the_geom column populated with POINT data.

Step 4 - Run some queries

Now that all the POINT geometries have been created for our landmark rows we can write some spatial queries against our data. Here are just a few of the types of queries we can run.

Using the ward geometry we have from a previous example, we can run a query that returns all the landmarks in the 43rd Ward.

This query returns the 5 closest landmarks to a given latitude and longitude :

Favorite Links and Quotes of 2011

2012-01-02T00:00:00-06:00

A quest to find the name and url of a gadget review site that I had tweeted about a few months ago led me to the TwimeMachine web app. TwimeMachine lets you read your old tweets and, while I was looking for the gadget website, I got a chance to take a stroll down memory lane and revisit some of my favorite links and quotes from the past year. I pulled out some of my favorites and have shared them below. While these lists aren't a comprehensive look at or summary of 2011, they do capture the things that I found interesting, thought provoking, and/or cool over the past year.

My Favorite Links from 2011

My Favorite Quotes from 2011

"I’m impressed with the people from Chicago. Hollywood is hype. New York is talk. Chicago is work." -Michael Douglas
"The arts are not a way to make a living. They are a very human way of making life more bearable." -- Kurt Vonnegut
"Another flaw in the human character is that everybody wants to build and nobody wants to do maintenance." -- Kurt Vonnegut
@zachklein: Just told to me: "Schools are the coal-fired power plants of education."

My Favorite Funny Tweets from 2011

@jonlech "Next year HTML5 will replace native apps" is the new "Next year will be the year of Linux on the desktop".
@hubs: What doesn't kill you makes you smaller. ~Super Mario
@dcurtis: The Container Store is like a strip club for people with OCD.
@larrybraverman: GUYS IF EGYPT CAN TAKE DOWN MUBARAK WE CAN TAKE DOWN TICKETMASTER

2011 by the Numbers

2012-01-01T00:00:00-06:00

Apps Shipped : 7

4 Android apps with one in the can set for release in a few weeks. 3 iOS apps. Not 100% sure what I can and can't disclose due to client agreements, but I am very proud and happy with the apps that I helped produce last year. Lots more mobile work on the agenda for 2012.

High School Programming Courses Taught: 1

In early 2011 I taught Android development to high schoolers participating in a pilot program for the 21st Century Youth Project. It was an amazing experience and I hope to work with them again in the future as the program matures.

Speaking Engagements : 4

I had the honor of being selected to speak at WindyCityGo and Chicago Code Camp last spring as well as speaking to user groups in Rockford and Milwaukee.

Jobs Changed : 1

In July I joined Redpoint Technologies and became a consultant for the first time in my career. While consulting isn't for everyone, I have enjoyed the diversity of the projects/clients I had the privilege of working on/with.

Side Hustles : Numerous

Along with maintaining a few sets of MonoTouch bindings, I put together a wiki for mobile app developers and started working with some of the data that the City of Chicago is publishing. I was able to help out some friends working on some stealth startups by offering technical advice and mentoring and have a few more tricks up my sleeve for the upcoming year.

Trips : 7

In addition to usual trips to Minneapolis to visit the in-laws and the guys trip out to Phoenix for the PGA event, I was able to squeeze in a "business" trip to Las Vegas, a vacation to southern California, and attend an amazing wedding in Greece.

Lucky Guy: 1

In reflecting back over the last year I am left feeling a tremendous amount of gratitude and appreciation for the amazing people, places and opportunities that I encountered over the past year. I am truly blessed.

Importing Shapefiles to PostGIS - Consuming Chicago Open Data

2011-12-29T00:00:00-06:00

The most common spatial format that geographic data is distributed in is ESRI shapefiles. The geographic datasets provided at the City of Chicago's open data portal are no different. In this post, I'm going to walk through converting an ESRI shapefile into SQL, importing that SQL into a PostGIS enabled PostgreSQL database, and querying the geographic data.

Prerequisites

Before we get started you will need to download and/or install the following data and software:

PostGIS/PostgreSQL database
The GDAL libraries
A dataset from the City of Chicago Data Portal. For this example I am going to use the Ward data provided by the city.
pgAdminIII - A PostgreSQL admin and management tool that is optional but highly recommended.

Step 1: SHP file to SQL file

The data published by the city uses a spacial reference system (SRS) called NAD 1983 StatePlane Illinois East FIPS 1201 Feet to store data. This SRS falls into the State Plane category which is typically great for measurement and maps covering a limited geographic area like a state or city. For most contexts this is perfect but, if you want to use this spatial data with mapping layers or geocoding services from Google or Bing, it will cause problems. Mapping providers like Google and Microsoft Bing expect data to be stored using the WGS 84 (EPSG code 4326) SRS. This means that if we want to use latitude and longitude coordinates from these services or utilize their mapping layers we will have to convert our data from State Plane to WGS 84. Thankfully the GDAL tools provide a utility to transform the data.

ogr2ogr -f "ESRI Shapefile" -s_srs "EPSG:102671" -t_srs "EPSG:4326" Wards4326.shp Wards.shp

Once the shapefile has been converted from State Plane to WGS 84, we can then use the shp2pgsql tool to generate the SQL statements necessary to add the geography data to our database.

shp2pgsql -s 4326  -I -c -W UTF-8 Wards4326.shp wards > wards.sql

Here is a sample of one of the insert statements generated by the shp2pgsql with geometry column (the_geom) abbreviated:

INSERT INTO "wards" ("data_admin","perimeter","ward","alderman","class","ward_phone","hall_phone","hall_offic","address","edit_date1","shape_area","shape_len",the_geom) VALUES ('111078823.37393899','98206.78600274','20','WILLIE COCHRAN','1','773-955-5610','312-744-6840','121 N LASALLE ST, RM 300 OFFICE 19, 60602','6357 S COTTAGE GROVE','20030527','111200062.771999999','98166.05290559999','0106000020E6100...'

Step 2: Insert Data into DB

Now that the dataset has been transformed and the SQL has been generated, it is time to add it to the database. You can do so by running the following command. (NOTE: you will have to swap in your own database name and user for the $DB_NAME and $DB_USER arguments).

psql -d $DB_NAME $DB_USER < wards.sql

Step 3: Write Queries

With the data entered into the database we can now write queries against it. Here is a query that returns information about the ward that contains the point specified by latitude and longitude arguments.

SELECT ward, alderman 
FROM wards 
WHERE ST_Contains(the_geom, ST_GeomFromText('POINT(41.927064 87.645658)', 4326));

The WHERE clause is calling the spatial relationship function ST_Contains. Spatial relationship functions in PostGIS take two input geometries and return either a boolean or another geometry. In our case, ST_Contains returns a boolean indicating if the point geometry passed as the second argument is contained in the geometry stored in the the_geom column of the wards table. The point geometry is constructed from another spatial function ST_GeomFromText. This function takes a textual representation of the geometry along with a spatial reference id (SRID) specifying the SRS that the geometry should be created in. In our case, we are using latitude and longitude values obtained from Google so we are creating the point geometry in the EPSG 4326 SRS.

Additional Resources

I found the following links useful as I started learning about PostGIS.

Announcing the App Dev Wiki

2011-10-08T00:00:00-05:00

AppDevWiki

Earlier this week I put together a wiki to centralize the links, libraries and miscellania that I have been collecting regarding mobile development. I did this mainly for personal use and to provide a reference for coworkers and colleagues getting into mobile dev but hopefully others will find it useful. Check it out and feel free to add your favorite tools, libraries and links to it.

MonoTouch Bindings

2011-09-14T00:00:00-05:00

Creating bindings for native, Objective-C based libraries can be somewhat confusing when first starting out. To help smooth the learning curve for those looking to create bindings (and hopefully share them) I have put together some links and an overview of the steps that I use.

As MonoTouch development is picking up steam again after the Novell/Xamarin deal I've noticed more and more people looking for help and information about just how to consume native libraries. Most of this information and the utility that auto-generates the code was gleaned from the #monotouch IRC channel, looking at other MonoTouch bindings and experimentation.

The core of this post was written in May 2011 when I was helping out a few folks with some binding issues. The general gist of the process still applies but somethings may have changed. Please let me know via comments or email if I am missing anything or if there are some corrections needed.

Useful Links

Binding Objective-C Types - MonoTouch Docs
Binding Details - MonoTouch Docs
An Example Project

Binding Steps

Step 1: Create the Binding Code

The binding that you are going to call from your C#/MonoTouch code you will need to create a C# version You can manually write the bindings by hand or use a utility to help automate the process. There is a tool you can compile from the source found in this gist that can help save some time. You will need to compile the tool using mcs and invoke it to generate the bindings like so :

mono ObjCParser.exe <FILENAME>.h

You can pass multiple header files associated with the Objective-C library that you are trying to bind. The tool generates three different .cs files which contain the C# bindings you can use. You will need to update the namespaces and the using statements as the files generated by the utility are using the MonoMac namespaces.

The tool isn't perfect and there are known issues. Cleaning this tool up is on my todo list but extremely low since I know the quirks and it is just faster for me to generate and fix it up than to polish it.

These are the biggest issues that those using the tool should be aware of:

Methods are included correctly in their corresponding C# classes but properties aren't. You'll need to grab the properties and stick them in the right classes.
If a method specified in a .h file spans multiple lines the tool can't recognize that. When you go to compile you'll get some errors.
Delegates can be tricky. When creating delegate mappings need to update and figure out how to handle the delegates. Due to the brute force nature of the generator tool, the delegates are typed as IntPtr's when in reality they should be typed so it requires so hand updating to straighten the delegates out.
NSURLRequest in Objective-CObjective-C is NSUrlRequest in MonoTouch. There are a few places where the Objective-C classes don't map exactly into MonoTouch classes due to naming convention issues.

Step 2: Make the DLL

Generate the bindings by invoking btouch and providing the relevant arguments for your files. The invocation looks something like this:

/Developer/MonoTouch/usr/bin/btouch -out=<YOURNAMEHERE>.dll <YOUR_BINDING_CODE>.cs

Step 3: Reference the DLL

Include a reference to the newly generated dll in your MonoTouch project. You will also need to include the static library in the project. For some reason it isn't enough to just link to the path. You actually need to have the .a file included in the .csproj file. You can set the build action to None.

Step 4: Update the Additional Arguments.

Finally, the MonoTouch project settings need to be updated so the Objective-C library is linked against during compile time. Update the Extra Arguments field in the iPhone Build settings under the Project Options. I've taken a screen grab showing the field.

You can read more in the official docs under the "Linking the Dependencies" section here

These are the basic steps. It isn't hard but it isn't exactly straight forward. My best recommendation is to take a look at my fork of the Localytics project on github and try and reproduce the bindings on your own.

Notes

There is a linker bug that Apple introduced in XCode 3.x that causes problems at compile time when trying to link in static libraries with THUMB enabled. You can run a command via the shell to check the dumped output (here is an example. Make sure to look at line 5, second column. The two byte address is the give away that the library is THUMB) but I don't have the command off the top of my head. The best way to handle this is to get the full Objective-C source and uncheck the THUMB code option. If you are still using XCode 3.2 then you HAVE to use a static library that has been compiled without THUMB code. The linker bug apparently has been fixed in XCode 4 and you should be able to link against both THUMB and non-THUMB libraries.
You also might want to look into making a fat static library. I do this for most of the bindings I publish so that there is only one static library to link against and you don't have to hassle with using one library which has been compiled for use with the simulator and one that has been compiled for the device. Checkout this Stack Overflow question for more details on how to make a fat static library.

Updated Decemeber 28, 2011 : Added link to fat static library instructions.

Mono for Android talk at WindyCityGo

2011-05-08T00:00:00-05:00

Here is the video and the slides from the Mono for Android talk I gave last month at WindyCityGo.

.NET on Android? MonoDroid Does by Kevin McMahon from ChicagoRuby on Vimeo.

Mono for Android?

View more presentations from Kevin McMahon

Quick Primer: Cocoa and Cocoa Touch for .Net Developers

2011-05-04T00:00:00-05:00

Cocoa and Cocoa Touch

At their core Cocoa and Cocoa Touch are composed of two frameworks. The Foundation Kit provides the core, non-UI classes and, depending on whether you're developing apps for OS X or iOS, AppKit or UIKit respectively provides the core UI classes. For data the Core Data framework is available.

Foundation

The Foundation framework provides the core, non-UI classes that all Cocoa and Cocoa Touch applications are built upon. Basic object behavior, memory management, object mutability, and notifications are all defined among the 80 classes that comprise the framework.

This is the framework that provides the root class NSObject. Much like System.Object, NSObject is the class that all other classes are derived from. NSObject provides the nuts and bolts which enable object-oriented functionality and behaviors in Objective-C. You will also find in Foundation classes like NSString, NSArray, and NSThread or data types, collections, and operating system abstractions respectively.

AppKit (OS X) / UIKit (iOS)

AppKit for Cocoa and its sister framework UIKit for Cocoa Touch provide the windows, dialogs, buttons, menus, scrollers, textfields and all the other UI elements available to developers. The AppKit framework is used for desktop applications and the UIKit for iOS applications.

The Window, View, and Application classes provided in the AppKit and UIKit framework define the core functionality of app. Each class plays a crucial role in displaying the user interface and responding to the various user events generated while the program is executing. These three classes, constitute what is considered to be the core program framework since all apps derive their functionality and behaviors from them.

While both frameworks share many of the same types and perform similar tasks, having separate frameworks does provide some benefit. Having two, specific frameworks makes it easier to provide device implementations for UI controls when called for (e.g. handling motion or touch gestures) but remain conceptually similar when it comes to behavior (e.g. window, view, and application class relationship), and it eliminates an unnecessary dependency that would be created by lumping desktop and iOS specific code together into a single framework.

It is easy to tell the difference between Cocoa and Cocoa Touch classes. Classes that are found in Cocoa are prefixed with an NS (e.g. NSWindow, NSView), and Cocoa Touch classes are prefixed with UI (e.g. UIWindow, UIView).

Delegates

The Cocoa framework leverages the delegate pattern to allow an object's behavior to be modified without having to resort to subclassing. Unlike C#, which includes a delegate language element, the concept of delegates come to Cocoa purely via the implementation of the delegate design pattern and not a mix language features and pattern.

A delegate in Cocoa is an object that implements some or all of a protocol (interface in Objective-C speak) and is assigned to another object to handle events. Classes using delegates typically define a contract via a protocol which provides the level of indirection needed to decouple the caller object and the delegate object. It is common practice in Cocoa to define all the methods in a delegate protocol as optional. This allows the selective implementation of event handlers for the events needing custom behaviors.

Notifications

Notifications in Cocoa provide a mechanism for decoupled message passing. Communication between objects is done by passing messages to and from objects. In order for the communication to take place, the sender must know about the receiver, and this knowledge of the other object introduces tight coupling between the two. Notifications remove the coupling by providing a one-to-many broadcast mechanism which allows objects to register with a notification center as notifications posters, observers, or both. When a notification is posted by an object, the notification center acts as a dispatcher and invokes any callback methods registered with the notification center for that particular notification.

Notifications sound very similar to delegates, but they differ in three key areas. First, there is no limit to the number of objects that can receive notifications. In a delegate scenario, only the delegate object associated with the host object can respond to events. Second, an object can register for any number of notification from the notification center and not just the methods defined by the delegate protocol. Finally, an object posting a notification does not require another object to invoke methods. It can simply fire the notification and not worry about whether there is an observer on the other end to respond.

Model-View-Controller

You will find many different design patterns being employed in the Cocoa framework but none are as pervasive as the Model-View-Controller (MVC) pattern. In this pattern there are three possible stereotypes that an object can take on. Model objects encapsulate data and behaviors; view objects handle display and user interaction; and controller objects bind the data and the objects together.

The benefits realized from the pattern come from the separation of concerns imposed on applications. Interactions between layers occur via well-defined interfaces, which provides the abstraction necessary to limit the impact of code changes, and the code is easier to reuse since the interfaces and API are well-defined.

It is important to note that Cocoa does bleed the line between some of the layers in the framework. The concept of the view-controller is prevalent in both Cocoa and Cocoa Touch, and there are some instances in Cocoa where there are model-controllers. When these roles are combined into a single class, the controller takes on the responsibilities that come with owning the second role and still provides the bridge to the third role. So in the case of a UITableViewController, the controller is responsible not only for its traditional role of tying the model with the view but also for how that data looks in the table which is typically the view's role.

Monotouch: Facebook Binding Updates

2010-12-12T00:00:00-06:00

UPDATE (12/30/2011) : Facebook Connect bindings are being maintained by the Mono Project

I pushed some updates to the monotouch-facebook project recently to eliminate potential linking problems that could come up. Apple introduced a bug in their linker that causes problems when linking non-Thumb MonoTouch code with Thumb code. The default settings for the Facebook iOS SDK project will produce a static library with Thumb code so I forked the project and turned off Thumb code generation.

I also made the fat static Facebook library a little fatter by linking the simulator version of the library (i386 architecture) in along with the iPhone and iPad library (armv6 and armv7 architectures). This fatter library doesn't require managing and maintaining two versions of the library for the different architectures.

The bindings have been refreshed due to the Facebook iOS SDK being updated recently. You can see the changes reflected in the example app. The biggest change introduced by the update is the app's Info.plist now needs to be modified to register a custom URL Scheme that will enable the example app to be called back after the user authenticates with Facebook. You can see what the Info.plist should look like in the picture below. You will need to replace <<<YOURAPPIDHERE>>> with your real app id.

I hope to get this info up on the monotouch-facebook project's wiki page soon. If you find any issues please open them on the project's issue tracker. Enjoy.

MonoTouch: Dropbox via DropNet, JSON.Net and RestSharp

2010-11-19T00:00:00-06:00

MonoTouch-ified code on github: DropNet, RestSharp, JSON.Net

Recently I wanted to add Dropbox access to a MonoTouch app that I am working on and came across the DropNet project. DropNet abstracts away all the plumbing involved to interact with Dropbox via their REST-based API and provides an easy-to-use C# API.In order to be able to use DropNet in a MonoTouch app, a few of the libraries that DropNet depends on, RestSharp and JSON.Net, had to be ported so that they too would build and run on MonoTouch. Thankfully, the process of getting the DropNet dependencies ported didn't require a lot of work. Chris Hardy had already done the JSON.Net port and John Sheehan, the maintainer of RestSharp, had already begun the process of porting RestSharp. After making a few changes to get RestSharp to compile and adding a MonoTouch-specific project to DropNet, I was able to access my Dropbox via my MonoTouch app. Very cool and very easy thanks to the open source contributions made by the C# and MonoTouch communities.I hope to post a DropNet demo app soon. In the mean time, you can grab the libraries I used from these repositories: DropNet, RestSharp, and JSON.Net. If you're interested in just DropNet for MonoTouch, pre-compiled binaries of RestSharp and JSON.Net are already included in the repository. Enjoy!

Chicago Alt.Net MonoDroid Talk

2010-11-11T00:00:00-06:00

View this presentation and others on Slideshare.

Wednesday I had the pleasure of introducing MonoDroid to the developers at the Chicago Alt.Net meetup. We had a great turn out at the meeting and there was a lot of interest both the Android platform and the MonoDroid tools. The talk consisted of the slides above and some code examples (both available on github) and was intended to show off the awesome work that the MonoDroid team at Novell has done in bringing C# to Android.

If anyone is interested in learning more about Android and developing apps in C# for Android, I strongly recommend you head over to the project website and sign-up for a preview invite. The MonoDroid team is inviting more developers to participate in the preview with each new release so now is as good a time as any to get signed up.

Ubuntu Tip : Broadcom 43xx Wireless Setup

2010-11-03T00:00:00-05:00

Recently I installed Ubuntu on my windows machine using the latest Wubi installer and ran into an issue getting my Dell XPS M1530 laptop's wireless adapter up and operational. My particular flavor of the M1530 uses the Dell Wireless 1505 Draft 802.11n WLAN Mini-Card wireless adapter. This adapter is built on the the Broadcom 43xx series of chips (in my case the Broadcom 4328) and unfortunately these devices don't work with Ubuntu 10.10 out-of-the-box.

To fix this, grab an ethernet cable and get on the your network the wired way. Pop open a terminal window and run:

~$ sudo apt-get install bcmwl-kernel-source
~$ sudo modprobe -r b43 ssb wl
~$ sudo modprobe wl

This should get the wireless adapter up and running and now you can use these instructions from the Ubuntu forums to connect to a wireless access point.

Hope this helps.

Monotouch: Flurry Demo App

2010-10-12T00:00:00-05:00

Github repository can be found here: Flurry Test App.

Recently a request was made for a working example of a Monotouch app that uses the Flurry bindings so I put one together. The example, while trivial in its nature, shows the basics required to incorporate the Flurry SDK Objective-C libraries and their bindings into a Monotouch app and provide an example call pattern that shows how to use the Flurry API.

There are a couple things to note about this demo app. You'll need to register with Flurry and get a unique application key to use with the test app. In the example code you will see that I have some comments about providing a real debug and release application key. A best practice is to have two separate keys so you can keep your production analytics separate from your test analytics. So while you are testing your app use the testing application key and switch it out for the release application key when submitting your app to the App Store.

The latest Flurry SDK is designed to work with iOS version 4.1. If you are looking to have your app run on devices still running iOS 3.x, you can either add a couple extra linker flags as extra arguments or use an older version (2.6) of the Flurry SDK. I plan on updating the demo example to include the linker flags needed to get 3.x support with the latest Flurry SDK.

Finally, I have included a line of code in the example that appears extraneous and out of place. This is to make sure that Monotouch doesn't strip out code that Flurry has an implicit dependency on. Monotouch aggressively prunes unused code from assemblies to shrink the size of apps and this trivial demo app doesn't make explicit use of anything from a part of the CoreGraphics library that Flurry needs (something which almost all non-trivial iOS apps will do by necessity) so it gets excised during compilation.

I hope this helps get people started. The Flurry analytics are really easy to use and provide a lot of valuable data. Please let me know if you have any questions or comments on the example.

Book Review: Tapworthy

2010-08-27T00:00:00-05:00

The Book

Tapworthy: Designing Great iPhone Apps by Josh Clark

"Designing a tapworthy app means designing for an economy of time, attention, and space."

The Review

Tapworthy is an indispensable resource for developers trying to make quality mobile applications for all platforms. While the book uses iPhone apps and user interface elements to illustrate the concepts discussed, many of the observations made about the mechanics, human interactions, and the psychology of what makes great applications are applicable to all mobile applications.The book does a good job of exploring the user interface elements found in iOS apps and provides a good summary of how and why you would use the elements in your designs. The coverage of this material is quite good but pales in comparison to the exploration of what goes into making a tapworthy app. It is in this exploration of what makes a tapworthy app that I got my two main takeaways from the book.The first is to be ruthless when cutting scope and narrowing the focus of your app. To help developers and designers do this, a series of questions are provided and discussed.

It is amazing how quickly issues with your design arise when your ideas are subjected to simple questions like:

What does your app do and why?
What specific problem does your app uniquely solve for users?
What makes this app mobile?
What mobile context are you designing for?
Why would you use this app when you are away from your computer?

These questions are straightforward and may seem somewhat obvious, but they are an easy way to vet ideas. If you can't quickly provide a compelling answers for these questions, then you might not have a best selling app idea. Conversely, the questions can be used to identify weaknesses that might need more attention and potentially turn a good idea into a great one.The second takeaway was to recognize the three mobile contexts: microtasking, local, and boredom. To make a good app, you need to tightly wrap the answers to the 5Ws (who is the user, what are they doing, why are they doing it on a mobile, where are they, and when are they doing it) around one or more of these. Something common among the most successful apps is how easy it is to identify the answers to the 5W questions plus which mobile context it applies to. When the scope of an app is perfectly tailored to a specific scenario or use case, users will find that every tap has a payoff and accomplishing tasks within the app will seem effortless. Efficiency becomes a feature.

The Summary

There is so much to like about this book. Tapworthy forces us to ask the right questions in designing mobile apps and provides invaluable tips and insights about maximizing your app's user experience. If you are serious about making good apps, do yourself a favor and pick this book up. You won't regret it.

Monotouch: Facebook iOS SDK Bindings

2010-08-18T00:00:00-05:00

UPDATE (12/30/2011) : Facebook Connect bindings are being maintained by the Mono Project

The MonoTouch libraries can be found on github.

It's late and I am tired so I'll be brief. I just pushed the binding of official Facebook iOS SDK to github. In addition to the bindings, the DemoApp, which was included along side the SDK, has been ported to MonoTouch. The code is straightforward and does a good job of getting you up to speed with the important elements of the SDK.

If you want to run the demo application, you will have to create a Facebook application on Facebook and grab the app id. You need the app id to pass back to Facebook during the login process and you can find out where to put it by looking through the comments of the DemoAppViewController class.

Please let me know if you have any issues with this library. Enjoy.

Monotouch: Flurry Analytics Bindings

2010-08-06T00:00:00-05:00

The MonoTouch libraries can be found on my fork of monotuch-libs on GitHub

For an example of how to build and use the binding check out this example project on github.

For my latest app I wanted to collect some analytics to see which screens and content included in the app are the most useful to users. In evaluating my mobile analytics options, Flurry's free of charge service and easy to use API made the decision to go with them over Google Analytics and Mixpanel an easy one.Integrating Flurry analytics into your app is pretty easy but there is a small amount of setup to be done prior. You will need to grab the iPhone SDK from Flurry and also register your application with them to get an API key. The API key is unique to your application and provides Flurry a way to know who is sending events and notifications back to them to log. The SDK includes a couple header files and the Objective-C libraries you'll need to include and link against in your MonoTouch projects. Once the Flurry libraries and the MonoTouch bindings have been obtained and an API key has been generated, we can integrate them into MonoTouch application and start collecting data.Initiating data collection is as simple as calling the StartSession method with the application's API key. That is all it takes to start collecting basic information about your app like the amount of times it has been launched, the number of different users using it, and other bits of info like hardware version and service provider.Here is some code showing how to turn analytics on.

using System;
using MonoTouch.Foundation;
using MonoTouch.UIKit;
using Flurry; // include the MonoTouch binding lib

namespace Foo
{
    [Register ("AppDelegate")]
    public class AppDelegate : UIApplicationDelegate
    {
        public const string FlurryApiKey ="...";

        public override bool FinishedLaunching (UIApplication app, NSDictionary options)
        {
            // 1 liner to kick the session off
            Flurry.FlurryAPI.StartSession(FlurryApiKey);

            // Do you app thing here...
        }
    }
}

If more detailed analytics are desired, there are additional methods available to help you glean whatever meaningful information you need from your application. The example below shows how you can automatically track the changes in navigation within a tab bar. When you pass a UINavigationController or a UITabBarController to the CurrentPageViews method, each navigation action as you move from one view or tab to another gets tracked. This is ideal for seeing which parts of your app users are interacting with the most.

using System;
using MonoTouch.Foundation;
using MonoTouch.UIKit;
using Flurry; // include the MonoTouch binding lib

namespace Foo
{
    [Register ("AppDelegate")]
    public class AppDelegate : UIApplicationDelegate
    {
        public const string FlurryApiKey ="...";

        public override bool FinishedLaunching (UIApplication app, NSDictionary options)
        {
            // 1 liner to kick the session off
            FlurryAPI.StartSession(FlurryApiKey);

            // create a navigatable controller to watch...
            UITabBarController tabBarController = new UITabBarController();

            // ...and pass it to CurrentPageViews.
            FlurryAPI.CurrentPageViews(tabBarController);

            // Do you app thing here...
        }
    }
}

I am touching on just a few things that you can do with Flurry. The SDK docs describe a number of other things you can do like creating and logging custom events and tracking how much time is spent performing activities. I'd recommend checking them out after you download the libraries.I've just started collecting analytics during beta testing and things appear to working smoothly.

If you find any issues with the MonoTouch bindings please let me know. Enjoy!

Book Review: Professional Android 2 Application Development

2010-05-26T00:00:00-05:00

Reto Meier's Professional Android 2 Application Development does a great job of educating the reader on what is necessary for developing Android applications. Core application fundamentals and advanced Android features are presented to the reader via a series of real-life application examples. Readers who work the examples and leverage the breadth of coverage provided on the Android 2 framework will be well on their way towards establishing an excellent foundation for building compelling Android applications.

After giving the customary history lesson and tour of the toolsets and development environment, the first half of the book deals with the components that make up an application. Chapters are devoted to activities and life cycle, UI views, data and file access, and key Android concepts like intents (message-passing mechanisms) and content providers (ability to expose data to other apps).

Once the fundamentals have been covered, the remainder of the book is spent exploring the advanced and optional features available in the SDK. Android-centric concepts like background services, notifications and widgets are given the same in depth treatment given to the fundamentals so you get a lot of the "why" along with the how. Features and functionality that naturally lend them to being abstracted away via an API like media playback, GPS and Bluetooth are given adequate coverage of what is available via the framework and, where pertinent, the Android-specific behaviors are highlighted.

While the book is divided into fundamentals and advanced topics, continuity is maintained throughout via the example applications used to emphasize the concepts presented. By building the to-do list, compass, and earthquake monitoring service applications while reading through the book, passive learning is transformed into active, directed learning. Unlike some programming books I've read in the past, these examples do real work, accomplish specific real-life tasks, and provide some utility once completed. Readers are not just extending these applications one feature at a time, they are also adding one key concept to their proverbial tool belt while doing it.

The speed at which the Android platform is being evolved and improved upon is staggering. Since April 2009 there has been 4 major releases of the Android OS with a 5th release rumored for this fall. While the breadth of coverage provided for the APIs and framework is nice while it is still relevant, the real strength of this book comes building an understanding of the core Android fundamentals. Readers looking for a solid introduction to Android development need to look no further than Professional Android 2 Application Development.

Retargeting Visual Studio project files with PowerShell

2010-05-06T00:00:00-05:00

I originally set out to write this post a little over a year ago. Back then I threw together a script to retarget all the project files from .Net 2.0 to .Net 3.5 for my previous company and recently I found myself having to a similar upgrade from .Net 3.5 to 4.0. I ended up using the same script again so I figured I'd go ahead and publish it.

The upgrade process done by Visual Studio on your current projects and solutions will only migrate the file format to the newest schema and will not retarget the framework to the latest version. That is where the script I've included below comes in. It will retarget all the C# project files found under the path provided to version 4.0 of the .Net framework.

C# project files are XML based and navigating the DOM with Linq to XML is a cinch but there are a couple small but important steps that the script needed to include. First, you need to append the namespace to the individual element names or else the elements will not be able to be found. Second, when saving the modified XDocument, a XmlWriterSetting instance needs to be instantiated and the OmitXmlDeclaration property set to true. Setting this property to true will make sure the XML that we save will be considered a valid project file by Visual Studio.

I've included the full script below as well as created a gist that can be found here. It is important to note that this script will edit all the csproj files found under the directory specified in the path variable. Make sure you backup these files or have them under source control prior to running the script. Enjoy.

UPDATE: Added change suggested in comments by Jeffery Snover

[Reflection.Assembly]::LoadWithPartialName("System.Xml.Linq") | Out-Null#specify the root of your source tree below$path = "C:\Code\chatsworth"$ns = "http://schemas.microsoft.com/developer/msbuild/2003"$xname = [System.Xml.Linq.XName]::Get("PropertyGroup",$ns)$tfname = [System.Xml.Linq.XName]::Get("TargetFrameworkVersion",$ns)    $xws = New-Object System.Xml.XmlWriterSettings$xws.OmitXmlDeclaration = $true$xws.Indent = $truefunction updatefx($filename){    #Write-Host $filename    $xml = [System.Xml.Linq.XDocument]::Load($filename)         $result = $xml.Descendants($xname)        foreach ($i in $result)    {        $fxelem = $i.Element($tfname)        if($fxelem)        {            $i.SetElementValue($tfname,"v4.0")        }    }    $xw = [System.Xml.XmlWriter]::Create($filename, $xws)    $xml.Save($xw)    $xw.Close()}$csprojs = Get-ChildItem $path *.csproj -Recurseforeach ($file in $csprojs){    updatefx $file.FullName}

6 Thoughts about Evernote's App Design

2010-04-14T00:00:00-05:00

Evernote is one of my favorite and most frequently used applications. The ubiquity of the service via all the devices in my life (laptop, desktop, iPhone, Nexus One, web, and iPad) and the ease in which I can capture and recall notes made adopting it into my daily workflow extremely easy. By taking a closer look at the clients, it became clear that the user experience, and the design decisions behind them, wasn't a happy accident.

Lately I have been thinking about user design and experience as I prep my app for the App Store. Here are six things that stood out most about the Evernote iPhone app and the take-away ideas I got from looking closer at the app.

1. The mobile apps immediately present 4 distinct actions for note acquisition.

Evernote breaks down into two key activities: note acquisition and note retrieval. Given the detached nature of the mobile device and the sluggishness still experienced with cellular networks, the note browsing and searching experience is not ideal. The constraints of the device and the unpredictable nature of the network, I believe, led to a focus on what a mobile device is good for (note capturing) and make that the key action in the mobile versions of its application.

Having the app launch into the note acquisition screen implicitly signals to the user that this is the type of activity that you should be doing on the device. It seems counterintuitive to restrict features to simply not port them directly from the desktop or web offering. But by limiting the scope of the application, it actually maximizes the experience for the user. In Evernote's case they cannot completely focus on note capture at the expense of cutting out the other actions. These additional activities are included, but they are relegated to the tab bar on the iPhone and the sub menus on Android devices.

2. Smart layout and design can make sub-optimal experience tolerable

Given the limited real estate available on mobile devices, it is unsurprising that note browsing is a sub-optimal experience. That being said, I think that Evernote does an excellent job making due with what little space it has. Visually we are given two options, depending on the orientation of the phone, in which we can browse our catalog of notes. While holding the phone in portrait mode, each note's metadata is visible and allows the user to see titles and tags in addition to a thumbnail image of the note. While holding the phone in landscape mode, the note browser is transformed into a tiled-thumbnail view which shows more notes in the visible frame. If you can recognize the note by the rough appearance or layout of the text, you can pretty rapidly find what you are looking for.

Most people hold the phone in portrait mode so it follows that the default view is the easier of the two to quickly grasp. The two views provide the user with choices and trade offs: lower information density with a greater amount of detail or higher information density with less detail. By giving the user options, Evernote overcomes the inherent limitations of the mobile device and improves the user experience.

3. Search function is a key but clunky feature in the mobile app.

Evernote has outstanding OCR software that makes everything searchable. Given that search is the killer feature of Evernote, it is surprising that search on mobile devices seems like a second-class citizen. The typical standard search box is visible on most of the non-note capturing screens, and the text search works as expected. Search does have some enhanced features like map view and search near here offered as options to help refine your search, but I am not a fan of either. The actual search queries appear to be executed on the server side and, as a result, the processing time can vary depending on your network connection. In order to do a location based search the app has to make network requests for the search results and get the map coordinates, and this typically translates to a noticeable wait when these types of searches are performed. I feel like search could cut out the location-based search filter entirely and be no worse off.

4. Sync Button is a "kitchen drawer" tab on the iPhone App

The sync tab is mislabeled, and the label masks all the other functions that are exposed on that tab. Contextually, account information and device-specific settings aren't readily associated to sync even though the sync process in Evernote synchronizes everything associated to your account. The action of synchronizing your notes could be integrated into the note screen, and the settings, account information, and about information could all be separate tabs managed by the tab controller already being utilized in the iPhone application. In fairness the move to limit the tabs is consistent with the less-is-more type of attitude, and the combination of the multiple actions into the single tab is most likely a compromise to simplify the interface.

5. The tips UX on the iPhone is well executed and non-obtrusive

The tips screen, integrated into the main view of the Evernote iPhone app, is an excellent way of sharing information about features and activities without being pushy and obtrusive. With a smooth animation that peels back the main view to show the tips view, the user can get a quick suggestion on a feature and then be back capturing or browsing notes. This is a small but well executed design element that adds to the experience.

6. Sharp branding

As far as the aesthetics go, I like the Evernote logo. A combination of an elephant and piece of paper plays off the "memory like an elephant" saying and the note-based nature of the application. The logo, paired nicely with a soft green color and a nice font, is the focal point of the splash screen welcoming you into the application. The other platforms do not utilize a splash screen since the application load times aren't as great as the iPhone, but the same basic logo/font/color scheme is consistent in the icons used on all platforms.

Lessons learned from the Evernote app:

Instead of frustrating users with clunky interfaces and hacks to enable certain features of your service or app, only port features or activities that enhance the service and take advantage of the features of mobile devices rather than expose the limitations of them.
Focus on the activities that can capitalize on the advantages of a mobile device instead of fighting the platform.
Optimize for those specific use cases that make sense that you want to capitalize on.
Be ruthless in what you cut out or be stingy in what you put into the mobile version
Be consistent in your branding, color scheme, and feel of your applications.
Good design can always speak louder than any type of instruction. Help users fall into the pit of success.

You can get the iPhone app in the iTunes App Store

Monotouch Quickie: Network Indicator Tip

2010-04-05T00:00:00-05:00

I've used this simple technique below many times in WinForms apps to toggle the wait cursor (hourglass) during long running operations and it is applicable for the situations that call for toggling the network activity indicator in Monotouch.When used with a using statement, the indicator is turned on when the object is constructed and turned off when the code within the using statement has finished executing and the object's Dispose method is called.

public class NetworkIndicator : IDisposable{   public NetworkIndicator ()   {      UIApplication.SharedApplication.NetworkActivityIndicatorVisible = true;   }   public void Dispose ()   {      UIApplication.SharedApplication.NetworkActivityIndicatorVisible = false;            GC.SuppressFinalize(this);   }}

Usage:

using(new NetworkIndicator()){    //Make network call here}

You wouldn't want to wrap this around a UIWebView (add the toggling of the indicator to the LoadStarted and LoadFinished events) but anytime your app is making calls out the network you can wrap the using statement around the method invocation and get the user friendly network activity notification.

Thoughts on the Day of Mobile conference

2010-03-08T00:00:00-06:00

Here is a collection of thoughts that I had about the Day of Mobile conference held at IIT last Saturday. This was the inaugural conference put together by the Tech in the Middle guys, and I thought that they did a great job. I look forward to seeing what they do next.

Overall Themes

Two main themes that emerged during the sessions: the future of mobile is web-based apps rather than device specific apps, and the road to mobile riches probably doesn't run through an app store.

Multi-platform development is hard

Certainly scenarios exist where multi-platform apps make sense, but it is imperative that the risk/reward ratio be in your favor to have a chance to be successful. Don't underestimate the amount of effort and headaches that developing and supporting multi-platform apps will create. Going the mobile web app route has it's limitations, but it is the closest thing to "write once, run anywhere" that mobile has.

Cool Tools

Really cool tools like PhoneGap and jQTouch are out there that help lower the barriers to making apps and, in the case of PhoneGap, multi-platform apps. Both tools have been released under MIT licenses and are free to use.

One Man's Secret Sauce for Success

David Whatley gave a funny presentation that provided a lot of laughs and some great insights into how the iPhone app store works. Even better was his ability to back up what he was saying with some real sales data and numbers. His secret sauce for success: PR, code re-use, and playing to your strengths.

App stores are glorified catalogs

Standing out or even being noticed amongst all the other apps is extremely difficult. Relying only on the app catalog to drive sales is effectively a "post and pray" strategy akin to trying to win the lottery. Try to find a niche and solve a problem. Focus on creating value for markets not just an app for it. Mark Murphy described many ways to make money in mobile other than direct app sales during his talk and in a series of blog posts about Android Business Models.

Books Recommended During the Conference

Overall, the signal-to-noise ratio at the conference was good but not great. I did manage to glean at least one or two new ideas from most of the sessions I attended, and it was great to see the enthusiasm that the Chicago tech community has for events like this.

Monotouch Binding Gotcha

2010-02-15T00:00:00-06:00

I stumbled across a subtle gotcha while exploring binding Objective-C types in MonoTouch. As luck would have it, someone else did also and posted a question about it on the MonoTouch IRC channel. The poster of the question eventually came across the answer and shared it there, and I am going to post it here in case anyone else makes the same mistake and is looking for some answers.

I was following along with the documentation for binding new Objective-C types on the MonoTouch site, and as a way to ease into the binding process, I chose a class to define from the CloudMade SDK that I am looking to expose in MonoTouch. The class selected was the BBox class (bbox.h) and I went about creating the following API definition shown below:

using System;using MonoTouch.Foundation;using MonoTouch.ObjCRuntime;namespace CloudMade{    [BaseType(typeof (NSObject))]      interface BBox    {        [Export("westernLongitude")]        float WesternLongitude {get;set;}                [Export("southernLatitude")]        float SouthernLatitude {get;set;}                [Export("easternLongitude")]        float EasternLongitude {get;set;}                [Export("northerLatitude")]        float NorthernLatitude {get;set;}                [Export("asString")]        string AsString();    }}

Once completed, I saved it as BBox.cs and attempted to generate the bindings by invoking btouch on the file. You can see below the unsuccessful message I received.

$ btouch BBox.cs /var/folders/E4/E44PAZnZGKGpVrmseo2N3++++TI/-Tmp-/9qgrm9nm.lnv/CloudMade/BBox.g.cs(46,71): error CS0117: CloudMade</span><span style="color: #000000;">.</span><span style="color: #000000;">BBox' does </span><span style="color: #0000FF;">not</span><span style="color: #000000;"> contain a definition </span><span style="color: #0000FF;">for</span><span style="color: #000000;">Messaging'/var/folders/E4/E44PAZnZGKGpVrmseo2N3++++TI/-Tmp-/9qgrm9nm.lnv/CloudMade/BBox.g.cs(28,30): (Location of the symbol related to previous error)/var/folders/E4/E44PAZnZGKGpVrmseo2N3++++TI/-Tmp-/9qgrm9nm.lnv/CloudMade/BBox.g.cs(57,71): error CS0117: CloudMade</span><span style="color: #000000;">.</span><span style="color: #000000;">BBox' does </span><span style="color: #0000FF;">not</span><span style="color: #000000;"> contain a definition </span><span style="color: #0000FF;">for</span><span style="color: #000000;">Messaging'/var/folders/E4/E44PAZnZGKGpVrmseo2N3++++TI/-Tmp-/9qgrm9nm.lnv/CloudMade/BBox.g.cs(28,30): (Location of the symbol related to previous error)Compilation failed: 2 error(s), 0 warningsbtouch: API binding contains errors.

After looking at the errors and seeing the CloudMade.BBox' does not contain a definition forMessaging' message, it looked as if I was missing a using statement. However, this was not the case as Messaging is a class in the MonoTouch.ObjCRuntime namespace and that namespace was already included in the using statements. The problem actually turned out to be that the interface had the same name as the file and that had caused the issues shown above as the temporary classes generated during the process caused conflicts. The solution to this issue was as simple as renaming the file to something other than whatever the interfaces you are defining are named.

So the moral of the story is:

Do not give the file that the API definition is being saved in the same name as one of the interfaces that you are defining.

Steer clear of that and you'll be binding Objective-C types with ease.

Nexus One - First Impressions

2010-02-09T00:00:00-06:00

My thoughts on the Nexus One and the Android OS? I like it. A lot.

Likes

Speed. I have the older iPhone 3G hardware and from a user experience perspective it was not that bad. When compared to the Nexus One, however, it is down right sluggish. This probably isn't as big of a factor when comparing a 3GS versus Nexus One, but for someone coming from a 3G iPhone, it is a huge plus.
Being able to run apps in the background. Browsing the web while streaming Pandora and downloading an app in the background works flawlessly and shows no noticeable signs of lag or sluggishness.
The OLED screen is really nice. Higher resolution and OLED screen looks great in low-light situations and is supposed to save precious battery by not drawing less power than normal LCD screens.
The Android OS is pretty sweet. It has a lot of nice features like the status bar, an active "desktop" that you can put interactive widgets on as well as app icons, and an easy way to get music and files on and off the device.
Integration with Google Apps is fantastic as expected. I love getting mail and talk updates in the status bar and the overall experience with the apps on the Nexus One is better than on the iPhone.

Dislikes

Cut and Paste is clunky. I can see why Apple needed to spend awhile working out the UX issues before rolling it out.
The touch interaction with the device has not been as good as the iPhone in my experience. I am not sure where the blame lies (hardware or software), but I sometimes find it difficult to select elements in the UI. This is not something that occurs frequently, but in the short time I've owned the device, it has occurred enough to be noticeable.
4GB of storage out of the box is lacking. It is an easy upgrade but given the amount of money that Google is charging for the device, this seems like they are skimping here.
The Android Market place experience is integrated nicely but isn't as tightly integrated as the iTunes App Store. This is arguably a good or a bad thing depending on how you look at it. As a user this is a bad thing since it makes finding and buying apps more difficult than just popping open iTunes. I've found the Android Marketplace, both on the phone and the web, hard to browse.

There are a few negatives that I can't pin exclusively on the device but are still worth noting. I have been using my AT&T SIM with the Nexus One and most likely will do so until my contract is up in a few months. With that caveat out of the way, the talk quality seemed poor and the phone gets really hot when talking for periods greater than 10 minutes. I hesitate to even mention these issues since I am not using the phone on the network it was intended, but I know there probably are others considering doing what I did, and this feedback might help if someone is on the fence.

The Nexus One is exactly the kind of phone and competition that was needed to push Apple. I strongly recommend anyone looking for a smartphone to give it serious consideration before running out and getting an iPhone.

iPhone Wireframes

2010-02-01T00:00:00-06:00

I stumbled across a great collection of iPhone wireframe templates tonight while going through my feeds. It got me thinking about the process I've been using to layout and design the app I am working on.

I've been using regular 3 x 5' notecards to sketch out different screens for the iPhone app I am working on. On the ruled side I'll scribble notes and call out must/should/wish components of the screens to help prioritize features. On the blank side I've been sketching out wireframes of the screens to help get a feel for the UI and flow of the app.

I've played around with Balsamiq and, while the tool is fantastic, I find myself still partial to the notecards. With the same rough dimensions of the iPhone and the flexibility of being able to quickly rearrange and reorder the screens, the cards suit my preferences as a visual-spatial learner well.

As with most tools and techniques, personal preference plays a large role in how and when they're employed. I always enjoy checking out how other people work and try and steal glean ideas from them. I've found the following blogs pretty useful for design, usability, and UX. I hope they help inspire you to create something cool.

I (heart) wireframes
information aesthetics
everydayUX
Sender 11

MonoTouch Quickie : UIPasteboard Snippet

2010-01-26T00:00:00-06:00

Came across the need to plop a string onto the clipboard (aka UIPasteboard) programatically last night and hit up the MonoTouch docs to see what was involved. It wasn't readily apparent what would work for the string expected to be passed as the SetValue method pasteboardType argument. Turns out, after digging into the official Apple docs, the string you need to provide is the Uniform Type Identifier (UTI) that corresponds to the data type being passed (in my case "public.utf8-plain-text"). For my future reference (always seems to take longer to find things at the iPhone doc site) here is a table of the relevant UTIs that might come in handy in the future.

string	public.utf8-plain-text
JPEG	public.jpeg
PNG	public.png
Url	public.url

And for good measure here is a snippet that shows putting a string on the general clipboard and reading it off.

string clipboardText = "Copy and Paste Me!";
UIPasteboard.General.SetValue(new NSString(clipboardText),"public.utf8-plain-text");

string actualClipboardText = UIPasteboard.General.GetValue("public.utf8-plain-text");
Assert.AreSame( clipboardText, actualClipboardText.ToString());

Enjoy.

Updated 1/30/2010: Replaced NSStrings with strings
Updated 6/28/2012: Updated SetValue call to wrap up the C# string into an NSString as the API takes an NSObject now.

Chatsworth House Keeping and Update

2009-12-12T00:00:00-06:00

I just moved Chatsworth from Google code over to its new home on github. I've got a couple more features in mind and figured now was as good a time as any to make the switch. I already host my iPhone samples and some personal projects on github and, given the smoother branching and merging experience of git, I think it will be more conducive to spiking some features and trying some ideas out.

As for the chatbot, I've recently added a link logging feature. Any URL sent to the chatroom now gets logged to the sqlite database. Users can query the database right from the chat window by entering /links [number previous of to links return] and the links, timestamp and the person who sent it will be sent in an individual IM to the requestor.

Going forward, the two areas that I think need the most improvement are installation and documentation. The majority of the questions and feedback that I have received are setup and configuration related. Improving the installation and documentation stories at this point make the most sense and would be worth the effort.

On the technical side of things, I am considering making a Chatsworth plugin for Windows Home Server. Currently I am running the service from my home server and, given the always on nature that suits the chatbot and the low/no maintenance needed to running once it is setup, the pairing seems natural and could help provide a little better setup and configuration experience.

I hope to work on this more over the holidays and please feel free to reach out with a question or feedback. Enjoy.

Monotouch: UIAlertView + UITextField = Crazy Delicious

2009-11-28T00:00:00-06:00

If you have ever tried to buy or install anything from the App Store or iTunes on your iPhone, then you certainly have been prompted for your password by a screen that looks like this:

The control used by Apple to prompt you for your password isn't available out-of-the-box in Cocoa Touch, but fortunately it is pretty easy to roll your own. I've put together a sample project that shows a couple different techniques that are available for creating and customizing the control, and I'll go over a few of them here.

The stock UIAlertView control consists of a title label, message label, and typically one or more buttons. It is important to note that in Monotouch, a default button setup isn't configured, and buttons have to be added explicitly. If a UIAlertView is configured without any buttons, then dismissing the control will have to be done programmatically because the user will have no way to dismiss the control. In both of my examples I've configured the control to have two buttons (Cancel and Ok), but I could have gotten by with just one. If only one button is used, it is important to also note that the button is considered the Cancel button by the control, and the CancelButtonIndex property will refer to that button.

The easiest way to go about composing a UIAlertView with a UITextField is to create an instance of a UITextField and add it as a sub-view. Since you're adding a layer on top of UIAlertView's view, the key will be fitting this new control into the UI. There are two ways of going about this. The first and maybe most obvious way to solve this problem is to make some room between the message label and buttons for the text field ala the iTunes password prompt. Since the UIAlertView control has already been laid out, moving those controls around within the frame is not as straight forward a task as it may seem. Before we tackle that we will explore a simpler method that overlays the text field directly on top of the message label. You sacrifice being able to display an additional message to the user, but the end result looks professional and is very easy to implement. This will also be the basis for getting the control to have the same look and feel as the iTunes password prompt, so it is important to understand this prior to attempting to move the controls around.

The key to overlaying the text field on top of the message label is setting the bounding rectangle for the UITextField. The bounding rectangle is where the text field draws the box in which a user enters text. For our purposes, the rectangle needs to be drawn in between the title label and the buttons. It is important to make sure that it covers the area where the message label is drawn. Thanks to the work of others we know that if we start drawing the text field at the x,y offset of 12,45 that the text field will hide the message label.

The code to overlay the text field is as follows:

void PromptForName(HandlerToUse handlerType){    UITextField tf = new UITextField (new System.Drawing.RectangleF (12f, 45f, 260f, 25f));    tf.BackgroundColor = UIColor.White;    tf.UserInteractionEnabled = true;    tf.AutocorrectionType = UITextAutocorrectionType.No;    tf.AutocapitalizationType = UITextAutocapitalizationType.None;    tf.ReturnKeyType = UIReturnKeyType.Done;    tf.SecureTextEntry = false;         UIAlertView myAlertView = new UIAlertView    {        Title = "Please enter your name",        Message = "this line is hidden"    };        myAlertView.AddButton("Cancel");    myAlertView.AddButton("Ok");    myAlertView.AddSubview(tf);    // More Setup Goes Here    myAlertView.Show ();}

The method starts by instantiating a UITextField control with a bounding rectangle passed via its constructor. The rectangle itself is constructed with four parameters via its constructor: the first two parameters set the x and y offset from the origin point of the control, and the last two parameters set the size of the drawing area. After the initial construction of the UITextField, a few additional properties are set to customize the display.

Among the properties set is the SecureTextEntry. Setting this property to true will make the text field act like a password field and hide all the characters that you've entered. Once the text field has been created and initialized, we move on to creating a UIAlertView. Via object initialization, the Title and Message properties are set with some text. Finally, two buttons are created, and the text field is added as a sub-view to the UIAlertView. Calling the show on the UIAlertView causes the alert to pop up. Below you can see the rendered control.

So now that we have the basic control setup, we can tweak it so that the text field and the message label can both be displayed.

If you recall our custom UIAlertView control is currently composed of two UILabels, two UIButtons and a UITextField that we added. The UILabels are derived from UIView and is not a subclass of UIControl; whereas, the UIButton and the UITextField are both derived from UIControls. Since we want to position the UITextField beneath the labels, we can use this knowledge to selectively shift only the UIControls in the view down leaving the title and message labels in place.

To accomplish this task the following steps need to be performed:

1) The control height needs to be increased to make space for the text field and provide additional space to move the UIControls. This is done by setting the frame to a larger size. The frame will be increased by the height of the text field plus a buffer, so the control has space between it and the others. This is what the frame looks like after being enlarged:
2) Once the frame has been enlarged, we'll loop through the sub-views looking for UIControls and adjust only those types down by the same text field plus buffer offset Here is what the control looks like after each UIControl is found during the iteration through the sub-views.

Here is the code that does the control adjustment:

public class TextFieldAlertView : UIAlertView{    private UITextField _tf;        // ...         private void AdjustControlSize()    {        float tfExtH = _tf.Frame.Size.Height + 16.0f;                var frame = new RectangleF(this.Frame.X,                                    this.Frame.Y - tfExtH/2,                                    this.Frame.Size.Width,                                    this.Frame.Size.Height + tfExtH);                this.Frame = frame;                foreach(var view in this.Subviews)        {            if(view is UIControl)            {                view.Frame = new RectangleF(view.Frame.X,                                            view.Frame.Y + tfExtH,                                            view.Frame.Size.Width,                                            view.Frame.Size.Height);            }        }    }}

So now that the desired look and feel of the control has been established, it is time to wire up the control. There are a couple options for handling events generated by the control: one is more in line with how Cocoa handles events, and another that is similar to how .Net works.

The Cocoa way to wire up delegates involves subclassing a special delegate class associated to the control and selectively overriding the methods for the actions you want to customize. In the case of the UIAlertView control, that delegate class is a UIAlertViewDelegate. The delegate class includes overridable methods like Clicked where you can define the actions to take when a button on the control is clicked or where you can extend behaviors by overriding methods like Preseneted which is called after the control has been displayed to the user.

The .Net way to wire up events is to provide specific delegates for specific events. To make interacting with the Cocoa Touch controls easier, Monotouch provides public events for each one of the methods that can be overridden in the UIAlertViewDelegate class. Having the individual public events makes wiring up controls more intuitive for the .Net developer, but it is good to know about the Cocoa-style approach especially when looking at Objective-C examples and/or ADC docs. I have examples of wiring up the control via both methods in the example source.

The last topic I'd like to cover briefly is how I encapsulated the customization of control by subclassing UIAlertView. The key to getting the control to look right is to override the LayoutSubviews method and build out the text field, add it to the UIAlertView and shift the controls around there.

public override void LayoutSubviews (){    // layout the stock UIAlertView    base.LayoutSubviews ();        // build out the text field    _tf = ComposeTextFieldControl(_secureTextEntry);        // add the text field to the UIAlertView    this.AddSubview(_tf);        // shift the UIControls to fit the text field    AdjustControlSize();}

I've added some more customizations to my subclassed UIAlertView control that allows you to enable the text field security via a constructor parameter and a tweak to the control's Transform property to shift the control up so it isn't hidden by the keyboard. You can see those changes and the entire working example here on github.

Enjoy.

Links to some of the resources used: - Alert View with Prompt (iPhone Development Blog) - Displaying a password or text entry prompt on the iPhone (Junecode Blog) - Look UIAlertView is Dating UITableView (codesofa) - iPhone Dev Center: UIAlertViewDelegate Protocol Reference (Apple, login required)

Fun with Monotouch and Multi-Level Table Views without Interface Builder

2009-11-22T00:00:00-06:00

With the recent release of Monotouch, which enabled development for the iPhone/iPod Touch platform using C# and .Net, it seemed like the perfect time to take a swing at mobile app development. The strong appeal of being able to leverage my C# and .Net experience while scratching an itch that I have had for a few apps was more than enough to entice me to order a brand new Mac mini and start learning the Cocoa framework.

My pet app project requires some pretty basic multi-level tabular data visualization, so that was the first thing I attempted to tackle. I started my learning endeavor by reading the view controller programming guide from Apple's ADC and working through a few of the tutorials listed on the Monotouch site. One of the example tutorials listed was for a basic RSS reader. Armed with his guide, I got up and running with a basic table view allowed me to drill down one level deep and return to the root via navigation button. This was a great introduction and the easy to follow steps combined with the screenshots certainly hit the mark; however, this was not quite the layout I was looking for.

The data that I wanted to display calls for more than just a list-view-to-detail-view relationship that the RSS reader implemented. As a beginner trying to figure out how to wire up my custom table controllers to each other and the navigation controller all via Interface Builder resulted in a lot of thrashing and a lot of ugly code. I eventually was able to roughly approximate the behavior I wanted, but it was pretty obvious to me there had to be a better way.

I set out to see if I could find more Monotouch examples to see if I could pick up some tips and stumbled across Craig Dunn's blog. Craig not only put together apps for the Monospace and PDC conferences (and graciously provided the source) but also posted a Roget's Thesaurus app that was just what I was looking for. It was a simple app, but it had all the elements in play that I was looking for and an incredible diagram that tied it all together.

One of the key tips and tricks I picked up from Craig's code was how easy it was to cut out the Interface Builder from the process. I also generally tend to avoid using the designer whenever possible in Visual Studio but here it was a key factor in my understand. This isn't to say that I'd never use the Interface Builder again or that it doesn't have its uses because it does but there was too much magic going on in how Monotouch links up the XIBs to their backing C# classes. It wasn't until I started explicitly creating views and view controllers instead of trying to wire them up after the fact did I start to understand how things were supposed to interact.

To implement a custom UITableViewController you need to set two properties with custom classes and override a method which is invoked by the framework when the view controller is loaded. You'll need to set the TableDelegate and DataSource properties on the controller with your own implementations of UITableViewDelegate and UITableViewDataSource. The implementation of the table delegate allows you to customize how the table will respond to certain events and the data source implementation provides not only the data the table uses but also how that data is to be displayed within the table. Typically the ViewDidLoad method is overriden to perform the view setup work needed during initialization of the view controller. Within the method the TableDelegate and DataSource properties can be set.

Example setting the TableDelegate and DataSource via the ViewDidLoad method:

namespace MultiLevelTableView{    [MonoTouch.Foundation.Register("RootViewController")]    public partial class RootViewController : UITableViewController    {        class DataSource : UITableViewDataSource { / Impl Here / }        class TableDelegate : UITableViewDelegate { / Impl Here / }                public override void ViewDidLoad ()        {            base.ViewDidLoad ();                        TableView.Delegate = new TableDelegate (this);            TableView.DataSource = new DataSource (this);        }    }}

Example setting the properties during UITableView construction:

namespace MultiLevelTableView{    [MonoTouch.Foundation.Register("RootViewController")]    public partial class RootViewController : UITableViewController    {        UITableView tableView;                class DataSource : UITableViewDataSource { /* Impl Here */ }        class TableDelegate : UITableViewDelegate { /* Impl Here */ }                public override void ViewDidLoad ()        {            base.ViewDidLoad ();                        tableView = new UITableView()            {                Delegate = new TableViewDelegate(this),                DataSource = new TableViewDataSource(this),            };                        //You can set more properties here like size and            //location in the frame etc.                        this.View.AddSubview(tableView);        }    }}

The meat of the table view controller falls in the implementations of the DataSource and TableDelegate.

A basic DataSource setup involves overriding two methods used by parent controller. The RowsInSection method tells how many rows need to be displayed in the table and the GetCell method returns a cell view which was customized for display by setting the text and display properties.

class DataSource : UITableViewDataSource{    static NSString kCellIdentifier = new NSString ("MyIdentifier");    RootViewController tvc;        public DataSource (RootViewController tvc)    {        this.tvc = tvc;    }        public override int RowsInSection (UITableView tableView, int section)    {        return tvc.RootData.Count;    }    public override UITableViewCell GetCell (UITableView tableView, NSIndexPath indexPath)    {        var cell = tableView.DequeueReusableCell (kCellIdentifier);                if (cell == null)        {            cell = new UITableViewCell (UITableViewCellStyle.Default, kCellIdentifier);        }                cell.TextLabel.Text = tvc.RootData.ElementAt(indexPath.Row);        cell.Accessory = UITableViewCellAccessory.DetailDisclosureButton;        return cell;    }}

The TableDelegate is where the behavior of the table to various events is defined. It is here in which we load up the next view to display when a user clicks on a cell. A basic implementation of a table view delegate involves overriding the RowSelected method with instructions on what to do with the row now that it has been selected. If the node selected happened to be a leaf node for example we might load up the detail's view to display the nodes properties or if the node was the parent of more child nodes we would load another list view to continue to drill down into the data. In our case we want to drill down to the next layer of data which is managed by the SubGroupViewController.

class TableDelegate : UITableViewDelegate{    RootViewController tvc;    SubGroupViewController sgvc;        public TableDelegate (RootViewController tvc)    {        this.tvc = tvc;    }        public override void RowSelected (UITableView tableView, NSIndexPath indexPath)    {        // get info from selected row        string selectedGroup = tvc.RootData.ElementAt(indexPath.Row);                // load up new controller to display        if(sgvc == null)            sgvc = new SubGroupViewController(selectedGroup);                // push the controller on the navigation stack        tvc.NavigationController.PushViewController(sgvc, true);    }}

The hang up for me with using Interface Builder to try and get the multi-level table views wired together was mostly due to not being familiar with the objects I was dealing with and not understanding what properties are needed to be initialized so the framework can display them correctly. Approaching the problem via the Interface Builder created a lot of noise that made seeing what was really needed to wire these table view controllers with the navigation controller difficult. In this case the the pre-packaged templates and generic layouts provided by Monotouch and Interface Builder were more of a hindrance than help but that is to be expected while learning a new technology.

I've packaged up my implementation of a multi-level table view app and put it on github. If anyone is looking for straight-forward, simple example of nesting table views hopefully this will help.

I also recommend checking out the following links which helped me immensely: - Alex York's Monotouch posts including the RSS reader - Sabon Rai's Sample Code for UITableView - Craig Dunn's Blog

Tree Surgeon: Review and a couple tips

2009-03-07T00:00:00-06:00

This past week I was playing around with Hudson and Team City and getting some NAnt scripts put together to use. In a happy coincidence I happened to catch a mention about Tree Surgeon from twitter and it had piqued my curiosity. Tree Surgeon is a project on CodePlex that has been around for a while and helps automate the process of setting up a source tree and assembling build scripts. It was just what I was looking for.

The goal of Tree Surgeon was to make setting up and laying out new projects using best practices dead simple. All the major tools and libraries that typically find their way into your .Net source trees are provided for you. In addition to laying out the directory structure for your source and libraries, a solution file gets created with three main projects to get you started. The basic project setup includes a console app, core library and unit test project. The build scripts come pre-wired to have NCover run your tests and generate reports from the results and also do things like packaging your build artifacts into zip files for deployment.

The whole process, start to project generated, is very easy. Download and run the installer. Launch the program, select the version of Visual Studio (2003, 2005, and 2008) and the flavor of testing framework (NUnit or MbUnit) and then hit generate. The files and directories, built out in your Documents folder, are then created and ready to be used.

There are two slight issues I ran into that I'd like to point out. Both issues had already been noted in the project forums and were easy to fix. When generating a source tree with MbUnit selected as the unit test framework, the build script generated has the unit test assembly referenced is named incorrectly. You will have to change it to match your project's unit test assembly name. The second issue has to do with running NCover and NUnit on x64 machines. I found that in order for NCover and NUnit to work on x64 machines I had to add two calls to the CorFlags utility to make executables work. This was accomplished by making the modifications to the "˜run-unit-tests' target below on lines 5-8.

   1: <target name="run-unit-tests">

   2:     <mkdir dir="${build.dir}\test-reports" />

   3:     <exec program="regsvr32" workingdir="tools\NCover" commandline="/s CoverLib.dll" />

   4:     <!-- Need the CorFlags Commands For x64 -->

   5:     <exec program="C:\Program Files\Microsoft SDKs\Windows\v6.0A\Bin\CorFlags"

   6:         workingdir="tools\NCover" commandline="NCover.Console.exe /32BIT+" />

   7:     <exec program="c:\Program Files\Microsoft SDKs\Windows\v6.0A\Bin\CorFlags"

   8:         workingdir="tools\NUnit" commandline="NUnit-Console.Exe /32BIT+" />

   9:     <exec program="tools\ncover\NCover.Console.exe"

  10:         workingdir="${build.dir}\Debug\UnitTests">

  11:         <arg value="//w &quot;.&quot;" />

  12:         <arg value="//x &quot;..\..\test-reports\Coverage.xml&quot;" />

  13:         <arg value="&quot;..\..\..\tools\nunit\nunit-console.exe&quot;" />

  14:         <arg value="&quot;MyProjectName.UnitTests.dll&quot;

  15:             &quot;/xml:..\..\test-reports\UnitTests.xml&quot; &quot;/nologo&quot;" />

  16:     </exec>

  17: </target>

Even though I am pretty late to the party with Tree Surgeon I am very happy to have stumbled across it. The whole source tree and build script setup process is the perfect thing to script out and I am really glad the project creator and contributors have taken the time to do this. It is a big help and I highly recommend you try it out the next time you are spinning up a new source tree for a project.

Alt.Net Seattle Recap

2009-03-05T00:00:00-06:00

I spent last weekend at the Alt.Net Seattle conference and had some time to reflect on it. This was my first experience with an open spaces style conference, and I have to admit that I am a big fan of the format. While I am not convinced this format would work for every type of gathering, it fit the needs for this type of group very well.

There was a lot made during a couple of sessions about being more accessible, newbie friendly and encouraging more new faces and ideas at these events. If you watch some of the video from Hanselman's Why So Mean session, you can get the general gist of some of the problems and solutions offered. While I think introspection is generally a good thing, I am not convinced that any progress on this front will be made, and question if these issues are as bad as some may think. As a first-time Alt.Net conference attendee and having only met one other person there in real life prior to last weekend, I never felt unwelcome or shunned and everyone that I talked to was cordial and friendly and definitely open to discussion.

However I didn't get on a plane to Seattle to talk about feelings. What drew me to the conference was the opportunity to talk about the software with some of the most passionate and opinionated developers in the world. By participating in the workshops and sessions, I was able to soak up and participate in some great conversations about agile and lean, LINQ, DDD, context/spec based testing, etc. These are topics that I don't always have the opportunity to discuss daily and certainly not with people who have the kind of expertise as those who were in Seattle. I've already been able to apply at work and on my side projects some of the things I've picked up, and I don't think I'm close to truly synthesizing all of the great conversations that I had.

While my overall experience was positive and worth both the time and expense, I did feel like there were some minuses from the trip. Some of the sessions turned out to be essentially just presentations and spurred very little discussion or participation. I expected that there might be some of this due to the lack of experience or expertise with the tech. Sessions like Miguel de Icaza's on Mono and the iPhone fell into that category since virtually no one there had any experience with developing for the iPhone and even fewer with Mono, but even things like some of the discussions on more common topics like DDD or Agile were somewhat eyes forward discussions and lacked some of the give and take that really made some of the other sessions.

Some of this may have been the result of people deferring to some of the ahem stronger personalities or undisputed domain experts in the field. The presence of some of these personalities in the sessions clearly defined or dramatically shifted the discussions. It did not take me long to learn and apply the law of two feet when I found myself at the same sessions as some of these people. I knew that it was a matter of time until the session's conversation was going to degrade or grind to a halt. My last complaint about the conference is about some of the new age crap that that was brought in by the facilitator. I don't think the butterfly and bumblebee metaphor stuff or the ringing of the bell really added to the experience and was not needed. I know that the facilitators were trying to make this a very Zen-like experience, but it was not.

In terms of key take-aways, I think I've identified a few. I talked with quite a few people about their experiences with agile and scrum. In hearing some other companies' practices and problems, I was comforted by the knowledge that my current company is not as dysfunctional as I thought. While I still think we can improve, I also realized that I should probably take a moment to appreciate the good things that we do and celebrate the stuff that what works well. The other take-away was that I feel like I am in a much better position to clearly articulate the goals that I had set for myself earlier this year. Prior to this weekend I had not done a good job articulating some of these goals and had yet to express them in SMART terms. Now I am going to incorporate things like contributions to open source projects and community demos and/or presentations into my measurables when tracking my progress on some of my goals.

The future of these conferences I think will be in the local or region open spaces starting to be held. Already conferences are planned for Vancouver and Houston that seem to fit this bill because they are drawing in people from the region versus nationally based on a quick perusal of their attendee list. I speculate that if you reduce the concentration of some of the more well known personalities in the community, you might be able to make up for any potential loss of expertise with an increase in the amount of active participation from fresh new faces. Additionally, I think some might find the benefits of participating in open discussions with developers in their own communities more meaningful as these types of interactions may yield long-term benefits.

Lastly, I'd like to thank the people of the Alt.Net Seattle group for putting this together, and you should be proud of the success the conference achieved. Job well done.

Chatsworth: A Google talk group chat bot

2009-01-26T00:00:00-06:00

For the past year and a half, I've been using PartyChat to participate in multi-user chats with friends. PartyChat essentially provides IRC type functional via GTalk and has been a great way to have on going conversations throughout the day while avoiding 100+ email threads.

The only pitfall PartyChat has to do with stability. PartyChat is a free service used by a large number of people, and it is run off the project creator's computer in his apartment. I do not know exactly why the service goes down intermittently, but the recipe of home server plus lots of users cannot be helping. While it stinks that PartyChat isn't always up, I understand I have no right to demand or expect 100% uptime, so I decided to do something about it. I leveraged some of the knowledge I picked up about XMPP, the protocol that Jabber and GTalk use, from another project and wrote a simple group chat bot called Chatsworth to improve the availability of group chat that my friends and I use and depend on.

Chatsworth is a windows service written in C# that provides basic chat room functionality. It does not have all the features that PartyChat has, but it does offer people the ability to setup and manage their own chat bots. Additionally, if you are concerned about having all your chat logs being available not just to Google but also to the people running the PartyChat servers, then Chatsworth is the group chat provider for you. Chatsworth is fully functional but still immature and under development. I plan to add some additional features, take care of a few loose ends and provide more unit tests in the immediate future.

Admittedly I could've just downloaded the PartyChat java source, compiled it, and ran it on my own set of servers, but where is the fun in that? I figured rolling my own chat bot would give me the opportunity to do more than address some of the availability issues I was having. Starting up Chatsworth provides me a non-trivial project that I can use to explore different software development concepts and techniques as well as get some code and design samples out on the web. So if you're in the market for group chat in GTalk, give Chatsworth a try. I am looking forward to building this project out further and would love to hear any feedback.

Just Say No To The Big Redesign

2009-01-11T00:00:00-06:00

--- wordpress_id: 78 layout: post title: Just Say No (to the Big Redesign) tags: - development - refactoring - programming

wordpress_url: http://blog.kevfoo.com/index.php/2009/01/just-say-no-to-the-big-redesign/

In a post Robert Martin made last Friday, he described a pretty common scenario that companies and teams go through in an effort to bring peace and harmony to their codebase and restore order over all their components, known as the big redesign. Having just gone through this at work and having been on the "Tiger Team" that ported/rewrote our legacy application shell that was a muddled mix of C++/MFC and C#/WinForms, this post really resonated with me.

The moral of Uncle Bob's story is that the only way to clean up messes in your codebase is to do via incremental changes iteration by iteration and release by release. If I would have read this post six months ago, I might have argued that this is an overly simplistic take and that exceptional cases exist that make big redesigns necessary. Having just gone through a big redesign; however, I am confident that fixing your messes iteration by iteration is the only way to fix your codebase issues for the long term especially if your team is trying to develop with agile processes.

My redesign change of heart did not come because of a spectacular failure or the system ending up in a worse shape than before. I like to think our sob story about how terrible our legacy codebase was made a pretty compelling case for a redesign (doesn't everyone?) but I'll spare you the back story. When it comes down to it, even the best reasons and intentions don't justify a full blown redesign.

Here is why in big bold letters:

You are not addressing the root causes

A codebase does not fall into disrepair over night. Having the Tiger Team do all the heavy lifting and making all the design decisions might solve the problem righthissecond but none of the problems that got you in this bind will have been addressed. Also, if the redesign is radical enough, you could actually be reducing your teams ability to manage and maintain your codebase even further. Choosing to solve your team's problems by delegating cleanup to a Tiger Team is the software management equivalent of giving a man a fish instead of teaching him how to fish.

Crunching some NFL Stats with F#

2009-01-10T00:00:00-06:00

To explore functional programming, I've decided to return to a familiar problem domain, football stats. I used this domain a couple years ago when I was in the process of making the transition from the Unix-based OS/Java world to the Microsoft/C# world. I am the type of person that learns better by doing than studying, so I'm going to try and jump in and cobble something together to start the learning process. I've watched the PDC presentation by Luca Bolognese, and I've read through the first couple chapters of Don Syme's Expert F#, so consider me armed with an F# Interactive window and dangerous.

The first stat that I plan to look at is the QB Score Stat as outlined by Berri, et al. in Wages of Wins. The stat is much easier to calculate than the traditional QB Rating used by the NFL, and if you read the link and/or book, you'll see that it correlates much better to wins and points than QB rating. For our purposes, I'll just outline the formula here but I do recommend checking out the links for more info.

QB Score = Total Yards - 3 * Plays - 30 * Turnovers

I got the 2008 QB stats from Yahoo, dumped them into Excel and then saved them off into CSV. This can be done programmatically fairly easily with HtmlAgilityPack and Linq to Xml but I'll save that for another post. I've provided a copy of the stats in CSV here.

So to get started here is what we have to do in order to calculate the raw QB score and the QB score per play for all the NFL QB's:

 1. Read in the CSV file 
2. Grab the relevant stats for our calculation 
3. Calculate the QB score per play for each QB 
4. Return the QB name and the score.

I'll tackle this step by step and we can verify our results via the F# Interactive window.

To read in the file we can leverage the .Net System.IO library. The call pattern to read a file into memory is identical to what you would see in C# or VB and is pretty straight forward.

 &lt;br /&gt;#light    &lt;br /&gt;open System.IO    &lt;br /&gt;let filePath = &amp;quot;D:\code\data\QB_Stats_2008.csv&amp;quot;    &lt;br /&gt;let stream = new FileStream(filePath, FileMode.Open)    &lt;br /&gt;let reader = new StreamReader(stream)    &lt;br /&gt;let csv = reader.ReadToEnd()    &lt;br /&gt;

Here is the output of the F# interaction window. val filePath : string val stream : System.IO.FileStream val reader : System.IO.StreamReader val csv : string As we can see from the output, 'csv' is string that holds the contents of the QB stats file. Since we know that the file is is a CSV file, we can break it down into its individual elements like so:

 &lt;br /&gt;let stats =    &lt;br /&gt;csv.Split([|'\n'|])    &lt;br /&gt;|&amp;gt; Seq.skip 1    &lt;br /&gt;|&amp;gt; Seq.map(fun line -&amp;gt; line.Split([|','|]))    &lt;br /&gt;|&amp;gt; Seq.map(fun values -&amp;gt;    &lt;br /&gt;string values.[0], // qb name    &lt;br /&gt;System.Int32.Parse(values.[5]), // att    &lt;br /&gt;System.Int32.Parse(values.[7]), // pass yds    &lt;br /&gt;System.Int32.Parse(values.[11]), // int    &lt;br /&gt;System.Int32.Parse(values.[12]), // rushes    &lt;br /&gt;System.Int32.Parse(values.[13]), // rush yds    &lt;br /&gt;System.Int32.Parse(values.[17]), // sacks    &lt;br /&gt;System.Int32.Parse(values.[20])) // fumbles lost    &lt;br /&gt;

Since 'csv' is a string, we can use the Split method to chunk the string up into individual lines using the '\n' character as our split token. Once split into individual lines, the pipeline operator on line 3 further processes each line. Sequences in F# can be thought of as IEnumerables from C# and come with some nice baked-in methods to help with processing. Our QB stats CSV file has as its first line a key to the data. We'll need to skip that first line before we get to process the real data, and to do so we'll use one of those nice baked-in methods (Seq.skip) to do so.

Line 4 further deconstructs the csv file into the individual comma delimited values tokenizing each line. After the lines have been tokenized the individual values can be read. Here I've created a tuple to hold each lines values. The tokenized values have been collected in a tuple that holds 8 values. The mapping of the values is specified by the comments.

Here is the output of the F# interaction window after step 2:

_val stats : seq _

After step two we have a sequence of tuples that have only the stats and information that we care about. The next step now becomes calculating the QB score. The calculation of the score requires three sub-steps, so let us revise the outline we laid out earlier to include them.

 1. Read in the CSV file 
2. Grab the relevant stats for our calculation 
3. Calculate the QB score per play for each QB

Create the formula function
Compute the components of the formula
Create the desired output
1. Return the QB name and the score

Let's tackle the first sub-step and codify the formula now and see what we'll need to provide from the data we just acquired.

 &lt;br /&gt;let qbcalc (plays,yards,turnovers) = yards - 3 * plays - 30 * turnovers    &lt;br /&gt;

This line of code creates a function called qbcalc that takes in a tuple composed of the plays, yards, and turnovers components of the formula.

If we run the qbcalc function through the interactive window we get:

val qbcalc : int * int * int -> int

The end result of this is the raw QB score. The arithmetic operations in F# are similar to most languages, so the formula is a straight forward expression without any surprises. Since we know plays, yards and turnovers are all integer values, we could further constrain the types of values that the tuple is composed of, but F#'s type inference already does this for us, so it is not needed. When the compiler analyzed this code, it was able to ascertain from the operations and the integers used that the plays, yards and turnover values were of type int and automatically created the int constraints.

The next step is to compute the individual values of plays, yards, and turnovers. Before we start, I just want to note that I am sure there is a slicker, more concise way to do this, but this is my first go at this, so pardon the mess.

 &lt;br /&gt;let names = stats |&amp;gt; Seq.map(fun(name,_,_,_,_,_,_,_) -&amp;gt; name)    &lt;br /&gt;

Here we start to perform operations on the stats sequence we captured from the CSV file. The basic structure of what I am doing here is grabbing the specific values of the components I am looking to either aggregate (names) or calculate (plays, yards, and turnovers) from the sequence and mapping them to a new sequence. Here is an example of how to create the plays sequence.

 &lt;br /&gt;let plays = stats |&amp;gt; Seq.map(fun(_,att,_,_,rush,_,sacks,_) -&amp;gt; att+rush+sacks)    &lt;br /&gt;

Here the stats sequence is pushed through the pipeline operator ( |> ) which allows you to chain functions in a sequence. This is happens because, as pointed out in Expert F#, the pipeline operator is just function application in reverse. This can be expressed like so:

 &lt;br /&gt;let (|&amp;gt;) x f = f x     &lt;br /&gt;

So in our case when we have the following:

stats |> Seq.map (fun(,att,,,rush,,sacks,_) -> att+rush+sacks)

Chaining the stats sequence with the the Seq.map function will apply the function we've defined in the parenthesis to each element in the stats sequence and return a new sequence with the results of the function. The function we have defined has a signature that matches the 8 value tuples that compose the stats sequence. Since only a few values are needed to be computed for the various values, "˜_' can be assigned to the values in the parameter definition and more meaningful names can be given to the values we care about. On the right hand side of the -> (a symbol that represents a function), we do the simple adding of the values. Again the results of this function are collected in a new sequence that is returned from the Seq.map call.

After all the individual components of the QB score formula have been computed, we're left with a bunch of individual sequence values that need to be reconstructed into something that we can pass to the the qbcalc function. The calculation function is defined as taking a tuple composed of a play, yard, and turnover values, so we need to utilize another method that Seq provides called zip.

Here is the code that crunches the individual components.

let getStats = let stats = loadQBStats let names = stats |> Seq.map(fun(name,,,,,,,) -> name) let plays = stats |> Seq.map(fun(,att,,,rush,,sacks,) -> att+rush+sacks) let yards = stats |> Seq.map(fun(,,passyd,,,rushyd,,) -> passyd + rushyd) let turnovers = stats |> Seq.map( fun(,,,int,,,,fum) -> int+fum) Seq.zip3 plays yards turnovers |> Seq.zip names

The final step to complete is to apply the qbcalc function to each play, yard and turnover tuple, and zipping up the resulting sequence with the names sequence rounds out steps and completes our task. The values were balled up into tuples in previous steps, so a lot of what is left to do is unpacking what we need to do the actual calculation and then reassemble to the output. The unpacking of the tuples are done with the fst and snd functions that are applied to the sequences. These methods return the fst, and the snd functions return the first and second elements of the tuples respectively. The last line of the doCalc function divides the raw QB score over the plays completing the calculation and then back pipes that sequence to be zipped up with the names. The zipped sequence gets returned, and at last we've calculated the QB score per play for the 2008 season. The last thing to note with the calculation is that in order to get better precision from the final result, the int values being divided need to be converted to a decimal. If the integers aren't converted, then the results of the division operation will be rounded down, and we'll lose precision on the calculation.

  &lt;br /&gt;let doCalc =     &lt;br /&gt;let stats =    &lt;br /&gt;getStats    &lt;br /&gt;let names =    &lt;br /&gt;stats |&amp;gt; Seq.map fst    &lt;br /&gt;let rawScore =    &lt;br /&gt;stats    &lt;br /&gt;|&amp;gt; Seq.map snd    &lt;br /&gt;|&amp;gt; Seq.map qbcalc    &lt;br /&gt;let plays =     &lt;br /&gt;stats    &lt;br /&gt;|&amp;gt; Seq.map snd    &lt;br /&gt;|&amp;gt; Seq.map (fun (plays,_,_) -&amp;gt; plays)    &lt;br /&gt;let components =    &lt;br /&gt;Seq.zip rawScore plays     &lt;br /&gt;Seq.zip names &amp;lt;| Seq.map(fun(x:int, y:int) -&amp;gt; System.Convert.ToDecimal(x)/ System.Convert.ToDecimal(y)) components    &lt;br /&gt;

Below is the complete source listing of my first crack at doing something useful with F#. There are a couple things (the packing and repacking of the tuples, the CSV parsing) that scream "optimize me". In my next F# post, I'll refactor this code to slim it down and package it up so I can display these results graphically via C#.

 &lt;br /&gt;#light    &lt;br /&gt;open System.IO&lt;/p&gt;  &lt;p&gt;let loadQBStats =   &lt;br /&gt;let filePath = &amp;quot;D:\code\ProFootballDB\Data\QB_Stats_2008.csv&amp;quot;    &lt;br /&gt;let stream = new FileStream(filePath, FileMode.Open)    &lt;br /&gt;let reader = new StreamReader(stream)    &lt;br /&gt;let csv = reader.ReadToEnd()&lt;/p&gt;  &lt;p&gt;let stats =   &lt;br /&gt;csv.Split([|'\n'|])    &lt;br /&gt;|&amp;gt; Seq.skip 1    &lt;br /&gt;|&amp;gt; Seq.map(fun line -&amp;gt; line.Split([|','|]))    &lt;br /&gt;|&amp;gt; Seq.map(fun values -&amp;gt;    &lt;br /&gt;string values.[0], // qb name    &lt;br /&gt;System.Int32.Parse(values.[5]), // att    &lt;br /&gt;System.Int32.Parse(values.[7]), // pass yds    &lt;br /&gt;System.Int32.Parse(values.[11]), // int    &lt;br /&gt;System.Int32.Parse(values.[12]), // rushes    &lt;br /&gt;System.Int32.Parse(values.[13]), // rush yds    &lt;br /&gt;System.Int32.Parse(values.[17]), // sacks    &lt;br /&gt;System.Int32.Parse(values.[20])) // fumbles lost    &lt;br /&gt;stats&lt;/p&gt;  &lt;p&gt;let qbcalc (plays,yards,turnovers) = yards - 3 * plays - 30 * turnovers&lt;/p&gt;  &lt;p&gt;let getStats =   &lt;br /&gt;let stats = loadQBStats    &lt;br /&gt;let names = stats |&amp;gt; Seq.map(fun(name,_,_,_,_,_,_,_) -&amp;gt; name)    &lt;br /&gt;let plays = stats |&amp;gt; Seq.map(fun(_,att,_,_,rush,_,sacks,_) -&amp;gt; att+rush+sacks)    &lt;br /&gt;let yards = stats |&amp;gt; Seq.map(fun(_,_,passyd,_,_,rushyd,_,_) -&amp;gt; passyd + rushyd)    &lt;br /&gt;let turnovers = stats |&amp;gt; Seq.map( fun(_,_,_,int,_,_,_,fum) -&amp;gt; int+fum)    &lt;br /&gt;Seq.zip3 plays yards turnovers |&amp;gt; Seq.zip names&lt;/p&gt;  &lt;p&gt;let doCalc =    &lt;br /&gt;let stats =    &lt;br /&gt;getStats    &lt;br /&gt;let names =    &lt;br /&gt;stats |&amp;gt; Seq.map fst    &lt;br /&gt;let rawScore =    &lt;br /&gt;stats    &lt;br /&gt;|&amp;gt; Seq.map snd    &lt;br /&gt;|&amp;gt; Seq.map qbcalc    &lt;br /&gt;let plays =     &lt;br /&gt;stats    &lt;br /&gt;|&amp;gt; Seq.map snd    &lt;br /&gt;|&amp;gt; Seq.map (fun (plays,_,_) -&amp;gt; plays)    &lt;br /&gt;let components =    &lt;br /&gt;Seq.zip rawScore plays     &lt;br /&gt;Seq.zip names &amp;lt;| Seq.map(fun(x:int, y:int) -&amp;gt; System.Convert.ToDecimal(x)/ System.Convert.ToDecimal(y)) components    &lt;br /&gt;

Useful links:

 - [Expert F# (Expert's Voice in .Net)](http://www.amazon.com/gp/product/1590598504?ie=UTF8&tag=kev02-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1590598504) 
- [Microsoft F# Developer Center](http://msdn.microsoft.com/en-us/fsharp/default.aspx "http://msdn.microsoft.com/en-us/fsharp/default.aspx") 
- [PDC Video : Introduction to Microsoft F#](http://channel9.msdn.com/pdc2008/TL11/) 
- [QB Score Stat](http://dberri.wordpress.com/2007/09/09/a-new-qb-score/) from [Wages of Wins](http://www.amazon.com/gp/product/0804752877?ie=UTF8&tag=kev02-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=0804752877)

Exploring functional programming

2009-01-04T00:00:00-06:00

I am trying to heed the Pragmatic Programmer's advice to learn a new language each year and this year I figured it would not be a bad idea to look at functional languages. There is a lot of buzz and blog posts about functional programming going on right now so there should be plenty of fresh material and this won't be my first exposure to functional programming. I'll have to dust off some of my notes from the programming languages class I took during some of my masters work.

I am planning to follow along with the Real World Haskell book club (which starts tomorrow night) and also mess around with F# so I thankfully won't have to rely on my one semester of OCaml to help me get going. As a fan of sports and statistics I'll probably try and use that as my problem domain while exploring these languages. I am really looking forward to trying to wrap my mind around functional programming as it is so different than thinking about objects and should be a great "neurobic" activity for the ol' brain.

Best thing I have read all day

2009-01-04T00:00:00-06:00

"Most programmers think it is a sin to write code w/o comments, but it is a greater sin to write code that cannot be understood without them" Paul Berry via Twitter

F# Support for the SyntaxHighlighter WordPress Plug-in

2009-01-02T00:00:00-06:00

I added the F# keywords to syntaxhighlighter.php and added the F# brush that Elijah Manor put together to the SyntaxHighlighter WordPress plug-in. I am not sure if anyone is still maintaining that project but you can download the zip here and install it the same way as the original.

To highlight F# code you can now do [sourcecode language="'f#'"]code here[/sourcecode]. You can also swap out "˜f#' for "˜f-sharp' or "˜fsharp'.

Mini9 & Vista Quick Review

2009-01-01T00:00:00-06:00

I have been playing around with my Dell Mini9 (1Gb RAM, 32GB SSD) netbook that I picked up recently over the holidays and finally got around to swapping the Ubuntu installation that came from the factory with a slimmed down version of Vista Ultimate. For a machine that has the type of resource constraints and intended use (email/web/light office app work) a typical full Vista install wouldn't be practical but thanks to the vLite configuration tool I was able to shrink my installation footprint down to roughly 3.5Gb. If you have the right tools (a couple gig flash drive, access to a copy of Vista, and some patience) then the conversion isn't that painful or time consuming. The one recommendation that I would like to emphasize is make sure that you have all the drivers downloaded ahead of time especially the network drivers since neither the wireless or Ethernet drivers got installed by default.. You can dump them on the flash disk as they don't take up that much space and it will expedite the process of getting your system fully operational.

Here are some of the links that I relied on heavily to get me through the conversion:
- Rick at Night's Install Vista on Dell Mini 9 (USB) Guide - K-Lite Mega Codec Pack - Dell's Inspiron Mini 9 (910) Driver Downloads (You can use the Windows XP drivers)

For a resource constrained machine it certainly does not seem sluggish. The Vista experience, while not in the same league as my tricked out M1530, is not terrible and the solid state drive really makes a world of difference in these netbooks as they are silent, low power, and fast as hell.

In my eyes the one serious drawback of these Mini9's is the size and layout of the keyboard and touchpad. The keyboard on a 9" laptop obviously has to be compressed and tradeoffs conceded but for someone like me who has stubby fat fingers this becomes more of a problem than I'd thought. The other major issue I have is with the touchpad. The touch sensitive surface that comprises the touchpad runs all the way to the space bar without any buffer or separation. I continuously hit the touchpad surface causing the cursor or focus to jump to where the pointer is. The keyboard issue by itself isn't a terrible problem, I'm sure I'll acclimate, but when you compound that with the lack of a buffer between the space bar the whole keyboard/mouse experience becomes extremely frustrating. I bought a bluetooth notebook mouse and can turn off the touchpad so I am not impacted by inadvertent contact but that defeats the purpose of this device for me since I'd much rather have my 15" laptop if I am going to have to be sitting at a table/desk/tray to use the external mouse for any length of time.

Overall the Mini9 isn't bad for couch surfing and travel but this isn't a machine that I could use for extended periods of time in the situations where a netbook would be convenient. While I like the concept and the price point that this class of portable addresses I can't strongly endorse the mini9 due to the layout and design of the keyboard and touchpad. s