Research projects

Stan Jarzabek

date updated: May, 2003

On this page, you find description of on-going and recently completed research projects, in which I am a Principal Investigator.

My research interests:

In last 10 years, I have been working mainly on software reuse and reverse engineering. In reuse, I focus on domain engineering methods for supporting Product Lines. In reverse engineering projects, I designed a Program Query Language (PQL) notation for specifying program queries and reverse engineering heuristics. Based on this notation, we designed a number of tools that help in program maintenance such as static program analyzers and reverse engineering tools. My other projects include Web-based process-driven project support tools. Our tools guide software engineers in following a project plan, as defined by project managers. Other project management tool, called F-Metric, is meant for project managers to monitor the project progress via analysis of project metrics.

Current projects on domain engineering for reuse:

Background: Most of software development efforts involve common problems, spanning from software requirements through architecture to implementation details. Software Product Line approach is a systematic way to identify and model these commonalties, and develop standard program solutions that can be reused in the many projects that need them. A Product Line comprises a family of software systems that share substantial commonalties. The essence of the Product Line approach is reuse of a carefully crafted, domain-specific generic Product Line architecture across  Product Line members. Reuse focused on Product Lines emerges as the most promising way to increase software productivity and quality. I work on domain modeling methods (describing common and variants requirements for Product Lines) and on software engineering techniques to design generic Product Line architectures. I am most interested in using meta-programming techniques for customization and evolution of component-based Product Lines.

Click on the header for project details:

XVCL: XML-based Variant Configuration Language (2000, on-going), click here to view XVCL at SourceForge

Eliminating redundancies with XVCL

Engineering Variant Requirements in Component-based Software Product Lines (started in 1999, on-going)

Completed projects (in which I still have much interest):

Domain Engineering in Business Domains (1995 - 2000)

Software Reuse Framework for Reliable Mission-Critical Systems (1999 - 2002)

Static program analysis and reverse engineering: methods and tools

Strategic re-engineering: Integrated evolution of business and software

Project execution and monitoring support tools

Support tools for business analysis and re-engineering

Current projects - details:

XML: XML-based Variant Configuration Language

What is XVCL?

XVCL (XML-based Variant Configuration Language) is a meta-programming technique and tool that provides effective reuse mechanisms [2]. XVCL is open source software (http://fxvcl.sourceforge.net) developed at the National University of Singapore. Being a modern and versatile version of Bassett’s frames [1], a technology that has achieved substantial gains in industry, the underlying principles of XVCL have been thoroughly tested in practice. Unlike original frames, XVCL blends with contemporary programming paradigms and modern design techniques. XVCL uses “composition with adaptation” rules to generate custom artifacts (code, documents, models, etc.) from a compact base of generic, reusable meta-components. Because its simple rules are designed to enable effective reuse, XVCL can successfully manage a wide range of software variants. 

Variants arise naturally – programs often must run on multiple platforms; customers typically need custom versions that evolve over time; software product lines encompass families of similar but distinct programs. Similar design and code patterns recur even within a single program. Because differences among such recurrences are usually subtle, they greatly complicate maintenance. The need to simplify how variability is handled motivated us to develop and use XVCL. XVCL provides general mechanisms for applying program variants to a common core of generic, adaptable meta-components. You can also use XVCL to manage variants in other product line assets such as software architecture, test cases, technical and user-level documentation and requirement specifications.

Using XVCL involves a methodology for creating solution structures for your application domain and for the types of variants you want to address. The XVCL processor automates the routine yet error-prone program construction tasks, allowing you to focus on what is novel about your problem domains, enhancing your creativity.

How does XVCL work?

XVCL works on the principle of adapting generic, reusable meta-components into specific components – for clarity, assume they are components of custom programs. Any location or structure in a meta-component can be a designated variation point, available for adaptation by ancestor meta-components. Program generation is 100% transparent to the programmer, who can fine-tune and re-generate code without losing prior customizations. Meta-components can evolve as needed without ever forcing retrofits.

You create meta-components by generalizing pieces of working programs, and/or by top-down domain analysis. From small number of meta-components, we can generate an unlimited number of different concrete components, classes or methods. A meta-component is an XML file containing code (written in any programming language), instrumented with XVCL commands for ease of change and evolution. XVCL commands, designed as XML tags, control meta-component composition and adaptation, select pre-defined, context-dependent options, and iterate meta-structures to generate fully customized programs. Meta-variables and expressions provide powerful parameterization mechanisms. Values of meta-variables are propagated across meta-components using scoping rules designed to enhance adaptive reuse in novel contexts.

Figure 1. XVCL processor

You organize meta-components into a layered meta-component architecture called an x-framework. An x-framework is carefully designed into layers to enhance reuse. It is also “normalized” to eliminate redundancies. Meta-components at lower-levels are relatively context-free building blocks to be adapted for reuse by the higher-level meta-components. The topmost meta-component, called the specification frame, controls the whole composition and can tailor any detail in the x-framework. An x-framework forms a base of reusable assets, such as a product-line architecture, from which you build custom programs.

Starting with the specification frame, the XVCL processor traverses an x-framework, executing XVCL commands embedded in meta-components in order to produce custom programs (Figure 1).

Applications and benefits of XVCL

Applications include implementing product line architectures, design of compact, non-redundant, easy to maintain program specifications (generated programs are never edited), and managing variants in multiple versions of software documents and models. We envision many other applications in software and non-software domains.

It is well known that redundant code obstructs program understanding and maintenance. Yet, programs are often polluted by such code. We have completed 4 projects in which we studied redundancies in commercial software and applied XVCL to reduce program complexity by eliminating recurring design and code patterns. XVCL achieved code reductions of:

·         68% in Buffer library (JDK 1.4.1); see detailed results at http://fxvcl.sourceforge.net

·         68% in n-tier application (C#)

·         61% in MS ADO wrapper, a proxy between application and ADO  (Java).

In other projects, we applied XVCL to design product line architectures for component-based systems written in Java, and using RMI, J2EE or CORBA for component communication. We designed Facility Reservation System (FRS) and Computer Aided Dispatch system (CAD) product line architectures [3,4].  Our FRSes were built as EJB™ components, organized into a 3-tier architecture. We used XVCL to create generic, reusable meta-components from which we could generate custom runtime EJB components that met functional variants for a specific FRS we wish to build.

CAD systems are used by police, fire and rescue and other similar organizations to dispatch resources (e.g., police cars) to handle incidents. CAD systems are distributed over the Internet, with components dedicated to different roles running on different computers. We addressed CAD variants related to functional requirements, component distribution, platforms and reliability. This project was funded by Singapore National Science and Technology Board and Canadian Ministry of Energy, Science and Technology, involving National University of Singapore, SES Systems Pte Ltd., University of Waterloo and Netron, Inc.

We also applied XVCL to manage variants in UML software models documenting FRS and CAD product lines [5]. In yet another project, we managed evolution of the City Guide System product line with XVCL.

XVCL is based on Bassett’s frame technology [1]. Frames have been applied in industry to manage variants and evolve multi-million-line, COBOL-based, information systems. While designing a frame architecture is not trivial, subsequent productivity gains and maintenance savings often repay the effort many times over. An independent analysis showed that frames can reduce large software project costs by over 84% and their times-to-market by 70%, when compared to industry norms (refer to QSM report in [1]). By reusing skillfully structured frame architectures, you need to focus on only the 5%-15% of a solution that is unique; the other 85%-95% is reused. These gains are due to the flexibility of the resulting architectures and their evolvability over time.

XVCL is extensible and, of course, free of COBOL heritage. We envision many software and non-software applications, as we can apply XVCL to any domain that can be represented as a collection of textual documents.

Reference:

[1] Bassett, P. Framing Software Reuse - Lessons from the Real World, Yourdon Press, Prentice Hall, 1997

[2] Wong, T.W., Jarzabek, S., Myat Swe, S., Shen, R. and Zhang, H.Y. “XML Implementation of Frame Processor,” ACM Symposium on Software Reusability, SSR’01, Toronto, Canada, May 2001, 164-172

[3] Jarzabek, S. and Seviora, R. “Engineering components for ease of customization and evolution,” IEE  Proceedings - Software, Vol. 147, No. 6, December 2000, 237-248, a special issue on Component-based Software Engineering

[4] Cheong, Y.C. and Jarzabek, S. “Frame-based Method for Customizing Generic Software Architectures," Symp. on Software Reusability, SSR’99, Los Angeles, May 1999, 103-112

[5] Jarzabek, S. and Zhang, H. “XML-based Method and Tool for Handling Variant Requirements in Domain Models”, 5th IEEE International Symposium on Requirements Engineering, RE’01, IEEE Press, August 2001, Toronto, Canada, 166-173

Eliminating redundancies with XVCL

In this experiment, we demonstrate  XVCL's potential to reduce program complexity by eliminating redundant code. We also show how XVCL can be effectively applied on top of OO techniques, enhancing program maintainability and reusability.

Redundant code obstructs program understanding and contributes to high maintenance costs. While most experts agree on that, opinions on how serious the problem of redundancies really is and how to tackle it - differ. In this case study, we analyzed redundancies in the Java Buffer library, JDK 1.4.1, recently released by Sun. We found that at least 68% of code in the Buffer library is redundant in the sense that it recurs in many classes in the same or slightly modified form. We effectively eliminated that 68% of code at the meta-representation built with XVCL. If we take into account both executable code and comments, then we can eliminate 72% of code. Due to the smaller code base, lack of the redundant code and ability to trace the impact of changes, our XVCL solution scores higher than the Buffer library in terms of ease of maintenance. In this experiment, we designed our meta-representation so that we could produce buffer classes in exactly the same form as they appear in the original Buffer library. While we were tempted to re-design the buffer classes, we chose not to do so, to allow for seamless integration of the XVCL solution into contemporary programming methodologies and systems. This decision did not affect essential results reported in this study.

Defining redundancy: Code fragments that we studied typically contain definitions of classes, class attributes, constructors or methods. Redundancy occurs among similar code fragments. It is difficult to define redundancy in general and descriptive terms. Therefore, we shall accept the following pragmatic definition of redundancy for the purpose of this study: Redundancy occurs in a group of similar code fragments, whenever we can unify all the differences among those fragments at the meta-level, with the XVCL technique. We also require that the result is beneficial for maintenance, that is, such a unified meta-representation should be easier to understand and maintain than the original program with redundant code fragments.    

More details of the case study can be found in the paper Eliminating Redundancies with a “Composition with Adaptation” Meta-programming Technique  

View analysis and results in section Case Studies at XVCL SourceForgeWeb Site

Engineering Variant Requirements in Component-based Software Product Lines (1999 - )  

Collaborators: Dong Jin Song (NUS), Paul Bassett (Netron, Inc., Toronto), Ajit Singh (University of Waterloo)

In this project, we attempt to define a scalable and extensible mechanism to handle variants, at both domain model and generic Product Line architecture levels. A suitable mechanism should allow one to structure domain engineering artifacts and precisely express variants. It will bridge a conceptual gap between a model of variants across Product Line  members and customizations of a generic architecture that are needed to meet specific variants. This gap has negative impact on productivity of programmers during architecture-based system engineering. There is also a problem of how to keep the complexity of a generic architecture under control over many years of evolution. Without a solution to this problem, a generic Product Line architecture will not stand the test of time and the Product Line approach will fail to bring long term benefits.

In this project, we address the above mentioned open problems in the Product Line research. In particular:

We develop prototypes of generic Product Line architectures characterized by the following qualities:

  1. different system perspectives, called areas of concern, defined as different views of the generic Product Line architecture (as much as it is possible). Our project focuses on variants in areas of concern related to component-based systems that have global impact on the system. The initial list of those includes: functional requirements, parallel structure, distribution, synchronization, platform dependencies (such as event-based communication in ActiveX or CORBA) and flexible runtime component structure (i.e., ability to allocate application functionality to components in a flexible way and to change component interfaces accordingly).

  2. ability to engineer (i.e., customize and evolve) variants in each area of concern independently from others (as much as it is possible).

  3. explicit mappings between variant requirements and relevant views of a generic architecture.

  4. explicit expression and enforcement of architecture constraints ensuring that no conflicting combinations of variant requirements are implemented into the target system.

We develop a construction environment for customizing and evolving generic Product Line architectures characterized by the following qualities:

  1. explicit mappings between areas of concern, variants within each area of concern and architecture customization/evolution process.

  2. support for customization  and evolution within each area of concern.

  3. a composition operation to combine separately engineered areas of concern into a custom target system satisfying required variants.

  4. customization process guided by definition of variant requirement dependencies and architecture constraints.

  5. automation of routine customizations (anticipated variants).

  6. human-guided evolution of a generic Product Line architecture (unexpected extensions of a target system or a generic Product Line architecture).

We develop and experiment with domain modeling methods capable of:

  1. structured description of commonalties and variants across Product Line  member systems, from perspective of different areas of concern. and at different levels of abstraction.

  2. describing variants that have a global impact on the system (i.e., cannot be localized in a single component or module).

  3. describing dependent variants both within and across areas of concern.

Papers resulting from this project

  1. Jarzabek, S. and Knauber, P. "Synergy between Component-based and Generative Approaches," Proc. ESEC/FSE’99 Joint 7th European Software Engineering Conference and 7th ACM SIGSOFT Symposium on the Foundations of Software Engineering Toulouse, France, September 1999, Lecture Notes in Computer Science No. 1687, Oscar Nierstrasz and Michel Lemoine (Eds.) Springer Verlag, pp. 429-445

Completed projects - details:

Domain Engineering in Business Domains (started in 1995, on-going)

Supported by NUS Research Grant RP3950615 and RP3950616

In this project, we have been doing domain engineering studies in facility reservation and library system domains. Understanding and precisely modeling common and variant requirements is essential in building a generic Product Line architecture. At the beginning, we concentrated on domain modeling methods and developed novel methods for structuring domain descriptions and modeling variant requirements in a domain. In the later stage, we experimented with frame technology (by Netron, Inc., Toronto) to design a generic architecture for facility reservation system Product Line. In this project, we emphasized ease of customization  and evolution of a generic architecture. These two requirements determine the success of the Product Line approach and are known to be difficult to achieve in practice. We built a Product Line construction environment comprising of domain model, Customization Decision Tree and frame processor to provide a descriptive and partially automated support for Product Lines.

Papers resulting from this project

  1. Jarzabek, S. “Component Criteria for Software System Families,” Proc. 11th CAiSE'99, Heidelberg, June 1999, Lecture Notes in Computer Science No. 1626, Advanced Information Systems Engineering, Springer Verlag

  2. Cheong, Y.C. and Jarzabek, S. "Frame-based Method for Customizing Generic Software Architectures," Proc. Symposium on Software Reusability, SSR’99, Los Angeles, May 1999, pp. 103-112

  3. Jarzabek, S. and Hitz, M. "Business-oriented and Component-based Software Development and Evolution," International Workshop on Large-Scale Software Composition, August 28, 1998, Vienna, Austria

  4. Lau, K. W. and Jarzabek, S. "A Generic Discretionary Access Control System for Reuse Frameworks", COMPSAC'98, August 19-21, 1998, Vienna, Austria, pp. 356‑361

  5. Cheong, Y.C. and Jarzabek, S. “Modeling Variant User Requirements in Domain Engineering for Reuse,” Proc. 8th European-Japanese Conference on Information Modeling and Knowledge Bases, Vammala, Finland, May 1998, pp. 231-250; also published in Information Modelling and Knowledge Bases, Eds. Hannu Jaakkola, Hannu Kangassalo and Eiji Kawaguchi, printed in IOS Press, Netherlands, ISSN: 0922-6389, pp. 220-234

  6. Jarzabek, S. “Modeling Multiple Domains for Software Reuse,” Proc. Symposium on Software Reusability, SSR’97, Boston, May 1997, ACM Press, pp. 65-79

  7. Jarzabek, S. “A Reuse Framework for Multi-Domain Software Development,” 3rd Asia-Pacific Software Engineering Conference, APSEC’96, Seoul, Korea, December 1996, US: IEEE Computer Society Press, pp.28-38

  8. Jarzabek, S. “From Reuse Library Experiences to Application Generation Architectures,” Proc. Symposium on Software Reusability, SSR’95, Seattle, USA, April 28‑30, 1995, ACM Press, pp. 114-122

  9. Jarzabek, S. and Tang, S.T. “Conceptual Modeling of Families of Software Systems,” Proc. 4th European‑Japanese Seminar on Information Modeling and Knowledge Bases, Stokholm, Sweden, May 31-June 3, 1994; chapter 19 in book Information Modeling and Knowledge Bases VI, Edts. H. Kangassalo, H. Jaakkola , S. Ohsuga and B. Wangler, IOS Press Amsterdam, 1995, pp. 299-312

Software Reuse Framework for Reliable Mission-Critical Systems (1999 - 2002)

Project supported by Singapore-Ontario Joint Research Programme. Project partners include NUS, University of Waterloo, Singapore Engineering Software Ltd. and Netron, Inc, Toronto. 

Principal Investigators: Stan Jarzabek and Dong Jin Song (NUS) and Rudolph Seviora (University of Waterloo). Collaborators: Paul Bassett (Netron, Inc.) and Ulf Pettersson (Singapore Engineering Software Ltd.). Master students: Wong Tak Wai.

In this project, we investigate methods for reuse-based development of reliable mission-critical software systems, with goals of increased software productivity and improved software reliability. To achieve these goals, we apply concepts and experiences of flexible software manufacturing to a selected class of mission-critical software systems. We work on method development together with Netron and apply methods at SES pilot projects. SES also provides expert knowledge of the mission-critical software system domain. We develop methods for building mission-critical applications more cost-effectively and also investigate how reuse technology can improve the system-wide qualities, such as performance and reliability. 

Project objectives:

  1. To define a reuse framework for flexibly manufacturing reliable mission-critical software systems in order to:

a.    improve productivity and reliability in development and maintenance of mission-critical software systems through standardization and reuse of software requirements, architectures and code modules,

 b.    achieve uniformity of mission-critical software product lines,

  1. To devise reuse-based analysis and design methods that take into account system-wide qualities such as reliability and performance. More specifically, we shall attempt to answer the following questions: how are system-wide qualities addressed in a generic architecture? How can we ensure that the required level of reliability is preserved after customization of the generic application architecture? Will the proposed approach enable creating easy-to-maintain software systems in the future? If we integrate together a number of trusted components - do we still obtain a trusted system?

  2. To develop software engineering methods for designing generic software architectures for reliable mission-critical software systems. In particular, we shall target frame technology, a method and a tool developed by Netron Inc.

  3. To define a methodology for transition from current development processes to the reuse-based software development.

Technology transfer objectives:

  1. To apply results in industrial pilot projects and to assess the impact of reuse-based software development on software productivity and quality in mission-critical software system domain.

  2. To develop prototypes of generic application architectures for selected product lines.  

  3.  To implement a reuse-based development practice at pilot projects.

The progress of the project: 

We selected a command and control Computer Aided Dispatch system, CAD for short, as a pilot. CAD domain includes includes police, fire & rescue, health and port sub-domains. All CAD sub-domains are in a way similar - they include an operator receiving information about an incident, a resource (such as police force unit) assigned a task of handling an incident, issues of task reporting/monitoring, etc. However, there are also many differences across sub-domains (e.g., rules of how resource are assigned to tasks, monitoring, reporting and timing requirements, specific information to be stored, component deployment strategies, etc.). Based on specifications provided by our  industrial partner SES, students at the University of Waterloo and NUS  developed a prototype CAD system for police, as a distributed, component-based system. We further selected Task Management to experiment with modeling and implementation of a generic architecture for CAD Product Line.

Static program analysis and reverse engineering: methods and tools

Master students: Wang Goushong, Ding Xin

Static Program Analyzers (SPA) are interactive tools that enhance program understanding by answering queries about programs. Query results display abstract program views that are easier to understand than program code itself. SPA tools save program maintenance costs, help in program conversions and re-engineering. In this project, we designed a program query language, PQL for short, to specify program queries and abstract program views. In PQL, we can query on global, system-level design as well as search for constrained code patterns. In the design of PQL, we identified query principles that are common to all source languages and separated them from language-specific aspects. Specifications of a source language parameterize otherwise language-independent PQL notation. This concept facilitates a table-driven implementation of the query resolution mechanism. Upon the program specification notation and PQL, we built a design framework for SPAs. Within the framework, we can study tool capabilities in the context of the underlying software maintenance process and programmer's behavior model. The framework facilitates systematic and cost-effective design of SPAs by generation of SPA components from specifications.

We have implemented SPA tools based on PQL for COBOL-85. We identified many difficult problems related to efficient query evaluation, solved only some of them, experiment with various media for storing program design information and extended PQL to allow for specification of program transformations.

The objective of reverse engineering is to extract design information from the program code. Reverse engineering can enhance program understanding during maintenance and is an essential phase of software re-engineering. Because there are many variations involved in reverse engineering projects (different languages sources, different reverse engineering heuristics), reverse engineering tools should be highly adaptable. We worked out a method for designing flexible (from the end- user point of view) and generic (from the tool designer point of view) reverse engineering tools. Our design method is based on conceptual modeling of tool capabilities and on separation of conceptual models from implementation-level considerations. Tools that we build can be customized to a reverse engineering task in hand, in particular, can work with different source languages, contain a user-level facility to specify reverse engineering heuristics and filters to tune in the reverse engineering process and can be ported across a range of physical program representations. 

Papers describing this project

  1. Jarzabek, S. and G. Wang “Model-based Design of Reverse Engineering Tools", Journal of Software Maintenance: Research and Practice, No. 10, 1998, John Wiley & Sons, pp. 353-380

  2. Jarzabek, S. “Design of Flexible Static Program Analyzers with PQL,” IEEE Transactions on Software Engineering, March 1998, pp. 197-215

  3. Jarzabek, S and Woon, I. “Towards precise Description of Reverse Engineering Heuristics,” Proc.  EUROMICRO Working Conference on Software Maintenance and Reengineering, IEEE Computer Society Press, March 1997, Berlin, pp. 3-9

  4. Jarzabek, S. "PQL: A language for specifying abstract program views," Proc. 5th European Software Engineering Conference, ESEC'95, Barcelona, September 1995, Lecture Notes in Computer Science, No. 989, Springer Verlag, pp. 324-342
  5. Jarzabek, S and Tan, P.K. “Design of a Generic Reverse Engineering Assistant Tool,” Proc. 2nd Working Conference on Reverse Engineering, WCRE, Toronto, Canada, July 14-16, 1995, IEEE Computer Society Press, Los Alamitos, USA, pp. 61-70
  6. Jarzabek, S. "Systematic Design of Static Program Analyzers," Proc. 18th Annual Int. Comuter Software & Applications Conf. COMPSAC'94, Taipei, November 9-11, 1994, IEEE Computer Society Press, Los Alamitos, USA, pp. 281-286
  7. Jarzabek, S. “Specifying Program Transformations with PQTL,” Proc. ICSE-17 Workshop on Program Transformations for Software Evolution, 24 April 1995, Seatle, USA, ed. William Griswold, TRCS95-418, University of California, San Diego, pp. 35-46
  8. Jarzabek, S. “Systematic Design of Static Program Analyzers,” Proc. 18th Annual Int. Comuter Software & Applications Conf.  COMPSAC’94, Taipei, November 9-11, 1994, IEEE Computer Society Press, Los Alamitos, USA, pp. 281-286
  9. Jarzabek, S., Shen, H. and Chan, H.C. A hybrid Program Knowledge Base system for Static Program Analyzers. Proc. First Asia Pacific Software Engineering Conference, APSEC'94, Tokyo, December 1994, IEEE Computer Society Press, Los Alamitos, USA, pp. 400-409
  10. Jarzabek, S. "Specifying Program Transformations with PQTL," Proc. ICSE-17 Workshop on Program Transformations for Software Evolution, 24 April 1995, Seatle, USA, ed. William Griswold, TRCS95-418, University of California, San Diego, pp. 35-46

Strategic Re-engineering: Integrated evolution of business and software

Today, many companies report maintenance costs mounting to 80% of a total computing budget. The pace of program evolution appears to be much slower than the pace of changes in business. As the result, many of today's programs fall short of user expectations. Methods and tools are needed to better link software systems to business needs. We believe, successful solutions to software evolution problems require an integrated effort, covering business re-engineering methods and technical aspects of software evolution.

In this project, we developed a conceptual and methodological framework for dealing with business and software re-engineering in an integrated way. The framework is to help companies in planning business and software re-engineering projects. The framework defines blueprints for re-engineering scenarios. We formulated a methodology for business & software re-engineering, called strategic re-engineering. Strategic re-engineering starts by business analysis and re-engineering. After business phase, a combination of CASE-based new development and re-engineering of existing systems is used to support re-engineered business processes. Strategic re-engineering forms a generic framework based on which a company can define a re-engineering methodology customized to its specific needs.

The following were deliverables from this project: a methodological framework for business-software evolution, expertise in planning re-engineering projects in real-life situations and tool prototypes for analysis of business and software models.

Papers describing this project

  1. Jarzabek, S. and Woon, I. "Interplay between an Enterprise Information Architecture and Domain Analysis," Proc. Third World Conference on Integrated Design and Process Technology, July 6, 1998, Berlin, pp. 154-161

  2. Jarzabek, S. and T.W. Ling “Model-based Support for Business Re-engineering,” Journal of Information and Software Technology, vol. 38, No. 5, May 1996, pp. 355-374

  3. Jarzabek, S. and Ling, T.W. “A conceptual model for business re-engineering methods and tools,” Proc. 14th Int. Conference on Object-Oriented and Entity-Relationship Modelling, OO-ER’95, Queensland, Australia, Dec. 12-15, 1995, in Lecture Notes in Computer Science, Springer-Verlag, Germany, Dec. 1995, pp. 260-269

  4.  Jarzabek, S “Lifecycle approach to strategic re-engineering of software,” Journal of Software Maintenance: Research and Practice, vol. 6, no. 6, December 1994, John Wiley & Sons,  287-317

  5.  Jarzabek, S., CL Tan and Tham, K. An Object-oriented Model for Recovered Designs in Software Reengineering. Information Technology Journal, vol. 6, no. 2, December 1994, 80-94

  6. Jarzabek, S. "Domain Model-Driven Software Re-engineering and Maintenance," Journal of Systems and Software, January 1993, 20:37-51
  7. Jarzabek, S. and Lim, W.M. "Modeling in Strategic Reengineering," Proc. 6th Int. Conference on Software Engineering and Knowledge Engineering, Riga, Latvia, June 1994, published by Knowledge System Institute, USA, pp. 249-256
  8. Jarzabek, S "Strategic Reengineering of Software: Lifecycle Approach," Proc. 6'th Int. Workshop on CASE, CASE'93, IEEE Computer Society, Singapore, July 1993, pp. 211-220
  9. Jarzabek, S. "Software Reengineering for Reusability," Proc. 17th Annual Int. Computer Software and Applications Conference COMPSAC93, IEEE Computer Society, Phoenix, USA, November 1993, pp. 100-106

Project execution and monitoring support tools

Master students: Teh Hsin Yee, Yu Zhilu

We designed process-driven project support tools. We are experimenting with both rigorous, semantically rich process models based on which we build highly specialized tools as well as with simple process models based on which we build generally useful project support functions. The challenge here is to define the process model that is flexible, can be customized to realities of a give software project and can evolve on the fly. We developed a prototype Project Execution Support System that guides software engineers in following a project plan, as defined by project managers. Based on the experiences with the prototype, we then developed WWW-based tools.

Other project management tool, called F-Metric, is meant for project managers to monitor the progress of the project, identify problem areas and modify the project plan (e.g., re-allocate resources, change project activities, etc.). Project monitoring is done based on the analysis of the project data collected by software developers and stored in the project database. We designed a conceptual level query language for project managers to help in analysis of project data.

There are many variations across software projects and our objective is to design generic cores for project support tools that can be customized to specifics of a software project in hand. Moreover, we want to reuse as much functionality as possible across tools and, finally, we want tools to share common project models and project data. We use domain engineering approach to design generic, customizable and integrated  project support tools.

Papers describing this project

  1. Jarzabek, S. and Huang, R. “The case for User-Centered CASE Tools,” Communications of ACM, August 1998, pp. 93-99

  2. Chee, C.L., Jarzabek, S. and Paul, R. “F-metric: a WWW-based framework for intelligent formulation and analysis of metric queries,” Journal of Systems and Software, No. 43, 1998, Elsevier Science Inc., pp. 119-132

  3. Teh H.Y., Jarzabek,  S. and Tiako, P. “WWW-based Communication Tool for Distributed Team-based Software Development,” Proc. Conf. Systemics, Cybernetics and Informatics and the International Conference on Information Systems Analysis and Synthesis, SCI'99/ISAS'99, Florida, August  1999

  4.  Huang, R. and Jarzabek, S. “PCS: A CASE Tool for Distributed Group Software Development,” International Federation for Information Processing Congress, IFIP’96, Advanced IT Tools, Canberra, September 1996, UK: Chapman & Hall, pp. 402-410

  5. Chee, C.L., Jarzabek, S. and Ramamoorthy, C.V. “An Intelligent Process for Formulating and Answering Project Queries,” Proc. 6th Int. Conference on Software Engineering and Knowledge Engineering, SEKE’96,  Nevada, USA, June 1996, pp. 309-316

  6. Jarzabek, S. "Specifying and Generating Multi-Language Software Development Environments," Software Engineering Journal, (IEE and British Computer Society), March 1990, 125-137

Support tools for business analysis and re-engineering

What do we need to know about the business in order to understand and, eventually, to improve business operations? Many business modeling methods have been described in the literature and applied in business re-engineering projects. We feel that current business modeling methods do not have a precise enough model of the underlying business knowledge. A model should be comprehensive enough to allow for a systematic study and precise formulation of re-engineering methods. It should also provide a framework for designing tools to support business re-engineering projects. We identify information requirements for business re-engineering based on the commonly used business re-engineering methods and case studies published in the literature. In this project, we formalize these requirements within the conceptual business model. Business models vary from a company to company and from one business re-engineering project to another. Therefore, we build a generic model first and then we customize the generic model to the needs of a given company and a re-engineering project in hand. We build the core of a tool environment for business re-engineering around the generic business model. We achieve a required level of tool flexibility by applying meta-CASE techniques. We derive the physical schema for tool repository and generate customized tools from the customized business model specifications. Tools built around our model can support business knowledge acquisition, business process modeling, performance/quality analysis and analysis of alternative business process re-engineering solutions.

Papers describing this project

  1. Jarzabek, S. and T.W. Ling “Model-based Support for Business Re-engineering,” Journal of Information and Software Technology, vol. 38, No. 5, May 1996, pp. 355-374

  2. Jarzabek, S. and Ling, T.W. “A conceptual model for business re-engineering methods and tools,” Proc. 14th Int. Conference on Object-Oriented and Entity-Relationship Modelling, OO-ER’95, Queensland, Australia, Dec. 12-15, 1995, in Lecture Notes in Computer Science, Springer-Verlag, Germany, Dec. 1995, pp. 260-269

  3. Jarzabek, S. and Ling, T.W. "Model-based Design of Tools for Business Understanding and Re-engineering," Proc. 7th Int. Workshop on Computer Aided Software Engineering, CASE'95, Toronto, Canada, July 10-14, 1995, IEEE Computer Society Press, Los Alamitos, USA, pp. 328-337