Enhancing an Application Server to Support Available Components

Modern client-server distributed computing systems may be seen as implementations of N-tier architectures. Typically, the first tier consists of client applications containing browsers, with the remaining tiers deployed within an enterprise representing the server side; the second tier (Web tier) consists of web servers that receive requests from clients and pass on the requests to specific applications residing in the third tier (middle tier) consisting of application servers where the computations implementing the business logic are performed; and the fourth tier (database/back-end tier) contains databases that maintain persistent data for applications. Applications in this architecture are typically structured as a set of interrelated components hosted by containers within an application server.

Various services required by applications, such as transaction, persistence, security, and concurrency control, are provided via the containers, and a developer can simply specify the services required by components in a declarative manner.

This architecture also allows flexible configuration using clustering for improved performance and scalability. Availability measures, such as replication, can be introduced in each tier in an application-specific manner. In a typical n-tier system, the interactions between clients and the web tier are performed across the Internet.

The infrastructures supporting these interactions are generally beyond the direct control of an application service provider.

The middle and the database tiers are the most important, as it is on these tiers that the computations are performed and persistency provided.

These two tiers are considered in this paper. Data as well as object replication techniques have been studied extensively in the literature, so our task is not to invent new replication techniques for components, but to investigate how existing techniques can be migrated to components.

Component-oriented middleware infrastructure provides clear separation between components that have persistent state and those that do not.

Therefore, it is natural to divide the replication support for these components into two categories: state replication and computation replication.

State replication deals with masking data store failures to make persistent data highly available to components, while computation replication deals with masking application server failures where the computations are performed.

We examine how an application server can be enhanced to support replication for availability so that components that are transparently using persistence and transactions can also be made highly available, enabling a transaction involving EJBs to commit despite a finite number of failures involving application servers and databases.

The Model-View-Controller (MVC) design pattern was originally brought forward by Trygve Reenskaug and applied in the SmallTalk-80 environment for the first time, the purpose of it is to implement a dynamic software design which simplifies the maintenance and extension of the software application.

MVC seeks to break an application into different parts and define the interactions between these components, thereby limiting the coupling between them and allowing for each one to focus on its responsibilities without worrying about the others.

MVC consists of three categories of the components: Model, View and Controller. This means that it separates the input, processing, and output for the applications and constructs them into a Model-View-Controller three tier structure

 

Dynamic Flash Interface

The Internet is a suitable tool for distributing information because it is a communication medium that reaches a wide audience. By using the web to advertise, companies can easily attract potential customers. Some elements used for web advertisements include animated graphics and sounds.

The aim for this project is to provide a website that can showcase the elements of a dance studio. The front-end, or interface of the website is designed with Flash technology that incorporates tasteful decorations as well as a consistent color theme. The content of the website is stored in a database, which can be updated easily.

The back-end of this dynamic website consists of PHP technology that connects the MySQL database with the Flash presentation. This project also provides an opportunity for this author to learn how to design with Flash.

While Flash animation has been around over a decade, it is a relatively new technology compared to the hypertext markup language. In the early days, Flash animation provided some entertainment value but did not contribute to the information sharing focus of the Internet, so it is found on a small percentage of all websites.

In addition, most browsers require a Flash player plug in to render the Flash animations. Even with frequent upgrading of Flash players to the latest version for proper compatibility, many companies in the entertainment prefer using Flash because of its possibilities for multimedia integration.

The Flash technology that we know of today can work with text, sounds, video and graphics in both static and dynamic contexts.

For small companies such as a local dance studio, Flash websites can be used to the same extent as larger companies to portray the professional image.

Shin Dance Academy (SDA) is one out of many dance studios in Southern California that offers a selection of dance classes to the public, which are taught by temporary instructors.

SDA is interested in utilizing whatever tools available to efficiently promote and thereby successfully recruit more students. As such, SDA finds marketability in maintaining a lively and up-to-date website. 

 

Customer Complaint Report Software

This application package uses VISUAL BASIC 6. For inputs/outputs user will use Menu for working on the system. They will use forms for displaying the database and also for view/update this.

Software

• System should be run under windows 95, 98, window NT 4.0 environment.

• Reports should be designed in Seagate Crystal Reports.

• Oracle 9i should be used as backend to store database.

• Forms should be designed in Microsoft Visual Basic 6.0 to enhance the productivity, for expressive form design, and less update time.

Hardware

• Visual Basic 6.0 and other application package should be installed on the Pentium III and other compatible machine.

Any machine that is connected to LAN must have Microsoft Visual Basic 6.0 and Seagate Crystal Report packages

Objectives Of System

• The aim of this project is to deliver a verified & validated data retrieval system.

• The primary objective of design & development of this system is to simplify the process of report generation.

• It should provide correct data in the reports independent of the objects & conditions used.

• Should reduce the time for provisioning of requested data.

• The enterprise managers can easily get data for analysis purposes.

User Requirement

The foremost requirement is to provide initial reporting framework.

• Should provide feature of Single point-of-entry to access reports.

• Should provide a range of information demand addressed.

• Should provide Business Self Service where possible to take up business decisions.

• Should provide Data Abstraction.

• Treat data from a business perspective instead of from an application perspective

• Should embed in itself Service-Oriented Architecture.

• Should be Maintainable.

• Should be Business aligned

• Should provide a framework for Efficient Report Development Process

• Should have a detailed source data analysis for effective modeling of universe.

• Should provide feature for changing the login and password of the logged in user.

• Should cater to adhoc-reporting requirements of the customer

An Intelligent Eye

This An Intelligent Eye project assumes that reader has a basic signal processing understanding and some algorithmic notions (complexity, optimisations).

The aim of this project is to give the reader a little overview of the existing techniques in digital image processing.

We are developing software and software is a part of larger system, so work begins by establishing requirements for all system elements and then allocating some subset of those requirements to software.

This system view is essential when software must interact with other elements such as hardware, people and database. System engineering and analysis encompass requirements gathering at system level with a small amount of top-level design and analysis.

Information engineering encompasses requirements gathering at the strategic business level and the business area level. In this step we just allot requirement to each system element according to their requirements.

To begin with we decided the operating system that has to be used as building round for project development i.e. Windows NT/XP and then we decided the language to be used for developing the software i.e. JAVA 1.5.

• Design

Software designing process partitions the equipments to either hardware or software system. It establishes overall system architecture. These processes translate the requirements into a representation that can in future be transformed into one or more executable programs. This design process translates requirements into a representation of the software that can be assessed for quality before coding begins.

The design is documented and becomes part of software configuration. Here we establish overall system architecture. All the requirements are divided into two levels - the software levels and the hardware levels. The framework of the project is developed here and is documented to become a part of the configuration. Here we set the interaction with the hardware will be performed with the help of modules which will contain functions that solely perform only this task.

• Testing

After the generation of the code, now our work can be tested for whether it is doing the desired operation or not. Testing is performed to uncover the errors if any, in the program so that result matches with the specified requirements. It focuses on logical internals of the software, ensuring that all the statements have been tested. After the

Successful completions of the projects tests were performed to test its smooth operation. The testing procedures used were:

• Unit Testing

• Black Box Testing

• White Box Testing

• Integration Testing

Support or Maintenance

This is the longest life cycle phrase. The system is tested and put into use. Maintenance involves correcting errors, which were not discovered in earlier stages of the process life cycle. The project was so designed that it was easier to maintain and to upgrade the Image processing software according to the need.

 

Image Steganography

The techniques for secret hiding of messages in an otherwise innocent looking carrier message belong to the field of steganography. The purpose of steganography is to conceal the very presence of secret information.

To make the communication more secure, the secret information can be compressed and encrypted before it is hidden in the carrier.

This is important because in this way we minimize the amount of information that is to be sent, and it is also easier to hide a random looking message into the carrier than to hide a message with a high degree of regularity. Encrypting the compressed message before hiding is recommended and provides double protection

Image steganography

As stated earlier, images are the most popular cover objects used for steganography. In the domain of digital images many different image file formats exist, most of them for specific applications. For these different image file formats, different steganographic algorithms exist.

Image definition

To a computer, an image is a collection of numbers that constitute different light intensities in different areas of the image . This numeric representation forms a grid and the individual points are referred to as pixels.

Most images on the Internet consists of a rectangular map of the image's pixels (represented as bits) where each pixel is located and its colour . These pixels are displayed horizontally row by row.

The number of bits in a colour scheme, called the bit depth, refers to the number of bits used for each pixel . The smallest bit depth in current colour schemes is 8, meaning that there are 8 bits used to describe the colour of each pixel .

Monochrome and greyscale images use 8 bits for each pixel and are able to display 256 different colours or shades of grey. Digital colour images are typically stored in 24-bit files and use the RGB colour model, also known as true colour .

All colour variations for the pixels of a 24-bit image are derived from three primary colours: red, green and blue, and each primary colour is represented by 8 bits . Thus in one given pixel, there can be 256 different quantities of red, green and blue, adding up to more than 16-million combinations, resulting in more than 16-million colours . Not surprisingly the larger amount of colours that can be displayed, the larger the file size

The development of the software involves a series of production activities where opportunities of human feasibility are enormous.

Errors may begin to occur at the very inception of the process where the objectives maybe erroneously or imperfectly specified as well as in later design and development stages because of the human inability to perform and communicate with perfection. 

A test case is simply a test with formal steps and instructions. They are valuable because they are repeatable, reproducible under the same environments, and easy to improve upon with feedback.

A test case is the difference between saying that something seems to be working ok and proving that a set of specific tasks are known to be working correctly. 

Software testing is a critical element of software quality assurance and represents the ultimate review of specification, design and testing.

Once the source code has been generated, the software must be tested to uncover as many errors as possible before delivery to the customer .Software testing is critical element of software quality assurance and represents the ultimate review of specification design and code generation.

Testing Principles

• All test should be traceable to customer requirements

• Test should be planned large before testing

• Testing should begin in the small and progress towards in the large.

• Testing is the major quality measure employed during the software engineering development. Its basic function is to detect error in the software. Testing is necessary for the proper functioning of the system.

Testing Objectives

• Testing is a process of executing a program with the intention of finding an error .

• A good test case is one that has a high probability of finding an error as yet discovered.

A successful test is one that uncovers an as yet undiscovered error

 

Bug Tracking System

With the strong focus that undergraduate computer science programs are now placing on software engineering there is still one area where students are not exposed to the technology that our colleges in the commercial sector have been embracing for some time.

That area is the implementation and use of bug tracking systems. This paper will discuss the design goals and development of a bug tracking system that is targeted for use by student groups to aid them in managing the development of software projects by minimizing the hassle of tracking bugs in the various versions of the software.

The final system itself allows groups to collect and store various computer anomalies, errors, and problems from the project that they are working on and to be able to effectively document and communicate these bugs to the members of their group in a real-time system.

The paper will examine design choices that were made to create such a system that provides powerful bug tracking abilities to students, while still serving as a gentle introduction to these systems as they are used in commercial software development.

We will also examine the ideal audience for this type of system and talk about its ability to scale to larger groups as the number of communication paths between group members grows.

Finally this paper will examine the benefits of exposing students to this type of software system during their time in school.

Bug tracking systems are a tool used by software developers to enhance the quality of their software products. The automation that bug tracking systems provide allows for efficient monitoring and controlling of reported bugs.

Generally bug tracking systems allow developers and testers to add bugs to a database, provide details about the bugs in the database and make updates to the bugs as progress is made. Along with these features there also features that allow bugs to be assigned to specific developers.

This allows for allows for developers to use the bug tracking system as a to do list when the development cycle enters a maintenance stage.

Finally bug tracking systems allow for the bugs that are entered into them to be prioritized making critical bugs easier to find in the database.

By providing a bug tracking system aimed at students we are giving students a chance to experiment with technology that the industry is currently using, but still have a system that serves as a gentle introduction to the use of bug tracking systems.

The use of a bug tracking system provides groups with an advantage when it come to documenting the system since the bug database serves as a record of the maintenance and improvements that have been made to the software.

The use of a bug tracking system also allows developer to keep track of bugs in a more organized fashion than other methods. Finally, after reviewing currently available bug tracking systems there were none available that were targeted to be used by students as an introduction to using bug tracking systems.

There are many benefits to introducing students to bug tracking systems. Specific to students there is the benefits that exposure to this technology can bring when they enter the work force.

However all developers can receive benefits offered by bug tracking systems like streamlining the bug tracking process, providing repeatable tests, and reducing development time and cost by allowing for improved coordination and communication among team members.

Exposure

One of the most important benefits of introducing this type of knowledge management technology is the exposure that it gives to undergrads. By giving them this exposure before they first enter the workforce they will be familiar with bug tracking systems.

This will be an advantage as when they start new projects there are many other things that they will likely need to be brought up to speed on such as coding standards, libraries, and development environments. Eliminating the need to learn how to use a bug tracking system will allow them to become productive members of the team in a shorter time span.

 

3D Graphics Library for Mobile Applications

The scope of this project is to develop a 3D graphics library for embedded systems like Mobile. The library is created for the basic API’s that will be able to render a 3D moving object into the screen. These sub-sets of API contain the basic operations that are necessary for rendering 3D pictures, games, and movies. The API’s are implemented based on the OpenGLES 1.1 specification.

The activities carried out include Study of OpenGL based on the specifications, study and comparison of OpenGLES with OpenGL, understanding and analysis of the State Variables that depict the various states in the functionality, which is to be added, new architecture & design proposal, design for new architecture & Data Structures, identification of sub-set of APIs, implementation, testing.

The API’s to be implemented were given priority based on the functionality of the API towards rendering the object into the screen, adding color and lighting effects to the object, storing the coordinates of the object.

And finally the movement of the object such as the rotation of the object through an angle in the screen, translating the object in the screen thro a distance and scaling which determines the position in which the object exists in the screen based on the depth buffer values. The coordinates corresponding to the object and the color coordinates corresponding to the RGBA values are stored and then rendered using various state variables.

What is OpenGL?

OpenGL is a software interface to graphics hardware. This interface consists of about 150 distinct commands that you use to specify the objects and operations needed to produce interactive threedimensional applications.

OpenGL is designed as a streamlined, hardware-independent interface to be implemented on many different hardware platforms. To achieve these qualities, no commands for performing windowing tasks or obtaining user input are included in OpenGL.

OpenGL doesn’t provide high-level commands for describing models of three-dimensional objects. These commands might allow you to specify relatively complicated shapes such as automobiles, parts of the body, airplanes, or molecules. With OpenGL, we can build up our desired model from a small set of geometric primitives - points, lines, and polygons.

A sophisticated library that provides these features could certainly be built on top of OpenGL. The OpenGL Utility Library (GLU) provides many of the modeling features, such as quadric surfaces and NURBS curves and surfaces. GLU is a standard part of every OpenGL implementation.

Also, there is a higher-level, object-oriented toolkit, Open Inventor, which is built atop OpenGL, and is available separately for many implementations of OpenGL.

OpenGL Rendering Pipeline

Most implementations of OpenGL have a similar order of operations, a series of processing stages called the OpenGL rendering pipeline. This ordering is shown in the following figure that describes how OpenGL is implemented and provides a reliable guide for predicting what OpenGL will do.

The following diagram shows the Henry Ford assembly line approach, which OpenGL takes to processing data. Geometric data (vertices, lines, and polygons) follow the path through the row of boxes that includes evaluators and per-vertex operations, while pixel data (pixels, images, and bitmaps) are treated differently for part of the process. Both types of data undergo the same final steps (Rasterization and per-fragment operations) before the final pixel data is written into the frame buffer.

Advantages of the proposed system of OpenGLES over the existing system and its Applications

• OpenGL is concerned only with rendering into a framebuffer (and reading values stored in that framebuffer).

• There is no support for other peripherals sometimes associated with graphics hardware, such as mice and keyboards.

• Programmers must rely on other mechanisms to obtain user input. • The GL draws primitives subject to a number of selectable modes. Each primitive is a point, line segment, polygon, or pixel rectangle. Each mode may be changed independently; the setting of one does not affect the settings of others (although many modes may interact to determine what eventually ends up in the framebuffer).

• Modes are set, primitives specified, and other GL operations described by sending commands in the form of function or procedure calls.

• Primitives are defined by a group of one or more vertices. A vertex defines a point, an endpoint of an edge, or a corner of a polygon where two edges meet. Data (consisting of positional coordinates, colors, normals, and texture coordinates) are associated with a vertex and each vertex is processed independently, in order, and in the same way. The only exception to this rule is if the group of vertices must be clipped so that the indicated primitive fits within a specified region; in this case vertex data may be modified and new vertices created. The type of clipping depends on which primitive the group of vertices represents.

• Commands are always processed in the order in which they are received, although there may be an indeterminate delay before the effects of a command are realized. This means, for example, that one primitive must be drawn completely before any subsequent one can affect the framebuffer. It also means that queries and pixel read operations return state consistent with complete execution of all previously invoked GL commands, except where explicitly specified otherwise.