Tag Archives: software

Thoughts on New Technologies in Software Projects

For all customers questions arise sooner or later about technology upgrades and changes in platforms, languages and APIs. When should it be done? To what technologies? How to handle the transformation? The questions can not be answered here, because it is a question which leads to different answers in different organizations, projects and teams.

One criterion to think about is standardization. In a lot of cases it is best to wait until a technology has reached a certain kind of standardization. The technology is supported then for a longer time without to much change and some backward compatibility. Some basic behavior and interfaces are quite fixed and are not to be expected to change to much in a short time. This is especially important for smaller organizations which can not handle too much change in a too short time range due to resource deficits. It can be more safe to wait until some standardization documents are out and some bigger players in the market have fixed some details and have committed their interest. The investment in a new technology is more safe afterwards.

A good example are OpenGL and OpenCL. OpenGL is a long time out now and is one of the standards for 3D graphics programming. It is expected, that OpenGL will evolve over time, but it is not to be expected to be disappearing in a short time range without any notification. To much companies and organizations are involved in the standardization process. One of the next big things might be OpenCL. With companies like Apple, Intel, AMD (, ATI), nVidia,… the list of supporters is long and technologies are evolving.

A wise decision to a new technology leads automatically to a competitive advantage due to the fact that competitors on the market might not have migrated, yet. The own organization’s products are faster, more accurate, more flexible. more easy to use or what so ever. One only has to be aware not to create an incompatible product.

With a change to a new technology one also should think about to put a kind of fall-back mechanism in which might change internally to a former implementation of the functionality to enable customers which might not have the latest technology available to use the own products. For OpenCL as an example, this might lead to a check for OpenCL compatible hardware and if not present to a fall-back to the older implementations. This slows down the application to a former level, but the customer is able to use the product which is more important than having the best performance.

These are just some thoughts on technology migration which came to my mind during some discussions with customers and managers. One should take care about the decision about new technologies. Not to change is not an option and it is also not an option to change the technologies every time there is something new at the market. One has to find the own speed and the right time for one self.

I18n and L10n in current software developments

When I have a look to current software developments and have in my mind the current process of a world becoming smaller and smaller, I start to wonder, why there is no more attention drawn to internationalization (I18n) and localization (L10n).

Why should be software be internationalized?

As long as their are only engineers and managers using my software, it might be OK to assume that my potential users are speaking English. On the opposite, my experience is that especially in Asian countries managers and engineers are not speaking very well. Some of the countries are not open for global business long enough that their  ‘older’ managers and engineers had no chance to learn and train English a long time. Young managers and engineers are to be expected to be better in speaking English, but as soon as one knows the significant differences in eastern and western languages, one knows, that there will still be a significant amount of people not speaking English so well. I know from experience what it means to lean a sino-tibetean language by learning Vietnamese myself.

It is even worse for software used by operators and fabrication staff. Imagine a MES system not localized to the language of the country. Even in Germany operators are not well educated in English. Should I prefer an English speaking MES system or a German speaking one? If the price, the functionality and the performance are almost equal, I prefer a German speaking system. If I would purchase the software for an international working cooperation, I would invest in multi-lingual software.

Marketing requirements

If I would develop software for a global market, I need to have to pay attention to meet the demand of as many people as possible to increase the number of potential customers to increase my sales. One of the easiest things to do is to present cutting edge software to customers in their mother tongue and physical units and time presentation in a way the customers are used to. If I worked in Vietnam, I would like to be able to switch my computer from Vietnamese to English (or even better: German). I would have a chance to use my computer in a more efficient way, to make less mistakes and to deal with the software in a more reliable way. I guess, this is also valid for a lot more people.

Quality Management

“Usability” is also a quality requirement. Have a look to PureSol Technologies website for some more information.The positively influenced characteristics are “Understandability”, “Learn ability” and “Operable”. For quality focused software projects this is also a factor to take into account.

Simple Conclusion: Do it

In current software developments we should always start projects with an additional focus on I18n and L10n. The additional time and work to enable my software to change the language and the output units is not that high. Using good frameworks for that, it’s very easy to achieve.

A simple framework example: I18n4Java

Let’s have a look to I18n4Java. It’s a small framework I created for my own applications. It’s stable and usable, but not very user friendly, yet. The L10n functionality is taken from the Java API. It’s a very good and reliable framework. Only the suggestopm for I18n implementation I did not like. The SUN recommendation can be found at http://download.oracle.com/javase/tutorial/i18n. The basic information is: Put all messages in property files and change them in reference to the language needed to be displayed.

This approach has some issues:

  1. The message to be display is separated from the source code. I need to look into additional files to find what is actually display. When I need to change messages, I need to open additional files.
  2. The situation is worse as soon as I need message with parameters. Without seeing the actual message, I do not know in which order I need to put the parameters into the message.
  3. I need extra codes for opening the properties files, additional error handling during loading errors and extra code to read the messages.

This limitations are overcome by I18n4Java. Additionally, it is very easy to use in code.

The only things to do is to add a translator to a class which needs I18n. In each class one just needs to create a Translator object:

Afterwards within the class I only need to put every message to be displayed in to the translator and to show the translated message:

The message is then automatically translated into the language selected with

and if an translation file is found for the selected language.

That’s all what is to be done to enable I18n in Java programmed software. The rest is a simple configuration file to set the language needed. I18n4Java automatically sets itself to the currently set OS locale and tries to translate everything in the language the OS is set to.

Layer Model of Software Development Responsibility

During my professional life, I often have to explain my point of view of software development responsibilities. When, who has and where to develop software? Does a factory or manufacturer have to develop its own software? Is there not a standard software already around which is more expensive, but already present and a responsible software vendor is out there in case of bugs? Do I need a own software development branch? Could an external system house or software developer develop my specific solutions?

To make this tough question even more difficult, let me give you the straight answer: “It depends…!” 🙂

Let me explain my own small model about the responsibility layers within a virtual high tech factory. These layers can be identified within every organization with some differences, but the principles stay the same.

In reference to the OSI model, I created a small model for explaining these issues. There are roughly five or six layers within the IT landscape within a factory.

The Layers of Responsibility

Layers of Responsibility
Layers of Responsibility

Layer 1: Hardware Layer

This layer is the typical machine which is bought from a vendor. The machine is put and installed in the factory and does its job. The responsibility is clear: The machine vendor is responsible for its machine to work. The own facility crew has to assure that all media are available, but the machine is under vendor’s responsibility.

Layer 2: Data Collection/ Measurement Layer

Within this layer, data is collected or measured for later usage in layers above. A lot of machines have standard interfaces for presenting information outside, but some information is still not visible per default and can only be parsed out of log files or got from other sources.

As long as the data comes from standard interfaces from the machine, the machine vendor is fully responsible to get the interface work as documented. As soon as there is no standard way the software for getting these information must be customized.

Layer 3: Data Preconditioning and Conversion

In this layer, data coming from layer 2 is preconditioned and converted into formats and data which is more suitable for layers above. Every company, factory or organization needs other data and with another grade of detail. To reduce the amount of data, uninteresting data has to be eliminated and the grade of detail can be reduced by statistical summarizing. This layer is very tightly coupled with layer 2.

Some machines have the possibility to precondition data, but in most cases the amount and the grade of detail for data are to be customized. This layer is under full responsibility of the customer and the customer has to think about ways to do this customization.

Layer 4: Data Storage

Collected data needs to be stored for later use in a flexible and reliable way. This storage should be done in standard tools like databases and file servers. The responsibility is at the vendors of this storage systems. It would be strange if a non-software company would develop its own database systems and file servers.

Layer 5: Calculation

The data stored should now be used meaningfully. To achieve these parameters and numbers have to be calculated to give the appropriate information. Due to a customized table space or server landscape where the data is stored and a customized definition of parameters and measurement values those calculations have to be customized, too. The locations of data and the detailed definitions of parameters vary from organizations, factories and companies to others. This layer is to be customized in responsibility of the own company.

Layer 6: Presentation

The presentation could and should be done in standard software. It does not matter in first place whether it is within an office suite or with dedicated reporting tools. The views within these tools have to be customized and this should be part of layer 5. The view itself is done with standard software and responsible is therefore the vendor of the used software.


As shown above, a lot of software is around to solve standard tasks like storage and presentation. The machine vendors should ship interfaces to get all interesting data out of the machines. Everything else could and should be customized due to varying forms of server landscapes, database schemes and grades of details. Every company, factory or organization has its own ideas on how to collect data and which grade of detail and what amount.

Therefore, in layers 2, 3 and 5, customization is needed and should be done in responsibility to the company using the software. There is no other way around. Machine vendors do not know the details of their customers and can not meet all demands. They can only create easy to use, reliable and well documented interfaces to get all important information out of the machine. Everything else has to be customized.

The question “Who should do the development?” is more difficult to answer. My answer would be: “If you can effort it, do it on your own. Hire at least two people who can program the software for the layers and be happy about the knwoledge and capability to make changes on your own.”

If your company, factory or organization is large enough to keep two or more programmers busy the whole time, you should hire them on your own and make the software on your own:

    • External software developers are more expensive due to the extra money they need for offices and administration.
    • In case of bugs, your own programmers know your company better and can fix the bugs easily.
    • In situations of change, your own people can make the needed changes. That’s faster and cheaper. I do not only speak about changing a company logo after a merger, but about changing a whole product lines or factories to new machines or products.


There are some obvious parts within an IT landscape where customization is needed and should be done: Data collection, measurement, pre-condition, conversation and final calculation. If it’s affordable, one should do it on its own to get the best benefit out of it and to be flexible in situations of change.