Object-Agent Oriented Programming

Object-oriented programming has been used for building intelligent agents, with the limitation it cannot represent complex mental attitudes. With logic programming it is possible to represent and infer relationships among mental attitudes such as intentions, goals and beliefs, with limitations in the usage of capabilities of action. This paper presents two alternatives for integrating object- oriented with logic programming, which enable agent programming. Java and Smalltalk have been used for providing one typed and another non-typed integration with Prolog.Sociedad Argentina de Informática e Investigación Operativ

Supporting Reengineering Scenarios with FETCH: an Experience Report

The exploration and analysis of large software systems is a labor-intensive activity in need of tool support. In recent years, a number of tools have been developed that provide key functionality for standard reverse engineering scenarios, such as (i) metric analysis; (ii) anti-pattern detection; (iii) dependency analysis; and (iv) visualization. However, either these tools support merely a subset of this list of scenarios, they are not made available to the research community for comparison or extension, or they impose strict restrictions on the source code. Accordingly, we observe a need for an extensible and robust open source alternative, which we present in this paper. Our main contributions are (i) a clarification of useful reverse engineering scenarios; (ii) a comparison among existing solutions; and (iii) an experience report on four recent cases illustrating the usefulness of tool support for these scenarios in an industrial setting

Proceedings of the Third Symposium on Programming Languages and Software Tools : Kääriku, Estonia, August 23-24 1993

http://www.ester.ee/record=b1064507*es

JAVA DESIGN PATTERN OBFUSCATION

Software Reverse Engineering (SRE) consists of analyzing the design and imple- mentation of software. Typically, we assume that the executable file is available, but not the source code. SRE has many legitimate uses, including analysis of software when no source code is available, porting old software to a modern programming language, and analyzing code for security vulnerabilities. Attackers also use SRE to probe for weaknesses in closed-source software, to hack software activation mecha- nisms (or otherwise change the intended function of software), to cheat at games, etc. There are many tools available to aid the aspiring reverse engineer. For example, there are several tools that recover design patterns from Java byte code or source code. In this project, we develop and analyze a technique to obfuscate design patterns. We show that our technique can defeat design pattern detection tools, thereby making reverse engineering attacks more difficult

Generating a Catalog of Unanticipated Schemas in Class Hierarchies using Formal Concept Analysis

International audienceContext: Inheritance is the cornerstone of object-oriented development, supporting conceptual modeling, subtype polymorphism and software reuse. But inheritance can be used in subtle ways that make complex systems hard to understand and extend, due to the presence of implicit dependencies in the inheritance hierarchy. Objective: Although these dependencies often specify well-known schemas (i.e., recurrent design or coding patterns, such as hook and template methods), new unanticipated dependency schemas arise in practice, and can consequently be hard to recognize and detect. Thus, a developer making changes or extensions to an object-oriented system needs to understand these implicit contracts defined by the dependencies between a class and its subclasses, or risk that seemingly innocuous changes break them. Method: To tackle this problem, we have developed an approach based on Formal Concept Analysis. Our FoCARE methodology (Formal Concept Analysis based-Reverse Engineering) identifies undocumented hi- erarchical dependencies in a hierarchy by taking into account the existing structure and behavior of classes and subclasses. Results: We validate our approach by applying it to a large and non-trivial case study, yielding a catalog of Hierarchy Schemas, each one composed of a set of dependencies over methods and attributes in a class hierarchy. We show how the discovered dependency schemas can be used not only to identify good design practices, but also to expose bad smells in design, thereby helping developers in initial reengineering phases to develop a first mental model of a system. Although some of the identified schemas are already documented in existing literature, with our approach based on Formal Concept Analysis (FCA), we are also able to identify previously unidentified schemas

A Programming Environment Evaluation Methodology for Object-Oriented Systems

The object-oriented design strategy as both a problem decomposition and system development paradigm has made impressive inroads into the various areas of the computing sciences. Substantial development productivity improvements have been demonstrated in areas ranging from artificial intelligence to user interface design. However, there has been very little progress in the formal characterization of these productivity improvements and in the identification of the underlying cognitive mechanisms. The development and validation of models and metrics of this sort require large amounts of systematically-gathered structural and productivity data. There has, however, been a notable lack of systematically-gathered information on these development environments. A large part of this problem is attributable to the lack of a systematic programming environment evaluation methodology that is appropriate to the evaluation of object-oriented systems

Semantic modelling for discrete event simulation.

Discrete event simulation modelling has been established as an important tool for management planning. This process has been aided by the availability of off-the-shelf simulation systems for microcomputers. Traditionally these have had text-based interfaces and very limited graphics. As the availability of powerful colour microcomputers have increased, graphical front-ends have been added. As clients have got used to consistent graphical interfaces (e.g. Apple Macintosh or Microsoft Windows), they have desired the same level of integration in their simulation support environments. Research in other fields has been utilised in improving simulation environments. These fields include relational databases, expert systems, formal languages and graphical environments. This thesis examines the use of artificial intelligence in the discrete event simulation field with the aim of examining some potential areas in which it might be possible to improve simulation environments. Existing simulation research in the artificial intelligence (AI) field is extended by investigating the graphical AI knowledge-base called semantic networks. This thesis demonstrates semantic modelling, a discrete event simulation modelling approach based on semantic networks, which attempts to give a consistent graphical interface throughout the life cycle of a simulation study. The semantic modelling approach also incorporates expert system and natural language research. A prototype system of this approach is described