Utilizing a Common Language as a Generative Software Reuse Tool

Transcription

1 Utilizing a Common Language as a Generative Software Reuse Tool Chris Henry and Stanislaw Jarzabek Department of Computer Science School of Computing, National University of Singapore 3 Science Drive, Singapore Abstract Generative techniques manipulate programs written in conventional programming languages to achieve goals of improved adaptability, maintainability, and reusability; helping us better manage complex software during development and maintenance. In this project, we focus on XML-based Variant Configuration Language (XVCL). We attack the following problem: can we implement generative mechanisms in a conventional language? We started with JET2 but quickly realized its limitations in supporting generative mechanisms. Then, we formulated a successful solution with PHP and implemented full XVCL capabilities in a system called PHP+. Practical contribution of the project includes giving PHP users reuse tool without learning a new language. On the fundamental ground, it provides insights into essences of meta-level mechanisms and their relations to conventional languages. 1. INTRODUCTION With increasing computational power, space, and demands, software complexity follows an ever increasing trends. While several decades ago, software codes measured at thousands lines of assembly codes, with the emergence of higher level languages, programmers and software developers are able to write more lines while keeping them fairly maintainable. As software becomes more complex, there is an increasing demands for reusability and maintainability. Complex software usually contains a high degree of similarity. Jarzabek described the usage of generative programming technique using XML, to extract similar components in codes, reducing the amount of code to be maintained (Jarzabek, 2007). The drawback is that developers need to learn a new XML-based language, called XML-based Variant Configuration Language (XVCL), while also learning similarity component extraction techniques. In this project, we choose to work on the following problem: could we implement generative mechanisms in a conventional language? Furthermore, we are interested to determine the essence of such implementation so that in the future, we can implement such techniques in a generic, conventional language; albeit, perhaps, one that satisfy certain constraints. 2. XML-BASED VARIANT CONFIGURATION LANGUAGE (XVCL) XVCL is a generative language working at meta-level (Jarzabek & Zhang, 2001). Programmers extract clones (code repetitions within a program) into generative templates that may Student Supervisor 1

2 be adapted differently depending on their parameters. XVCL may partition software into generic, adaptable meta-components. Meta-level partitioning crosscuts modular decomposition along class/method dimensions in arbitrary ways. XVCL reduces the amount of code maintained, increasing the reuse potentials and maintainability. Since XVCL was developed specifically to tackle the problem of software reuse and maintenance, it becomes a good reference language to build upon in this project. Readers who are interested in more thorough treatment of XVCL may visit XVCL website at (Note: In this report, we describe XVCL and later PHP+ commands with the notation <command>.) 2.1. XVCL Processor and x-frame XVCL processor processes a meta-level program representation called an x-framework, generating entire software codes in target language with the correct variant features included. The processor processes the x-frameworks based on a specification file provided by developer. The basic unit of XVCL meta-level program decomposition is called an x-frame. All XVCL codes and codes written in the target programming language(s) are enclosed in the x-frames. It provides a logical separation of codes and assist in controlling the generation process. A typical x-frame includes codes in the target programming language to be generated and XVCL commands. In specification x-frame (SPC), the XVCL commands guides the generation process and provide variant parameters. The template x-frame contains the template of the code to be generated, annotated with the variation points Unique Features Generation Control: <adapt>, <break>, and <insert> <adapt> processes another x-frame. The processing is recursive the processing of the current x-frame will resume only after the child x-frame is completely processed; any <adapt> in child x-frame will be processed according to this rule. <adapt> allows the processing output to be emitted to a file. <adapt> also provides mechanism for applying different variant features to the target x-frame. <insert> is used together with <adapt>. <insert> inserts the snippets to all variation points, marked with <break>s with matching name, in the x-frame being adapted by the <adapt> statement. Three different <insert> commands are provided: <insert-before>, <insert>, and <insert-after>, each of them inserts before, at, and after the respective <break>. Multiple <insert>s are allowed and they will be processed in order of insertions. The inserted snippets will only be processed when the corresponding <break> is processed Top-down Variant Configuration: <set>, <value-of>, and <remove> Variant features may also be introduced by means of variables. Users may set a variable to a value in the x-frame, this value will become available to the current x-frame and all the descendent x-frames adapted by the current x-frame after its declared. Note that a variable with the same name set in higher x-frame (the ancestor x-frame) will override the value set in the current x-frame. This top-down feature is important as it allows developers to modify the variant features at the highest level possible instead of searching through the x-frames for the most local variable declaration. The <set> command sets a variable to a value while <value-of> retrieves the variable value. The <remove> command removes declared variable with the specified name. While 2

3 <set> will not override variable declared in the parent x-frame, it will replace the variable if it is declared in the same x-frame Key Supporting Features Some further key supporting features in XVCL includes: <while> loops through multi-valued variable set using a <set-multi> keywords. At each iteration, one value will take the place of the multi-valued variable; <select>/<option> provides a conditional code execution path based on the value of a given variable; <ifdef> and <ifndef> executes code block if a given variable is defined or undefined respectively; <message> allow developers to print debugging messages. 3. INITIAL STUDY: ENHANCED JAVA EMITTER TEMPLATE (JET2) JET2 is a code generator. It uses template files as code templates, control files as generator flow control, and parameter files to specify variations during generation. A successful implementation of generative framework in JET2 will appeal directly to developers who have coded in JET2 before. JET2 also closely resembles Java Server Pages (JSP) syntax, a popular web scripting language, making it easier for developers well-versed in JSP to pick up the language and experiment with generative reuse techniques Advantages & Limitations While we successfully implemented basic <adapt>, we were stumped by JET2 flat structure. When a template includes another template, the included template will become part of the first template; it is as if we wrote both template files as one. This prohibits us from having a fine-grained top-down control during setting up of variant parameters. One of the problem caused by this flat structure was described at the end of the previous section. JET2 is not Turing-complete. It is missing important functionalities available in languages such as C, Java, or PHP. For example, t is missing general purpose loops; resulting in our inability to manipulate generation flow without complicated workaround Evaluation To determine the efficacy of JET2 generative technique, we attempted to wrap Java Buffer Library (Jarzabek & Li, 2006). We were able to implement a simpler group of similar classes but encountered difficulties with harder examples that require top-down variant mechanisms. Our experience reinforces our knowledge and intuition in writing reusable templates. The findings from this effort led us to consider a wider range of language for our purposes. We need the flexibility of a Turing-complete language to implement key features of a generative framework. We also note the need to be able to separate the meta-level language from the target language. This leads us to consider a class of languages called meta-languages, which are able to naturally provide separation of control code and the code for the target programming language to be generated. (We do realize that natural meta-languages are not a necessity, but rather a major convenience. We may use string construct to contain the target language, essentially mimicking meta-languages.) 3

4 4. PHP+: A GENERATIVE REUSE TOOL FOR PHP 4.1. Motivation PHP: Hypertext Processor (PHP) is a widely-adopted meta-language. PHP is capable to produce HTML codes using templates in the form of PHP-embedded HTML codes. In PHP web applications, developers already use PHP to introduce variation such as data retrieved from database. Coupled with the widespread knowledge of PHP programming among web developers, PHP is a promising language to build our generative framework Implementations To implement the generative framework, we choose to focus on writing a PHP library that implements the framework. We call the library PHP+. PHP is usually used in tandem with a web server. The server will executes a PHP interpreter. In our case, this is not convenient. We need to invoke the interpreters in many PHP files during <adapt> process. Furthermore, instead of tunneling the output of the interpreter to the web server, we need to have it written to a file. To overcome these difficulties, we use a rare usage form of PHP interpreter: the Command Line Interface (CLI). This is equivalent to running a shell script in UNIX systems. As many PHP systems resided in UNIX boxes, we found it convenient to utilize UNIX redirection in our implementation PHP+ Frames We divide the generation templates into one of the two frame types: 1. Specification frame containing the variant parameters used to generate the code and control statements controlling the flow of the generation. There may be multiple SPCs in the entire project. An SPC may adapt other specification frames or template frames. As a convention, we give SPC.spec.php file extension. 2. Template frame provides an actual code template used to generate codes in the target languages. It contains codes in the target language and PHP+ tags used to specify variant features. A template frame usually adapts only other template frames. As a convention, we give template frame.pp file extension Key Features: <adapt>/<insert>/<break> The <adapt> command runs another instance of PHP CLI on the file to be adapted. We pass all variant information (such as symbol tables and inserted snippets) down to the child instance. When an output file is specified, the output of the <adapt>ed frame is redirected to the specified output file. Otherwise, the output will be written to the same file as the parent frame. As PHP functions may only accept values and arrays as parameters, we implement <insert> by means of an Inserter class (this is a simple wrapper over a two-level associative array). Users may create an Inserter object and store insertion snippets for each <break> in the object. Users pass the object during a call to <adapt>, which subsequently passed this information to child CLI process. To keep the implementation simple, each CLI instance will hold a main Inserter object that merges all insertion information available thus far. When invoking a child CLI process 4

5 during <adapt>, we pass this object along with user-defined object to the child CLI. During initialization process, the child process will merge the two objects into one main Inserter. <break> simply requests the main Inserter object to <adapt> all insertions with the same name as the <break> (the procedure writes each insertion into a temporary frame and <adapt> that frame). <break> function also passes a user-defined default insertion to be used if the Inserter object does not have any insertion snippet for the <break> (<insert-before> and <insert-after> does not affect the default insertion) Key Features: Top-down variant variables As with XVCL, variables declared in ancestor frames will override variables declared in the current frame. We also need to make sure that a variable declared in the current frame will be able to override the same variable declared earlier in the same frame. To ensure this behaviour, we rely on a two-tiered symbol table to hold the (key, value) pair of variable name and its value. PHP associative array provides natural implementation of the table. We keep two associative arrays, one to keep variables declared in ancestors frames (that means variables passed down to the CLI process), another to keep variables declared in the current frame. Thus, we are able to follow the said behaviour exactly Convenient Features PHP is far more flexible and less rigid as compared to XVCL or JET2. Most convenient features, such as <while>, <select>/<option>, and multi-values variable may be implemented by utilizing built-in PHP constructs such as loops, conditionals, and arrays. Thus, we need not implement any of the convenient features of XVCL. 5. EVALUATION 5.1. Case Study: Java Buffer Library To evaluate PHP+, we translates the XVCL solution for Java Buffer Library (Jarzabek & Li, 2006) into PHP+ to assess whether it is possible translate XVCL constructs into PHP+. The translation from XVCL to PHP+ is straightforward and mechanical, we took less than 4 hours to hand-translate the entire XVCL Java Buffer Library (that generates a total of 71 Java classes) into PHP+. Frame types Buffer Library in XVCL Buffer Library in PHP+ Specification frames Template frames All frames Table 1. LOCs comparison between Java Buffer Library in XVCL and in PHP+. We assess the quantitative performance of PHP+ in terms of lines of codes (LOCs) in comparison to XVCL-based solution. The LOC count includes meta-commands, target language, and comments (discarding all blank lines). We further subdivide the comparison into two: one for specification frames and another for template frames. Our results show insignificant difference between the two implementations, with PHP+ being slightly shorter. This result confirms that PHP+ is at least as efficient as XVCL in terms of code economy. 5

6 5.2. The Essentials of a Generative Framework Through our implementation of PHP+, we discover several key implementation techniques that forms the essence of the implementation. These insights may be used to implement generative framework in other conventional languages: Processing separation on <adapt>: we need to separate information defined in ancestors frames and those defined in the current frame. The current frame may not modify parent frames information so that the parent frames can continue its processing predictably. Two-tiered symbol table is needed to implement the top-down variable overriding. Inserter objects: most languages do not have an easy mechanisms to pass the insertions to an <adapt> function directly. Thus, we may use suitable objects to do this. For a language that implements meta-level, generative framework to be feasible in day-today usage, we found that it needs to be either a tag-based language or a language supporting multi-line strings. Tags and multi-line strings tremendously improve codes readability. 6. CONCLUSION PHP+ reduces the learning curve associated with learning the language construct and conventions of XVCL. By using a common language to implement essentially the same reuse capabilities as XVCL, we hope that more developers will be enticed to adopt the generative reuse techniques in day-to-day software development process. This will benefit developers and maintainers. Furthermore, our studies have revealed the theoretical requirements and techniques for implementing generative framework in generic common languages. We believe that the same techniques may be adapted to other languages as well. While not all languages are suitable for such usage, we may soon find such framework implemented in more languages. As for PHP+, we plan to further develop the PHP+ Library and prepare it for community testing and adoption. We seek to continuously improve the API of PHP+ to make it easier to use while making the implementation more efficient. 7. REFERENCES [1] Jarzabek, S. (2007). Effective software maintenance and evolution: A reuse-based approach. Boca Raton, FL, USA: Auerbach Publications. [2] Jarzabek, S., & Li, S. (2006). Unifying clones with a generative programming technique: a case study. Journal of Software Maintenance and Evolution: Research and Practice, 18 (4), July, 2006, [3] Jarzabek, S., & Zhang, H. (2001). XML-based method and tool for handling variant requirements in domain models. 5th IEEE International Symposium on Requirements Engineering (pp ), Toronto, Canada, August,