Semantic annotation, publication, and discovery of Java software components: an integrated approach

Component-based software development has matured into standard practice in software engineering. Among the advantages of reusing software modules are lower costs, faster development, more manageable code, increased productivity, and improved software quality. As the number of available software components has grown, so has the need for effective component search and retrieval. Traditional search approaches, such as keyword matching, have proved ineffective when applied to software components. Applying a semantically- enhanced approach to component classification, publication, and discovery can greatly increase the efficiency of searching and retrieving software components. This has been already applied in the context of Web technologies, and Web services in particular, in the frame of Semantic Web Services research. This paper examines the similarities between software components and Web services and adapts an existing Semantic Web Service publication and discovery solution into a software component annotation and discovery tool which is implemented as an Eclipse plug-in

The theory of classification part 5: axioms, assertions and subtyping

The algebraic calculus for reasoning about the complete behavior of object types and the effects of axioms upon subtyping were analyzed. The translation of pure algebra into a piecemeal treatment in terms of variants, pre-, and post conditions was studied. The existing object subtyping rules were applied to derive subtyping rules governing the strengthening, or weakening of the assertions as there was a direct relationship between axiom strengthening, and subtyping. It was found that weaker preconditions co-existed with stronger invariants, and the same system satisfied the stronger of the two

The theory of classification part 12: building the class hierarchy

The construction of specific object instances and the development of simple class hierarchy are discussed. The class hierarchy development includes recognizable classes, with mixtures of default, abstract and concrete methods. Generators that are extended into flexible object creation functions with initialization values passed to superclass functions, mimicking the behavior of real object-oriented languages. It is shown that the classes that are derived by inheritance give rise to objects of exact types, which match the expected interfaces of their superclasses and the separately-declared interfaces

The theory of classification part 19: the proliferation of parameters

We consider in more detail the kinds of manipulations performed upon polymorphic class-types. These are expressed using function-bounded type parameters of the form: ? <: F[?], where F is a type function, describing the shape of the interface that the type

The theory of classification part 13: template classes and genericity

The object-oriented type theory for non-specialists is discussed. It is shown that how parametric polymorphism, known as templates in C++ and genericity in Ada and Eiffel, can be added to the Theory of Classification. The generic types could be created by abstracting over parts of simple types. A generic type is modeled as a type function expecting an actual type argument

The theory of classification: part 14: modification and objects like myself

The Theory of Classification to handle constructor-methods, through the use of which an object can create another object 'like itself', was discussed. It need implementations of List-methods like cons, heads and tail to manipulate the multimaps, which were essentially association lists with duplicate keys. A sequence of model state updates was modelled as a nested series of method invocations. The constructor-level recursion was a generally useful feature used in the theory for the definition of more complex kinds of datatype

The theory of classification part 20: modular checking of classtypes

A first-order type system has two things to commend it. Firstly, it is quite simple to implement a type-checker that can check types for exact correspondence, or for subtype compatibility with a given type. The type of the source object can be compared with that of the target variable to see if the former can be converted up to the latter, using subtyping rules like those we discussed in [1]. Secondly, code that has been checked once need never be checked again, or recompiled in new contexts. This is because the type system can never reveal more specific information about an object that is passed into a more general variable (which we have called the “type loss problem”), so the code need only be checked once over the most general type that it can accept