85,275 research outputs found
Type System for the ComponentJ Programming Language
Dissertação apresentada na Faculdade de Ciências e Tecnologia da Universidade Nova de Lisboa para a obtenção do grau de Mestre em Engenharia Informática.With the constant evolution of software systems need arises for more structured implementations,
where processes like software updates and changes in systems can be
easily made, with no need to change what had previously been implemented. One possible
solution to this problem is the use of component-based programming languages.
This kind of programming languages tries to promote not only code reuse but also a
black-box discipline where it is not needed how a service is implemented, but only its
interface so that it can be used.
The ComponentJ programming language seeks to provide a simple way to perform
component creation and composition, making this new programming paradigm somewhat
easy to use. Because ComponentJ is meant to be an extension to the Java programming
language it becomes possible to implement components using the whole
expressiveness of this language. It is also possible, in ComponentJ, to dynamically
change components and the object structure based on runtime decisions. This dynamic
reconfiguration process allows, for instance, to perform changes/updates to a certain
software system without having to stop its execution.
The goal for this project is to implement a type system for the ComponentJ programming
language, based on the work presented in [32, 28]. Type verification is
syntax driven, and uses structural equivalence of types. Advanced techniques such
as subtyping and type inference are also included in order to make the language more
flexible. Besides the static type checker, a dynamic checker is also included, allowing
the type safe application of runtime changes to the system (dynamic reconfiguration
of objects) before their application
Recommended from our members
A software classification scheme
Reusing code is one approach to software reusability. Code is the end product of the software lifecycle. It is delivered in a low level representation that is difficult to reuse unless an almost perfect match exists between available features and required specifications. There is a need to organize large inventories of software such that reusable code is easy to locate and exchange. The relative success in the reuse of code fragments reported by some software factories is due in part to their capacity to encapsulate domain specific functions and create specialized libraries of components classified by these locally standardized functions.A general software classification scheme that organizes reusability related attributes and common functions from different domains is proposed as a partial solution to the software reusability problem. For the problem of selecting from similar, potentially reusable. components, a partial solution based on evaluation of common characteristics is also proposed. A library system is presented that integrates the proposed classification scheme with an evaluation mechanism based on inherent component attributes, programming languages characteristics and reuser experience.The fundamental contribution of this dissertation is a formal treatment of a faceted scheme for software classification leading to better understanding of reusability at the code level. This approach has been prototyped in a library system for the semi-automatic classification of software components. Analysis were performed to evaluate the classification scheme. The results show the potential of the scheme in organizing collections of code fragments, in improving retrieval, and in simplifying the classification process. Tests of the evaluation mechanism showed positive correlation with evaluations conducted by potential reusers
Evolution of a Modular Software Network
"Evolution behaves like a tinkerer" (Francois Jacob, Science, 1977). Software
systems provide a unique opportunity to understand biological processes using
concepts from network theory. The Debian GNU/Linux operating system allows us
to explore the evolution of a complex network in a novel way. The modular
design detected during its growth is based on the reuse of existing code in
order to minimize costs during programming. The increase of modularity
experienced by the system over time has not counterbalanced the increase in
incompatibilities between software packages within modules. This negative
effect is far from being a failure of design. A random process of package
installation shows that the higher the modularity the larger the fraction of
packages working properly in a local computer. The decrease in the relative
number of conflicts between packages from different modules avoids a failure in
the functionality of one package spreading throughout the entire system. Some
potential analogies with the evolutionary and ecological processes determining
the structure of ecological networks of interacting species are discussed.Comment: To appear in PNA
Recommended from our members
Reusability in software engineering
This paper surveys recent work concerning reusability in software engineering. The current directions in software reusability are discussed, and the two major approaches of reusable building blocks and reusable patterns studied. An extensive bibliography, parts of which are annotated, is included
Building object-oriented software with the D-Bus messaging system
Object-oriented programming is a widely adopted paradigm for desktop software development.
This paradigm partitions software into separate entities, objects, which consist
of data and related procedures used to modify and inspect it. The paradigm has evolved
during the last few decades to emphasize decoupling between object implementations, via
means such as explicit interface inheritance and event-based implicit invocation.
Inter-process communication (IPC) technologies allow applications to interact with each
other. This enables making software distributed across multiple processes, resulting in a
modular architecture with benefits in resource sharing, robustness, code reuse and security.
The support for object-oriented programming concepts varies between IPC systems.
This thesis is focused on the D-Bus system, which has recently gained a lot of users, but
is still scantily researched. D-Bus has support for asynchronous remote procedure calls
with return values and a content-based publish/subscribe event delivery mechanism.
In this thesis, several patterns for method invocation in D-Bus and similar systems are
compared. The patterns that simulate synchronous local calls are shown to be dangerous.
Later, we present a state-caching proxy construct, which avoids the complexity of
properly asynchronous calls for object inspection. The proxy and certain supplementary
constructs are presented conceptually as generic object-oriented design patterns. The
e ect of these patterns on non-functional qualities of software, such as complexity, performance
and power consumption, is reasoned about based on the properties of the D-Bus
system. The use of the patterns reduces complexity, but maintains the other qualities at a
good level.
Finally, we present currently existing means of specifying D-Bus object interfaces for the
purposes of code and documentation generation. The interface description language used
by the Telepathy modular IM/VoIP framework is found to be an useful extension of the
basic D-Bus introspection format.Siirretty Doriast
Generic programming in the mCRL2 toolset
The mCRL2 tool set [GKM+08] is a tool set for verification and validation of concurrent processes, based on process algebra speci??cations. The mCRL2 language is based on the Algebra of Communicating Processes (ACP), which is extended to include data and time. This paper reports on experiences with generic programming in C++ as applied in the implementation of the tool set. C++ concepts, a type system for templates [RS06], form a key ingredient of this style of programming. Using concept definitions, requirements on template types can be defined that are type checked during compile time. The main benefits for the mCRL2 tool set are uniform and exible interfaces that operate on well-defined types, and a signi??cant increase in code reuse. The use of concepts also promotes the writing of code that corresponds closely to pseudo code, since the chosen concepts correspond naturally with domain specific concepts. This will be illustrated by a simple use case, namely substitution functions. Generic programming is about generalizing software components, to enable reuse in a wide variety of situations. In C++, generic programming is enabled using templates. C++ concepts are proposed as a means to type check template types. A concept is a set of requirements (valid expressions, associated types, semantic invariants, complexity guarantees, and so on) that a type must fulfill to be correctly used as an argument in a call to a generic algorithm, see [RS06]. Language support for concepts has been proposed [GJS+06] for the next version of the C++ standard, C++0x. Concepts will be used to make the specification of the C++ standard library more complete and precise. A derivative of the GNU C++ compiler [Gre08] already implements language support for concepts. In the mCRL2 tool set we have used a portable library for concept checking. Most uses of generic programming in general, and more specifically the use of concepts, that are described in the literature treat the construction of data structures and algorithms that operate on these, see e.g. [GL05]
Reusable Knowledge-based Components for Building Software Applications: A Knowledge Modelling Approach
In computer science, different types of reusable components for building software applications were proposed as a direct consequence of the emergence of new software programming paradigms. The success of these components for building applications depends on factors such as the flexibility in their combination or the facility for their selection in centralised or distributed environments such as internet. In this article, we propose a general type of reusable component, called primitive of representation, inspired by a knowledge-based approach that can promote reusability. The proposal can be understood as a generalisation of existing partial solutions that is applicable to both software and knowledge engineering for the development of hybrid applications that integrate conventional and knowledge based techniques. The article presents the structure and use of the component and describes our recent experience in the development of real-world applications based on this approach
- …