Properties of JDK which could be verified or validated

Verification proves that a product meets all requirements that have been specified during the previous activities and these activities are carried out correctly, whereas validation is concerned about meeting the user’s requirements [Lewis, 2005, p.7].

As we all know, JDK can be either verified or validated, because it’s delivered in two different ways, Sun provides JDK as a source code package as well as compiled version. Therefore customer can go through the source code and investigate software flaws (if there is any). I’d like to highlight few properties by which we can verify or validate this software. The table below listed some of the properties that I want to discuss them.

        Property                      Verify     Validate
-------------------------------------------------------------
Source Code Documentation               X
Software portability                    X
Error Handling                          X            X
Objects and Functions Integrity         X            X
Code Efficiency                         X
Usability                                            X
User Friendliness                                    X
Software Documentation                               X

Source Code Documentation is the process that continually should be maintained during the software development; otherwise as the program grows it becomes unmanageable when there is not adequate code documentation. I believe this is the property which should be verified throughout entire process of software development. If we look through Java Source code we would find many documented codes throughout source codes. Of course it can be observed by end user, since the code is freely available but this code documentation has been done during development.

Let’s take a look at a piece of code that accompanies JDK compiled version.

/*
* Structures to define packet layout.
*
* See: http://java.sun.com/j2se/1.5/docs/guide/jpda/jdwp-spec.html
*/

enum {
JDWPTRANSPORT_FLAGS_NONE     = 0x0,
JDWPTRANSPORT_FLAGS_REPLY    = 0x80
};

typedef struct {
jint len;
jint id;
jbyte flags;
jbyte cmdSet;
* Source code is copied from a JDK Include file.

The highlighted part of the code is an HTML which describes this part of the code and can be delivered to the end user, obviously correctness of it can not be validated because the producer should provide this information to the customer, but it can be verified by producer.

Software Portability is one of the concerns of Java developers and Sun Microsystems; they claim that their product creates a virtual environment which can be executed on a vast variety of platforms, which means platform independency. Sun could get to this point that the major platforms support Java, since Sun doesn’t allow any other bodies to redistribute its product nobody can port the latest version of Sun Java to another platforms, FreeBSD and OpenBSD suffering from these kinds of restrictions, though there are some improvements in this area and old releases of Java has been ported to FreeBSD but I myself couldn’t get a considerable result from them, they do not support full Java features.

Error Handling is one of the most important features that software must have, dealing with internal errors as well as user errors, graceful internal error handling should be considered during software development; therefore, any internal errors that happens for any reason must be handled in the way that can be traced and corrected. JDK developers should consider error handling and verify it to generate acceptable error messages that lead the user to the failure point. In another hand, the user should be able to receive adequate and understandable error messages when he uses this product which falls into validation process.

Objects and Functions Integrity should be controlled, verified and validated during development process and after it, a failure in a mathematical function would lead to a catastrophe, or maybe a security function if it doesn’t perform correctly in a certain circumstances would make the software useless. So this can be verified throughout and after development process.

Code Efficiency purely needs verification, continuous changes of codes and program units is to reach to an efficient piece of code with less complexity and higher performance, this can not be validated as a Code Efficiency verification, but the user may run a benchmarking test to measure the performance and validate the product.

Usability of the software is a quality property by which we determine how a user can use this software with less difficulty and get benefit of this product, Wikipedia has a good definition for Software Usability, “Usability is a term used to denote the ease with which people can employ a particular tool or other human-made object in order to achieve a particular goal. Usability can also refer to the methods of measuring usability and the study of the principles behind an object’s perceived efficiency or elegance.” [Wikipedia.org] This should be validated by user.

User Friendliness is considered as a factor of user satisfactory, ease of use along with logical combination of tools and utilities. Friendliness of JDK is a subject of many controversies, it’s easy to develop a software but standard development and debugging tools were not fast enough and there was not integrated software development tool for it until Forte for Java, SunOne Studio and NetBeans evolved to this point that I believe they have put a great effort to provide such complex tools. Honestly, I believe they are still slow in compare to other competitors.

Software Documentation which is the most important factor of quality has been done in a very nice and user friendly format, JavaDoc which is initially used for internal JDK documentation is turned to a tool for Java developers, almost all of methods and objects are clearly discussed and covered in Java documentation and available when it’s delivered to the end user. Although Software Documentation can be validated during product generation process, it’s intended to provide adequate information to end users in order to get benefit of the delivered software. So I think this is users right to validate the Software Documentation conformance to the delivered product.

In this article, some of properties can be either validated or verified, like Software Documentation with slight changes or Error Handling as I mentioned above.
User Friendliness, for example, is a quality property which can be measured when a user works with the software, but it’s also possible to employ apply psychology, ergonomics and few other facts to formulate the User Friendliness of software, in this way, the delivered product corresponds to the user requirements.

REFERENCES:

Lewis, W.E. (2005) Software Testing and Continuous Quality Improvement, Second Edition, Auerbach Publication, USA, ISBN: 0-8493-2524-2

Livadas, L. (2006) ‘Management of QA and Software Testing, Seminar for Week 1: Overview of Quality Assurance Techniques‘ [Embanet] Available at: MASSHR-QA-060928-01 Sem 1 (Accessed: 30 Sep. 2006)

Wikipedia.org (2006) ‘Usability’ [Internet] Available at: http://en.wikipedia.org/wiki/Software_usability (Accessed: October 4th, 2006)