Abstract
The problem of changes in software development is a complex one, and it is almost impossible to avoid it. Indeed, the continuous evolution of the real world causes frequent changes in functional requirements, which entail frequent modifications to the software, yielding a gradual decay of its overall quality. To tackle this problem, two methodologies have been proposed: waterfall methodologies, and incremental/iterative methodologies. The formers try to prevent changes, whereas the second ones consider system development as a step by step process.
TopIntroduction
The problem of changes in software development is a complex one, and it is almost impossible to avoid it. Indeed, the continuous evolution of the real world causes frequent changes in functional requirements, which entail frequent modifications to the software, yielding a gradual decay of its overall quality. To tackle this problem, two methodologies have been proposed: waterfall methodologies, and incremental/iterative methodologies. The formers try to prevent changes, whereas the second ones consider system development as a step by step process.
The concept of software refactoring is at the base of iterative and incremental methodologies. According to Fowler software refactoring is “… a disciplined technique for restructuring an existing body of code, altering its internal structure without changing its external behavior.” (M. Fowler, http://www.refactoring.com/).
Analogously, changes to the database structure are also relatively frequent (Roddick, 1995). They are particularly critical, since they affect not only the data, but also the application programs accessing them (Ambler & Sadalage, 2006; Karahasanovic, 2001). Therefore, similarly to software refactoring, database refactoring aims to modify the database schema, and to change the corresponding application programs accordingly.
Ambler & Sadalage (2006) gave the definition of database refactoring: It “is a simple change to a database schema that improves its design while retaining both its behavioural and informational semantics.”. The database refactoring is the basis of evolutionary data modeling methodologies, which are the database analogous of the iterative and incremental ones. Ambler & Sadalage (2006) also observed that a disadvantage in the application of refactoring is the lack of mature supporting tools.
In this paper we deal with the problem of developing tools supporting the evolutionary data modeling process. First of all, we observe that the characteristics of the problem can be naturally framed in the agent paradigm, because the evolutionary data modeling can be seen as a process in active databases able to change their beliefs and structure. Moreover, the evolutionary data modeling can be compared to the design of an agent acting in an open environment: the environment can be represented by the user needs and requirements (which change in an unforeseeable way), while the database development process is represented by the evolution of a reactive agent. Then, by following the AOSE (Agent-Oriented Software Engineering) view, we show that the use of tools and techniques from AI (Artificial Intelligence) can help facing the problem of developing supporting tools to automate evolutionary data modeling. To this end, after a brief introduction to the basic concepts in agent theory, and the highlighting of relationships among agents, software engineering, and databases, we point out the correspondence between agents and data modeling by showing a suitable architecture based on the logic of interrogation (Hintikka et al., 2002).
TopBackground
Before dealing with the problem of database refactoring, along with the more general data modeling, and the role of agents in solving it, we need to briefly introduce the concept of agent, highlighting advantages of agent technology.
The term agent has not reached a universally accepted definition, as pointed out by Franklin & Graesser (1996), but the essence of being an agent can be summarized as follows:
“Anautonomous agentis a system situated within and a part of an environment that senses that environment and acts on it, over time, in pursuit of its own agenda and so as to effect what it senses in the future.” (Franklin & Graesser, 1996).
Luck et al. (2004) proposed to divide applications of agents in three main categories:
- •
Assistant agents, which replace humans in the execution of some task (e.g., agents for hotel reservation);
- •
Multi-agent decision systems, where the agents in the system make some joint decisions;
- •
Multi-agent simulation systems, used to simulate real-world domains like biological populations.
Key Terms in this Chapter
Schema Changes: They are operations which allow database schema to evolve according to the changes of the external world.
Schema Property: A schema property is a proposition about the constituents of the schema. An example of schema property is the first normal form.
Schema Level Consistency: A schema is consistent if it is “well-formed (i.e. a schema with some desired properties).” (Li (1999), p.365).
Schema: the database schema is constituted by attributes (fields), tables (of fields), and the relationships between attributes (functional dependencies) and between tables.
Database Refactoring: It indicates little changes in the database schema which preserve both the meaning of the data and the behaviors of the applications. These changes improve the quality of the design.
Functional dependency: Given two sets of attributes X and Y, a functional dependency between them is denoted by X ? Y. The constraint says that, for any two tuples t1 and t2 having t1[X] = t2[X], then t1[Y] = t2[Y]. More precisely, given a table R, X ? Y ? ?t1, t2 ? R.(t1[X] = t2[X] ? t1[Y] = t2[Y]).
Agent: Agent is a hardware or software system able to act without human intervention (autonomy) both by itself (pro-activeness) and reacting to the environment changes (reactivity), also interacting with other agents (social ability).
Evolutionary Data Modeling: Methodologies to iteratively and incrementally model database systems so that schema and applications evolve in a parallel way.