SubText is the engine behind our company blog. With the goal of ensuring a smooth transition between the main website and the blogs, I spent some time tightening up the styles for the aggregate and individual blogs last week.  This required a custom SubText skin and lot of css tweaking.

Though I’ve previously had the SubText source running on my machine, there was no need to update or rebuild the solution in my current case so just went ahead with a local installation using the Microsoft Web Platform Installer (Web PI). 

I just checked the SubText box, provided answers to a few key setup questions (admin user credentials, SubText database, etc) and I was up and running in minutes.  

Once the setup was complete, I was asked if I’d like to launch SubText.  The SubText Installation Wizard picked up where Web PI left off and the setup couldn’t have been easier. 

Web PI provides quick and easy installs for lots of goodies.  Check it out.

Hey there. From time to time I’m going to use this space to write about my perspectives on IT management and strategy. With that as a warning, I'll dive right in...

The first topic I want to discuss is one I have nerded-out on for years. It’s the issues I've seen when IT (and some Business) Management use Return on Investment (ROI) calculations.

ROI's (as I understand it) are universally used in Finance to calculate investment returns.  However, like so many other business practices, IT Managers have grabbed onto the concept and tried to apply it to their "project portfolios".  In theory, using core investment calculations to inform IT business decisions is awesome.  However, I’ve found that using ROI's for something as complex as IT projects often leads to some pretty bizarre behavior and findings. The worst part is that having talked with tons of IT decision-makers over the years, invariably they’ll want to talk about the ROI of the project at some point.  Urgh.

OK - without sounding like too much of a curmudgeon, I think a simple ROI (what did I get, minus what did I spend) works really well for something like a stock sale.

I sold it for $8, I bought it for $5. Boo-yah - I made $3! Now I'll account for the taxes and transaction fees, and maybe I’ll display my awesome investing prowess as a percentage…

However, IT projects are a much more complicated transactions and the simple correlations of “buy price” and “sell price” aren’t enough. There are tons of reasons why your company could have sold more products or gained employee efficiency, and trying to trace those reasons to one or two IT projects is really, really difficult (read: probably wrong).

Plus, in our line of work we are often asked to represent ROI’s as a forecast (what do I think I'll get, minus what do I think I'll spend) instead of actual dollars. I’ll come back to this at another time, but we’ve all seen the gamesmanship that’s brought into the forecasting piece.

This new project should save everyone in the company an hour a week – they’ll of course use every minute of that that time selling more products - so this project is actually going to make the company more money…

Regardless of how you deal with the complexities of accurately calculating and estimating Research, Development, Sales, Opps and Warranty costs against expected returns over time (adjusted for NPV), it’s my contention that the most critical question in IT projects usually goes unaddressed in forecasts…

What’s the chance the return’s going to come at all?

For example, using the simple “stock” math of cost versus return you can make a good case for buying lottery tickets.

I can make 10 million bucks, and it only costs me a dollar! Huzzah! I’m totally gonna’ get a raise!

The problem is that the chances of winning the 10 million are 1 in 100 million.

Oops! That means, I could end up spending… uhm, carry the 1… Oh…

Unless you address the core question of “What are the odds I’m going to see a return?” ROI forecasts can be totally bunk. You should at least be able to argue that the project has a reasonable chance of succeeding (or even completing) before you plunk down a single dollar in the investment.

So – more to come on this topic in the future. ROI’s seem simple, and yet more often than not I’ve seen them miscalculated, misunderstood and/or misused.  IT Leaders seem to love them, and yet having worked on dozens (hundreds?) of them over the years, I am extremely suspicious of their results.

I think there's a better way to calculate and forecast the return, cost and % chance likelihood of success.  I'll try to get on that really soon...

I just wrote about how I like to present on unfamiliar topics. With this said, Domain-Driven Design (DDD) is no exception. This is yet another area I knew enough about to be dangerous but I certainly was no expert.  As it turns out, researching this topic wasn’t easy. I could be wrong, but it is as if DDD is a secret to which few are privy. If you search the Interwebs, you will likely find little information about DDD until you start rolling over rocks to find that one great write-up, a handful of podcasts and videos and the Readers’ Digest version of the Blue Book which apparently you must read if you really want to get the complete, unabridged skinny on DDD.  Even Wikipedia’s write-up is skimpy which I didn’t know was possible…

Here’s a list of valuable resources.  If you, too, are interested in DDD, this is a good starting place. 

1. Domain-Driven Design: Tackling Complexity in the Heart of Software by Eric Evans
2. Domain-Driven Design Quickly, by Abel Avram & Floyd Marinescu
3. An Introduction to Domain-Driven Design by David Laribee
4. Talking Domain-Driven Design with David Laribee Part 1, Deep Fried Bytes
5. Talking Domain-Driven Design with David Laribee Part 2, Deep Fried Bytes
6. Eric Evans on Domain Driven Design, .NET Rocks
7. Domain-Driven Design Community
8. Eric Evans on Domain Driven Design
9. Jimmy Nilsson on Domain Driven Design
10. Domain-Driven Design Wikipedia
11. What I’ve Learned About DDD Since the Book, Eric Evans
12. Domain Driven Design, Alt.Net Podcast
13. Applying Domain-Driven Design and Patterns: With Examples in C# and .NET, Jimmy Nilsson
14. Domain-Driven Design Discussion Group
15. DDD: Putting the Model to Work by Eric Evans
16. The Official DDD Site

In this presentation, I provided a brief introduction into TDD and talked about the confusion and misconceptions around the discipline. I, of course, shared a bit about Dan North, the father of BDD and touched upon some crazy hypothesis dreamed up by Sapir and Whorf. I then gave a Behavior Driven Development overview (my impressions of the implementation and lifecycle) and then touched upon available tools, how to get started and I threw in a number of reference and reading materials which you will find below.

As an added bonus, I demonstrated how easy it is to include/exclude hyphens and alter the spelling of “behavior” at will.

1. Introducing BDD, Dan North
2. Oredev 2007 - Behaviour-Driven Development, Dan North
3. Behavior-Driven Development, Scott Bellware
4. Behavior Driven Development, Wikipedia
5. BDD Wiki
6. A New Look at Test-Driven Development, Dave Astels
7. Behavior Driven Development – An Evolution in Testing, Bob Cotton
8. The Truth about BDD, Uncle Bob Martin
9. Language and Thought, Wikipedia
10. Sapir-Whorf Hypothesis, Wikipedia
11. What’s in a Story?, Dan North

Fairway completed the final round of the inaugural Mario Kart Wii Tournament today.  Brett S, sans his mighty nunchuk, cruised past the field of 16 racers and edged out Mike for the victory.  Congratulations to Brett S on the victory – you truly plays Mario Kart like a teenager. 

The next Mario Kart Wii Tournament hasn’t been scheduled yet but but it’s sure to be a good time.  And we’ll see if we can’t post some shots of the live action next time.  Witnessing a 4 player Mario Kart race on a 7x7 projected screen would make a fan of anyone.

I mentioned in a previous post that we’ve started a languages club at the office.  In an effort to decide which language we will first concentrate on, I volunteered to give the rundown on F#.  Rather than providing a summary here, I’ve provided my slide deck for your viewing enjoyment.  There’s nothing special here outside of a some pretty cool characters from The 56 Geeks Project by Scott Johnson and collection of information from my prior functional programming presentations.  

The folks at the Open Web Application Security Project publish a list of the top 10 vulnerabilities. In a recent CodeBrew I provided a quick overview of them all and spent a good amount of time focusing on the most prevalent vulnerability, Cross Site Scripting (XSS). 

I gave an overview of XSS, stepped through a quick demo (sorry vulnerable site), reviewed the three XSS variations and talked a bit about how to protect one’s site. 

References and reading materials were also included in the presentation and, look at that, they are provided here too.

1. Open Web Application Security Project
2. The OWASP Top Ten Vulnerabilities (pdf)
3. OWASP List of Vulnerabilities
4. The 56 Geeks Project by Scott Johnson
5. ha.ckers.org
6. OWASP XSS Prevention Cheat Sheet
7. Wikipedia
8. Is XSS Solvable?, Don Ankney
9. The Anatomy of Cross Site Scripting, Gavin Zuchlinski

We started a work language club at work this week.  Thus far, we have a collective interest in a number of languages: Python, Ruby, F#, Erlang, Objective-C, Scala, Clojure, Haskell and Go. There are more but these 9 received the most votes.

During the first few meetings we are going to determine which language we should tackle first. To help make our selection, each member will provide a quick overview of their favored language by answering the following set of questions:

1. Why are you interested in learning “your” language(s). (There’s lots of work, I’m an MS shill, It’s hip and  fun, etc)
2. What type of language is it?  (OO, dynamic, functional, procedural, declarative, etc)
3. What types of problems is your language best suited to solve?  (Algorithms over big data, rapid application development, modeling, merely academic, etc)  
4. Can you provide examples of where/how it is being used?  If it isn’t being used, why not?  (Erlang was invented at Ericsson to provide an extremely fault tolerant, concurrent system.) 
5. Quick history – Who created/sponsored the language?  When was it created?  Is it currently active?
6. Does the language have hardware support (an attempt was made at one point to create processor instruction sets specific to Prolog), or can it run as an interpreted language inside another language (like Ruby in the JVM)? 
7. Are there facilities for programs written in this language to communicate with other languages?  How does this affect its utility?
8. Does the language have a IDE tool support?  (Think Eclipse or Visual Studio)
9. How well is the language supported in terms of books, community and documentation?
10. What’s the number one things which differentiates the language from others?  (i.e. Why is it cool?)
11. How is the language applicability to us as consultants?  What would the impact be of using the language in terms of cost, maintainability, personnel costs, etc.?
12. What’s the number one things which differentiates the language from others?  (i.e. Why is it cool?)

This should provide an decent introduction into nearly a dozen languages and give us enough context to decide which single language deserves our undivided attention for the weeks to come.  Stay tuned for the winner…

About a year ago, I sent the group a list of my favorite podcasts.  Apparently it’s time I share an updated list of my top 12 subscriptions.  I listen to everything that is published by the folks towards the top of the list, but as you start moving down the list, I tend to listen only if I’m interested in the topic.  Surprisingly, I often am. 

Most of these podcasts should be considered .NET-centric.  However, those which talk to everything and anything technical (at least sometimes) are highlighted with an asterisks.

1. Hanselminutes *
2. Herding Code *
3. Stack Overflow *
4. Elegant Code *
5. Software Engineering Radio *
6. Spaghetti Code
7. .NET Rocks *
8. The Thirsty Developer *
9. Polymorphic Podcast *
10. Deep Fried Bytes
11. Alt.Net *
12. You Look Nice Today *

If you’re interested in checking them out, each show can be found in the App Store or you can import into iTunes using the attached OPML dump. 

Today we held the final round of the first-ever, double-elimination Fairway Dart Tournament.  Congratulations to Ray who solidified the win with a ridiculous quadruple bull’s eye – or maybe it was 5 bulls?  We’ll have to consult the video tape.

Stay tuned for the next tournament.  I’m sure everyone will continue practicing in hopes to dethrone seemingly unbeatable Ray to win the gold prize – a coveted Fairway t-shirt and bragging right galore.

I did an in-house presentation on Lean Software Development (LSD) and Kanban Systems recently.  Beyond what I had previously learned from various podcasts, I knew little about either topic prior to compiling my slide deck.  In the process of building my presentation, I learned a ton.  I found the concepts weren’t very difficult to grok; however, I found little detailed information was available online.

Hence this post which is merely a list of valuable resources.

1. Principles of Lean Thinking, Mary Poppendieck
2. Lean Software Development, Mary Poppendieck
3. Lean Programming, Mary Poppendieck
4. Lean Software Development, Wikipedia
5. Implementing Lean Software Thinking: From Concept to Cash, Poppendieck
6. Lean Software Development Overview, Darrell Norton
7. Lean Thinking: Banish Waste and Create Wealth in Your Corporation
8. The Goal: A Process of Ongoing Improvement
9. The Toyota Way
10. Extreme Toyota: Radical Contradictions That Drive Success at the World’s Best Manufacturer
11. Elegant Code Cast 17 - David Laribee on Lean / Kanban
12. Herding Code Episode 42: Scott Bellware on BDD and Lean Development
13. Seven Principles of Lean Software Development, Przemys?aw Bielicki
14. Kanban Boards for Agile Project Management with Zen Author Nate Kohari
15. Herding Code 55: Nate Kohari brings Your Moment of Zen
16. James Shore on Kanban Systems
17. Agile Zen Product Site
18. A Leaner Form of Agile, David Laribee
19. Kanban as Alternative Agile Implementation, Mark Levison
20. Lean Software Development, Dr. Christoph Steindl
21. Glossary of Lean Manufacturing Terms
22. Why Pull? Why Kanban?, Corey Ladas

Note: This post was originally published on johnnycoder.com in August, 2009.

 Setting Up Your Environment

Getting Android running on Eclipse is easy, but the documentation was pretty dispersed.  Here is a quick start based on my experience on Vista.

Download Eclipse.  I’m using eclipse-jee-ganymede-SR1-win32, I already had the J2EE version installed, I imagine you could use any the regular Java version.

Install the ADT plugin, the directions on the Android site are fine.  You should also download the Android SDK.  I am using android-sdk-windows-1.1_r1, so check the current version to see if anything has changed.   

There are a few interesting things in the SDK:

\tools Directory

These are the command line tools that you won’t be needed TOO much.  Most of the things you can do in the command line are better performed in the DDMS perspective in Eclipse (more on that shortly!) 

One thing that I’ve already needed the command line for is creating an sdcard.  You’ll need one if you want to use the camera or record any media on the emulator.  The beginning of this tutorial on Camera Capture describes the the process pretty well.  All I had to do was add an sdcard into the spot where Android stores it’s user data on Vista, like this:

C:\…\android-sdk-windows-1.1_r1\tools> mksdcard 1024M C:\Users\<USER_NAME>\AppData\Local\Android\SDK-1.1\sdcard.img

\samples directory

Full of useful code that will get you started.  Personally I thought the NotePad application was a great starter app (if visually boring), using a couple activities linked together and SQLite.  If you just want open one of these apps, use the steps under Creating an Android Project in the Eclipse with ADT setup guide.

Let's Start Coding!

Well, you have everything you need, lets jump in and see how it works.  The Hello World Tutorial on the Android site is fine.  Go ahead and follow the steps to create a new Android application.  It will auto-create some code for you.  Jump down to the section Run the Code: Hello Android and you’ll setup the run configuration.  Once you have the emulator running, go ahead and look through the remaining tutorial, it will teach you a little bit about coding in Android.  Stop at Debugging Your Project though, and lets look at some useful tools.

DDMS (Davlik Debug Monitor Service)

This is a good time to dig into the a tool that will really enable you to develop to the emulator.  It runs as a perspective within Eclipse, so lets open it now, and switch to that perspective. 

I don’t want to get too bogged down in the details of this screen.  The most important detail for you right now is the LogCat.  This is where you can view all the errors you would be coding if you were me.

LogCat isn’t too complication.  You can set

the debug level - (V) is Verbose, (D) is debug – here, or under Windows –> Preferences –> Android –> DDMS *NOTE - You can also see the ADB Debugger Port in that menu, we’ll be using that shortly.

One further note on LogCat.  A couple times the logging seemed to stop when I started using LogCat, especially if ADB.exe process stopped, or I had to restart the Emulator.  When this happened, I found selecting my application under the Devices tab seemed to work.  Give it a try if your logging stops.

Breakpoint Debugging

Alright, last topic.  I’m pushing the limits of “quick start” already!

If you’ve been a software developer sometime in the last decade, you expect to be able to step through your code.  You can with Android, but the setup is a little different from other Eclipse projects… Here is a good Eclipse setup guide that has an excellent section describing Debugging the emulator with Eclipse.

My only issue was the port my debugger was sitting on was different, so make sure to check Windows –> Preferences –> Android –> DDMS and check the ADB Debugger Port.

I believe you need to set breakpoints, before launching the app.  If you have a breakpoint set like this:

When your application hits that code, Eclipse will automatically prompt you to switch to the Debug perspective.  Let it switch, and you will be able to step through your code.

You should have enough to begin work in Eclipse.  Good Luck!

After completing a ridiculous amount of research over the past couple of month, I presented on functional programming early last week.  Even though I’ve playing with F# quite a bit lately, I didn’t focus on any specific functional or multi-paradigm language.  Instead my presentation included an overview of functional programming in general.

Update 4/28/2009: I’ve posted my slide deck.  Check out Part 1 of the Functional Programming Series.

I compiled a good number of references during my research. If you are interested in learning more about functional programming, I suggest you consult any of the references below. Or you may just wish to wait for me to publish my slide deck. 

1..NET Rocks - Show 377: Ted Neward and Amanda Laucher on F#
http://www.dotnetrocks.com/default.aspx?showNum=377

2..NET Rocks - Show 310: Simon Peyton Jones on Haskell and Functional Programming
http://www.dotnetrocks.com/default.aspx?showNum=310

3..NET Rocks - Show 293: F# Moves Forward
http://www.dotnetrocks.com/default.aspx?showNum=293

4..NET Rocks - Show 266: Jon Harrop Makes Us F#
http://www.dotnetrocks.com/default.aspx?showNum=266

5.Deep Fried Bytes - Episode 24: Chatting about F# with Chris Smith and Dustin Campbell
http://deepfriedbytes.com/podcast/episode-24-chatting-about-f-with-chris-smith-and-dustin-campbell/

6.Deep Fried Bytes - Episode 23: Functional Programming in C# with Oliver Sturm
http://deepfriedbytes.com/podcast/episode-23-functional-programming-in-csharp-with-oliver-sturm/

7.Software Engineering Radio - Episode 108: Simon Peyton Jones on Functional Programming and Haskell
http://www.se-radio.net/podcast/2008-08/episode-108-simon-peyton-jones-functional-programming-and-haskell

8.Software Engineering Radio - Episode 89: Joe Armstrong on Erlang
http://www.se-radio.net/podcast/2008-03/episode-89-joe-armstrong-erlang

9.Software Engineering Radio - Episode 84: Dick Gabriel on Lisp
http://www.se-radio.net/podcast/2008-01/episode-84-dick-gabriel-lisp

10.Software Engineering Radio - Episode 62: Martin Odersky on Scala
http://www.se-radio.net/podcast/2007-07/episode-62-martin-odersky-scala

11.Herding Code - Episode 18: Matt Podwysocki on F# and Functional Programming
http://herdingcode.com/?p=45

12.Pragmatic Podcast - Episode 24: Stuart Halloway on Programming Clojure
http://www.pragprog.com/podcasts/show/24

13.Elegant Code Codecast - Episode 24: Matt Podwysocki on Functional Programming
http://elegantcode.com/2009/02/27/code-cast-24-matt-podwysocki-on-functional-programming/

14.Matthew Podwysocki’s Blog
http://codebetter.com/blogs/matthew.podwysocki/default.aspx

15.Wikipedia
http://en.wikipedia.org/wiki/Functional_programming

16.Real World Functional programming in .NET, Petricek

17.Functional Programming for the Rest of Us, Slava Akhmechet
http://www.defmacro.org/ramblings/fp.html

18.Why Functional Programming Matters, John Hughes
http://www.cs.chalmers.se/~rjmh/Papers/whyfp.html

19.Functional Programming HOW TO
http://www.amk.ca/python/writing/functional#introduction

20.Expert F#, Syme, Granicz and Cisternino

21.Foundations of F#, Pickering

22.An Introduction to Microsoft F#
http://channel9.msdn.com/pdc2008/TL11

23.F# Eye for the C# Guy, Leon Bambrick
http://secretgeek.net/content/fsharp_leonb.pdf

You never know when “life” will happen—loss, theft, damage, infection, etc—and I’ve been unprepared too many times. So I’ve created a complete backup & restore strategy, which has reduced my downtime from as much as a week, to under a day. I figured someone somewhere out there might find this useful.

Backups

If you don’t have backups, MAKE THEM NOW. Below are some tools and tips for simplifying backups and gathering all the necessary information to restore your system before you need it.

Tools

I highly recommend Carbonite (http://www.carbonite.com/) to manage and store backups. For less than $5 a month I get unlimited, online, instant backups with an intuitive tool for managing it all. My backed-up files appear as drive on my computer and can be accessed easily any time I’m online. And, their customer service was very responsive the one time I had to deal with them.

I’ve tried other tools such as Mozy, which is similar to Carbonite except it’s not unlimited or instant. And its tool for managing backups is frustrating and confusing. When I had an issue, their customer service was very unresponsive and unable to correct my problem. It’s even more expensive.

I’ve also tried manually copying important files to an external hard drive, but it turns out I’m not very reliable. Plus, it slowed down my computer while it was copying, and it took forever. That’s probably why I couldn’t stay on top of it.

Tips

• The simplest way to ensure all desired files get backed up is store them all within a single directory. Obviously, you can have as many sub-directories within that as you need. The My Documents folder on PCs and the Home directory on Macs are the natural choice for backed up files.

• If you use an email client such as Outlook, make sure that the data file (.pst) is saved in this backed-up directory. Also, make a list of all the email address for which you use this client. Include both incoming and outgoing mail server names, logins, and passwords. And save this list in the backed-up directory.

• If you’re using Firefox, move the bookmark file to your backup folder. For instructions on how to do this, see here: http://ilias.ca/blog/2006/04/customize-the-firefox-bookmarks-location/.

• Make a list of all the software you have installed on your computer. Include passwords, serial numbers, activation codes, URLs, phone numbers, and anything else you might need to install all the software. PRINT this list and put it somewhere safe, especially if it contains passwords.

• Gather all the installation discs required to install your software, and store them together.

Restore

I start by installing all my software first and worrying about my files afterward. Below is the order in which I install everything.

1. Operating system
2. Operating system updates
3. Office (Word, Excel, PowerPoint, Outlook)
4. Outlook email accounts
5. Access
6. Visio
7. Project
8. Visual Studio
9. SQL
10. Carbonite
11. Firefox
12. Safari
13. Yahoo messenger
14. RoboForm
15. Blackberry sync software
16. MS Money
17. Dreamweaver
18. Fireworks
19. Flash
20. TortoiseSVN
21. Secure shell
22. FinalDraft
23. GIMP
24. CutePDF
25. Adobe Flash player
26. Adobe Reader
27. Amazon MP3 downloader
28. Audible manager

Restoring files is easy with Carbonite. Once the client is installed, you can simply go to the drive that appears on your desktop and select the files you wish to restore.

This is a good item to read as a follow-up on the Wireless Application Market article.  Regardless of what platform you’ve decided to develop for, UI design is going to be another issue for you.  Not unlike web development, page size is one of the the first areas you should address.  Specifically, what is the minimum screen width you should support? 

One option is a design that will scale horizontally and vertically, another is designing and implementing multiple screens for a variety of screen sizes.  I’ll go out on a limb and say a scalable design is preferable if it’s possible for your application.

Which Screen Sizes?

Some great research has been done on Mobile Screen Size Trends over at a blog by Sender11.

Note: screen size is usually listed width x height. 

The gist is that QVGA is the most common phone screen size right now, meaning supporting a width of 240 is essential.  The top end screens are rapidly increasing in both size and pixel density.

How to Get Support Screen Sizes?

This is an area web UI designers are going to find familiar as well.  If possible applications should be drawn by screen percentage, really this is just like using tables in HTML.  In fact, my personal choice for a UI Toolkit for J2ME is a product called KUIX, which uses a layout system called TableLayout which is fairly close to HTML tables.  Certainly not the only way to get there, just one option for how to get closer to scalable layouts.

Thinking of building a wireless application?

Great!  Just head over to Apple and download the iPhone SDK, or maybe head over to Blackberry and look into their SDK, or check out Microsoft, or Java, or Android...  That will satisfy everyone right?   Unfortunately, not even close.   Before you even look at platforms, you have to make the decision that can potentially eliminate more potential users from your user base (Mac vs. PC anyone)?

Smart Phones vs. Dumb Phones

Would you be willing to eliminate 90% of your potential users before you write a line of code?  Smart phones currently account for ten percent of the cell phone market, and is forecasted to only reach twenty percent by 2013. Still Mac developers know a small slice of a big pie can be pretty sweet, especially when those are the users most likely to download your application!

Those ninety percent-ers are really a red herring anyway. Smart phone users are downloading around 5 applications per phone, most dumb phone users aren’t downloading any (I haven’t found stats on downloads there..) Many dumb phones are now able to download Opera Mini web browser though, so a web application may be a better option than a rich client if you have to reach them… I’ll be writing more on mobile web development in a subsequent blog.

Platforms and Market Share

Market share is always changing. Have no question you will be aiming at a moving target. I find these year over year charts pretty informative:

charts from http://jkontherun.com/2008/09/12/smartphone-mark/

if already dated.  Both Linux (in part because of Google Android) and iPhone are gaining market share rapidly.  The point remains though, that if you write an application for the iPhone, or a Blackberry specific application, you will be limiting yourself to a much smaller audience. 

Sales channels are a concern within this fractured marketplace as well.  Apple’s iPhone store is the place for iPhone application, while RIM, Nokia, Google have, or are launching, their own stores.

These stores naturally cover just their own platforms…  Watch for evolution of this marketplace, which is really just getting started.

Java? Kind of the Answer…

It should be, but it’s not the multi-tool of mobile platforms we are looking for.  A few points should be considered right out of the gate

1. the iPhone has NO Java support implemented or planned
2. Microsoft Mobile doesn’t come with a JVM (limiting you to customers savvy enough to download one)
3. Google Android uses a non-standard JVM call Dalvik, which requires extra work to get J2ME apps running

Still, it' is heartily supported by the other phone manufacturers and platforms.  If you are careful to avoid platform specific APIs as much as possible, you can get up to 70% coverage of the smart-phone marketplace with minimal re-writes.  You also expose yourself to the many java mobile download stores and sites, although many are geared towards games.

The iPhone is really problematic here if you want to write a sexy application, and you don’t have a version for the hottest phone on the planet, you’re not going to look good.  There are a couple attempts to create porting for Java to the iPhone’s Objective-C machine, like InnaWorks alcheMo or cross-compiler solutions like XMLVM.  No personal experience with either one yet.

Conclusion

You can walk down the hierarchy of phone models and OS’s and see the market for your products fracture into smaller and smaller pieces. BUT, if you really want to hit the market with the next great mobile application, and aim for close to 100% of the smart phone market, you probably need:

• a J2ME version for most of the market
• an Objective C version for iPhone
• a embedded C++ version for Windows Mobile
• a J2ME version modified to run on Android

I’d put them in that order, and really just try to nail the J2ME and iPhone.  Android is evolving rapidly, and I suspect it will be easier to adapt J2ME applications to for Davlik VM as more people port their J2ME apps to Android.

I did a presentation on Aspect-Oriented Programming at our company CodeBrew yesterday.  I was really happy with how well the talk came together and I was delighted by all of the positive feedback.

My slide deck generated a lot of buzz.  As you can see, I borrowed heavily from the popular O'Reilly Head First book series.  It took me way too long to put the presentation together but it was definitely worth it.  And it was fun -- fun for me and the rest of the group.
 

I mentioned my recent interest in AOP in last month's professional retrospective.  It's interesting stuff and since I've done much of the legwork already I'm thinking about putting together a short blog series which explains the basics.  All in favor?

Update 4/28/2009: I’ve posted my slide deck.  Check out Part 1 of the Head First AOP Series.