7,502 research outputs found
A heuristic-based approach to code-smell detection
Encapsulation and data hiding are central tenets of the object oriented paradigm. Deciding what data and behaviour to form into a class and where to draw the line between its public and private details can make the difference between a class that is an understandable, flexible and reusable abstraction and one which is not. This decision is a difficult one and may easily result in poor encapsulation which can then have serious implications for a number of system qualities. It is often hard to identify such encapsulation problems within large software systems until they cause a maintenance problem (which is usually too late) and attempting to perform such analysis manually can also be tedious and error prone. Two of the common encapsulation problems that can arise as a consequence of this decomposition process are data classes and god classes. Typically, these two problems occur together – data classes are lacking in functionality that has typically been sucked into an over-complicated and domineering god class. This paper describes the architecture of a tool which automatically detects data and god classes that has been developed as a plug-in for the Eclipse IDE. The technique has been evaluated in a controlled study on two large open source systems which compare the tool results to similar work by Marinescu, who employs a metrics-based approach to detecting such features. The study provides some valuable insights into the strengths and weaknesses of the two approache
A Model-Driven Architecture Approach to the Efficient Identification of Services on Service-oriented Enterprise Architecture
Service-Oriented Enterprise Architecture requires the efficient development of loosely-coupled and interoperable sets of services. Existing design approaches do not always take full advantage of the value and importance of the engineering invested in existing legacy systems. This paper proposes an approach to define the key services from such legacy systems effectively. The approach focuses on identifying these services based on a Model-Driven Architecture approach supported by guidelines over a wide range of possible service types
Object-oriented modelling with unified modelling language 2.0 for simple software application based on agile methodology
Unified modelling language (UML) 2.0 introduced in 2002 has been developing
and influencing object-oriented software engineering and has become a standard
and reference for information system analysis and design modelling. There are
many concepts and theories to model the information system or software
application with UML 2.0, which can make ambiguities and inconsistencies for a
novice to learn to how to model the system with UML especially with UML 2.0.
This article will discuss how to model the simple software application by using
some of the diagrams of UML 2.0 and not by using the whole diagrams as
suggested by agile methodology. Agile methodology is considered as convenient
for novices because it can deliver the information technology environment to
the end-user quickly and adaptively with minimal documentation. It also has the
ability to deliver best performance software application according to the
customer's needs. Agile methodology will make simple model with simple
documentation, simple team and simple tools.Comment: 15 pages, 30 figure
Aspect-oriented interaction in multi-organisational web-based systems
Separation of concerns has been presented as a promising tool to tackle the design of complex systems in which
cross-cutting properties that do not fit into the scope of a class must be satisfied. Unfortunately, current proposals
assume that objects interact by means of object-oriented method calls, which implies that they embed interactions with
others into their functional code. This makes them dependent on this interaction model, and makes it difficult to reuse
them in a context in which another interaction model is more suited, e.g., tuple spaces, multiparty meetings, ports, and
so forth. In this paper, we show that functionality can be described separately from the interaction model used, which
helps enhance reusability of functional code and coordination patterns. Our proposal is innovative in that it is the first
that achieves a clear separation between functionality and interaction in an aspect-oriented manner. In order to show
that it is feasible, we adapted the multiparty interaction model to the context of multiorganisational web-based systems
and developed a class framework to build business objects whose performance rates comparably to handmade implementations;
the development time, however, decreases significantly.ComisiĂłn Interministerial de Ciencia y TecnologĂa TIC2000-1106-C02-0
Ontological Representations of Software Patterns
This paper is based on and advocates the trend in software engineering of
extending the use of software patterns as means of structuring solutions to
software development problems (be they motivated by best practice or by company
interests and policies). The paper argues that, on the one hand, this
development requires tools for automatic organisation, retrieval and
explanation of software patterns. On the other hand, that the existence of such
tools itself will facilitate the further development and employment of patterns
in the software development process. The paper analyses existing pattern
representations and concludes that they are inadequate for the kind of
automation intended here. Adopting a standpoint similar to that taken in the
semantic web, the paper proposes that feasible solutions can be built on the
basis of ontological representations.Comment: 7 page
- …