1.7. Annotated Sample Technical Questionnaire
This questionnaire, based on which other scoping questions can be formed, serves as a guide to the porting technical leader. The customer in this case is an internal or external organization that needs to port its application(s) to the Linux platform.
1.7.1. Platform-Specific Information
What is your current development platform for the application?
This question is about the development platform used to develop the application. It does not assume that the development platform is the same platform the application is deployed on. This is asked in the next question.
What platform does the application currently run on?
Porting engineers need to know which source or reference platform the application to be ported is using.
Has this application been deployed on any other platform than the development one? If so, which version of the platform is it running on?
Asking this question gives you a sense of the portability of the application if it has been ported to other platforms. A word of caution: Although an application may have been ported to other platforms, it may have been done on older versions of the platform.
Describe any hardware (that is, graphics adapters or cards) used by your application and whether the required drivers are available on the Linux platform.
Make sure any platform dependencies are available on Linux.
1.7.2. Application-Specific Information
Please describe your application and its architecture in detail.
This is where the customer describes the application architecture. Have them include an architectural diagram if possible. All components in the application need to be described. This should also tell you what type of application framework, if any, the application runs on. Most Java applications run on product-specific frameworks such as WebSphere or Weblogic. If they are written in C++, they may run on a CORBA framework, which means you may have to deal with a specific CORBA framework that may or may not exist on Linux.
What are the different components of your software? Please provide a name and version number for each component.
This gives you a sense of the breakdown of their applications. Being able to break the application into different discrete components can mean that the porting work can be broken into smaller independent tasks.
Which of these pieces needs to be ported or not ported? Please include the version number.
The customer needs to tell you what is in scope and what is not in scope.
What percentage of the application(s) to be ported is/are written in the following programming languages?
Visual Basic (Microsoft)
Shells (ksh, csh, perl, awk, others)
Ascertains the complexity of the application by asking what languages they are using and what percentage of those are in use.
Please provide a rough estimate of the number of lines of code in the software, listed by language types.
This is another way of asking Question 4. Asking questions in different ways often brings up data points that contradict each other. This opens the door for open discussions that can result in better project scoping.
For Java apps: Does the application use the JNI to link native libraries? Please describe.
 Java native interface.
Ascertains the complexity of the application to be ported. Most of the time, Java applications that are not 100 percent pure Java need platform-dependent routines that can only be handled in native language such as C. Be aware of such platform-dependent code, because it takes more time to port.
Does the application use kernel modules? If so, please describe.
Ascertains the complexity of the application to be ported. Kernel modules and routines used by the application are nonportable. These will take more time to convert to equivalent routines in Linux.
Is this a 2D/3D graphics application? Please describe.
Ascertains the complexity of the application to be ported. Make sure compatible graphics toolkits and development tools are available in Linux, whether they are supplied in Linux by default or by other third-party vendors.
Does the application use UNIX pipes, message queues, shared memory, signals, or semaphores? Please describe.
Most of these have standard UNIX interfaces that can be easily ported to Linux. Although the interfaces may be standard, implementation underneath the covers will differ. The catch is to make sure that the intended behavior remains the same when ported to Linux.
Is the application, or any of its components, multithreaded? If so, which threads library is currently being used? Does the application rely on any proprietary threading priorities on your development platform?
Depending on the source platform, multithreading interfaces can vary from standard to nonstandard. Linux supports several threading libraries, but the one that is standard in present and future Linux distributions is the Native Posix Threads Library (NPTL) implementation. NPTL is discussed in other sections of this book. The point is that the closer the source implementation is to NPTL, the easier it is to port.
Does the application perform operations that assume specific byte storage order? Is this likely to be an issue during the port?
This question relates to the "endian-ess" of the application. Most Linux ports will target the Intel platform, which is small-endian, whereas most source platforms will be big-endian. Nonportable code that assumes endian-specific characteristics will break when not ported correctly. Worse yet, the ported code will not exhibit errors during the porting phase. The problem usually crops up during system testing, where it is harder to find.
Which compiler(s) and version are used in the development platform?
Java (what version?)
Platform (HP, AIX, Sun, Microsoft, NCR, AS/400, S390, True64) compiler? Which platform?
Others (please specify)
Ascertains the complexity of the application to be ported. If the source application uses the GNU gcc or g++ compiler, it becomes easier to port to Linux because the native compiler for Linux is GNU gcc or g++. Applications that are developed on other platforms and are compiled in their native compilers tend to use native compiler semantics, which must be converted to GNU compiler semantics. C++ applications become harder to port than C applications when the application starts to use C++ features such as templates. Because some C++ standards are implemented differently by different compiler vendors, porting this type of code takes more time than simpler C or C++ code.
In addition to the development environment, are there any dependencies on debugging tools such as memory leak debuggers, performance analysis tools, exception handling, and so forth?
This goes back to scoping and dependencies. Third-party tools that may or may not exist in Linux need to be assessed. Who needs to provide for the license? Who is responsible for obtaining the tools? What will be the support structure if third-party support is needed?
Is this a socket-based application? If so, does it use RPC? Please describe.
Although Linux supports standards-based socket and RPC semantics, the intent is to ascertain portability. Asking this question may bring to light nonportable architecture the customer may have implemented in the application. This question can also lead to questions on what setup is needed at the testing phase.
Does the application use any third-party software components (database tools, application server, or other middleware)? If so, which ones?
Every third-party software component adds complexity to the port. If any third-party software components are used, ask what version of the component is used and whether it is available on Linux. Third-party components may require extra time to learn and even to configure or build if necessary.
How is the application delivered and installed? Does it use standard packaging? Will the installation scripts need to be ported, too?
A Linux standard packaging mechanism is RPM. RPM is discussed in other parts of the book. Ascertain whether the customer will need the packaging part of the application ported, too.
Is the application or any of its components currently in 64-bit? Will any component need to be migrated to 64-bit?
With the advent of 64-bit platforms and operating systems, this question pertains to the level at which the application needs to run or be ported. Most 32-bit applications will port to a 64-bit environment without problems through the use of modern compilers. Today's compilers have become efficient at flagging syntax and semantic errors in the application at compile time, allowing the porting engineer to make necessary changes. The one consideration here is that it will require additional time for porting and debugging.
1.7.3. Database Information
What databases are currently supported? Please include version numbers.
Almost all enterprise applications today require a database back end. It's important to make sure that the database for the application is available on Linux. Differences in database products and versions can add substantial porting effort to the project.
What database is the ported application expected to run with?
In addition to Question 1 in this section, what database does the customer expect the ported application to run with on the Linux platform?
Does the application use any nonrelational or proprietary databases?
Any proprietary database needs to be ported to Linux. Make sure the code to run the database is available and is part of the scoped porting work.
How does the application communicate with the database?
Programming language(s) (for example, Java, C/C++, other)
Database interface(s) (for example, ODBC, OCI, JDBC)
Ascertains that programming languages and interfaces are available on Linux, whether or not they are supplied by third-party vendors.
Does the application require the use of extended data types (XML, audio, binary, video, and so on)?
This information can be used to assess the skills needed by the porting group for porting the application.
1.7.4. Porting Project Time Schedule Information
What is the desired General Availability date for the application on the target platform?
This question is asking whether any business objectives need to be considered when creating the porting schedule.
Has the porting of the application already started on the target platform?
This is helpful in assessing complexities and problems that are discovered prior to officially starting the porting project.
What is the estimated port complexity level (low, medium, or high)?
Take the answer to this question with a grain of salt. There may be other factors present today that may not have been fully realized in previous porting efforts.
What factors were considered in this complexity ranking?
Any information from previous porting efforts needs to be assessed and compared to future porting efforts on the Linux platform.
If the application has been ported to another platform, how long did that port take? How many resources were dedicated to it? What problems were encountered?
This question attempts to compare previous porting efforts to the Linux port. This is useful only if the porting engineer technical lead has previous porting experience on other platforms as well as Linux.
What is your rough estimate of the project porting time and resources required?
The application or parts of it may have already been ported to other platforms, and knowing the time it took to port to those other platforms may be of some use. Experience and lessons learned from previous ports may come in handy. Knowing some of the lessons learned may help you avoid problems when porting to Linux.
1.7.5. Testing-Specific Information
Please describe the acceptance testing setup.
What kind of networking and database setup will be required for unit testing?
How much testing will be required after porting (number of days, number of resources)?
Do you have established test scripts and application performance measurements?
Will benchmarks need to be run for comparison testing?
Is performance data available on current platforms?
When were the performance tests last executed?
All "testing-specific" questions pertain to application software testing on the Linux platform. Asking these questions may bring out other issues related to porting test scripts and the software application test harness, which will add risks and time to the whole project. Pay close attention to the response to Question 1 in this section. Question 1 relates to the type of acceptance criteria that needs to be agreed on before porting starts. An example acceptance criterion is: Module A and B should pass test suites C and D, without failure. When the acceptance criteria are met, the port is considered complete, and formal QA tests can then be performed on the application.
1.7.6. Porting Project Execution Information
Please select one or more options, according to how you would like to proceed with this project.
Technical assistance will be provided to the porting engineers as necessary.
Customer will be responsible for acquiring third-party licenses and technical support.
Other (please describe).
Add other items in this part of the questionnaire that you need the primary customer to consider. Some issues may relate to staff training or testing the application.
What kind of hardware will be needed for the project?
Consider asking this question to ascertain whether existing hardware may be used or whether extra hardware will be neededfor porting, testing, training, and support purposes if necessary.
Although this questionnaire is comprehensive, it should not be the only basis for scoping. Scoping should also include actual examination of application source code when pertinent. Software application documentation needs to be examined to learn more about the application from a customer usage point of view.