The project aims to apply and extend cutting-edge software reuse techniques to build automated reasoning components that will cheapen the development of intelligent systems and thus lower the barrier of entry to their various markets. It also aims to assemble these automated reasoning components to rapidly build reuse-oriented CASE tools that will provide far more integrated and automated support than the ones currently available. The project will thus apply software reuse to enhance automated reasoning and vice-versa
This project aims to investigate the cross-fertilization between cutting-edge concepts in software engineering and artificial intelligence. More specifically, it aims to integrate, for mutual benefits, recent advances in, one the one hand, model-driven and component-based software engineering for software reuse , and, on the other hand, rule-based constraint programming for automated symbolic and numerical reasoning  . The long term goal of the project is to provide a highly integrated and extensible framework of methods, tools and components allowing for much faster and cheaper development of applications that require automated reasoning. Such applications are ever more pervasive due to several recent trends such as ubiquitous computing, semantic web services, digital entertainment and media convergence.
An integrated framework for engineering applications that incorporate Automated Reasoning (AR) shall ideally provide: (a) an overall Reuse-Oriented Software Engineering (ROSE) method, and (b) an associated set of CASE tools and built-in AR components that facilitates the application of the method.
The overall development method must include the following elements:
· An overall application development process;
· A procedural component development sub-process;
· A knowledge-based component development sub-process;
· A set of artifacts to build at each step of each process and sub-process;
· A set of languages to specify these artifacts;
· A set of consistency and completeness constraints on both individual artifacts and their relationships.
The associated tool and component set must include the following elements:
· A development process and sub-process management tool;
· A set of editors for the artifacts;
· An integrated artifact repository;
· An engine for searching needed artifacts within the repository and on the web;
· A set of automated validation and testing services for individual artifacts and their relationships;
· A set of transformation engines and transformation rule bases to automatically generate or reverse engineer artifacts at a given abstraction level (knowledge level, formalization level, implementation level) and process stage (requirement, refinement, programming, testing), from artifacts at another level and/or stage;
· A set of AR components that are tested and easily extensible and reusable;
· A set of interoperability interfaces between these different tools.
The ROARS project focuses on only a subset of such method elements and tools listed above. This subset includes:
· A model-driven, component-based sub-process for the development of knowledge-based systems;
· The set of artifacts to produce at each step of this sub-process;
· A set of reusable and extensible AR components for deduction, abduction, belief revision, inheritance, finite domain constraint solving and their seamless integration;
· An engine to search artifacts and components in the repository and on the web, assembled from theses AR components;
· A model transformation engine assembled from these AR components;
· A model transformation base to certify component conformity to the engineering method guidelines.
For the remaining method elements and tools, the ROARS project intends to maximize reuse of adequate available solutions and standards. In particular, it is committed to reuse:
· The standard object-oriented modeling, meta-modeling and model transformation languages defined by the Object Management Group (OMG, www.omg.org) to specify software artifacts at the knowledge level, including UML2.0 , OCL2.0 , MOF2.0  and QVT ;
· The aspect-oriented extension of Java, Aspect J  and its component-based extension, JavaBeans  or alternatively the corresponding Aspect# and C#.Net to specify software artifacts at the implementation level;
· UML modeling tools such as IBM Rational Software Modeler  or Objecteering UML Modeler and Profile Builder  for editing the knowledge-level artifacts;
· The KobrA model-driven, component-based, object-oriented software engineering methodology  as a starting point to be adapted and extended for all the development processes.
ROARS is also committed to reuse, through their syntactic and semantic integration, two expressive and versatile formalisms that are simultaneously knowledge representation languages with well-defined logic-based formal semantics and Turing-complete, general purpose, concurrent programming languages:
· CHRD (Constraint Handling Rules with Disjunctive bodies) , , a term rewriting language (a.k.a. CHRV in the literature);
· TFL (Transaction Frame Logic)      a logic programming language.
CHRD and TFL have complementary strengths. CHRD supports the integration of constraint solving , monotonic deduction , abduction  and belief revision  AR services using rules with a first-order relational syntax allowing multiple goals, and first-order classical logic semantics . TFL supports the integration of monotonic and non-monotonic deduction and inheritance AR services using rules with high-order  object-oriented   syntax and first-order, non-monotonic transaction logic semantics  . The result of their integration, a new language called CHORD (Constraint Handling Object-oriented Rules with Disjunctive bodies), will support all the above AR services in a unifying framework using rules with a high-order, object-oriented syntax allowing multiple goals, and first-order, non-monotonic transaction logic semantics. In ROARS, CHORD will be used to specify software artifacts at the formalization level. The benefits of such an intermediate level with well-defined formal semantics to mediate between the knowledge and implementation levels has been independently acknowledged for a long time in both knowledge representation and formal methods research . From an AR perspective, it is the key to guarantee the soundness of the inference engines being developed or used, while from a software engineering perspective, it is the key to automatically check model properties prior to their implementation.
ROARS’ four-level development schema is illustrated in Fig. 1. Starting from a knowledge-level KobrA model of a given component encoded in UML, OCL and QVT, a formalization-level CHORD base is constructed.
From such CHORD base, implementation-level aspect and object oriented source code is produced in Aspect J and Java or in Aspect# and C#. This code is then weaved and compiled into a deployment-level Java or .NET component.
While mapping among the first three levels will initially be carried out manually, the idea is to gradually automate theses tasks as the CASE tools and AR components investigated and prototyped during the ROARS project become available.
The key features that will make CHORD ideal as the intermediate formalization level language for the ROARS framework are the following:
· Its object-oriented syntax and formal semantics for inheritance is well-suited to mediate between ROARS’ knowledge level and implementation level languages that are both object-oriented;
· Its high-order object-oriented syntax that supports both meta-programming and code reuse through inheritance fits ROARS’ top requirement of self-extensibility;
· The distinction it inherits from CHRD between constraints defined (a) locally to a given rule base and (b) externally in either an underlying host language or another rule base naturally fits ROARS’ component-based architecture; the AR services provided by one ROARS component will be formalized by the constraints locally defined in its CHORD base, whereas the AR services required by such component will be formalized by the constraints that it reuses as pre and post conditions in its CHORD base but that are defined in the CHORD bases of other ROARS components;
The concurrent computation model it inherits from both CHRD  and TFL  will allow the formalization of concurrently executing ROARS components.
AR currently finds itself in a paradoxical state. On the one hand, it has never been more widely needed to provide the competitive differential for a variety of practical, real-world applications that include bio-technology, business intelligence, administrative process rationalization, simulations, games, digital entertainment and ubiquitous, customized information delivery. On the other hand, it has undergone over the last 15 years an impressive modernization, paved with many breakthroughs, resulting in ever more rigorously defined concepts and scalable techniques . It has also vastly diversified from its root in logic-based monotonic deduction, to encompass new reasoning tasks such as belief revision, inheritance, abduction, induction, analogy, constraint solving and optimization, and new mathematical basis for its reasoning such as probability theory, decision theory, calculus and algebra as well as other computational metaphors such as neural networks or evolutionary computation. Yet, AR in general (and its most conceptually advanced and powerful techniques in particular) remains very rarely used in the commercial and industrial software that would most benefit from them. The root of this paradox is that the development cost of incorporating AR functionalities into mainstream software applications remains highly prohibitive.
There are two alternatives for such incorporation. The first is to develop from scratch the specific AR functionalities needed for the application at hand. This option is too costly for three reasons. First, developing an inference engine from scratch is a daunting task that might exceed in size and conceptual complexity the rest of the application’s development effort. Second, while knowledge engineering methodologies  are available to guide the development of a knowledge base to work with an inference engine, there exists no such methodology for the development of the engine itself. Third, this task can only be carried out by developers with a comprehensive and up to date background in both artificial intelligence and software engineering, and such people are very scarce and expensive.
The alternative is to reuse an AR software into the application. But this is equally costly because such software tends to be built using obsolete software engineering methods that ignore the issue of reuse. It is rarely based on mainstream IT standards (such as UML, Java or .Net), but rather on exotic logics or non-standard extensions of Prolog for which no textbook is available. It rarely comes with adequate middleware, more often than not only a bridge to C. This makes it costly to integrate with other software inside an application. It also comes at best with open source code but without requirement, modeling or testing artifacts, without a user-friendly reasoning explanation GUI and without proper documentation and user-manual. It is also not integrated with standard CASE tools (such as UML modelers  ) or IDE (such as Eclipse  or Visual Studio ). This makes it costly to customize and extend. However, the need for such extensions is pervasive. Typical AR software generally offers only a single reasoning service (e.g., logic-based monotonic deduction). However, during the life-cycle of the application, other, more sophisticated or flexible services generally become needed (e.g., probabilistic-based deduction with belief revision).
For all these reasons, ROARS aims at providing an extensible framework of AR components engineered for reuse using the most advanced ROSE methods and based on mainstream IT languages such as UML, Java and .Net. We believe that such framework will sufficiently lower the cost of incorporating AR in the many applications that need them to trigger a breakthrough in its widespread use. The hitherto untapped potential for both model reuse and code reuse among AR components is very high, since conceptually many advanced AR techniques reuse more basic ones. For example, deduction in first-order logic is merely deduction in propositional logic extended with first-order term unification; similarly, first-order probabilistic reasoning is essentially propositional Bayesian reasoning extended with first-order term unification; and induction in first-order logic is essentially the composition of hypothesis construction search, with deduction reused for hypothesis testing .
ROSE currently finds itself in a paradoxical state similar to that of AR. On the one hand, it has never been more crucial to turn software development as cost-efficient and scalable as other engineering disciplines. Following the synergetic widespread adoption of systematic software processes such as RUP , object-oriented modeling in UML , object-oriented programming in C++, Java and C#, and quality standards such as CMM , it is fairly consensual that next productivity breakthrough can only come from the widespread adoption of reuse-oriented practices.
On the other hand, ROSE has become the most active sub-field of software engineering research over the last decade, resulting in many reuse techniques that promise to dramatically extend the basic reuse benefits of object-orientation and the UML:
· Product Line Engineering (PLE)  to reuse a core functionality across variations in functional and non-functional requirements;
· Component-Based Development (CBD)  to reuse a coherent set of related functionalities that are encapsulated together with:
1) a user-interface to be deployed as a stand-alone system (which distinguishes a component from a library or module);
2) a set of API to be called as a client by other components and to call other components as servers in a larger system (which distinguishes a component from a regular stand-alone software system), and
3) meta-data to facilitate its assembly with these other components in various such larger systems;
· Aspect-Oriented Development (AOD)  to reuse code (or models) that encapsulate concerns, such as persistence, logging or distribution, that are both (a) recurrent across application domains and (b) orthogonal among themselves and from the core functionalities of each application;
· Model-Driven Development (MDD)  to reuse across implementation platforms, pre-code software artifacts such as computation independent domain models, application requirement specifications and application platform independent models at various refinement levels;
· Built-In Contract Testing (BICT)  to reuse test suites, which in turn allows assessing the reusability of components in different contexts than the ones for which they were originally designed.
While these different techniques emerged independently, they are clearly complementary. The KobrA method recently integrated all of them, together with standard techniques such as top-down refinement and object-oriented development, into a coherent whole. It is a significant breakthrough in ROSE because:
· It promotes artifact reuse over the entire range of development stages, from requirement to modeling, implementation and testing;
· In contrast to previous methods, it provides precise guidelines for most software engineering aspects, including a finely grained recursive process, the artifacts to specify at each step, well-formed rules for each of these artifacts as well as for the relations between them and quality metrics and control;
· It is fully platform and tool independent by relying on the UML standard
· to specify all the software artifacts (except for code that is beyond the scope of the UML and for which KobrA put forward the “Normal Object Format”, an abstract language that integrates the semantically common constructs of C++, Java and C# while abstracting from their syntactic differences).
Yet, in spite of all these research advances, reuse-oriented practices remain virtually absent in the overwhelming majority of software houses, even those with the highest standards in process compliance and quality metrics. The root of this paradox is that for most software development teams, time to market of the next product or product release is an overriding concern, indeed often a matter of survival for start-up firms. To such teams, even the best ROSE methods such as KobrA, present an unsavory feature combination:
· They represent a radical departure from current practice that implies a high-level of disturbance and instability before being assimilated by the team;
· They provide clear time to market benefits only over the long term and for an entire portfolio of development efforts.
Consequently, resistance, explicit or tacit, against their thorough adoption remains high.
Similarly to what happened with the transition from ad-hoc development to current object-oriented software engineering methods, transition from such methods to ROSE methods such as KobrA is unlikely to become commonplace before highly sophisticated reuse-oriented CASE tools become available. These tools must automate most of the new reuse-fostering tasks that are added to the software process by ROSE methods and which involve a prohibitive short-term overhead when manually carried out. Target tasks for automation are:
· Reuse-oriented management and search of the integrated artifact repository;
· Design pattern guided model refinement;
· Model checking for properties such as absence of deadlocks and livelocks, and compliance to syntactic and semantic consistency and completude guidelines (both for individual artifacts and for their relationships);
· Code generation from models;
· Test suite generation from requirements and models.
Since all those CASE services require various forms of AR, reusable AR components are as crucial to the widespread adoption of ROSE methods, than are these ROSE methods to the development of such components. This realization is the key insight that motivates and directs the ROARS project.
The ROARS project is an international multi-institutional partnership that aggregates senior and junior researchers from the following institutions:
Institut für Rechnerarchitektur und Softwaretechnik,
The senior researchers currently involved are:
§ Dr. Jacques Robin, Associate Professor at CIn-UFPE;
§ Dr. Thom Frühwirth, Associate Professor at FI-UU;
§ Dr. Colin Atkinson, Full Professor at FMI-UM;
§ Dr. Armin Wolf, Researcher at FIRST;
§ Dr. Luis Menezes, Researcher and Lecturer at CIn-UFPE;
§ Dr. Silvio Meira, Full Professor at CIn-UFPE;
The junior researchers currently involved are:
§ Jairson Vitorino, PhD. student at CIn-UFPE, co-advised by Jacques Robin, Luis Menezes, Armin Wolf and Thom Frühwirth;
§ Marc Meister, PhD. student at FU-UU, co-advised by Thom Frühwirth and Jacques Robin;
§ Matthias Gutheil, Dietmar Stoll PhD. students at FMI-UM, advised by Colin Atkinson;
§ Eduardo Almeida, Vinicius Garcia PhD. students at CIn-UFPE, advised by Silvio Meira
§ Luiz Lacerda, Fabrício Teles and Marcos Aurelio, MSc. student at CIn-UFPE, advised by Jacques Robin;
The ROARS project is is being funded for 2006-2007 under the Brazilo-German scientific cooperation program PROBRAL CAPES/DAAD.
The main ongoing activities are the following:
§ Colin Atkinson and Jacques Robin, in collaboration with Dr. Xavier Blanc and PhD. Student Reda Bendraou of the Laboratoire d'Informatique de Paris 6, Université Pierre et Marie Curie, are defining an upgrade of the KobrA method to leverage the expressive power of the latest OMG standard languages UML2.1, OCL2.0, MOF2.0 and SPEM 2.0;
§ Jairson Vitorino and Luis Menezes are developing, following the KobrA method, CHROME (Constraint Handling Rules Online Model-Driven Engine) a model-driven, adaptive, compilation-based, efficient Java-hosted engine for CHRD bases that will serve as the bottom and most reused component of the ROARS framework;
§ Marc Meister is defining a systematic mapping from CHR bases to TFL bases to provide a unified formal logical account of the declarative and operational aspects of both monotonic and non-momotonic CHR bases and their execution;
§ Matthias Gutheil is developing MOSES, an versatile editor and repository tool for modeling, meta-modeling, semantic web ontology and services CASE based on a single, self-contained, meta-circular, minimal language that reuses a small core of the UML2.1 infra-structure and OCL2.0 and extend it with an arbitrary number of ontological meta-levels;
§ Oliver Hummel is developing Extreme Harvester, an engine to search the web for software component source code that match a needed software service specification given a input query;
§ Dietmar Stoll is defining an extension of the KobrA method to develop software components deployed as web services and assemble them to implement business processes captured as task workflows;
§ Marcos Aurelio is defining the syntax and semantics of CHORD, investigating what type of object-orientation and inheritance services to integrate with the relational rule-based constraint programming services provided by a CHRD engine; he is also maintaining and extending CHREX (Constraint Handling Rule Engine Xtreme programmed), a non-adaptive, interpretation-based, Java-hosted CHRD engine that he developed with Jairson Vitorino using Xtreme programming (the goal of CHREX is to constitute an experimentation platform for CHRD extensions while CHROME is still under development).
§ Fabrício Teles is developing, following the KobrA method and reusing CHREX, a software component to automatically allocate and reallocate workers to tasks in a software house that is simultaneously developing new products and for new versions of existing products for multiple clients with various levels of priority;
§ Luiz Lacerda is extending the KobrA method with new artifacts and a sub-process for engineering GUI components.
Jairson Vitorino, Jacques Robin and Thom
Frühwirth. Fast Prototyping of
Intelligent Components: Towards a Model-driven Compiler for Rule-Based
Constraint Programming. 8th International Conference on
Marc Meister, Khalil Djelloul and Jacques Robin.
A Unified Semantics for Constraint
Handling Rules in Transaction Logic. 9th International Conference on Logic
Programming and Non-Monotonic Reasoning (LPNMR'2007).
Jacques Robin and Jairson Vitorino. ORCAS: Towards a CHR-Based Model-Driven
Framework of Reusable Reasoning Components. 20th Workshop on Logic
 Abdennadher, S. and Frühwirth, T. Integration and Optimization of Rule-Based Constraint Solvers. Lecture Notes in Computer Science 3018, Springer, 2004.
 Almeida, E, S.; Alvaro, A.; Lucrédio, D.; Garcia,
V. C.; Meira, S, R, L. RiSE Project:
Towards a Robust Framework for Software Reuse. In Proceedings of the IEEE International Conference
on Information Reuse and Integration (IRI),
 Andrade, E.A. Indução de Programas Lógicos Orientados a Objetos. Master’s Thesis. CIn-UFPE. 2003.
 Andrade, E.A. and Robin, J. Inductive
Object-Oriented Logic Programming. In Proceeding of the 2nd Workshop on Implementation Technology for
Computational Logic Systems of the European Network of Excellence in
Computational Logic (ITCLS’03),
 Atkinson, C., Bayer, J., Bunse, C., Kamsties, E.,
Laitenberger, O., Laqua, R., Muthig, D., Paech, B.,
Wust, J. and Zettel, J. Component-based Product Line Engineering with UML. Addison-Wesley, 2002.
 Atkinson, C. and Kühne, T. Rearchitecting the UML Infrastructure, ACM Transactions on Modeling and Computer Simulation, 12(4) 2002.
 Atkinson, C., Bunse, C., Groß, H. and Kühne, T..Towards a General Component Model for Web-Based Applications. Annals of Software Engineering 13(1-4). 2002.
 Atkinson, C. and Kühne, T. Profiles in a Strict Metamodeling Framework. In Journal of the Science of Computer Programming, Evans, A. Kent, S. and Selic, B. 2002.
 Atkinson, C., Barbier, F., Belloir, N., Bruel J.M., and Groß H.G. Built-In Contract Testing for Component-Based Development" in Business Component-Based Software Engineering. Barbier, F. (Ed). Kluwer International. 2003.
 Atkinson, C., Bunse, C. and Wüst, J. Driving Component-Based Software development through Quality Modeling. In Component-Based Software Quality: Methods and Techniques, Cechich, A. et. al. (Eds). Springer. 2003.
 Atkinson, C. and Kühne, T. Aspect-Oriented Development with Stratified Frameworks. IEEE Software, 20(1). 2003.
 Atkinson, C. Unifying
MDA and Knowledge Representation Technologies. The Model-Driven Semantic
Web Workshop (MDSW 2004),
 Hummel, O. and Atkinson, C. Extreme Harvesting: Test Driven Discovery and Reuse of Software
Components. International Conference
on Information Reuse and Integration (IEEE-IRI),
 Bistarelli, S., Frühwirth, T., Marte, M. and Rossi, F. Soft. Constraint Propagation and Solving in Constraint Handling Rules. Computational Intelligence 20(2), Blackwell Publishing, 2004.
 Component+ Project. The Component+ website. http://www.component-plus.org/
 Damasceno, A.L.G. Desenvolver Agentes de Futebol com Objetos e Lógica. Master Thesis. CIn-UFPE. 2003.
 Eaton, P.S., Frühwirth, T. and Tambe, M. Constraint Agents. Constraints Journal 7(1). Kluwer. 2002.
 Frühwirth, T. On the Number of Rule Applications in Constraint Programs. Electronic Notes in Theoretical Computer Science 48. 2001.
Goes By II: More Automatic Complexity Analysis of Concurrent Rule Programs. In Proceedings
of 8th International Conference on Principles of Knowledge Representation and
 Frühwirth, T. As Time Goes By: Automatic Complexity Analysis of Simplification Rules. Electronic Notes in Theoretical Computer Science 59. 2002.
of Concurrent Guarded Multi-Set Transformation Rules. In
Proceedings of the International Symposium on Logic-Based Program Synthesis and
 Frühwirth, T. The
T. and Abdennadher, S. The
 Frühwirth, T. and Abdennadher, S. Essentials of Constraint Programming. Springer. 2003.
 Frühwirth, T., Di Pierro, A. and Wiklicky, H. Probabilistic Constraint Handling Rules. Electronic Notes in Theoretical Computer Science 76. 2002.
 Hoche, M., Müller, H., Schlenker, H. and Wolf, A.:
FIRSTCS - A Pure Java Constraint
Programming Engine. In Proceedings of the 2nd International Workshop on
Multiparadigm Constraint Programming Languages (MultiCPL'03)
 IESE. The KobrA project website. http://www.iese.fraunhofer.de/Kobra_Method/
D., Gavioli, A., Prado, A.F., Biajiz, M., Yamamoto, C.H., Almeida, E, S and
Meira, S.R.L. Component Retrieval using
Metric Indexing. In Proceedings of the IEEE International Conference on
Information Reuse and Integration (IRI),
 Lucrédio, D., Almeida, E, S. and Prado, A, F. A Survey on Software Components Search and
Retrieval, In Proceedings of the the 30th IEEE EUROMICRO Conference,
Component-Based Software Engineering Track, 2004,
 Macedo, H.T and Robin, J. Increasing Profitability: Voice-Based Browsing for Recommendation System Web Services. In: Proceedings of the 3rd Atlantic Web Intelligence Conference (AWIC’05), Lodz, Poland. Lecture Notes in Artificial Intelligence (LNAI). Springer. 2005.
Macedo, H.T and Robin, J. A Mediator Architecture Providing
Ubiquitous Access to Web Content via Voice Portals, Web Services, Ontologies
and Natural Language Generation. In Proceedings of the 3rd
International Information and Telecommunication Technologies Symposium
 Meira, S.R.L.,
 Menezes, L.C.S., Moura, H.P., Ramalho, G.L. Formal Semantics for Agent-Oriented
Programming Languages. In Proceedigns of the 4th Simpósio
Brasilieiro de Linguagens de Programação (SBLP’00).
 Menezes, L.C.S., A framework for defining object-oriented languages using action
semantics. In Proceedings of the 4th Simpósio Brasileiro de
Linguagens de Programação (SBLP’00).
 Menezes, L.C.S. Action Semantics for Logic Programming Languages. In Proceedings of
the 3rd International Workshop on Action Semantics (AS’00),
 Menezes, L.C.S., Moura, H.P. Component-based Action
Semantics: A new Approach for Programming Language Specification. In
Proceedings of 5th the Simpósio Brasilieiro de Linguagens de
 Menezes, L.C.S., Ramalho, G.L., Moura, H.P. An Extensible Definition for Action
Semantics. In Proceedings of the 4th International Workshop on Action Semantics
 Menezes, L.C.S., Moura, H.P., Monteiro, M. The Abaco System: An Action Tool for
Programming Language Designers. In Proceedings of the 4th
International Workshop on Action Semantics (AS’02),
 Ramalho, F.S and Robin, J. Mapping UML Class Diagram to Object-Oriented Logic Programs for Formal Model-Driven Development. In Proceedings of the 3rd UML Workshop in Software Model Engineering (WiSME 2004).
 Ramalho, F.S, Robin, J. and Schiel, U. Concurrent Transaction Frame Logic Formal Semantics for UML Activity and Class Diagrams. Electronic Notes in Theoretical Computer Science, 95(17). 2004.
 Silva, K.S. Replay: Análise e Depuração de Sistemas Multiagente Baseados em Conhecimento Lógico Orientado a Objetos, com Aplicação a RoboCup. Master Thesis. CIn-UFPE. 2005.
 Wolf, A. Adaptive Constraint Handling with CHR in Java. In Lecture Notes in Computer Science 2239, Springer. 2001.
 Wolf, A. Reduce-To-The-Opt: A Specialized Search Algorithm for Contiguous Task Scheduling. In Lecture Notes in Artificial Intelligence 3010, Springer, 2004.
 Wolf, A. An Empirical Comparison of Intelligent Search Strategies Based on Adaptive Constraint Handling Rules, To appear in Theory and Practice of Logic Programming (TPLP). 2005
 Wolf. A., Gruenhagen, T. and Geske, U. On Incremental Adaptation of CHR Derivations. Journal of Applied Artificial Intelligence 14(4). Special Issue on Constraint Handling Rules. 2000.
 Wolf, A. and Schlenker, H. Realizing the Alternative Resources
Constraint Problem with Single Resource Constraints. In Proceedings of the
15th International Conference on Applications of Declarative Programming and
Knowledge Management (INAP’04),
 Abdennadher, S. Rule-based Constraint Programming: Theory and Practice, Habilitation, Institut für Informatik, Ludwig-Maximilians-Universität München, 2001.
 Bonner, A.
and Kifer, M. Transaction
Logic Programming. Technical
Report CSRI-323. Computer Systems Research Institute,
 Bonner, A. and Kifer, M. Concurrency
and Communication in Transaction Logic. Proceedings of the Joint International Conference
and Symposium on Logic Programming.
 Chen, W.,
Kifer, M. and
 Carnegie Mellon Software Engineering Institute. The Capability Maturity Model for Software. http://www.sei.cmu.edu/cmm/.
 Eclipse. http://www.eclipse.org/.
 Eriksson, H.E., Penker, M.,
 Fensel, D. Formal Specification Languages in Knowledge and Software Engineering. Knowledge Engineering Review 10(4). 1995.
 Gross, H.B. Component-Based Software Testing with UML. Springer. 2004.
 IBM. IBM Rational Software Modeler. http://www3.software.ibm.com/ibmdl/pub/software/rational/web/datasheets/rsm.pdf
 Kifer, M. Deductive and Object Data Languages: A Quest for Integration. In Lecture Notes in Computer Science 1013. Springer. 1995.
 Kifer, M., Lausen, G. and Wu, J . Logical Foundations of Object-Oriented and Frame-Based Languages. Journal of the ACM 42. 1995.
 Kleppe, A., Warmer, J. and Bast, W. MDA Explained - The Model-Driven Architecture: Practice and Promise. Addison-Wesley. 2003.
 Kruchten, P. The Rational Unified Process: An Introduction, 3rd Ed. Addison-Wesley. 2003.
 Laddad, R. AspectJ in Action: Practical Aspect-Oriented Programming. Manning Publications. 2003.
 Microsoft. Microsoft Visual Studio Developer Center. http://msdn.microsoft.com/vstudio/.
 OMG. The MOF 2.0 specification. http://www.omg.org/cgi-bin/doc?ptc/2003-10-04.
 O’Neil, J. JavaBean Programming from Ground-up. Osborne/McGraw-Hill. 2001.
 The QVT-Merge Group. QVT 1.8.: Revised submission for OMG MOF 2.0 Query/Views/Transformations Request For Proposal. 2004.
 Russell, S. and Norvig, P. Artificial Intelligence: A Modern Approach. 2nd Ed. Prentice Hall. 2003.
 SoftTeam. Objecteering UML. http://www.objecteering.com/products.php
 Studer, R., Benjamins, V.R. and Fensel, D. Knowledge Engineering: Principles and Methods. Data Knowledge Engineering 25. 1998.
 Yang, G. A
Model Theory for Nonmonotonic Multiple Value and Code Inheritance in
Object-Oriented Knowledge Bases. PhD. Thesis, Computer Science Department,
Stony Brook University of
© Jacques Robin 2005. Last Updated: 15/03/2007