Posts

A Better Approach to Internationalizing and Localizing Software

Adapting software so that it supports multiple languages and locale formats is not trivial and it is important to your global success. A localized User Interface can have a positive impact on your customers’ satisfaction with your product. The globalization requirements span your software architecture and ongoing development practices. It is important to create ongoing processes so that internationalization (i18n) and localization (L10n) can be easily integrated into your sprints and releases.

Why Software Localization is Valuable

Companies that are looking to grow globally find that fully localized software is one of the key elements to sustained growth. You may gain some initial traction without localization, but if you want to move beyond early adopters and be more competitive, the localization process is an essential step. The localized software is easier to use and helps build long-term customer satisfaction. In addition, companies that invest in i18n and L10n often find they are at a competitive advantage in international markets which helps maintain pricing power.

But before you can effectively localize, you must internationalize your software to enable multilingual capabilities. This includes:

  • Adding locale frameworks
  • Externalizing strings
  • Refactoring string concatenations
  • Replacing locale-limiting programmatic functions/methods and patterns
  • Database internationalization
  • Managing potential 3rd party product issues

Getting Started

Internationalizing your existing application may seem daunting but the effort is typically rewarded with increased revenues. There’s a reason many companies underestimate the effort required to internationalize software. Many good programmers don’t have experience with internationalization and are therefore unfamiliar with best practices. They may regard i18n as a simple string externalization exercise – which of course is not the case. To complicate matters, without tools to keep the development teams on track, it is inevitable that i18n technical debt will creep into new features. Below are some tips and suggestions to help make your internationalization and localization efforts efficient, effective, and successful.

1. Dedicated Team

It’s not uncommon for some companies to start internationalization efforts with only one or two developers. Within a few months, they are pulled from i18n and put onto a “higher priority” project and sometime later replaced with different developers. This inconsistent approach almost always fails. After a year or more and significant resources expended, the project is still not complete, and the opportunity cost only continues to rise.

Creating a dedicated project team is the most important step in ensuring your internationalization effort will be successful. Using third-party contractors to lead the effort, combined with some of your own development resources, is one way to make sure the team persists even when internal resources are diverted. This approach has the advantage of allowing multiple internal developers to participate in the i18n process, rapidly improving the learning and socialization of internationalization techniques.

2. Software Architecture

Before diving into externalizing strings, it is important to first look at the software requirements and architecture. Is Unicode required? String externalization in the user interface is obvious, but are strings also passed through and processed in your software back end? How will you support locale selection within your application’s various programming languages? How will locale be selected and is there a fallback? What changes will need to be made within your database? Are there third-party libraries that need to be considered? Like many programming tasks, getting the approach correct up front will save many hours of wasted time doing rework. Are you choosing to use established methods for locale support or creating your own (we don’t suggest the latter)? Using standard resource file types and conventions will make automation of the translation process much easier.

3. Finding i18n Bugs

One of the more challenging aspects of internationalizing existing software is finding all of the i18n issues. Within thousands or even millions of lines of code, these can be difficult to identify and resolve. Fortunately, there are static analysis tools available, like Lingoport’s Globalyzer, to make the task of finding and fixing i18n bugs faster and easier. It is also important to put in place a method to quickly check new source code as it is being written so that internationalization becomes part of the agile process rather than addressed later in backlogs when it will cost much more in time and hassle. When developers can quickly scan their work from their IDE to find i18n issues, they are much more likely to fix the issues as they are writing the software.

4. Automation

The very nature of agile development involves rapid new feature development. For localization, this means many relatively small localization changes, performed more frequently. Traditional approaches to software localization involve many manual steps to perform a localization update. The process of finding and enumerating new strings from resource files in repositories, sending them out for translation, and returning the translations to the repo, can be tedious and error-prone. When changes are made to the source string, sequencing of the returned translations is almost always an issue. In addition, errors in the source files are multiplied across all of the locales during translation so it is important to validate the formatting prior to sending the files for translation. The good news is that this entire process can be automated so that no one needs to take on the role of “file nanny”, shuttling files back and forth to translation. For example, Lingoport’s Resource Manager handles these tasks using continuous integration along with an automated connection to your localization company or translation management system.

5. Selecting a Translation Partner

Language Service Providers (LSPs), also known as translation agencies, provide professional translation services including software and app localization.

Selecting a translation agency that has experience in and an understanding of software and app localization is key for ensuring your localized product is well received in new language markets.

Here are some things to look out for when evaluating translation agencies:

  1. Will the localization process be synced with your development process and does it fit seamlessly into your existing workflow?
  2. Do they offer integrated technology solutions to provide continuous translation and streamlining string hand-offs?
  3. Are they providing a veteran team of in-country linguists and industry tools to deliver quality translations that meet your deadlines and budget?
  4. Are they a full-service agency that can be called upon throughout the enterprise with professional translation services that include website, documentation, video and marketing content translation?
  5. Do they provide an optional Quality Assurance (QA) step that includes efficient, in-context validation of language and formatting to ensure your product looks and functions as intended?

When selecting an LSP, you are outsourcing a set of specialized and time-sensitive tasks that are closely coupled to your creative and development process. Quality should be a priority at each step in the process, from project set up through quality assurance. Working with a localization partner who can navigate both cultural and technological challenges will not only take your product across borders but also help it succeed across language markets.

The unique challenges of software demand dedicated effort to internationalization and localization. The proper tools and partnerships are required to meet your agile development workflow. Lingoport and Acclaro provide the expertise and solutions to help you meet your worldwide market goals.

Acclaro

 

Acclaro is a strategic partner of Lingoport.

 

Achieving the Happy Path: The Transformation of i18n and L10n for Agile Development

The internationalization (i18n) and localization (L10n) happy path for software development brings i18n and L10n features and requirements of a sprint or release together with no exceptional errors and no organizational friction. That is a bit of a twist on the Happy Path term used in QA, but I’m appropriating and bending as there’s no parallel concept for software globalization. The traditional agile i18n and L10n path is full of brush, rocks, and detours. There’s much we can do to clear the way.

Reasons why i18n and L10n and Agile development are traditionally not graceful pedestrian partners include: human time-delaying processes, limited understanding of i18n among developers, lack of, or ad hoc automation, delayed i18n and L10n QA, vendors and resources which are outside of the development team’s direct control and human errors that add up to blow out timelines. In Lingoport’s own industry survey, which is weighted toward localization savvy participants, only 6% felt they had a strong agile i18n/L10n process in line with their development teams.

Why It Matters:

Markets outside a company’s home country often represent some of the greatest opportunities for growth and stability. Agile development, with its focus on targeted scope and frequent product updates, has a different cadence than traditional software localization, QA, and i18n review, which historically could take weeks or months per release. The impact is that the same delight of frequent updates home users enjoy might not be presented to global customers, with only quarterly or less frequent updates.

This is a competitive weakness. But there’s more to it. If i18n and L10n fall outside of the regular cadence of development, they are by nature part of the backlog. Any bug fixes, file changes or localization updates now involve revisiting code when the developers have moved on to their next efforts. By far, the most efficient and least expensive times to find, fix and update are when the developers are in the code working on a feature and not later. This is one of the important credos of why agile development is embraced in the first place.

Definition of Done:

I18n and L10n are attributes of development, and unless specifically being performed on an application for the first time, they should be part of the definition of “DONE”. That’s no different from other requirements, like security or usability. If you think of i18n and L10n this way, you naturally need to look at how to measure, track and process i18n and L10n in parallel with feature development. You also have to consider how to do it at scale, over multiple teams and possibly over multiple products. Looking at i18n and L10n in this way makes it very clear that automation will help substantially in the achievement of the happy path for agile global software development.

Automation:

Early on in the broader adaptation of agile software development, sprints were typically three to four weeks. Now two weeks and less seems to be the norm. Much of that compression has been made possible through automation. Git, dashboards and coding quality checks take center stage here. If we let computers do what they are good at, people can focus more on where they bring the most value.

When it comes to i18n and L10n, consider that a SaaS product is often likely to have perhaps 10+ developer teams. Now think of 10 more products, all with two-week sprints presenting many small changes, spread over various parts of product source code. It gets more complicated if the product architecture uses a micro-services strategy, often with hundreds of source code repositories. With the pressure of sprint timing, it’s no wonder there’s a disparity with how localization actually gets performed and interfaces with development. It’s also no wonder that i18n and L10n bugs tend to pile up over time.

Automation can streamline multiple parts of the i18n and L10n process, making globalization a measured and easy part of the development process; but the minute you have to wait for someone to gather files, send or read an email, search to fix a problem, run a script or FTP an update, file an unspecific bug or update a translation, you have built-in process friction that is likely to break that release cadence. Lingoport Suite changes that for developers and L10n stakeholders.

Developers and i18n/L10n:

Globalyzer SummaryI18n is a vague software requirement. There are some obvious best practices, like the avoidance of embedding strings in your code (obvious, but it still happens), and less obvious issues (i.e. string concatenations, not passing locale into a method, date/time issues, encoding issues, programming patterns that will negatively impact localization and more).

This is no different than any other quality requirement, like security or even automating bug checking. The closer you can get to when the code is being written, the more efficient it is to correct a potential problem in terms of time, development velocity, cost and your definition of done, not to mention the closer you will be to achieving the happy path. Lingoport’s Globalyzer will present i18n issues right in the developer’s IDE (Development Environment) and/or the checks can be automated on pull requests/code check-in. I18n (and L10n) issues are presented on a dashboard for each repo making i18n and L10n status accountable. It’s a fair bet that individuals and teams will not want red marks on that dashboard in association with their code. What gets assisted, measured and visible gets done.

Developers also shouldn’t have manual tasks regarding L10n. Lingoport’s Resource Manager checks for changes to resource files (many types), checks the files for basic quality issues (i.e. no duplicate string IDs, missing curly brackets and general format issues – 40+ checks) and automatically packages and sends those files to the company Translation Management System (TMS) or to a localization vendor portal directly. When the localization files return with translation updates, they are again checked and if there are no critical errors, they are automatically updated into the repo for testing. All this is clearly displayed and tracked in the Dashboard, status emails and Lingobot queries. Nobody has to be a file nanny.

GlobalyzerGlobalyzer and Resource Manager come with extensive default detection and filtering for many programming languages (i.e. JavaScript, Java, C# and much more) and resource file types. Globalyzer uses machine learning capabilities to finely tune i18n static analysis to pinpoint issues and eliminate false positive detections. Setting up and performing functions can be as simple as calling Lingobot from within collaboration tools like Slack or even from an IDE.

If internationalizing for the first time, Globalyzer’s Workbench speeds up both issue detection and i18n refactoring. The Workbench is meant for i18n power users. More commonly used by development teams, Globalyzer Lite, runs from within popular IDEs or can be called during check-in via API.

QA and i18n/L10n:

Family Search HomepageQA are the gatekeepers of the definition of done, but they need a clear path to measure quality. As developers update interfaces, Lingoport Resource Manager automatically updates changes with pseudo-localizations that can be used to test for language and locale requirements without needing to speak the target languages. Pad characters with target encoding, with a clear beginning and end mark, are added to strings with controllable expansion depending upon target locale requirements. Testers can see quickly if there are problems.

When problems occur, they can be traced back to where they occur in the source code, rather than limited to describing an issue. That’s less time hunting for the issue for developers, and a more efficient process overall in pursuit of the happy path of software development.

Localization Managers:

If localization managers and L10n teams (always understaffed) don’t have to chase down files, updates, and problems, they can instead concentrate on vendor relations, project management, interacting with development, marketing, and in-country teams. These are higher value tasks.

L10n Managers can see the process status readily over many products and repos where teams are doing their work. Having a system and a process also helps Localization Managers to be in control of the quality of their deliverables and product destiny. Most Localization Managers would rather be spending more time on high impact initiatives, such as coordinating global teams and building global strategy, than i18n and L10n bookkeeping tasks.

Localization Vendors:

Agile development presents localization vendors with business issues. It typically means many small localization updates over lots of repositories. Consider that one repo has 16 new words, another has 42, another 116, and so on. The minute a vendor has to deal with any file inspection or formatting issues, the vendor turnaround mandate is difficult. Localization file engineering can’t be absorbed over small word counts. If the software development customer is automatically sending files that have been inspected, then the vendors can cleanly deliver the translations, repeatedly. With our process and using our software, we often see i18n, L10n and respective QA turnarounds go from weeks to under three days, which is critical to keeping i18n and L10n within the definition of done.

Linguistic QA (LQA):

Translation has its own set of quality issues involving context. Words between languages often don’t map a clear transition of use case, with one word equaling exactly another from language to language. This is why we have Linguistic QA, which can be performed by an outside vendor as well as from input from in-country teams.

Traditional LQA again falls outside of sprints. The normal process is to go through the interface and when a problem is found, the LQA team member makes a screen print showing the work to change, with a suggestion filed into a tracking system. That suggestion has to be reviewed and confirmed and then needs a localization engineer or developer to find and update the file and word in the source that corresponds to the update. Again, the usual process involves a clumsy multi-party human set of problems that take time outside of sprint schedules. Instead, Lingoport’s InContext QA lets a reviewer see translation in context with the running application, click on a message to change it directly, input the new word(s) along with any bug reporting notes and submit it for approval. If approved, it can pass back through the TMS or vendor portal for translation memory update or management as needed. No more screenshots, file sleuthing and slow processes. It’s fast and helps teams be reactive to in-country stakeholders. It’s brilliantly simple in practice.

The Happy Path:

I18n and L10n should be part of the happy path of globalized software releases. That is, by using automation to streamline the processes computers are good at performing, we compress i18n and L10n into each sprint and release.

There may be cases where outside issues, like a vendor delay or in-country LQA delays force some delivery of a well-localized product beyond a sprint, but that can have a contingency plan before releases, as the updates can be automated into the source code. That becomes the less happy path, but it beats letting i18n and L10n bugs pile up.

Using the benefits of automation, precision issue checking, metrics and visibility will make for a faster and higher quality product delivery for worldwide customers. That matters for your customers and worldwide stakeholders as well as for your company’s bottom line.

i18n Quick Planning Guide

Internationalization (i18n) is the process of preparing software so that it can support local languages and cultural settings. Let’s say you land a new contract with a company in Japan, or your management team is looking to make an aggressive push into the EU. Then internationalizing your software is the path towards meeting the needs and expectations of local users in those markets.

Software i18n, though, involves many steps and is difficult to achieve efficiently and reliably without the proper step-by-step methodology. The wrong execution can have major ramifications for your development team’s time and your company’s revenue.

To that end, Lingoport has published the i18n Quick Planning Guide to ensure a more successful i18n process. Submit the form below, and receive the guide via email.

Enter Your Information to Download the Planning Guide

  • This field is for validation purposes and should be left unchanged.

What Is i18n?

Internationalization (i18n) is the process of preparing software so that it can support local languages and cultural settings. An internationalized product supports the requirements of local markets around the world, functioning more appropriately based on local norms and better meeting in-country user expectations.

Let’s say you land a new contract with a company in Japan, or your management team is looking to make an aggressive push into the EU. Then internationalizing your software is the path towards meeting the needs and expectations of local users in those markets.

I18n is often misrepresented as Localization (L10n) and sometimes even Translation. I18n is product development focused so that in the case of software, one code base is made capable of supporting worldwide languages and locale-specific formatting and behaviors. It’s a critical and sometimes underestimated step that is needed for successful and scalable L10n. Conversely, Localization makes a product specific to a target market or region(s), including translation of the interface and possible adaptation of terminologies and more.

Releasing software that has not been properly internationalized can lead to many problems, including lack of market acceptance. Addressing and fixing i18n bugs after product release results in additional costs, time, resources, and a potentially damaged reputation in local markets. Retrofitting a product for a global market after release, in contrast to internationalizing the source or during development, can be time-consuming, costly, and provide alternative products with a competitive advantage.

What Does Software i18n Involve?

Typical software internationalization tasks include:

  • Developing software to be independent from a specific language or limiting character set, and independent from cultural conventions (e.g., date display, time display)
  • Locale Frameworks
  • Achieving Unicode compliance
  • Elimination of hard-coded text (strings) in the code
  • Removal and reworking of concatenated strings
  • Support for collation of data
  • Support for bi-directional languages, such as Hebrew and Arabic
  • Plus more, including issues that may be application and market specific

Benefits of Internationalizing Software

Benefits of software i18n include:

  • Higher quality software that meets the technical and cultural needs of multiple locales
  • Reduced time, cost, and effort for localization (L10n)
  • Single source code for all languages of the product
  • Simpler, easier maintenance for future iterations of the product
  • Greater in-country customer acceptance and satisfaction

i18n Stories

Companies come to Lingoport with their i18n problems, so we’ve seen a lot that can go wrong with global software releases. Here are some brief examples:

One company had been internationalizing for years, but had persistent i18n bugs that garnered complaints. When counted, there were nearly 500 of them on one product alone. That’s a significant impact, expensive to fix and distracting from new features. By using Lingoport software to support ongoing development, they can now measure and fix i18n issues during development, which is much faster and results in a higher quality global product experience. Using Lingoport’s Globalyzer and Lingoport services assistance, they are working their way through the i18n bugs.

Still another company knew they had an i18n business case, but it was not immediate. They hired summer interns to externalize strings and perform minimal i18n adaptations. Without good direction or appropriate skills allocation, they didn’t get very far. They then sent the i18n offshore to a general contractor, spent over $500,000, and still didn’t have a properly internationalized application. In the meantime, they didn’t feel they were much closer to product readiness, and were passing up new opportunities.

Continuous Internationalization & Localization

Agile development has changed i18n and L10n tasks dramatically, as software changes faster but in smaller increments. It’s easy for i18n and L10n to fall behind. Regarding i18n, it’s often not apparent to a developer that there is an i18n problem in the code they are writing, as the scope of i18n is broad and there are QA challenges. For L10n, there is all kinds of management and manual task overhead, as files get moved around and updated. We believe that some of the biggest globalization efficiency gains for software companies to realize will be in systematically and continuously integrating i18n and L10n with agile teams, rather than hoping to find and fix issues in QA cycles when the development team may have moved on.

The key here is automation. Not necessarily of the actual translation via some machine translation, but managing legacy and new development for i18n issues and moving files for localization from the build to the translator and back again in a very visible and verified manner.

To do this, we automatically monitor software code repositories for i18n and L10n changes and issues/violations.

Continuous i18n and L10n features include:

  • Visibility – Dashboard measurement and drill-down of i18n and L10n violations and changes via static analysis of source code repositories including tools for fixing problems early during development
  • Automation – i18n support in the developer’s IDE, upon check-in and regularly run on targeted source code. Automated analysis, verification and exchanging of localization resource files from the build to translation (or translation management technologies) and back again to the build for staging and linguistic QA
  • Metrics – Tracking progress, coding quality, translation timing and more so that you can plan and improve
  • Integration – Integration with the tools that you are already using, such as a Translation Management Solution (TMS) and Slack for communications

As you add and update features and locales to your software, you have an automated framework for faster, trouble-free global releases.

Why Continuous i18n and L10n is important:

In practice, most software development endeavors treat localization as a delayed and often manually managed process, outside of ongoing sprints and releases. This is contrary to agile and good software development management practices.

There’s all kinds of “bookkeeping” issues around managing what’s changed, missing files, getting it out for localization, then putting it back in the source code. By its nature, this delays the process, lends itself to handling errors later when the teams have moved on, shortchanges QA efforts and delays localized releases. It’s costing you time, headcount, and cleanup, and it impacts the global imperatives of your company. Continuous i18n and L10n is simply a much more effective strategy.

i18n Implementation Tips

For legacy i18n refactoring and new development:

1. Learn, Build and Support the Business Case
Continuous i18n and localization (l10n) in support of agile development is going to have a cost. Unless the business case is defined, the project is unlikely to get done. Make sure you build a strong business case to compel all team members to align on i18n implementation.

2. Clarify Your Global Release Objectives and Concurrent Development
i18n touches a good deal if not all of your application, rather than being like adding a feature or fixing a bug in a particular sprint and area of your code. It usually involves more than your software’s presentation layer, as data is input, stored, transformed and retrieved. When internationalizing your product for the first time, you’ll need a branching, merging and testing strategy that covers the full i18n scope.

3. Assess and Document Requirements
Establish user requirements as they relate to target locales. i18n is almost never just a string externalization exercise you can pass to an intern. You’re going to need to put some thought into locale requirements, how data is going to flow through your application, changes to your database, methods/functions/classes that will have to be made locale-aware and of course the U/I and all it’s strings.

4. Build a Plan
An i18n project plan typically starts with about 200 tasks and increases with size and complexity (consider this for multi-tiered applications). To build this type of plan, one option is to analyze the code base with Lingoport’s i18n software product, Globalyzer, which provides detailed static analysis on internationalization issues that will need to be addressed. Combine that with architectural analysis from whiteboard discussions and requirements documentation.

5. Reduce Risks and Manage Trade-offs
Being late in deploying your global software is very costly to your business. The risk can be a broken agreement, market launch and business plan. A three-month delay may make an annual revenue goal unattainable. Ensure that your executive management team is fully bought in to your i18n efforts, and that your team has the budget, resources and tools to get the job done efficiently, reliably and successfully.

Internationalizing a large application is generally resource intensive. In cases where you have lots of legacy code, you may need an implementation partner in order to keep up with ongoing development objectives outside of internationalization.

6. Long Term Support
Once you internationalize and localize your software, your ongoing development has a new set of requirements. Measure i18n just like any other coding quality. Do not wait until testing to find out if i18n is broken. For your ongoing agile development, it’s good to automate the management of changes to strings that may change somewhat with every release.

Common Mistakes Made When Trying to Internationalize

Be sure to avoid these 10 common i18n process mistakes:

1. Don’t Forget What Drives Internationalization
Your company’s top and bottom lines. The costs of being late or delivering lousy quality products endure beyond any benefits of cutting corners on development.

2. Don’t Assume Internationalization Is Just an Older Software Legacy Issue
No framework, whether it’s React.JS, J2EE, .Net, Java, Ruby on Rails, PHP or whatever is new and improved, internationalizes itself. You still need to perform all the steps necessary to implement locale and all the associated i18n practices.

3. Don’t Assume You Can Treat Internationalization Like Any Other Feature Improvement When It Comes to Source Control Management
It’s typical for new feature development and bug fixing to be conducted in parallel with i18n. However, in the process of performing i18n, you are going to be breaking major pieces of functionality within your application as you make large changes to your database and other application components. In order for respective developers to work on their own tasks and bugs, you typically need to branch code, often with specifically orchestrated code merges.

4. Don’t Assume Internationalization Is Just a String Externalization Exercise
String externalization is important and highly visible, but the scope of i18n includes so much more. For example: creating a locale framework, character encoding support, major changes to the database, refactoring of methods/functions and classes for data input, manipulation and output.

5. Don’t Wing It on Locale
Designing how locale will be selected and managed often doesn’t get the amount of thought and planning deserved. How the application interacts with the user, detects or selects locale, and then how it correspondingly behaves is a design process needing input from an experienced architect, product marketing and the development team.

6. Don’t Create Your Very Own Internationalization Framework
Various companies have half-way implemented internationalization using their own homegrown methods for string extraction and locale management when there were already well established methods provided within their programming language framework or established solutions like ICU. Using these methods or solutions will ensure that your code is far easier to maintain. No unpleasant surprises.

7. Don’t Think That the Team Internationalizing Your Software Can Work without a Working Build
Without a working build, the developers can’t smoke test the changes they are making. Even if you provide a dedicated QA person, developers need to be able to compile and run themselves to head off problems later. It’s too hard to rely on reconstructing coding errors at a later time and make for unnecessary bug fixing iterations, lost time and poor quality. It’s odd that we even have to mention this, but it comes up.

8. Don’t Run Out of Money
I18n planning often suffers from underscoping. Lapses in funding can cause expensive delays, as new funding takes more time than anyone imagined to get approved. And chances are, if you need to ask for more money, than you also need more time, which brings you back to consequences regarding tip #1.

9. Don’t Use a Half Thought-Out Character Encoding Strategy
Use Unicode, rather than native encodings. If you have budget and time constraints and you’re only targeting dominant languages in markets like Western Europe, North and South America, you can often get away with ISO Latin – 1, but even for Eastern European languages, go Unicode. Then when you do, make sure your encoding works all the way through the application.

10. Don’t Use Your Same Testing Plan, or Just Rely on Localization Testing, When Your Functional Testing Needs to Grow to Include Internationalization Requirements
Use pseudo-localization of not only the interface, but send test data using target character sets, locale altered date/time formats, phone numbers and more, from data input to database, to reports and so on. In your pseudo-localization testing, expand data fields to fit physically longer strings, accounting for expanded strings from translation. Pseudo-localization is automated when you use Lingoport’s Resource Manager.

State of the i18n Industry

Lingoport recently conducted The State of Continuous Internationalization & Localization Survey. There’s been plenty of talk within our industry about making i18n and L10n continuous, automated and in step with Agile development. However, we wanted to uncover the true state of the industry and therefore launched the survey.

The reality is, the industry still has a long way to go… For example, only 8% of respondents thought they did an excellent job at measuring and managing i18n requirements. Download the report to see where the industry stands on localizing for every sprint, the lag time between feature releases and L10n turnaround, and other global software development issues.

Download the survey results.

Lingoport’s Market-Leading i18n Software & Services

Lingoport is the premier i18n software and services company in the market. If you are looking for software, or for i18n assessment, consulting or implementation services, we encourage you to explore the following links and to contact us at any time.

  • Lingoport Globalyzer – Find and fix i18n bugs. Lingoport Globalyzer is your operating system for exceptional global software. Avoid rework. Find and fix i18n issues as the code is written. Default rules and machine learning pinpoint existing i18n issues in source code for a wide variety of programming languages and database scripts. Improve your agile software development for global markets with Lingoport’s flagship i18n software.
  • Lingoport Resource Manager – Automate change detection and export/import resource files for localization with Lingoport’s localization process management software. Eliminate error-prone, manual processes and save thousands of hours of engineering time.
  • Lingoport Dashboard – The hub of our i18n suite. See it all, drill down, create notifications and manage the process. Bridge gaps between localization & development. Increase visibility and track globalization metrics.
  • Lingoport i18n Services – Benefit from our 17 years of experience. Enjoy expert teams for software i18n assessment, planning and implementation.

Lingoport Webinar: Highly Effective i18n Planning

JavaScript Internationalization – the Good, the Bad, and the Ugly Whitepaper

There are many standard practices to follow when implementing proper internationalization (i18n). For those looking to understand the details of proper i18n when coding in JavaScript we’ve put together this white offering.

Download “JavaScript i18n-the Good, the Bad, and the Ugly” whitepaper, which will allow you to leverage the expertise of Lingoport’s experts to improve your i18n JavaScript.

Submit the form below, and the whitepaper will be emailed to you.

Current Locale Resulting Block | Internationalize JavaScript

Enter Your Information to Download the Whitepaper

  • This field is for validation purposes and should be left unchanged.

Lingoport Releases Globalyzer 6.1: Machine Learning and more

Breakthrough for Software Internationalization with Machine Learning

TLDR: Globalyzer finds and fixes internationalization issues that are complex and important for creating software for worldwide customers. Highlights:

  • New machine learning accelerates i18n issue detection accuracy, lowers false positives
  • More intuitive tuning than existing methods
  • Faster time to global releases

5/14/18

For Immediate Release

Lingoport has released Globalyzer 6.1, which adds the power of machine learning to find internationalization (i18n) issues faster, and with pinpoint accuracy, over multiple programming languages and database scripts. Machine learning makes i18n easier and more intuitive.

Globalyzer’s Machine learning is a step forward in automatically and accurately finding internationalization (i18n) errors within source code as it’s being written or checked in. Machine learning makes customizing i18n detection faster and more accurate while eliminating false positive detections quickly.

Internationalization is the first step to making applications that behave elegantly in terms of regional formatting and other requirements. It’s a critical but difficult requirement for software companies looking to expand their reach in worldwide markets. Finding i18n issues early in software development, when they are fast and easy to fix, saves time to market and expense.

Source code has unique conditions that can make i18n detection challenging. Often what is wrong in some cases is perfectly fine in others. For example, elements can seem to need translation, that in some cases have become programming variable names, which creates an i18n false positive detection. Globalyzer has always had methods to manage problematic false positives, however, machine learning makes customizing Globalyzer’s many default programming language i18n rules three to five times faster, with better immediate results and a more intuitive tuning process.  

Lingoport’s Globalyzer is used by many of the world’s best known technology companies, supporting development for worldwide customers. These companies avoid i18n and L10n rework and produce a high quality user experience concurrent with their new development and product releases.

“Managing false positives is the number one concern we hear from developers, so it’s exciting that our team has built a new approach that’s easy and straightforward,” stated Adam Asnes, Lingoport’s CEO. “With Machine Learning, Globalyzer becomes even more adaptable for the speed of agile development globalization.”  

Globalyzer 6.1. Includes additional features, such as access to Lingobot within the developer’s IDE. Release notes are available here: http://bit.ly/2rCTyTz


About Lingoport:

Lingoport provides a software suite and professional services that enable globally focused companies to create and maintain software that works elegantly in every language and locale.

The Lingoport Suite includes Globalyzer, Resource Manager, and Lingoport Dashboard. Working together, these products continuously monitor, fix and manage both internationalization and localization in each software sprint and release.

www.lingoport.com

Contact: Adam Asnes, aasnes@lingoport.com

Address: 3180 Sterling Cir #201

   Boulder, CO

   80301

###