59 research outputs found
Transparent Persistence with Java Data Objects
Flexible and performant Persistency Service is a necessary component of any
HEP Software Framework. The building of a modular, non-intrusive and performant
persistency component have been shown to be very difficult task. In the past,
it was very often necessary to sacrifice modularity to achieve acceptable
performance. This resulted in the strong dependency of the overall Frameworks
on their Persistency subsystems.
Recent development in software technology has made possible to build a
Persistency Service which can be transparently used from other Frameworks. Such
Service doesn't force a strong architectural constraints on the overall
Framework Architecture, while satisfying high performance requirements. Java
Data Object standard (JDO) has been already implemented for almost all major
databases. It provides truly transparent persistency for any Java object (both
internal and external). Objects in other languages can be handled via
transparent proxies. Being only a thin layer on top of a used database, JDO
doesn't introduce any significant performance degradation. Also Aspect-Oriented
Programming (AOP) makes possible to treat persistency as an orthogonal Aspect
of the Application Framework, without polluting it with persistence-specific
concepts.
All these techniques have been developed primarily (or only) for the Java
environment. It is, however, possible to interface them transparently to
Frameworks built in other languages, like for example C++.
Fully functional prototypes of flexible and non-intrusive persistency modules
have been build for several other packages, as for example FreeHEP AIDA and LCG
Pool AttributeSet (package Indicium).Comment: Talk from the 2003 Computing in High Energy and Nuclear Physics
(CHEP03), La Jolla, Ca, USA, March 2003. PSN TUKT00
Creation of Pair Test Online Application
This project researches, analyzes, designs and implements a software application to provide the ability for the PAIR Test to be automated. Currently, the PAIR Test is only available in an offline/manual format. The offline process is not efficient and the data collected does not get stored into a database. The goal of this project is to enable the PAIR Test to become more efficient and have the ability to store results of the testing process into a database for future data analysis. The system will also remove the manual scoring and relationship profile creation by automating this process, resulting in the automatic creation and population of a Portable Document Format (PDF)
The exploration of a category theory-based virtual Geometrical product specification system for design and manufacturing
In order to ensure quality of products and to facilitate global outsourcing, almost all
the so-called âworld-classâ manufacturing companies nowadays are applying various
tools and methods to maintain the consistency of a productâs characteristics
throughout its manufacturing life cycle. Among these, for ensuring the consistency of
the geometric characteristics, a tolerancing language â the Geometrical Product
Specification (GPS) has been widely adopted to precisely transform the functional
requirements from customers into manufactured workpieces expressed as tolerance
notes in technical drawings. Although commonly acknowledged by industrial users as
one of the most successful efforts in integrating existing manufacturing life-cycle
standards, current GPS implementations and software packages suffer from several
drawbacks in their practical use, possibly the most significant, the difficulties in
inferring the data for the âbestâ solutions. The problem stemmed from the foundation
of data structures and knowledge-based system design. This indicates that there need
to be a ânewâ software system to facilitate GPS applications.
The presented thesis introduced an innovative knowledge-based system â the
VirtualGPS â that provides an integrated GPS knowledge platform based on a stable
and efficient database structure with knowledge generation and accessing facilities.
The system focuses on solving the intrinsic product design and production problems
by acting as a virtual domain expert through translating GPS standards and rules into
the forms of computerized expert advices and warnings. Furthermore, this system can
be used as a training tool for young and new engineers to understand the huge amount
of GPS standards in a relative âquickerâ manner.
The thesis started with a detailed discussion of the proposed categorical modelling
mechanism, which has been devised based on the Category Theory. It provided a
unified mechanism for knowledge acquisition and representation, knowledge-based
system design, and database schema modelling. As a core part for assessing this
knowledge-based system, the implementation of the categorical Database
Management System (DBMS) is also presented in this thesis. The focus then moved
on to demonstrate the design and implementation of the proposed VirtualGPS system.
The tests and evaluations of this system were illustrated in Chapter 6. Finally, the
thesis summarized the contributions to knowledge in Chapter 7.
After thoroughly reviewing the project, the conclusions reached construe that the
III
entire VirtualGPS system was designed and implemented to conform to Category
Theory and object-oriented programming rules. The initial tests and performance
analyses show that the system facilitates the geometric product manufacturing
operations and benefits the manufacturers and engineers alike from function designs,
to a manufacturing and verification
Proceedings of the 4th International Conference on Principles and Practices of Programming in Java
This book contains the proceedings of the 4th international conference on principles and practices of programming in Java. The conference focuses on the different aspects of the Java programming language and its applications
Abstraction over non-local object information in aspect-oriented programming using path expression pointcuts
Aspect-oriented software development (AOSD) consists of a number of technologies that promise a better level of modularization of concerns
that cannot be separated in individual modules by using conventional
techniques. Aspect-oriented programming (AOP) is one of these technologies. It allows the modularization at the level of software
application code. It provides programmers with means to quantify over specific points in the base application code, called join points, at which the crosscutting concern code must be triggered. The quantification is achieved by special selection constructs called pointcuts, while the triggered code that is responsible for adapting the selected join point is provided by special construct called advice. The selection and adaptation mechanisms in aspect-oriented programming depend heavily on the distinguishing properties of the join points. These properties can either be derived from the local execution context at the join point or they are considered to be non-local to the join point. Aspect-oriented systems provide a plenty of pointcut constructs that support accessing the local join point properties, while they rarely support the non-local properties.
A large research effort has been achieved to extend current aspectoriented systems in order to solve the problem of non-locality. However, none of these proposals support the non-local object relationships. There are many situations where a good abstraction over nonlocal object information is needed, otherwise, the developers will be obliged to provide complex and error-prone workarounds inside advice body that conceptually do not reflect the semantics of join point selection and mix it with the semantics of join point daptation. Such recurrent situations occur when trying to modularize the object persistence concern. Object persistence, the process of storing and retrieving objects to and from the datastore, is a classical example of crosscutting concern. Orthogonal object persistence meets the obliviousness property of AOP: The base code should not be prepared upfront for persistence. This thesis addresses the shortcomings in current aspect-oriented persistence systems. It shows that the reason for such shortcomings is due to the lack of supporting non-local object information by the used aspect-oriented languages. To overcome this problem, this thesis proposes a new extension to the current pointcut languages called path expression pointcuts that operate on object graphs and make relevant object information available to the aspects. As an explicit and complete construct, a formal semantics and type system have provided. Moreover, an implementation of path expression pointcuts is discussed in the thesis along with its usage to show how the aforementioned problems are resolved
Spray: programming with a persistent distributed heap
We introduce a programming paradigm for distributed applications based on a persistent distributed heap. A proof-of-concept implementation is provided as a Javascript library, together with several examples that embody popular patterns for web applications
An Event Monitor and Response Framework Based on the WSLogA Architecture
Web services provide organizations with a powerful infrastructure by which information and products may be distributed, but the task of supporting Web service systems can be difficult due to the complex nature of environment configuration and operation. Tools are needed to monitor and analyze such Enterprise environments so that appropriate engineering, quality control, or business activities can be pursued.
This investigation resulted in the development of a software development kit, the WSLogA Framework, which is inspired by the vision of Cruz et al. (2003, 2004). The WSLogA Framework provides distributed Enterprise systems with a platform for comprehensive information capture and environment management. Five component groups are intended for employment to enable integrated workflows addressing monitoring and response activities, but these components may also be used individually to facilitate the phased integration of the WSLogA Framework into existing environments. The WSLogA Framework\u27s design is portable across technology platforms (e.g., Java and .NET) and a variety of technologies may be substituted for the provided implementations to address unique system architectures.
The WSLogA Framework supersedes existing logging and monitoring solutions in terms of both capability and intent. Applications based on the WSLogA Framework have an internal, real-time view of their operation and may adjust their environment based on the information provided by events related to their or system activities. The WSLogA Framework is intended as a software development kit around which system functionality may be organized and implemented, which makes the WSLogA Framework an architectural peer or complement to traditional application frameworks such as Spring\u27s Web module. WSLogA Framework based systems should be envisioned as information appliance elements rather than traditionally scoped applications or services
Towards Process Support for Migrating Applications to Cloud Computing
Cloud computing is an active area of research for industry and academia. There are a large number of organizations providing cloud computing infrastructure and services. In order to utilize these infrastructure resources and services, existing applications need to be migrated to clouds. However, a successful migration effort needs well-defined process support. It does not only help to identify and address challenges associated with migration but also provides a strategy to evaluate different platforms in relation to application and domain specific requirements. This paper present a process framework for supporting migration to cloud computing based on our experiences from migrating an Open Source System (OSS), Hackystat, to two different cloud computing platforms. We explained the process by performing a comparative analysis of our efforts to migrate Hackystate to Amazon Web Services and Google App Engine. We also report the potential challenges, suitable solutions, and lesson learned to support the presented process framework. We expect that the reported experiences can serve guidelines for those who intend to migrate software applications to cloud computing.Muhammad Aufeef Chauhan, Muhammad Ali Baba
- âŠ