The localization industry has been late to the party regarding continuous integration (CI) of its services with software development. Continuous Globalization is finally getting the attention it deserves now, and that’s a good thing not only for the software industry but also for end users around the world. Here’s what continuous integration, and more specifically continuous internationalization (i18n) and localization (L10n) are, and what it can mean for your software development process.
The Basics of Continuous Globalization
For the uninitiated, Wikipedia defines software continuous integration, or CI, as the practice of merging all developer working copies to a shared source repository several times a day. Multiple builds and automated tests and quality profiles are run against the code to identify bugs and other issues quickly. The sooner you find those issues, the less costly in time, effort, and money they are to fix. CI is fundamentally supportive of agile development principles. Automated quality profiles can include coding quality measurements, security, and more.
Lingoport has been working with some of the largest, well known global technology brands with its continuous internationalization suite of software, Lingoport Suite, including internationalization support for developers, QA support, and localization streamlining. These products work seamlessly with agile-friendly localization providers, providing software companies with systems and services to back up their fast moving product development efforts.
Beware the Invisible Costs
Happily, we don’t usually have to extol the benefits of CI to development teams. I’ll also note that internationalization (i18n) and localization (L10n) requirements are far more openly received than years ago.
That said, managers will comparison shop to lower localization costs per word but can inexplicably regard engineering costs involved in chasing i18n bugs, accounting for localization file updates, and iterative testing as invisible. That typical process involves manual, error-risk prone work even if there are scripts involved. If anything goes wrong with file formatting or myriad other nits, the time to trace it back and fix it eclipses a few penny savings here and there, and can be downright costly in financial terms and damaging from a brand perspective when viewed holistically.
For example, if you consider a SaaS application, perhaps with 5 to 15+ simultaneous sprints running at any given time and with three to five developers per sprint team, there is a lot of room for i18n issues to arise. The localization for any particular sprint or release might be quite small. For example: a few words added in one menu, a new error message, and some new functionality that add up to five to 10 new files with an average of 34 words needing localization per file. The minute someone has to manually handle any of that, you’re losing money and momentum. It costs far less in money and time if i18n issues are found right during day-to-day development, and the localization flow from repository to translator and back to the repository is managed automatically, including validation checks.
Dealing with Short, Fast Development Cycles
If your teams are agile (most teams are at least using some form of agile methodology now), it is particularly challenging to include both internationalization and localization processes within a two to three week or shorter cycle. However, we’ve seen clients using systems go from 5 week localization turnarounds, to three days. Consider that if your i18n and L10n are not integrated and automated within your sprints, you are defacto pushing them into the backlog. As your developers move on to successive sprints, if there is a problem with i18n and L10n that needs development and QA attention, they have to stop what they are doing, figure out what the problems are, where they are located, and fix them, and then QA must again verify that fix. That costs time, money, and momentum. It also likely means that your globalized users have to wait for new releases.
Keep in mind that many software development projects are moving to micro services architectures, which break repositories into many little components that get mixed and matched based on product configurations. This makes the business case for continuous i18n and L10n even more pronounced.
Human Factor Issues
Let me give you examples of human factor problems that cause quality, development/QA costs and localization delay issues:
A very common developer practice is to concatenate a string or message to the user. The message builds based on elements such as variables, plurals, and conditions that determine what the software needs to convey. This is how developers are taught to write code. It’s very efficient if there’s only one language involved. Even if that concatenated string is properly externalized, the word order is likely to be completely different in another language, making the translated version at best quaint, and at worst nonsensical. Since the translator doesn’t see the whole string together, they can’t produce a quality translation. However, if concatenations are found right in that day’s work for the developer, correction is quick and painless. Wait until testing, and now we have a multi-step process.
Another example is a developer not using a proper class or method that can support locale, or not passing locale to a class. Perhaps they are using a calendar class, such as SimpleDateFormat (Java). This will render a US formatted date just fine and will pass unit tests, but it’s not going to go well on a system with a different locale date formatting preference.
If you catch these sorts of issues as the developer is writing or committing their day’s work, it’s minutes to fix them. Find them later, and likely QA has gotten involved, the developer has to track down the issue (often not obvious to locate in the code), verify it’s fixed and then update a bug report. It’s no wonder these issues slip in favor of a release date.
Automation, Efficiency, and Speed
For QA, a pseudo-locale is created automatically which adds pad characters around strings so that the tester can see the U/I in English. The pad characters prove that the interface can expand to support likely longer translated dialogs and more complex character sets. Again, nobody has to remember to run a script at some point in time. The updates are automatic and continuous. When the interface is changed by the developer, the pseudo-locale update is automatically updated. This gives QA departments immediate functional U/I test cases for every new feature that confirms to worldwide requirements.
For localization, the changed U/I resource files are automatically detected. Those files are then automatically vetted for quality checks (i.e., no duplicate string IDs, proper file formatting, and more) and sent out for translation or pushed into a Translation Management System (TMS). The localization vendor, which must understand and even thrive in agile localization, then delivers the translations, which are updated leveraging a TMS, Localization Vendor Portal or other translation systems, and our Resource Manager process verifies the file formatting again and takes care of updating the source repository.
Nobody has to track down all the resource files, measure for changes, run a script, verify the file formatting, and figure out issues like duplicate string IDs or silly things like a missing curly bracket in the file format. When the translation comes back, there is no need to manually check the files again, track the fact that some translations came back before others, find a missing translation, or some broken file parameter or encoding. That’s all done. If there’s an issue, it’s clearly described and the fix is fast. If as fallible humans we were to miss any of that, it’s often not detected till much later and even so, it can be hard to unravel. Because there is no human processing delay, linguistic testing can begin faster and within context of the application.
Integrating i18n and L10n has another human factor effect that changes the cultural thinking of the company. When measurement and updating is quick, visible, and relatively painless, you change the way that developers think about globalization requirements. You’ll find teams learn to automatically think about the global implications of their development efforts and the needs of new customers, and factor that into their decisions upfront. As one executive described it, the teams moved from being like a US based company that is looking to do international business, to a global mindset, looking to write software for the world. That makes for global product leadership, rather than a simple checkmark for minimal product requirements.
Strengthening Your Competitive Edge in Global Markets
Remember, there are competitors whose primary model is to copy what is successful in some markets, but use a better localized product to outcompete dominant industry players in new markets. Internationalization and localization are now not just about reaching new customers, they are also about defending customers and capitalizing on new opportunities going forward. What some people think is good enough, is not good enough. It’s best to give your global customers a continuous, excellent, up-to-date experience, or someone else will do that for you.