Abstract: Animated graph gives some good impressions in
presenting information. However, not many people are able to produce it because the process of generating an animated graph requires some technical skills. This work presents Content
Management System with Animated Graph (CMS-AG). It is a webbased system enabling users to produce an effective and interactive
graphical report in a short time period. It allows for three levels of user authentication, provides update profile, account management, template management, graph management, and track changes. The system development applies incremental development approach, object-oriented concepts and Web programming technologies. The design architecture promotes new technology of reporting. It also helps user cut off unnecessary expenses, save time and learn new things on different levels of users. In this paper, the developed system is described.
Abstract: An application framework provides a reusable design
and implementation for a family of software systems. Application
developers extend the framework to build their particular
applications using hooks. Hooks are the places identified to show
how to use and customize the framework. Hooks define the
Framework Interface Classes (FICs) and the specifications of their
methods. As part of the development life cycle, it is required to test
the implementations of the FICs. Building a testing model to express
the behavior of a class is an essential step for the generation of the
class-based test cases. The testing model has to be consistent with the
specifications provided for the hooks. State-based models consisting
of states and transitions are testing models well suited to objectoriented
software. Typically, hand-construction of a state-based
model of a class behavior is expensive, error-prone, and may result in
constructing an inconsistent model with the specifications of the class
methods, which misleads verification results. In this paper, a
technique is introduced to automatically synthesize a state-based
testing model for FICs using the specifications provided for the
hooks. A tool that supports the proposed technique is introduced.
Abstract: Design Patterns have gained more and more
acceptances since their emerging in software development world last
decade and become another de facto standard of essential knowledge
for Object-Oriented Programming developers nowadays.
Their target usage, from the beginning, was for regular computers,
so, minimizing power consumption had never been a concern.
However, in this decade, demands of more complicated software for
running on mobile devices has grown rapidly as the much higher
performance portable gadgets have been supplied to the market
continuously. To get along with time to market that is business
reason, the section of software development for power conscious,
battery, devices has shifted itself from using specific low-level
languages to higher level ones. Currently, complicated software
running on mobile devices are often developed by high level
languages those support OOP concepts. These cause the trend of
embracing Design Patterns to mobile world.
However, using Design Patterns directly in software development
for power conscious systems is not recommended because they were
not originally designed for such environment. This paper
demonstrates the adapted Design Pattern for power limitation system.
Because there are numerous original design patterns, it is not possible
to mention the whole at once. So, this paper focuses only in creating
Energy Conscious version of existing regular "Builder Pattern" to be
appropriated for developing low power consumption software.
Abstract: The aim of a biological model is to understand the
integrated structure and behavior of complex biological systems as a
function of the underlying molecular networks to achieve simulation
and forecast of their operation. Although several approaches have
been introduced to take into account structural and environment
related features, relatively little attention has been given to represent
the behavior of biological systems. The Abstract Biological Process
(ABP) model illustrated in this paper is an object-oriented model
based on UML (the standard object-oriented language). Its main
objective is to bring into focus the functional aspects of the
biological system under analysis.
Abstract: The present paper is oriented to problems of simulation of anticipatory systems, namely those that use simulation models for the aid of anticipation. A certain analogy between use of simulation and imagining will be applied to make the explication more comprehensible. The paper will be completed by notes of problems and by some existing applications. The problems consist in the fact that simulation of the mentioned anticipatory systems end is simulation of simulating systems, i.e. in computer models handling two or more modeled time axes that should be mapped to real time flow in a nondescent manner. Languages oriented to objects, processes and blocks can be used to surmount the problems.
Abstract: An application framework provides a reusable design
and implementation for a family of software systems. Application
developers extend the framework to build their particular
applications using hooks. Hooks are the places identified to show
how to use and customize the framework. Hooks define the
Framework Interface Classes (FICs) and their possible specifications,
which helps in building reusable test cases for the implementations of
these classes. This paper introduces a novel technique called all
paths-state to generate state-based test cases to test the FICs at class
level. The technique is experimentally evaluated. The empirical
evaluation shows that all paths-state technique produces test cases
with a high degree of coverage for the specifications of the
implemented FICs comparing to test cases generated using round-trip
path and all-transition techniques.
Abstract: A key aspect of the design of any software system is
its architecture. An architecture description provides a formal model
of the architecture in terms of components and connectors and how
they are composed together. COSA (Component-Object based
Software Structures), is based on object-oriented modeling and
component-based modeling. The model improves the reusability by
increasing extensibility, evolvability, and compositionality of the
software systems. This paper presents the COSA modelling tool
which help architects the possibility to verify the structural coherence
of a given system and to validate its semantics with COSA approach.
Abstract: The most influential programming paradigm today
is object oriented (OO) programming and it is widely used in
education and industry. Recognizing the importance of equipping
students with OO knowledge and skills, it is not surprising that most
Computer Science degree programs offer OO-related courses. How
do we assess whether the students have acquired the right objectoriented
skills after they have completed their OO courses? What are
object oriented skills? Currently none of the current assessment
techniques would be able to provide this answer. Traditional forms of
OO programming assessment provide a ways for assigning numerical
scores to determine letter grades. But this rarely reveals information
about how students actually understand OO concept. It appears
reasonable that a better understanding of how to define and assess
OO skills is needed by developing a criterion referenced model. It is
even critical in the context of Malaysia where there is currently a
growing concern over the level of competency of Malaysian IT
graduates in object oriented programming. This paper discussed the
approach used to develop the criterion-referenced assessment model.
The model can serve as a guideline when conducting OO
programming assessment as mentioned. The proposed model is
derived by using Goal Questions Metrics methodology, which helps
formulate the metrics of interest. It concluded with a few suggestions
for further study.
Abstract: This paper aims at improving web server performance
by establishing a middleware layer between web and database
servers, which minimizes the overload on the database server. A
middleware system has been developed as a service mainly to
improve the performance. This system manages connection accesses
in a way that would result in reducing the overload on the database
server. In addition to the connection management, this system acts as
an object-oriented model for best utilization of operating system
resources. A web developer can use this Service Broker to improve
web server performance.
Abstract: Concurrency and synchronization are becoming big
issues as every new PC comes with multi-core processors. A major
reason for Object-Oriented Programming originally was to enable
easier reuse: encode your algorithm into a class and thoroughly
debug it, then you can reuse the class again and again. However,
when we get to concurrency and synchronization, this is often not
possible. Thread-safety issues means that synchronization constructs
need to be entangled into every class involved. We contributed a
detailed literature review of issues and challenges in concurrent
programming and present a methodology that uses the Aspect-
Oriented paradigm to address this problem. Aspects will allow us to
extract the synchronization concerns as schemes to be “weaved in"
later into the main code. This allows the aspects to be separately
tested and verified. Hence, the functional components can be weaved
with reusable synchronization schemes that are robust and scalable.
Abstract: In this paper we present a way of controlling the
concurrent access to data in a distributed application using the
Pessimistic Offline Lock design pattern. In our case, the application
processes a complex entity, which contains in a hierarchical structure
different other entities (objects). It will be shown how the complex
entity and the contained entities must be locked in order to control
the concurrent access to data.
Abstract: Software maintenance and mainly software
comprehension pose the largest costs in the software lifecycle. In
order to assess the cost of software comprehension, various
complexity measures have been proposed in the literature. This paper
proposes new cognitive-spatial complexity measures, which combine
the impact of spatial as well as architectural aspect of the software to
compute the software complexity. The spatial aspect of the software
complexity is taken into account using the lexical distances (in
number of lines of code) between different program elements and the
architectural aspect of the software complexity is taken into
consideration using the cognitive weights of control structures
present in control flow of the program. The proposed measures are
evaluated using standard axiomatic frameworks and then, the
proposed measures are compared with the corresponding existing
cognitive complexity measures as well as the spatial complexity
measures for object-oriented software. This study establishes that the
proposed measures are better indicators of the cognitive effort
required for software comprehension than the other existing
complexity measures for object-oriented software.
Abstract: The ability of the brain to organize information and generate the functional structures we use to act, think and communicate, is a common and easily observable natural phenomenon. In object-oriented analysis, these structures are represented by objects. Objects have been extensively studied and documented, but the process that creates them is not understood. In this work, a new class of discrete, deterministic, dissipative, host-guest dynamical systems is introduced. The new systems have extraordinary self-organizing properties. They can host information representing other physical systems and generate the same functional structures as the brain does. A simple mathematical model is proposed. The new systems are easy to simulate by computer, and measurements needed to confirm the assumptions are abundant and readily available. Experimental results presented here confirm the findings. Applications are many, but among the most immediate are object-oriented engineering, image and voice recognition, search engines, and Neuroscience.
Abstract: The changing economic climate has made global
manufacturing a growing reality over the last decade, forcing
companies from east and west and all over the world to
collaborate beyond geographic boundaries in the design,
manufacture and assemble of products. The ISO10303 and
ISO14649 Standards (STEP and STEP-NC) have been
developed to introduce interoperability into manufacturing
enterprises so as to meet the challenge of responding to
production on demand. This paper describes and illustrates a
STEP compliant CAD/CAPP/CAM System for the manufacture
of rotational parts on CNC turning centers. The information
models to support the proposed system together with the data
models defined in the ISO14649 standard used to create the NC
programs are also described. A structured view of a STEP
compliant CAD/CAPP/CAM system framework supporting the
next generation of intelligent CNC controllers for turn/mill
component manufacture is provided. Finally a proposed
computational environment for a STEP-NC compliant system
for turning operations (SCSTO) is described. SCSTO is the
experimental part of the research supported by the specification
of information models and constructed using a structured
methodology and object-oriented methods. SCSTO was
developed to generate a Part 21 file based on machining
features to support the interactive generation of process plans
utilizing feature extraction. A case study component has been
developed to prove the concept for using the milling and turning
parts of ISO14649 to provide a turn-mill CAD/CAPP/CAM
environment.
Abstract: Object-oriented simulation is considered one of the most sophisticated techniques that has been widely used in planning, designing, executing and maintaining construction projects. This technique enables the modeler to focus on objects which is extremely important for thorough understanding of a system. Thus, identifying an object is an essential point of building a successful simulation model. In a maintenance process an object is a maintenance work order (MWO). This study demonstrates a maintenance simulation model for the building maintenance division of Saudi Consolidated Electric Company (SCECO) in Dammam, Saudi Arabia. The model focused on both types of maintenance processes namely: (1) preventive maintenance (PM) and (2) corrective maintenance (CM). It is apparent from the findings that object-oriented simulation is a good diagnostic and experimental tool. This is because problems, limitations, bottlenecks and so forth are easily identified. These features are very difficult to obtain when using other tools.
Abstract: Testable software has two inherent properties – observability and controllability. Observability facilitates observation of internal behavior of software to required degree of detail. Controllability allows creation of difficult-to-achieve states prior to execution of various tests. In this paper, we describe COTT, a Controllability and Observability Testing Tool, to create testable object-oriented software. COTT provides a framework that helps the user to instrument object-oriented software to build the required controllability and observability. During testing, the tool facilitates creation of difficult-to-achieve states required for testing of difficultto- test conditions and observation of internal details of execution at unit, integration and system levels. The execution observations are logged in a test log file, which are used for post analysis and to generate test coverage reports.
Abstract: Object-oriented programming is a wonderful way to
make programming of huge real life tasks much easier than by using
procedural languages. In order to teach those ideas to students, it
is important to find a good task that shows the advantages of OOprogramming
very naturally. This paper gives an example, the game
Battleship, which seems to work excellent for teaching the OO ideas
(using Java, [1], [2], [3], [4]).
A three-step task is presented for how to teach OO-programming
using just one example suitable to convey many of the OO ideas.
Observations are given at the end and conclusions about how the
whole teaching course worked out.
Abstract: The traditional software product and process metrics
are neither suitable nor sufficient in measuring the complexity of
software components, which ultimately is necessary for quality and
productivity improvement within organizations adopting CBSE.
Researchers have proposed a wide range of complexity metrics for
software systems. However, these metrics are not sufficient for
components and component-based system and are restricted to the
module-oriented systems and object-oriented systems. In this
proposed study it is proposed to find the complexity of the JavaBean
Software Components as a reflection of its quality and the component
can be adopted accordingly to make it more reusable. The proposed
metric involves only the design issues of the component and does not
consider the packaging and the deployment complexity. In this way,
the software components could be kept in certain limit which in turn
help in enhancing the quality and productivity.
Abstract: The paper proposes a new concept in developing
collaborative design system. The concept framework involves
applying simulation of supply chain management to collaborative
design called – 'SCM–Based Design Tool'. The system is developed
particularly to support design activities and to integrate all facilities
together. The system is aimed to increase design productivity and
creativity. Therefore, designers and customers can collaborate by the
system since conceptual design. JAG: Jewelry Art Generator based
on artificial intelligence techniques is integrated into the system.
Moreover, the proposed system can support users as decision tool
and data propagation. The system covers since raw material supply
until product delivery. Data management and sharing information are
visually supported to designers and customers via user interface. The
system is developed on Web–assisted product development
environment. The prototype system is presented for Thai jewelry
industry as a system prototype demonstration, but applicable for
other industry.
Abstract: An application framework provides a reusable design
and implementation for a family of software systems. Frameworks
are introduced to reduce the cost of a product line (i.e., a family of
products that shares the common features). Software testing is a timeconsuming
and costly ongoing activity during the application
software development process. Generating reusable test cases for the
framework applications during the framework development stage,
and providing and using the test cases to test part of the framework
application whenever the framework is used reduces the application
development time and cost considerably. This paper introduces the
Framework Interface State Transition Tester (FIST2), a tool for
automated unit testing of Java framework applications. During the
framework development stage, given the formal descriptions of the
framework hooks, the specifications of the methods of the
framework-s extensible classes, and the illegal behavior description
of the Framework Interface Classes (FICs), FIST2 generates unitlevel
test cases for the classes. At the framework application
development stage, given the customized method specifications of
the implemented FICs, FIST2 automates the use, execution, and
evaluation of the already generated test cases to test the implemented
FICs. The paper illustrates the use of the FIST2 tool for testing
several applications that use the SalesPoint framework.