Thesis Work and Students

Guidelines from start to defense

	Student	Status	Thesis
40	Mamta Wadwani	Defense 11/06	User Interface Testing Tool
39	Navya Teja Amerineni	Defense 11/06	Visual Ruby Unit Testing Tool
38	Anu Paturi	Defense 11/06	COM Interop Wrapper for Managed Code
37	Len Choo Ong	Defended 09/06	Alternate Code Generation for Abstraction Based Mock Objects
36	Aysha I Shaikh	Defended 07/06	RFaIR - Radio Frequency aided Information Retrieval
35	Anil Bobba	Defended 04/06	Framework for eXtreme Feedback
34	Pavan Podila	Defended 02/06	DotSpect - A Language independent AOP Tool
33	Hanumatha Rao Adusumali	Defended 11/05	Mapping State Tables To Realize Mock Objects
32	Jaivardhan Bhati	Defended 11/05	Web Service Performance
31	Anita Bennur	Defended 11/05	Abstraction Based Mock Object Framework
30	Jimy Chang	Defended 07/05	Tool for testing Web Services
29	Radha Kartala	Defended 04/05	Performance Testing Tool for .NET
28	Jinqiang Chen	Defended 04/05	Naked Objects in .NET
27	Buu Tien Phan	Defended 11/04	Fetch on Demand Algorithm for Session Management
26	Sushil Digewade	Defended 08/04	.NET Assembly and Configuration Management Tools
25	Dinesh Ravva	Defended 07/04	Inter-Process Event/Messaging model for .Net
24	Srinivas Rao	Defended 04/04	Infrastructure for outsourcing services: A software model
23	Sohani Patel	Defended 04/04	JSP Framework
22	Jay Gattani	Defended 03/04	AOP in .NET
21	Prerna Khosla	Defended 02/04	O-R Mapping Framework
20	Jatindera Walia	Defended 09/03	Design Metric Tool
19	Paige Presley	Defended 04/03	Distributed Data Delivery System
18	Kwangyeon Shin	Defended 04/03	Visualization of Web Services
17	Keeil Sung	Defended 03/03	Design Patterns Wizard
16	Shaolong Wu	Defended 11/02	A Framework for Display of Information from a Data Source
15	Shikha Chawla	Defended 08/02	Remote Dynamic Method Invocation
14	Bing Zheng	Defended 08/02	Web Information Archival System
13	Steven Wang	Defended 07/02	SNMP Trap Watcher
12	Peiyu Sun	Defended 07/02	Perf. Analysis of EJB App. Servers
11	Vijayabaskar Gangadaran	Defended 05/02	Java Unit Test Tool
10	Penghui Yang	Defended 04/02	.NET UML Viewer
9	Neil Bandopadhyay	Defended 04/02	Architecture and Prototype of a Wireless Alert System
8	Praveen Andrews	Defended 08/01	Performance Analysis Java vs. C++
7	Rachana Adapa	Defended 04/01	Flex Frame: Simulatable framework
6	Zhihong Liu	Defended 04/01	A Study of COM+ Performance
5	Tao Zhang	Defended 04/01	An XML Stylesheet Generator
4	Hang Heidi Cheng	Defended 11/00	Porting of an efficient JVM to Win32
3	Doğan Kartaltepe	Defended 11/00	JOVA: Java Object Visualization Aid
2	Leena Naik	Defended 10/00	Performance and Practicality of JNI
1	William Bagdan	Defended 11/99	COM Viewer

11/06: User Interface Testing Tool by Mamta Wadwani

er Acceptance testing is one of the most challenging tasks to be achieved in the field of Software Testing. A product is not worth if it's not accepted by the user. This task, though of high importance, is mostly done using manual approach. In our thesis, we contribute towards enhancement of a GUI testing tool, Carabiner, which attempts to automate the process of user acceptance testing. Carabiner inspects each GUI control in isolation in order to make sure that each control follows design guidelines. Carabiner provides a "Bless" or "Curse" metaphor to the user to show their acceptance or rejection for the interface.
We have improved Carabiner giving it ability to automatically configure the rules and rerun the harness. With this new feature developers can easily select the rules of interest and rerun the harness to see the immediate results. Additionally they can also reset the rules to default or cancel the current rule selection to undo their changes. Users can provide their feedback using a simple interface. This feedback is tied to the JUnit framework and hence plays an important role during GUI design. We have also added six new rules to the Carabiner rule repository.

11/06: Visual Ruby Unit Testing Tool by Navya Teja Amerineni

Ruby is a new, powerful, dynamic, object-oriented language, which is also light-weight and portable. To identify the correctness, completeness, security, and quality of developed software, testing is essential. Unit testing is a popular testing technique which tests units of code isolated from each other. Ruby has good unit testing frameworks, but does not have good unit testing tools to improve the efficiency and ease of use of the frameworks. Available unit testing tools, mostly console based, do not have good user interface and provide results in a manner that is difficult to interpret. Available graphical user interface based testing tools do not provide additional features other than what the framework provides.
In this thesis we proposed and implemented a unit testing tool for Ruby. The tool addresses the drawbacks and limitations of the available testing tools and also provides additional features to ease the process of unit testing in Ruby. The tool solves the problem of complex results by providing a tree view of the test methods along with the test result. The tool provides features like re-running tests, categorizing tests, ignoring tests, and informs the user of errors in the inputs. To facilitate the above features a good user interface has been developed using the FXRuby GUI toolkit.

11/06: COM Interop Wrapper for Managed Code by Anu Paturi

COM Interoperability, also called COM Interop, provides communication between COM components and .NET applications. COM components can not be directly utilized in .NET applications due to architecture and implementation differences. In order to overcome these differences, COM Interop provides a wrapper around the COM component called Runtime Callable Wrapper (RCW). RCW also takes care of data marshalling, exception handling, and object lifetime during interoperation between .NET and COM components. During interoperability, marshalling overhead may be incurred due to incompatible threading models between the COM component and .NET client. Another issue during interoperability is the Object lifetime. This may arise due to the holding of COM object resources till they are garbage collected. Unfortunately, none of these issues are handled by the RCW.
In this thesis we proposed and implemented a wrapper to the RCW in Visual C# to handle COM Interop issues. The wrapper will address the threading model issue by determining the threading model of the COM component. It will then set the same apartment settings for the .NET application. The wrapper will also take care of the object life time issue for us by releasing the COM object immediately after its use. To facilitate easy use of this wrapper by the developers we have developed a plug-in wizard for use in Visual Studio .NET 2003.

09/06: Alternate Code Generation for Abstraction Based Mock Objects by Len Choo Ong

Previous work in the area of Mock objects and unit testing proposed an Abstraction Based framework for creating Mock objects. While this approach has its advantages, it suffers from some significant disadvantages. Namely, the creation of mock was very slow and the dependency on State Machine Compiler restricted how specification of state transition for the Mock objects.
In this thesis, we propose an approach to map the state table into mock object on the fly. Our solution addresses both the drawbacks of previous work. By using dynamic code generation capabilities in .NET we generate a state based class that maintains the state of the mock. The dynamic generation of mock using this approach proves to be faster, taking less than 100ms. Further more, our new approach allows us to specify multiple state transitions, making the Mock object effective for unit testing.

07/06: RFaIR - Radio Frequency aided Information Retrieval by Aysha I Shaikh

The term 'Information Radiator' (IR) was first introduced by Alistair Cockburn. An IR is a large display of critical team information updated continuously and located at a place which can be viewed anytime by team members. They have proved to increase the performance and efficiency of a team by enhancing the open communication of information among team members. They are very helpful in tracking the progress of a project, work breakdown, etc. Unfortunately, many of the current IR's have been so developed that its true essence has been marred. Some of the reasons being, using charts and whiteboards instead of electronic medium as display, inefficient scripts to retrieve information limiting the resource of information to text files, and inhibiting the power of visual graphics, and tool being domain specific thus restraining extensions to future data resources. Thus an absence of an automated generic tool that could be deployed over the internet has been observed.
In this thesis we propose an approach to build the tool as a web service which can be deployed over the internet and consumed as a service by the users. The web service retrieves corresponding data from a particular backend, for an ID it receives from the client application. To automate the process of getting the context of the person for whom the information has to be fetched and displayed, we have made use of the Radio Frequency Identification (RFID) technology. We introduce a layer of abstraction between the web service and the various backend resources from which it fetches data, thus promoting extensibility to future backend resources without modifying existing code.

04/06: Framework for eXtreme Feedback by Anil Bobba

eXtreme Programming (XP) relies heavily on feedback. Feedback consists of the frequent review of the results or output of various activities and tests done as a part of software development. The term and concept of eXtreme Feedback (XF) is born out of XP. To make XF publishing and notification possible in a wide scale, a framework designed around delivering feedback is necessary. In this thesis we have taken XF to the next level by developing a general purpose eXtreme Feedback Framework (XFF) that would make the whole concept of XF almost effortless. The thesis started with two specific goals, to design and implement a framework for XF, and to show a proof of concept by putting it to use in two real world scenarios.
The publisher-subscriber model is used in implementing XFF. The framework can be thought of as a "bus" that "transports" feedback from the publishers to the subscribers located anywhere on the network. The framework uses a combination of web services and TCP/IP for this purpose. A service oriented approach is used in building the framework. The framework is flexible both in terms of deployment and communicating feedback. It has the speed through the TCP/IP and flexibility by using web services. As one of the XP principles states, if an activity is deemed beneficial it should be done to eXtreme. So by developing XFF, we have put this principle to practice.

02/06: DotSpect - Language Independent AOP Tool by Pavan Podila

Aspect Oriented Programming (AOP) is a new paradigm for solving certain class of software problems where Object Oriented (OO) paradigm fails to provide effective solutions. The .NET Framework is a rich and powerful platform for building tools and applications. However in the AOP space, it lacks the maturity offered by tools for the Java platform. Existing AOP implementations for .NET either use XML for describing aspects, or weave aspects at runtime, or target a specific language like C#. XML syntax introduces too much verbosity whereas runtime-weaving may not be suitable for every type of problem. Also targeting a specific language does not allow aspects to be written in any other .NET supported language.
In this thesis we propose DotSpect, an AOP implementation for .NET that aims to remedy these issues. It provides concise language syntax for describing aspects, similar to AspectJ for Java. It supports a static-weaving facility, allowing aspects to be woven into existing assemblies. Cross-cutting behavior can be written in any language, making the tool language-independent. DotSpect is designed with an extensible architecture which simplifies future additions to language syntax and support for more .NET languages.

11/05: Mapping State Tables To Realize Mock Objects by Hanumantharao Adusumali

Mock objects are test-oriented replacements for collaborator objects and help developers in testing the details of an object that has dependencies. Mock object frameworks are tools that help developer automate the mock object creation and training process. Unfortunately, current mock object frameworks are based on object-collaborator interactions which are complex and hard to express. There is need for improvement in the mock object creation process.

One such improvement is the recent work of abstraction based approach to creating mock objects in which behavior is represented using a state table. In this thesis we propose an approach to map the state table to realize mock objects. We use the State Machine Compiler (SMC) to generate a class to maintain the state of the mock. We map the user given simple state table input into the input format specified by the SMC and generate mock object based on the state behavior specified.

11/05: Analysis and Enhancement of Web Services Performance by Jaivardhan Bhati

There is greater need for software components to be distributed. How do software components communicate and exchange data efficiently? Remoting technologies like COM, CORBA, RMI, and .NET Remoting address this issue, however, they lack either platform independence or tie you to specific software infrastructure. Web services, due to their use of XML, have gained popularity for their platform neutral ability to allow components to communicate. However, XML is verbose and may lead to poor performance.

In this thesis I study the performance of XML web services. I analyze the performance for different size of data exchange. I observe that sending data over XML degrades linearly as the size of the XML increases. I then explore ways to improve this performance. By using the DIME protocol, the performance is improved, however, it also results in the loss of platform neutrality. We derive further conclusions based on the analysis.

11/05: An Abstraction Based Mock Object Framework by Anita Bennur

Mock objects are representatives for real objects that a piece of code under test collaborates with. The code can invoke methods on the mock which in turn behaves exactly as it has been trained to. Mock object frameworks seek to automate this process of creating and setting up a mock object. However, the frameworks in vogue today place an inordinate amount of stress on the implementation details of the collaboration between the code and the mock. This diverts the focus from the behavior of the mock to the implementation of the mock. While the idea of mock objects is a breakthrough for test driven development, its implementation in terms of frameworks can be improved.

In this thesis we propose a radical shift in the way mock object frameworks are perceived and used. We specify a means by which the behavior of the mock can be abstracted and created dynamically. In this approach the behavior of the mock is synthesized from the expression of its state. This abstraction oriented framework truly captures the essence of mock objects and also serves as, arguably, one of the most productive means to using mocks. The successful design and implementation of our framework provides the proof of concept for our hypotheses.

07/05: A Web Service Testing Tool by Jimy Chang

After a huge growth in Web Services, it is now necessary to debug and test them accordingly. It is less acceptable for them to have broken and unusable features, because of their frequent use and deployment. One can argue that in the vigorous drive to reduce costs and increase the consumer base, a fully functionally service is more than necessary. As such, a low development time coupled with an effective debugging tool would be very advantageous. This thesis provides such a tool by creating a generic client using which Web Services can be tested. Using Reflection and static proxies created from Web Services Description Language (WSDL), this tool is able to de-couple the service from its client during the development stage. In essence, we have a client that can mimic the remote function calls from most clients and also provide an interface to other testing utilities. The benefits of our tool are at least threefold: early detection of bugs and defects, lower development time, and more robust code.

04/05: Performance Testing Tool for .NET by Radha Kartala

NUnit is a unit testing framework that can be used with all the .NET languages like C#, Visual Basic, Visual C++. It was written in C# based on the JUnit testing framework for Java. While JUnit mainly involved testing the functionality of the code, an extension of JUnit, called JUnitPerf developed by Mike Clark, introduced performance testing to Java developers. While functionality testing leads to the production of error-free software, performance testing leads to the development of quality software. The motivation of this thesis was to bring a similar extension of a performance testing tool to .NET developers.

The objective of this thesis is to extend NUnit to incorporate performance testing. We tried to base our tool on JUnitPerf which was inheritance based. It was very convenient to extend JUnit. But NUnit is attribute-based and NUnit 2.2, which is the current final release, does not provide any mechanism for extensibility. An iteration release called NUnit 2.2.1 provides an extensibility mechanism that we used to extend NUnit classes and introduce new behavior. Consequently we created TimedTest and LoadTest attributes as an extension to NUnit. Our performance testing tool is conceptually based on JUnitPerf and has the same attributes, TimedTest and LoadTest, that JUnitPerf provides as JUnit test decorators.

04/05: Naked Objects in .NET by Jinqiang Chen

Naked Objects framework implementation in Java eliminates the need to design Graphic User Interfaces (GUI) for software systems. However, the framework was based on Java AWT component that is slow, incomplete and not being actively improved. Java also currently does not support other programming languages. In this thesis we have created a prototype of Naked Objects framework implementation in .NET using C#. Our framework uses simpler and more efficient controls to generate the GUI. It may be used to build application in any .NET language. We demonstrate how our framework provides flexibility and high potential for future refinement.

11/04: A Study of Fetch on Demand Algorithm for Session Management by Buu Tien Phan

Session management in clusters is a serious problem faced by most enterprises that provide interactive Web applications. Existing session persistence techniques, such as centralized database persistence, known as Microsoft SQL server or memory-to-memory replication, known as Broadcasting algorithm, suffer from severe limitations. Centralized database persistence may suffer from Single Point of Failure while the Broadcasting algorithm may suffer scalability problem since the replication of session objects adds significant overhead. The Fetch on Demand algorithm is introduced as a software solution that overcomes the above-mentioned challenges associated with session management. The study focuses on implementation of the Fetch on Demand algorithm, analyzing the performance and comparison to existing designs.

08/04: .NET Assembly and Configuration Management Tools by Sushil Digewade

With the .NET initiative, Microsoft has introduced a much-improved Windows development platform. VS.NET is the development environment of the .NET platform. VS.NET is relatively new and with the intent of improving it, Microsoft has enabled the extensibility features on it. The thesis work comprises of design and development of two tools that would be operated from within the VS.NET. These tools would be used during development and deployment of software on the .NET platform. The primary goal of these tools is to improve the productivity of a .NET application developer. The configuration file editor tool, named SmartEdit, facilitates a developer to efficiently edit the XML based configuration files of a .NET application. The SmartEdit tool is integrated in the VS.NET and could be invoked directly on a configuration file. The other tool, DView, would be used to view the dependencies of the installation units, or the assemblies, of the .NET platform. The DView tool is external tool and could be attached to the VS.NET. This tool could be used in the development as well as the deployment environment.

07/04: Inter-Process Event/Messaging model for .Net by Dinesh Ravva

The existing event model in .Net framework dispatches events synchronously to its handlers within process. In it, the existing code has to be modified to vary the handlers for events. This thesis presents a messaging framework for .Net that provides a new event model, which enables to vary the event handlers without the need for modifying or recompiling the existing code. It also dispatches event messages to its handlers asynchronously. Varying handlers is achieved by bringing out the event registration and the event dispatching mechanisms out of the process and into the messaging framework. The framework is modeled along the lines of the publisher-subscriber model of the messaging oriented middleware. We also provide an easy to use API and an intuitive administrative console for the developers to interact with the framework. .Net Enterprise Services are used for effective implementation of the framework. The framework also supports security in the form of the secured topics.

04/04: Infrastructure for outsourcing services: A software model by Srinivas Rao

A model for offering services on Internet that enables outsourcing services is presented with examples of areas where this model would be useful. Development of infrastructure that could enable a service provider with minimal effort is discussed. Various technologies that can be used to implement this infrastructure are considered with reference to their benefits and drawbacks, available tools and ease of implementation. Based on these factors, Web Services model is chosen for implementation using the Java Web Services Developer's Pack from Sun Microsystems. Requirements imposed by such infrastructure are discussed along with general outline of functionalities of the server and the client. Design considerations and implementation of this functionality are detailed and the software design patterns that can be used are highlighted. Use of the developed infrastructure is illustrated with a simulated service provider.

04/04: JAVA Tag Library Based Server Side HTML Mapping Controls by Sohani Patel

Web applications have become popular for various uses including online shopping, information search and communication. HTML is one of the most widely used languages for development of such applications that depends on server side languages like JSP to solve its inherent problems. Embedding HTML in the JSP makes the code lengthy and unreadable for the big applications, which also makes it difficult to modify and maintain. Separating the logic from the presentation can solve this problem. An inherent problem with HTML controls to retain the state also needs to be addresses. Also, JSP needs to adapt to new development in the technology and provide ability to generate code for languages other than HTML, like WML for PDAs.
This thesis is an attempt to provide custom tags to provide flexibility and ease of maintenance of JSP code. Several custom tags are developed using Java to provide flexibility to respond according to the browser making the request and to retain the state of the control. HTML was selected in this project for mapping of the controls. All custom tags are designed to allow formatting using Cascading Style Sheets. A unique control, Repeater, was developed to provide database access and capability to iterate through the data retrieved from the database to populate the nested custom tags. The custom tags developed in this thesis are designed to work with and without use of the Repeater developed in this project.

03/04: AOPINJECTOR - A Post Compilation Aspect Oriented Injection Tool For The .Net Framework by Jay Gattani

Aspect Oriented Programming (AOP) is a new programming paradigm being researched upon at present. AOP proposes a number of new ideas and methods to efficiently deal with software complexity in arenas where the Object-Oriented Paradigm fails to provide even a suboptimal solution. In this thesis we present AOPInjector which is a post-compilation aspect oriented programming tool designed for the Microsoft .NET framework. It is an attempt to understand the underlying concepts of AOP as well as a proof of concept of an extensible tool to provide AOP support for applications developed with the .NET framework. The following design goals were considered: To keep the syntax as hygienic as possible and consistent with the syntax of the C# programming language; To reduce the learning curve of a AOP programmer using the tool; Finally to rely upon efficient IL code injection at the post compilation phase instead of run time method interceptions. The implementation of the tool in this thesis has served as a realization of these goals.

02/04: O-R Mapping Framework for .NET by Prerna Khosla

The Object Relational Mapping Framework has been designed and implemented to provide transparent persistence. With transparent persistence the manipulation and traversal of persistent objects is performed directly by the object programming language in the same manner as an in-memory non-persistent objects. The framework integrates the object oriented programming capabilities with relational database management systems like Oracle, MS-SQL etc, making database objects appear as programming language objects. The framework in this manner aids developers in concentrating their efforts to target the business application problem at hand rather than focus their efforts on working on the persistence layer, which is outside the applications domain. The framework is designed and implemented for the .Net environment, which lacked such a framework facility. The implementation is done using C# as the implementation language and MS-SQL as the RDBMS.

09/03: Design Metric Tool for Java Applications by Jatindera Walia

Software is increasingly becoming integral to human life, being used to solve day to day problems. Software systems of present are going to work as backbone for the ones that will be written in future. This requires that the software systems of today should be of good design so as to be extensible for tomorrow. Ability to quantitatively measure the design of software will lay down some concrete evidence whether it will stand the test of time.

This thesis is an attempt to develop a tool which measures the Design Metric of an application written in Java using the concepts provided by Robert Martin. The tool known as Design Metric Tool is written in Java and helps the developer of a Java application understand the coupling between the classes and packages of the application. It calculates the metric value which gives the developers an indication of the stability and extensibility of the design. Furthermore, the design of the Design Metric Tool has been analyzed using the tool itself.

04/03: Distributed Data Delivery System by Paige Presley

Even though there are a number of system tools that deliver remote system information, there is often a need for data that these tools cannot deliver. It is often very time consuming to remotely log onto and query each machine for the desired information. The objective of this thesis is to develop a distributed data delivery and directory lookup system, which will allow quick and easy monitoring of remote information.

We first place a querying process on the remote computers. Next, we deliver the query results to a central directory using an LDAP service. Finally, we provide a graphical representation of the query results. For each piece of data that a user would like to monitor, a simple Java class is placed on the remote computer. This provides greater flexibility and extensibility to the data gathering mechanism. In this thesis we present the architecture and the design of the system and discuss its merits and drawbacks as well.

04/03: Visualization of Web Services by Kwangyeon Shin

Web Services are platform-neutral language-independent software components in contrast to COM, EBJ and CORBA. They provide a Web Service Description Language (WSDL) document that declares methods, their parameters, and their results. These are some what equivalent to the Interface Definition Language (IDL) of COM and CORBA. It, however, uses an XML-based format which is usually quite complex and not human-readable.

In this thesis, we implemented a tool that represents a WSDL document as a lucid, easily understandable graphical diagram based on the UML notation. A UML representation of a web service will be more intuitive to understand and should improve the productivity of the developers using it. The core part of the tool is implemented as a Web Service; this allows us to develop the visualization client part of the tool on any language and any platform. Indeed we developed two kinds of clients in the thesis: a .NET client and a Java client.

03/03: Design Patterns Wizard by Keeil Sung

Design patterns are emergent technology for implementing robust, reusable and extensible object-oriented software. They describe a solution to a recurring design problem in a systematic and general way. The patterns, however, must be implemented each time they are applied since a design pattern only describes the solution to a particular problem. It's not itself code.

This thesis presents the architecture and implementation of a tool that automates the implementation of design patterns. The user of the tool interactively provides application-specific information for a pattern and the tool automatically generates Java code realizing the pattern. The tool derives the details of each pattern from an XML based representation that we have designed. The tool is designed to be extensible. It not only supports editing or evolving an existing design pattern but also allows for new pattern to be introduced.

11/02: A Framework for Display of Information from a Data Source by Shaolong Wu

The complexity and new technologies used in current Web Publishing requires expensive resources to develop and maintain a web site. Our goal is to find a method to simplify this process. We have developed a framework to display information from a XML data source. In our framework, all the processes including retrieving the XML data from the database, transforming the data into HTML and displaying the resulting HTML occur on the client machine. The framework is composed of several components and Java objects. An input Template, which must follow a Schema, defines which data to display and how to display it. From the Template, the Query and an XSL Stylesheet are automatically generated. Using this Query, the XML data is then retrieved, and transformed into HTML using the Stylesheet. The only input from the user is the Template, which can be generated using a tool provided.

Some of the benefits the framework provides are ease of use and maintenance, scalability and performance. The users do not have to specify any database access queries; do not have to write a servlet, JSP or ASP code. They simply need to specify their needs in XML format. The scalability and performance of the web server is improved since the transformation is done on the client side using Java based tools.

08/02: Remote Dynamic Method Invocation by Shikha Chawla

In a Distributed Networking environment, a client and a server can communicate using Java RMI (Remote Method Invocation). The capabilities, i.e., the services provided by the server are defined in an interface. In today's ever -changing environment it is very difficult to keep up with the rapid changes between a client and a server.

Static invocation is to bind to an interface and then invoke a method, which has two major disadvantages. One the client has to know in advance what services it needs from the server. The other is that if in future there is any enhancement or change to the particular interface the client has to be provided with a new interface altogether or else the whole system collapses.

The objective of this thesis is to implement dynamic invocation so that the client does not need to bind to any particular interface. This is accomplished by creating a RDMI (Remote Dynamic Method Invocation) tool, which enables the client to introspect and query a server for all possible services and then invoke a remote method dynamically. The method may have parameters, which may be primitive, remote objects or even non-remote objects that are defined on the server side.

08/02: Web Information Archival System by Bing Zheng

The World-Wide Web now contains about 800 million pages, encompassing about 6 terabytes of text data on about 3 million servers. New technologies are urgently needed to capture and manage the overwhelming and easily accessible Web information. This thesis presents a new kind of client-side archival system,"Web Information Archival System," or WiAS. It is a program that uses local disk storage to archive the Web pages containing useful information for future references. WiAS is linked directly to the Microsoft Internet Explorer to simplify the archiving process; it provides a windows explorer like interface to browse and organize the archived information; it utilizes an underlying database management system to handle the archive-related data; and most importantly, it introduces a powerful housekeeping mechanism to automatically remove outdated information from the archive, therefore, ensuring enough storage capacity to deal with the continuously growing Web information.

07/02: SNMP Trap Watcher by Steven Wang

SNMP, the Simple Network Management Protocol, is a protocol used to remotely manage the nodes on a TCP/IP network. It is the most popular protocol in the field of network management. SNMP Traps, which is the only proactive approach in SNMP, are event report messages that are sent from an SNMP agent to a Network Management System. Our objective is to develop a language neutral interface to handle SNMP traps. SNMP Trap Watcher uses COM and ActiveX technology, which provide a way to reuse and integrate components at run time. In this thesis, a multi-threaded ActiveX control is implemented using Microsoft's Active Template Library. Several techniques are introduced about how to use COM to synchronize threads. At the end of this thesis, examples are provided on how to use the SNMP Trap Watcher in different language environments, including Visual Basic, Visual C++ and Java.

07/02: Performance Analysis of EJB Application Servers by Peiyu Sun

EJB application servers are widely used for enterprise applications nowadays. The performance is always a very important issue when evaluating an application server. However, most of performance tests in the past assume that the server can use unlimited resources. And they only test how an application responds with a certain number of requests. In this thesis, we designed and implemented a series of consistent test cases for Weblogic 6.0, JBoss 2.4.4, and BAS 4.5. We tested the performance of each type of enterprise beans. The number of requests is changed gradually to show the servers scalability. We also tested the servers under different caching policies to see how they perform when available resources change. The results show that Weblogic has superior performance and scalability over the other two. JBoss also has impressive performance for a free, open source server. BAS has similar performance compared with JBoss.

05/02: Java Unit Test Tool by Vijayabaskar Gangadaran

Software testing is an important technique for validating and checking the correctness of software. However, effective and efficient testing turns out to be difficult, expensive, laborious, error prone and time consuming. Testing is generally considered costly and time-consuming. The idea that seems to work best is test early and test often. In this thesis we present a testing tool, Java Unit Test Tool (JUTT), that would let developers to unit test their java classes without having to write a separate test driver program. The tool is unique in the way it functions, in that it works like a command interpreter, with each new line of command executed immediately after the user presses the return key and the results available immediately. Since there is no intermediate compilation step involved, it gives the user the flexibility to try out different test plans and ideas on the fly, saving a significant amount of testing time. The core functionality of JUTT includes allowing users to declare variables, both primitive and object reference type, initialize the variables, assign one variable to another, call methods on objects and query for the value of a variable. The syntax for all the above statements is the same as in the Java language, making it easy for developers to start using the tool right away without having to learn any new syntax.

04/02: .NET UML Viewer by Penghui Yang

The Microsoft .Net Framework is a new platform that gives the Windows developers a simplified and unified way to access the Windows resources. One of the important features of the .Net is the .Net Reflection, which allow the programmers to perform the type discovery, late binding and reflection emit at runtime. The objective of this thesis is to develop a tool that can help the .Net developers to deal with the complexity of the .Net assembly by showing the object models in the UML notations. The result of this thesis is the .Net UML Viewer, implementation of which heavily depends on the .Net Reflection. The users of the .Net UML Viewer can view the internal structure of a .Net assembly and the UML class diagrams simply by navigating around the model by clicking on classes in the UML notation. They can navigate between various associated classes even if the classes are not defined in the assembly.

04/02: Architecture and Prototype of a Wireless Alert System by Neil Bandopadhyay

WAP (Wireless Application Protocol) is a protocol for accessing information from the mobile devices and WML is the Wireless Markup Language to develop a wireless application. These are analogous to the HTTP and HTML of the Internet world. Wireless applications provide mobility to the user and thus it is extremely useful because it can be accessed from anywhere. Another important feature of wireless applications is the capability to generate Push messages based on certain events without user interaction. This Push feature is a new addition to the WAP 1.2 specification of the WAP forum and this is indeed a very powerful arsenal for delivering content to the user without the user having to specifically go and retrieve it.
This thesis is aimed at the architecture and prototype of a wireless alert system that can be easily applied in everyday life. The architecture for a wireless alert system along with the performance and functionality issues that were addressed is presented. The prototype application presented here is a stock browsing application with wide scale support for creating and managing portfolio of stocks. The user can set a threshold value for each stock in the portfolio. The system continuously monitors the stock prices and anytime the price goes below the threshold, an alert message is generated to the mobile browser.

08/01: Performance Analysis of Java vs. C++ For Computationally Intense Software by Praveen Andrews

A frequent question we face these days in the Object-Oriented software development world is about the performance of Java. In the past, a general skepticism has always revolved around implementations of Object-Oriented languages. However, C++ proved itself to be fairly efficient and is widely used today in computational intensive software. On the other hand, Java is yet to be accepted as a language that provides adequate performance for computational intensive software. Java has gone through quite a bit of revisions and is currently at version JDK 1.4.
The objective of this work is to present information that will help engineering and other organizations considering using Java technologies for their computational intensive software. We will describe in general selective computations and mathematical equations, present the details of our implementation of these equations, and finally, compare the computational time taken for solving these equations in both C++ and Java.

04/01: Flex Frame: Framework to visually configure simulatable objects by Rachana Adapa

There have been many domain-specific software tools developed for simulation. Though they explore the depths of the domain, these tools are limited to their own domain. This thesis is based on the idea of developing an extensible software system, called "Flex Frame," which enables development of simulation applications related to any domain. It is a general-purpose tool and its generality is achieved through higher levels of abstraction. The input to this framework would be entity classes provided as Java ". class" files. The core of this part of the framework enables visually configuring connectable objects. The system also provides another framework to create models out of the applications developed using Flex Frame. These models consist of a layout of simulatable and display entity instances that are user-interactive. Flex Frame is built using the unified software development methodology, intending to make it a robust, manageable, and reusable system.

04/01: A Study of COM+ Performance by Zhihong Liu

COM+ is one of the latest developments of Microsoft’s component technology. It comes with Windows 2000 operating system and is only available in this operating system. COM+ is basically the combination of the existing technologies such as COM, MTS and MSMQ, together with some new features such as asynchronous method invocation and neutral apartment. COM+ is the key infrastructure in the Microsoft’s Distributed interNet Architecture, which is Microsoft’s solution for enterprise N-tier applications.

In this thesis, I provide a brief introduction about the concepts in COM, MTS and COM+ technologies. Tests are done to evaluate the performance of COM+. The new features of COM+ such as Object Pooling, Just In Time Activation, different threading models in COM and COM+ are tested. The study has shown that it is much slower to put the component in COM+ applications as compared to in-process components and out-of-process component. The overhead of COM+ is as big as 10 times. Other studies has also shown that object pooling will not help much to improve the scalability of a software unless the component is very huge itself, which is not the case in most of the enterprise applications. The study suggests that we should avoid using COM+ unless it is absolutely needed. For example, if the functionality of the component is just retrieving information from database or file system, we should not put the component in COM+ applications. Only when we need to modify the data and we need to use the transaction features, we should use COM+.

04/01: An XML Stylesheet Generator by Tao Zhang

eXtensible Markup Language (XML) is designed and developed by World Wide Web Consortium (W3C). Its’s simplicity, combined with its platform and application independence, makes it attractive for data exchange in increasing number of areas, especially between disparate systems. Schema is a mechanism to define the model or structure for XML documents. Extensible Style Language (XSL) is a stylesheet transformation language especially for XML. It allows for an easy transformation of the contents of an XML document into other formats including XML, PDF, HTML, etc. While XSL makes it easy to transform XML, writing an XSL stylesheet itself is not too easy, especially for non-programmers. Further, it requires that each XML documents structure be studied and understood. It would be nice to have a tool that can generate the stylesheet automatically.

In this thesis, we design and develop an XSL Stylesheet Generator that automatically and dynamically generates stylesheets. This application is implemented based on the close relationships among XML, Schema and XSL, and uses Java and an XML Parser. It first generates a tree view of the structure of an XML document. It then lets the user choose, from the tree notes, what information they want to be presented in the transformed HTML output. Finally, it generates the XSL stylesheets according to the user's selections. Among all of its benefits, efficiency, user friendliness, ease of use and wide applicability are the most important.

11/00: Porting of an efficient JVM to Win32 by Hang Heidi Cheng

Java as a popular Object-Oriented programming language is well known by its unique virtue - "Write Once, Run Anywhere," which is made possible by its Java Virtual Machine (JVM). JVM interprets bytecodes into native code at run time. Embedded JVM is in highly demand since JAVA is gaining its spots in embedded system. Different JVMs are needed for different embedded devices because of the different types of processors. There are few embedded JVMs for win32 since Windows CE, a Microsoft embedded OS is quite new to the market. Kaffe is a fully JAVA compliant open source JVM. It was written from scratch and developed in GNU environment on UNIX. The objective of this thesis work is to port Kaffe to Win32. The whole process of the porting main algorithms of Kaffe, results of regression test, performance will be discussed in this thesis. The efforts will help efforts on porting it to Windows CE.

11/00: JOVA: Java Object Visualization Aid, Use of Reflection to Realize UML by Doğan Kartaltepe

The Java package java.lang.reflect provides programmers an interface to access reflective information about classes and interfaces during run time. Through this, programmers can get information about fields, methods and constructors. The reflected fields, methods and constructors can be used to operate on its respective object or put to some other use. Together with class Class, debuggers, class browsers and object inspectors can be built. Java Object Viewing Aid (JOVA) uses these to build models, of classes and their relationships, in the United Modeling Language representation. Users of JOVA can build UML models of their own Java classes or existing classes. As opposed to some other software engineering tools, JOVA singles out one class, at a time, on which to focus. A clear consistent representation of the internals of the class inspected is present to the user. JOVA has brought the concepts of reflection and UML together to enhance the productivity of software developers.

10/00: Performance and Practicality of JNI by Leena Naik

The Java Native Interface (JNI) allows applications written in Java programming language to interoperate with applications written in native programming language such as C and C++. Developers as well as management are interested in JNI for one of the two reasons. Either they have existing code that they want to use without rewriting in a Java application, or they are developing a Java application, some parts of which are best-written in native code. The continued use of existing, or legacy code may be an economically wise decision.

The objective of this thesis is to evaluate the performance of invoking JNI functions in terms of speed and memory usage. The performance considerations and recommendations put forth will help developers to analyze the cost of using JNI functions in their applications. The measurements in the thesis indicate that in some performance critical applications it may be necessary to port native code to Java programming language or device other alternatives instead of relying on JNI.

11/99: COM Viewer by William Bagdan

With the increased use of the Component Object Model, otherwise known as COM, there has becomes an increased need for the development of tools to assist in the use of this technology. One such tool would allow the viewing or browsing of all the relevant information a developer would need in an easily understandable format. Although there are existing tools, which do provide some or all this information, none at the present have been specifically designed for this purpose. Due to this, the information is either incomplete, or too much information is presented to easily extract the information desired.

Understanding the information a developer would want to see would be just one consideration. Another main factor would be how they would want to see it, when possible a graphical presentation that allows the user to easily navigate through the information, over a text driven presentation is preferred. Therefore the tool developed and described in this thesis provides a visual browser. Visually, by presenting as much information in a graphical form that the user should already be familiar. The browse component allows the developer to understand the interconnections between the various interfaces and coclasses. What results is a powerful tool that allows a large or small COM based development design to be easily explored and understood by the development team.