Localizing and Translating Software

By Ryan Smyth
(Winner 2006 Silver Faucet Award
Guitar and Drum Trainer – SIA Best Application Using .NET 2005 and 2006)

Everyone has their own take on who, what, when, where, why and how to localize and translate software. The marketing guys want everything and have no clue what it is beyond, “a new Japanese version”. The programmers will sometimes ask for an Excel file with all the strings in Japanese. The translator that got hired by the intern is about to finish high-school and will do whatever he’s told. The translation company that got hired after the kid got fired would prefer things done their way, but since you’re paying they’ll do whatever you ask. It can be a real mess trying to get things done.Since I’ve pretty much done everything from end to end at least a few times or more, I think I’ve got a fairly well balanced opinion on how to get things done right. I’ve worked on pretty much everything from professional journal articles and ad copy to small applications and documentation to large projects that incorporate client applications and server daemons with integrated websites. In each area different approaches and processes can work better and while there’s no “one right way” to get things done, there are some general principles and things that can help to keep the flow tight and produce good results. If you’re considering having your software translated, then hopefully this article will serve as a decent basic primer on software localization and translation issues for you, and point out some trouble spots and things that you will need to consider.

This time around I’m working on another few relatively small end-user applications, and sitting on the opposite side of the fence for one of them. For the sake of ease I’ll call them “App A” and “App B”. I’ll refer to them as examples from time-to-time.

Interpretation – Not Translation

I’ve already ‘translated’ App A before, end-to-end from the GUI and documentation to web content. I say ‘translated’ because while people understand that, that’s not really what I do. I don’t believe in ‘translation’ per se for software and web content (or much of anything else for that matter). It’s just a bad idea. You invariably end up with weirdness. Instead, some kind of ‘interpretation’ works better to get things right in the target language. Sometimes that means cutting things out and re-writing large sections. This is more important the further away you get from the original language group. e.g. While it’s pretty straight-forward to go from English to Spanish and vice-versa, you’ll have a tougher time going from English to Japanese and vice-versa. At all times you’ve got to keep your eye on the most important aspect of the ‘translation’ – your users.

Doing Things Right the First Time Around

Back to App A… While it’s already been translated, the original translation was pretty much unusable beyond itself. It was done directly in the EXE file and since then has undergone some serious upgrades with new resources and deleted resources, which I was expecting. So a good amount of work is getting redone and the work that has already been done is relegated to wasting time with copy & paste.

However, this time around it’s getting done right. The translations are now being pulled out into resource DLLs (the software is done in C++) that can be easily translated later on. That doesn’t help at the moment, but it’s certainly a step in the right direction.

If you’ve never pulled resources out into resource files, it’s a very good idea to start programming like that now. If you ever do localize and translate your software, you’ll be ready to do it very quickly, and it will make the actual programming more manageable for you.

The Right Tools

I’ve seen software translations done in Word, PowerPoint, and Excel. They’re almost always the wrong tools to use. PowerPoint and Excel have no place at all in any software translation. Word on the other hand does have some good uses, and they’re always called “Track Changes”.

Tracking changes in Word is most useful for larger projects where you need to keep track of the quality of a translation. Once the original translation is done, you’ll need to have it copy edited and then proof-read if the copy editing shows that the original translation had too many errors. Judging what constitutes “too many errors” is shouldn’t necessarily be numerical though; the type of error is more important, e.g. style considerations are often more important than simple tense, particle or article errors.

That isn’t the ideal way to get a translation done as you introduce extra steps where human error can occur, but it does give you some more control over the quality of the translation if you can’t do it yourself. For a typical small mISV I wouldn’t recommend going that route as the number of steps becomes much larger and the costs of doing it that way increase greatly.

Regarding human error, one problem that I’ve seen far too often is ‘copy and paste’ not being done right. The low-paid person handling the final document invariably ends up missing some characters when copying. Then again, I’ve seen people start re-typing things, which is an even worse idea.

While Word and tracking changes is good for quality control, it’s almost always better for the translator and editor/proof-reader to make changes directly in the resource that will be used. This eliminates any possibility of human error being introduced through copy and paste or retyping. If you’re using the ‘copy and paste’ method, you should probably get your proof-reader to go over things once more, which is an unnecessary step.

There are some very good translation tools available for a variety of uses. I use appTranslator (http://www.apptranslator.com/) and am very happy with it. It’s easy to use for translators and keeps things simple. While it may be missing some features that some more expensive solutions offer, it more than makes up for this in usability. i.e. You can either pay your translator to learn some new complex translation software, that you’ll have to pay for, or you can give them a free appTranslator Translator Edition that is highly-intuitive and simple to use. I’ve never missed anything or needed anything that I don’t already have in appTranslator.

If you want to keep costs low, then appTranslator is ideal. The professional version is reasonably priced and you can distribute a free ‘translator edition’ to your translators. Many other solutions require you to pay for the software licenses for each translator. This can really bring your costs up very rapidly, especially if you’re planning more than one translation. Also, with the easy to use interface in appTranslator, your translators won’t be fussing around with low-level or difficult interfaces that increase the risk of them making errors, either technical or grammatical. Those costs are invisible, but can end up costing much more when you end up redoing work that should have been ok in the first place.

There are several key benefits to working with resource files and a tool like appTranslator:

  1. Translation is done at a low-level which eliminates intermediary steps where human-error can be introduced.
  2. The work process is simplified greatly, which allows your translator/copy-editor/proof-reader to focus on their tasks, and not technical issues.
  3. You protect yourself against future upgrade issues with the ability to import translations from previous versions of your software.

On a side-note, I don’t believe that the cost of software should always be determined by a feature set; service and support takes time from real people and quite often that quick response to a support email can save your bacon. I’ve found that Serge, the appTranslator developer, is quick with support emails and very responsive. For me this adds significant value to the application as I’ve got someone to get answers from if I need. For many mISVs this probably strikes home as a real advantage that we as small developers have over larger companies with complex, slow, and often frustrating support procedures.

The Right Process with the Right People

Using the right tools is often enough to basically force you into a process that will produce a high-quality translation for you. However, even the best of tools will give you enough rope to hang yourself. These dangers are often avoided by using the right people to get the job done.

App B has already had its interface translated into Japanese, so only the documentation and web pages remain. The application will still need to be proof-read though. Since it’s a utility with some technical language in it, using an excellent translator that does fashion and tourism translations probably isn’t a good idea, so we’ve enlisted a Japanese proof-reader that works in IT.

While this should be a no-brainer, I’ve seen more than one translation done by someone who didn’t understand the subject matter, and the results were very poor. Don’t think that you can get just any-old “native speaker” to work on the project. It won’t work. Just for example, take something like the short paragraph below and ask your grandmother to explain it to you:

“Editing compressed audio will degrade the quality of the final product unless the compression is lossless such as with FLAC. Another consideration for achieving better quality results is to use a higher bit-depth and sample rate. However, if you’re recording at something like 48,000Hz, then you’ll want to make sure that you have a high-quality sample rate converter if you’re publishing at 44,100Hz.”

Nothing too difficult there, but if your translator doesn’t understand what FLAC, bit-depth and sample rate are, you’re bound to end up with some pretty bizarre stuff at the end of the day.

For another perhaps more poignant example:

“Instead of using where, try using an inner join.”

In that example your translator doesn’t have any choice but to leave “where” as “where” and “inner join” as “inner join”. The terms are opaque and not subject to translation as they are a part of a computer language and not a human language. For cases such as those, it’s important not only that your translator understand what a “where” clause and an “inner join” are, but also that you properly format them with italics, bold, a different color, or some other way to denote that they are opaque. Special formatting may not be possible in some dialogs or message boxes, which only goes to reinforce that your translator should be competent in your subject matter.

Consistency in the Original

If you start with dog-poo, the best translation you can expect is shiny dog-poo. And they both stink. Make sure that your original application and documentation are good quality.

A large part of that quality is being correct and consistent in your writing style and choice of words. E.g. “click”, “press” and “select” all have different meanings and should be used consistently in the correct places. You click a button with your mouse. You press a key with your finger. You select an item from a list with your mouse by clicking on it. E.g. “Press F4 to display the Preferences then click the ‘Advanced’ button to display the ‘Advanced Preferences’. Under the ‘Languages’ heading select your language from the drop down menu.” You wouldn’t click the F4 key and you wouldn’t press the ‘Advanced’ button.

Also make sure to be specific in what you mean and avoid ambiguous terms. “Upload”, “download” and “transfer” all have different meaning. “Transfer” includes both “upload” and “download”, and shouldn’t be used unless you want to include both cases.

When you have an item or function that has several synonyms, choose one and stick with it. While in general prose it’s nice to mix up the language for style, for software it will only create confusion, and for your translator, this can be disastrous. Are you talking about two different things or the same thing?

For some things synonyms should be divided to mean different things. E.g. “Options” and “Preferences”. “Options” is typically better for a main menu item while “Preferences” is typically better for sub-menu item. This is moot if you only use one of those words, but there are other situations where the general principle will hold, e.g. “folder” and “directory”.

If you need to, create a glossary of terms while you’re writing your interface and documentation. This will help you keep things consistent for you, your users, and your translator. Remember that things can take on radically different meanings in another language, and clarity in your original not only produces a better product in the original language, but also in any translations that you create.

A Small Technical Note

Formatted strings are wonderful and beautiful and make life grand, but don’t put more than one variable in them if you can avoid it. It’s better to break them into smaller manageable chunks with one variable per formatted string. For example:

("%d results returned for %s", count, term)Could also be written as:

("Search for %s returned %d results", term, count)What happens when your translator creates a wonderful, elegant translation for the second of those two and it reads something like:

("%d results returned for %s", term, count)Ooops. Your program just threw an error because you ended up with mismatched types.

Instead, try something like this:

("Search Term: %s", term) ("Total Results: %d", count)The problem becomes worse when the types are the same because you won’t even catch an error and the output, while technically correct, turns out to be gobbledy-gook when someone reads it.

Another Technical Note

App A and App B are done in different languages, C++ and Delphi respectively, and have different translation methods. While the resources are all neatly contained in language resource DLLs for App A, App B is using INI files instead. Both have certain advantages and disadvantages.

INI files are most certainly much easier to translate with a simple text editor like Notepad or EditPlus, while DLLs require special software that can cost you a few dollars. If forced to choose between them, I’d side with DLLs in a heartbeat. The pain of having to use/buy a special tool is small compared to the advantages of being able to easily manage those language resources and update them.

While examining the INI resources for the Japanese translation of App B, each and every variable in the INI file needs to be manually checked between versions. This is time consuming and costly. For App A, it’s just a matter of importing an existing translation into appTranslator, which takes all of 5 seconds.

The point here isn’t so much that it’s faster, but rather that maintaining the application is both more accurate and easier.

For my flagship product (Guitar & Drum Trainer, or simply GDT), I program in C#, and while I never did release the previous translations of the previous version (due to lack of time), I will be localizing and translating the current version again into Korean since it’s a complete rewrite. For me those maintenance issues are less important as I speak English and Korean and can very easily fire-up Visual Studio and make any changes to the program that I need. If you don’t speak the language that you’re translating into, then you don’t have that luxury and maintenance becomes a greater worry.

If you’re programming in .NET, then there are some convenient tools available to you and your translator. For Visual Studio 2005, look for “WinRes.exe” in “C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\Bin”. You can find more information about it at http://msdn2.microsoft.com/en-us/library/8bxdx003(vs.80).aspx.

The Help File from 3 Perspectives

I write the documentation in English for GDT and for App B. I’ve already mentioned some of the important considerations for writing above, and they all basically boil down to clarity and consistency. From this perspective, things are fairly easy to deal with.

However, App B has Japanese documentation. Yikes. I don’t speak Japanese and won’t be able to personally ensure the quality. For a case like this, the process needs to be more robust to take care of quality issues.

GDT will have Korean documentation, but since Korean isn’t my native language, I know that there’s no way I’m going to touch that. I’m fine with translating the actual application into Korean as I’ve translated a few audio and multimedia applications from Korean into English and have an excellent grasp on the language in that area, so I have a proof-reader for that. Prose is a different story entirely and recognizing my limitations there is important. For that I’ve got a translator working on it.

The help file for App B is quite long and maintaining it could be problematic. The documentation for GDT is fairly short and is unlikely to expand to a level where maintenance becomes a real issue. For this my translator simply opens up the HTML and starts typing. Nothing difficult or complicated there.

Back to App B… As maintenance plays a very real part in the product life-cycle, it’s important to manage those help file resources as easily as possible while still maintaining a high level of quality. As the Japanese are well-known for perfectionism, quality is especially important.

The process I’ve chosen for this project is slower and more complicated, but is designed to keep quality high and keep the help project maintainable. I’ve chosen two tools for that:

  1. Help and Manual XML Edition
  2. Microsoft Word

The approach here is more like the old-fashioned edit-on-paper method. The basic translation is done in Help and Manual, exported to a Microsoft Word format for editing with the Track Changes option in Word. If the original translation turns out to have met its quality standards, then the changes are entered into the Help and Manual project. If not, the Word file is sent to another proof-reader for a basic “cleaning” from a fresh pair of eyes, then those changes are entered into the Help and Manual project where they can be exported to a CHM help file, a PDF, and set of files for online help.

This process introduces the possibility of human-error with copy & paste mistakes, but given the scale of the project, a more robust solution isn’t really justified.

Later on updates are more manageable with a single help source file and the process can continue with little redundant effort.

The process is basically dictated by the scale of the project. In other words, of all the resources allocated to the project, how much needs to be allocated to managing it versus doing it.

For the original English translations, I can quite easily create and maintain the help files. There’s nothing difficult about this. Here I’m the author. (As I mentioned above, instead of just ‘translation’, I ‘interpret’ parts, rewrite parts, and add new content where I find portions to be thin.)

For the GDT help translation, it’s quite small and easily manageable. An HTML editor or text editor is sufficient for the translation, and things are very straight-forward. If your application is small and the help is simple, you may find that this approach works for you.

App B has a large help file and there are quality issues to deal with. A simple process like for GDT won’t be sufficient. In this case, my role is managerial and my task is to ensure that the end product meets quality standards. If you have a larger application with more complex documentation, then a more robust process like this may work well for you.

Some Process Mistakes to Avoid

No matter how you decide to go about your translation project, there are some pitfalls to avoid. While these may seem trivial to some, I lost track long ago on how many times I’ve seen things like these happen.

Don’t try to translate an application and help before it’s done. If you make any changes to the application or the help, you’ll end up having to have things translated again. While you don’t necessarily need to have a final release ready, your interface should at least be finished with no additional controls or strings to be added. However, if the translation is being done in-house, then this approach can work, but will still involve some redundant work.

Don’t try to do it “one piece at a time”. If you try to get small parts of the application or help translated in small pieces, you may end up needing to use different translators. This can result in inconsistencies in style and word use, which reduces quality. Even if you use the same translator, if you spread out the translation over a long time, your translator may not have the previous translations anymore and if you haven’t made sure to keep your original consistent, it’s unlikely that your translator will be able to keep the new work consistent with the previous work.

Prepare the software before translating it. This includes taking care of any code page issues, extracting resources into DLLs, and making sure that formatting issues for dates, times, currencies, numbers and the like are taken care of. If you start with a mess, you’ll end up with a mess.

In Closing

There are many things that I haven’t covered above, such as support issues, or that I’ve glossed over very quickly, such as choosing a translator. However this article is by no means meant to be exhaustive or complete, and there are plenty more resources on software localization and translation available on the Internet to help fill in the gaps.

Hopefully this will help out a few people that have been thinking about providing their software to a broader market or highlighted some things to think about for those that are struggling with some common problems.

About the Author

As the “Renegade” behind Renegade Minds, Ryan writes and markets Guitar & Drum Trainer, a specialized audio player for musicians to more easily transcribe, practice and learn new songs by ear. He also offers several other programs and utilities at Renegade Minds. During the day, he’s the ALTools Evangelist for ESTsoft. Originally from Ontario, Canada, Ryan has called South Korea “home” since 1996. In addition to his many interests in software and software marketing, Ryan also enjoys playing various sports, studying to improve his Korean language skills and plotting world domination… errr… ‘liberation’ that is. :)

[tags]software localization, software internationalization, micro-ISV, micro-ISV best practices[/tags]

read more
Bob WalshLocalizing and Translating Software

Vendor Profile: Avangate

[Ed. Note: while at ESWC’06 in Cambridge, U.K. in November, I got to know several people from Avangate, a ecommerce/electronic distribution company based in Europe. I asked them to put together their pitch to micro-ISVs, and here it is. Any other vendors interested in selling to micro-ISVs and willing to put the time in to tell us what exactly they have are welcome to contact me at bobw@safarisoftware.com]

Selling your software online with Avangate
By Delia Ene
Marketing Communications Manager / Avangate BV

OK, there are several eCommerce platforms specifically designed for software sales and software registration services out there. As usual, when there is a choice, you need to know how to choose between them.
This presentation is not a comparison between providers, but a brief presentation of Avangate, eCommerce platform & software registration provider. Avangate is headquartered in The Netherlands, and part of the GECAD Group of companies (the creator of RAV, Reliable Anti-Virus Technology).

Below you’ll find the main points of the Avangate eCommerce solution. There is also a special offer for microISVs.

Whos’ who – Avangate

eCommerce platform for electronic software distribution providing all the tools and expertise you need to:

  • Accept payments online
  • Optimize the online software sales and logistical process
  • Increase your website visibility on the Internet

Why choose Avangate?

eCommerce offer includes:

  • an easy to use and secure online payment system
  • additional marketing and sales tools, such as an affiliate management system, automated cross selling options


  • software marketing services plus consultancy on how to increase software sales via the internet.

Avangate’s eCommerce platform allows you to:

  • Start selling in 24 hours
  • Accept multiple payment methods
  • Customize your Ordering Interface
  • Multilanguage, multicurrency
  • Real time Order Delivery – Key/ Code and Software Delivery
  • Cross Selling & Promotions Management Tools
  • Affiliates Program
  • Merchant & Shopper Support
  • 3-D Secure Merchant & Shopper Protection
  • Sales Reports & Statistics

We won’t go here into the nitty-gritty. Detailed information on platform features can be found on the Avangate website. Essentially, all Avangate options are easy to integrate and deploy. Software vendors are able to just click and implement a new sales mix; add straightforward licensing management system, special promotions and online sales reports.

A point worth insisting on are the software marketing services. We support you with expert advice on how to sell software online by:

  • Increasing your site’s visibility in all major search engines.
  • Distributing your product among the top ranked download sites and software directories on the Internet.
  • Better structuring your website and content, making sure you clearly present the power and benefits of your products, convincing your visitors to download and try them.

Whether you require our usability audit or software submission service, our expertise will ultimately help increase your website exposure and your software sales. Ask for our free personalized web analysis and we’ll take an expert look at your site suggesting appropriate web marketing solutions to help improve your online business.

Detailed information on Avangate software marketing services: http://www.avangate.com/ecommerce-services/

As a plus, there is also myAvangate, a web-based reseller management system specifically designed for software sales. myAvangate is still a Release Candidate – your chance to test it for free. More info on http://www.avangate.com/reseller-management-software/

Avangate’s special offer for microISVs:

-> attractive commission (two schemes you can choose from: 4.9% +1.95 EUR/2.5 USD or 8% minimum charge 1.95 EUR/2.5 USD). Fees are clearly explained on the Avangate website (go to http://www.avangate.com/start-selling).

-> three months web marketing services worth 1000 USD (SEO audit, software submission, PPC management, according to your needs)*.

*)Special conditions apply: minimum one year contract with Avangate and online sales of minimum 1000 USD per month.

Interested? Contact us. We are here to help developers sell software better and safer online. Email info@avangate.com and mention ref no: MicroISV offer BW.

[tags]Avangate, micro-ISV vendors[/tags]

read more
Bob WalshVendor Profile: Avangate

Making Plans for 2007 and mymicroisv.com

Having finally finished Clear Blogging (plug: available Feb. 7, recommended reading for micro-isv’s), I can start working on several stalled projects, including MyMicroISV.com. A year ago when Micro-ISV: From Vision to Reality came out, I conceived of this site as a blog+resources site. The blog has worked out – mostly because of the many guest posters who’ve shared their knowledge and perspective here – but the plus part has not.

So my plan for making over MyMicroISV.com is to make it a blog + wiki, and have that wiki become the single best place new and experienced micro-isv’s can go for how to succeed information. Think of it as the FAQ of the micro-isv world. I’ve talked to 8 other micro-isv’s who’ve agreed to contribute “starter pages” on numerous subjects, but there’s two big questions in my mind still unanswered: what wiki platform to use and how to structure it so it grows as good wiki should?

As much as I enjoy MyMicroISV.com, I have other projects too, and that means I’ve got to have a wiki that needs the least amount of administering to and yet provides the best results. That makes me think a hosted solution would work best. Also, while I use Wikipedia every day, I think it’s ugly beyond words and wiki markup is geeky lame, especially as of 2007.

That said, the main contenders are MediaWiki and Wet Paint, with two other possibilities: Google Jotspot and Drupal. Wet Paint would be perfect if they simply let me pay for it instead of it being “free” with Google ads built in. Google Jotspot might be great – but Jotspot is in lock down since Oct. 31 when it was acquired by Google. Who knows when it will next see the light of day? Drupal I’ve heard from others can do just about anything – if you’re prepared to invest mega-hours.
So, what wiki platform would you suggest for MyMicroISV.com?

[tags]Wikis, wiki, mymicroisv.com[/tags]

read more
Bob WalshMaking Plans for 2007 and mymicroisv.com

Know your rules of engagement

by Bob Walsh

One of my favorite sites, thinkvitamin.com, just put up a post I’d recommend every micro-ISV read: Tara Hunt on The Rules of Engagement. Tara sets out to answer:

What is that magic ingredient that turns people from ‘consumers’ of your software into active and enthusiastic evangelists? The truth is that there is no single magic ingredient, but there are some underlying principles to delighting your current customers that may just lay the groundwork to creating an evangelist or two.

And does a fantastic job. If you’re wondering why and how micro-ISVs are now in the community-building business, read this post and Tara’s previous post, Why 50% isn’t Good Enough.

[tags]community-building, micro-ISV[/tags]

read more
Bob WalshKnow your rules of engagement

Use STRING to get programming accomplished

By Bob Walsh

My friend Matt Cornell posted a great trick that should be in every micro-ISVs bag of tricks. This technique is ideal for those lingering small code projects we all have, but just have not found the motivation to code.

Matt’s technique? Think STING:

  • S – Select one task.
  • T – Time yourself.
  • I – Ignore everything else.
  • N – No breaks.
  • G – Give yourself a reward.

Now I have to add an “R” item to make this technique a little more valuable:

  • S – Select one task.
  • T – Time yourself.
  • R – Review the Desired Outcome.
  • I – Ignore everything else.
  • N – No breaks.
  • G – Give yourself a reward.

Reviewing the desired outcome puts first and foremost what you are aiming for, but I’m quibbling here. Definitely read his post about applying STING in full.

[tags]Matt Cornell, Productivity[/tags]

read more
Bob WalshUse STRING to get programming accomplished

Why Widgets mean money for micro-ISV’s

by Bob Walsh

Two recent posts have turned my mind back toward the subject of widgets and micro-ISVs. A widget is basically a mini application that runs in any number of ways — on your desktop, and Google sidebar, and Windows live, in any number of third-party applications and in both Vista and an Mac OS.

When Steve Rubel at micropersuasion.com notes something, it’s worth you noting it to. Have a look at this post by Steve, “Major Marketers Cozy Up to Widgets“. And when Richard MacManus at Read/WriteWeb picks up on the same trend, it’s definitely worth spending some time thinking about how this emerging trend relates to your micro-ISV.

Have a look at klipfolio.com, or pageflakes.com: widgets are growing up fast, and by their very nature don’t attract the giant software companies. No one needs or wants Adobe PhotoShop as a widget. But (see below) I could see a widget for this.

I presently say for areas widgets and micro-ISVs play together:

  • The white box widget. It’s easy to forget when you’ve got the mindset of selling directly to customers there is another entirely different way of making money: create an application (or in this case a widget), and let others brand and sell it. White box widget makers like LabPixies are selling widgets to advertisers as a way of delivering their message. Someone has to writing these widgets.
  • The advertising by other means widget. Let’s say you have a micro-ISV application like Andy Brice’s PerfectTablePlan. You could create a Windows Vista widget that would do a small part of your app’s overall functionality, feed it to the Microsoft Vista mega marketing machine and drive a hell of a lot of traffic your way.
  • The Simplify My Life widget. We all need new and better ways of dealing with the rapidly rising levels of complexity in our lives. Widgets, by their limited nature, deliver simplicity when created well. Here’s five seven widgets that I for one would buy and or be willing to install:
    • File backup. As I work away in office, this widget lets me with one click back up things as I create and change them. Notice the one click part – I see the file in say Google sidebar, click it, and I never have to worry about backing it up again.
    • The Make me a Slideshow Widget. take a bunch of shots say on our recent trip to London. Then what? I want to make a nice slideshow in PhotoShop Elements for friends and family, but don’t have the time. What if there was a widget that would let me dump in pics, and some graphically inclined human somewhere out there created the slideshow for me?
    • The CastingWords Widget. I need this one right now! Drag an interview.mp3 file to it, get the transcript back in two days.
    • Fitness/Health/Eating rightLabpixies has done a first generation of the this – give me a place where I can track my calories. The app I would buy? That widget is my online personal trainer portal – I pick the trainer at the web portal, they monitor the food I enter in the widget, the workouts I do and pump encouragement right to my desktop. If you designed this app, you could make money four ways – off of customers who need trainers, trainers who would kill for an easy to use app to manage their clients, advertising and affiliate payments to Amazon groceries/drugs. And by the way, I’ll be your first paying customer.Labpixies calorie counter
    • The Online Spending app. This widget would let me categorize on the fly my online purchases (perfect spot for SSE if Amazon and others ever adopt it).
    • The Media Tracker Widget. As my entertainment time is getting spread out between mainstream TV, podcasts and online video, it’s taking longer and longer to decide what I want. A widget that delivered 3 interesting, human edited, picks to me a day from regular TV, podcasts and video would be valuable. We could recycle all those couch potato types into productive members of society again via Amazon Mechanical Turk! :)
    • The Romantic Dinner in a kit Widget You want to make a nice meal for your Significant Other, but you’re the pan washer, not the chef in the house. Enter the Instant Romantic Dinner widget, where with one click it pre-populates my Amazon Grocery cart and emails me step by step instructions. In fact, you could run with in any number of directions…
  • The I haven’t thought of it yet Widget. Given all the talent and inventiveness in the micro-ISV community, I will bet there’s plenty of potential widgets above and beyond the present eye candy/coding example level out there. I for one am looking forward to them.

[tags]widgets, gadgets, micro-isv[/tags]

read more
Bob WalshWhy Widgets mean money for micro-ISV’s

The mental case for physical exercise.

By Bob Walsh

Over the years I’ve never understood why most programmers are content to rest on their (ever-growing) laurels when it comes to exercise. Maybe because I started exercising when I was a reporter in San Francisco in my pre-programmer days that I’ve always at least tried to exercise regularly.

In the past, I’ve always hectored my fellow programmers about the stress reduction, medical and physical benefits of exercise. It turns out there’s now plenty of evidence physical exercise makes you smarter as well.

Research shows that aerobic exercise actually increases brain mass by growing new capillaries, which is associated with an increase in neural activity. In addition, exercise increases levels of many brain chemicals, including norepinephrine and serotonin (linked to improved mood, self esteem, impulse control, and greater focus) and dopamine, which is the major driver of the attention center of the brain.

“There is nothing that affects brain neuroplasticity as much as exercise. It causes a rapid and persistent uptick in the factors and chemicals that enhance learning and mood. Every week, 4-8 papers are released in the neuroscience literature on the positive effects of exercise on the brain.”

The above is from Dr. Edward Hallowell (author of CrazyBusy and a leading expert in ADD in all of its forms) quoting Harvard psychiatrist Dr. John Ratey who’s upcoming book of exercise and the brain has already generated media attention.

“I’ve said for years that exercise is like Miracle-Gro for the brain,” Ratey said in a Chicago Tribune story. “But now we’re learning so much more about it, and just how much exercise causes a huge increase in the growth factors in the brain.”

So, if you feel like your brain needs an upgrade to deal with the complexities of IT today, maybe you need to start working out (again).

[tags] Brains, exercise[/tags]

read more
Bob WalshThe mental case for physical exercise.

The InstallAware micro-ISV pitch

[Ed. Note] Sinan Karaca is the CEO of InstallAware, a small ISV founded in 2003 by InstallShield alumni. Sinan did a great presentation at the European ShareWare Conference earlier this month. I was so impressed with how many features InstallAware included that really addressed the needs of micro-ISVs who need bulletproof installs but don’t want to spend 50% of your development time being driven insane by InstallShield, I asked him to make his pitch here to micro-ISVs.

If you try InstallAware Express, Developer, Studio or Studio Admin and like it, Sinan has made available a 10% discount to mymicroisv.com readers: enter the discount code NOHEADACHE – this takes 10% off any order.


By Sinan Karaca

Do developers actually need an MSI (Windows Installer) setup?

Yes. There are various reasons for this:

  • It is required for Microsoft logo certification. You cannot get certified for the Designed for Windows XP / Vista logos unless you have an MSI installer. Getting the Designed for Windows logo makes a quality statement about your product; it is a vote of confidence in your work. It’s not hard to get this logo, you just need to follow a basic set of guidelines and have an MSI installer.
  • Most system administrators won’t even consider purchasing products that aren’t available with an MSI installer. This is because only MSI setups can be distributed silently and automatically on corporate networks with thousands of computers without paying any per-seat distribution fees that come with distribution systems for non-MSI (EXE) installers. Having an MSI installer lets you penetrate large enterprises to whom you can sell thousands of licenses – why lock yourself out of this huge customer base?

What differentiates InstallAware from other MSI authoring tools?

MSIcode Windows Installer Compiler:

InstallAware is based on a drag-drop scripting language called MSIcode:

  • MSIcode is human readable script that spells out what the installer does, and when – using simple commands such as “Install Files c:\my project\*.* to $TARGETDIR$”.
  • MSIcode is unique to InstallAware and protects you from all internal details of Windows Installer. MSI files contain:
    • Hundreds of rows of database entries in many interlinked database tables, which comprise the basic setup structure,
    • Actions and sequences, which determine the order in which setup actions are carried out,
    • Custom code that was built by skilled developers, inside custom-built DLLs that are embedded into the MSI file.
  • InstallAware protects you from all three of these evils. The moment you build an InstallAware project, the InstallAware compiler automatically populates all the necessary database tables, creates the correct sequences, and injects the necessary custom code into the MSI package. This is all without you ever knowing what is going on “under the hood”. While programming skills and a substantial investment of time are normally a must to build MSI packages, InstallAware lets even non-skilled novices to build complex, powerful setups in record time.

Visual Designers that automatically generate and maintain MSIcode:

While most setup authoring tools offer various forms scripting, there are some serious problems with those scripting environments:

  • A new scripting syntax and programming language must be learned,
  • The scripting environment is completely divorced from the visual designers,
  • Any settings that were configured visually (ex: files, registry keys, shortcuts) are practically inaccessible from the script – thus making it very hard to control or customize such actions at runtime.

InstallAware can be thought of as the Visual Basic or C# of setup authoring tools. Similar to these tools which generate code in the background as controls are dragged and dropped on top of forms, InstallAware generates MSIcode in the background as you work in the visual designers. Want to customize anything? Just switch to the MSIcode view and tweak to your heart’s content. At the MSIcode view you get to see, and update, every setup command that was created for you by the visual designers. Switch back to the visual designers, and your latest MSIcode edits are rendered for you visually. This two-way integrated editing allows for:

  • Rapid prototyping of setup projects,
  • Adding intelligence to your setup at the exact point where you need it, and
  • Easy maintenance and customization of complex projects.

Nothing is hard-coded in InstallAware – you can customize the MSIcode view as much as you like:

  • It’s very easy to build applets like CD browsers in MSIcode (sample project provided),
  • InstallAware’s Web Update capabilities were built using MSIcode, a testament to the power and flexibility of this scripting environment.

Powerful Dialog Designer:

InstallAware ships with a state-of-the-art dialog designer that lets you:

  • Use unique Flash and HTML controls as interactive progress billboards to entertain and educate your users – before your application has even installed!
  • Completely customize every aspect of your setup dialogs, to insert any kind of custom fields, graphics, or navigation (you can even consolidate multiple setup wizard screens into a single screen, like the new Microsoft installs),
  • Seamlessly collect information from the setup wizard and painlessly access that information in your MSIcode script,
  • Customize any of the 15 pre-built setup themes (including themes that look just like the Windows XP operating system installer, the Visual Studio installer), or build your own from scratch. Themes in InstallAware are a lot more than just custom colors or bitmaps!

Using the dialog designer lets you gather business intelligence from your end-users in ways not thought possible before:

  • Ask users for information in your setup wizard, not on a web form where they can walk away from a download,
  • When uninstalling, ask users why they are removing your product, right within the setup wizard,
  • Seamlessly submit any captured information as a native part of the (un)installation process.
  • InstallAware lets you engage in an active dialog with your end-users.

Painless Runtime Installations:

InstallAware lets you install many complex runtimes with a single click on a check-box in the IDE:

  • Any runtime dependencies will be automatically included for installation.
  • Troublesome runtimes such as Microsoft SQL Server Express 2005 are reliably installed – and that even includes checking for and installing a specific, named instance.
  • Most runtimes compress 50% better – all at no extra cost or effort to you (this compression benefit also applies to your main application files).
  • Runtimes can be isolated from your main setup, so they are automatically downloaded from the web, only when needed. Your main setup will still be fully functional and install your main application without forcing a web connection.
  • This is called partial web deployment, and the same idea can also be used to separate large parts of your application from your main setup download, to reduce the size of your setup.

[tags] Installers, InstallAware, MSI[/tags]

read more
Bob WalshThe InstallAware micro-ISV pitch

Everything you wanted to know about Graphics but were afraid to ask…

… can be found in this great post by Kathy Sierra at the Creating Passionate Users blog: Add graphics to your blog, book, or presentation.
Kathy covers:

  • tips for creating visuals that tell the story better and faster than words,
  • types of graphics to use and when,
  • how to figure out what the graphic should be in the first place.

The Creating Passionate Users bloggers are all authors of bestseller Head First books (http://www.wickedlysmart.com)–a new brain-friendly series from O’Reilly. This is a very good blog to have on your micro-ISV RSS list.

[tag] Micro-ISV, how-to graphics, blogging[/tag]

read more
Bob WalshEverything you wanted to know about Graphics but were afraid to ask…