See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/267450881

Automated Code Generation Using Case-Based Reasoning, Routine Design and

Template-Based Programming

Conference Paper · April 2012

DOI: 10.13140/2.1.1470.4641

CITATIONS READS
7 2,600

2 authors, including:

Yuri Danilchenko
Northern Kentucky University
2 PUBLICATIONS 24 CITATIONS

SEE PROFILE

All content following this page was uploaded by Yuri Danilchenko on 28 October 2014.

The user has requested enhancement of the downloaded file.

 Automated Code Generation Using Case-Based Reasoning,
Routine Design and Template-Based Programming
Yuri Danilchenko and Richard Fox

Department of Computer Science

Northern Kentucky University
Nunn Drive
Highland Heights, KY 41099
{danilcheny1, foxr}@nku.edu

compiler requires too detailed an input as the programmer

Abstract must still produce the algorithm in a proper syntactic form.
In Artificial Intelligence (AI), a variety of approaches
Automated code generation is the process whereby a have been explored to support software development.
computer program takes user specifications in some form Case-Based Reasoning (CBR), for instance, can be used to
and produces a program as output. Automated code
maintain a library of code routines (e.g., objects, methods),
generation can be the process undertaken by a compiler,
which generates an executable program from a source
select the code routines that best match user specifications,
program, but it also applies to the situation where the input and present the those options to the software developer.
is a task described at some level of abstraction and the Alternatively, through genetic and evolutionary
output is a program that can perform that task. Several programming, code can be mutated and tested for
different approaches have been utilized to varying degrees improvements. If improved, the new code becomes a base
of success to automate code generation, including Case- for the next generation of code. Random changes can
Based Reasoning, formal methods and evolutionary potentially lead to code that is more concise, more
algorithms. In this paper, a system is introduced which efficient, or more correct.
combines Case-Based Reasoning, Routine Design and At present, neither CBR nor evolutionary approaches
Template-Based Programming to generate programs that has yielded an ACG system that can replace a software
handle straight-forward database operations. This paper developer. In this paper, the research focuses on three
presents the approach taken and offers some brief different but related areas. First, code generation is
examples. thought to be a design problem. A solution will be a plan.
Plan steps can be specified at a generic level and then
Automated code generation (ACG) is the process whereby refined into more detail. Eventually all plan steps will be
a computer program takes user specifications in some form filled in with code components from a component library.
and produces a working program as output. When the user Once selected, these components are combined and used to
input is some abstract description of a task, as opposed to fill in a program template.
source code in some high level language, ACG presents Although the word “plan” is being used, the plan is a
both a challenging problem and an opportunity to reduce description of a solution, or a design to solve the stated
cost. Automating the programming task, which normally problem. The plan steps provide goals to be fulfilled.
requires a great deal of expertise involves employing Code components are selected to fulfill each of these
techniques that comprise design or planning, logic and goals. Thus, the problem is one of designing a solution
programming knowledge. The benefits of ACG include through a code component library.
reducing or eliminating expenses involved in software The plan itself is retrieved from a library of plans, based
development and maintenance, which studies have on user specification. Additionally, if the selected plan
indicated could cost corporations as much as 10% of their does not precisely match the user specifications, alterations
yearly expenses (Jones 2010). can be made. The refined plan can be stored for future
One form of ACG is the compiler. The user provides retrieval. Thus, an ACG system can be built as a
source code as input and the compiler generates an combination of Routine Design (RD), Template-Based
executable program. Compilers have been in regular use Programming (TBP) and Case-Based Reasoning (CBR).
since the late 1950s when the first high level languages In this paper, the Automated Coder using Artificial
were developed. Although initially many programmers Intelligence (ACAI) system is presented. The paper is laid
scoffed at the idea that ACG could produce efficient and out as follows. Section 2 identifies related work and some
correct code, very few programmers today would write background into both RD and CBR. Section 3 presents the
code in a low level language, favoring the high level ACAI system. Section 4 contains a brief example and
languages and compiler technologies. However, the
description of the system in action. Section 5 offers some such as a data access layer. Although the developers
conclusions and future work. modify the case components by hand, SAME monitors any
such operations to capture the changes for future uses.
Related Work The Case-Based Reasoner for Software Component
Selection (Fahmi and Choi 2009) is currently only a
The earliest instance of CBR is found in the system CHEF conceptual design of a CBR system for software
(Hammond 1986), a program to generate Szechwan component selection. As with the previous two systems,
cuisine recipes based on user goals. CHEF utilized a this system automates only the selection of case
library of previous dishes for cases. Cases included such components from a library of reusable software
pieces of information as ingredients, textures, and components. Cases include function, associated
preparation instructions. The CHEF system would retrieve components, component justification and case justification
a closely matching recipe based on the user specification, in support of providing rationale for why a component
compare the goals of the matched recipe to the user’s might be used.
specifications, identify goals that were not met, or While the previous systems automated only a portion of
constraints that would not be met, and attempt to repair the the process, the Case-Based Software Reuse System, or
selected recipe. The new recipe would be stored in the CAESAR, (Fouqut and Matwin 1993) offers an example of
library so that the system could learn over time. This a complete ACG. CAESAR applies a variant of CBR
initial CBR system demonstrated the utility of the called compositional software reuse to perform code
approach: solving new problems through previous generation in the domain of linear algebra. Cases are
solutions. A CBR system would perform four primary reusable mathematical routines written in C. Code
tasks: case retrieval, case reuse, case revision, segments are retrieved based on user specifications and
caseretention. partial matching, along with plan decomposition.
The Kritik system (Goel, Bhatta and Stroulia 1997) Inductive logic is used to capture frequently occurring
developed in the late 1980s applied CBR to the physical instances of code segments so that these can be stored for
design problem. Cases would represent component parts future use. Such groupings are called slices.
and Kritik would propose a design for a physical artifact Finally, Menu Browser Using Case Based Reasoning
by selecting components. Unlike CHEF where cases were (MESCA), applies CBR to the problem of generating a
represented by goals, Kritik represented its cases by their user interface based on reusable software components
structure, function and behavior. The components’ (Joshi and McMillan 1996). Here, the reusable
structures would be used to ensure that the components did components are menus and the system will adapt menus to
not violate constraints, components’ functions would be fit specified functions, application types, user-tailored
used to match goals, and components’ behaviors could be fields and graphical design.
used in simulation to ensure that the device functioned as Aside from a great number of CBR efforts, the ACAI
expected. CHEF and Kritik are noted for their contribution system highlighted in this paper draws from both RD and
to CBR although neither addressed ACG. TBP. RD (Chandrasekaran and Josephson 2000) is a class
The Individual Code Reuse Tool, or ICRT, applies CBR of design problem in which the overall design strategy is
to software reuse (Hsieh and Tempero 2006). A library of well known and can be represented through plan
software components comprises the cases for the system. decomposition. That is, solving an instance of the design
In ICRT, the software components are represented by both problem is handled by decomposing the problem into
complete code segments and incomplete or partial code subproblems or components. Each component itself might
segments, the latter of which may be syntactically invalid be further decomposed.
as is. Cases are stored in a flat structure and indexed using In RD, at the lowest level, specific design steps are
attribute-value pairs. Indexes are assigned by the software available as component descriptions. A component
developers using the system. Components are selected description defines in English, through code, or
using a nearest-neighbor algorithm and brought to the mathematically how a given component is constructed and
developer’s attention. It is up to the developer to utilize the placed into the overall design. Commonly, there are
suggested code segment or not. Therefore, while CBR is multiple component descriptions available for any
used, it is not an automated system. Of particular note component. Therefore, the best component description is
however is the indexing scheme. Case attributes are selected using some form of matching knowledge based on
represented using functionality cards, describing for each user specifications, constraining factors, and demands
code segment the segment’s language, feature, property imposed by other components. RD has been applied to
and description. numerous problems from physical design (air cylinders) to
In the Software Architecture Materialization Explorer abstract planning (air force mission planning) and abstract
(SAME) system, the goal is to produce object-oriented design (nutritional meal design) (Brown and
designs (Vazquez, Pace and Campo 2008). These designs Chandrasekaran 1989, Brown 1996, Fox and Cox 2000).
are then presented to the developers who use the designs to Template-based programming (TBP) originated in the
produce the final programs. The designs are produced 1960s but came into use primarily in the 1990s. The idea
from a case library of various software architectural parts, is to represent program logic in a generic form that can be
filled in later by another program. For instance, a loop over event durations. As each plan is generic in nature, the
might be represented generically only to have its details queries listed above can be solved by just a few plans.
filled in at a later time when those details become known. Even so, the user’s goals may match multiple plans, in
TBP has been applied to a number of problems ranging which case ACAI uses a combination of matching plans
from the numeric subroutines to web site generation rather than selecting a single plan.
(Fernandez et al 1993, Jiang and Dong 2008). A plan comprises several sections. First, the plan has a
name and a description. Next, a plan has a number of
An Automated Coding System: ACAI steps broken down in three distinct types: input, operation,
and output. Input steps describe from where the program
The Automated Coder using Artificial Intelligence (ACAI) will obtain its input. Operation steps describe the
system is a first pass at a purely automated code generation individual, executable portions that must make up the
system (Danilchenko 2011). Code generation systems cited program to solve the given problem. Operation steps
in the previous section either required human involvement include a variety of types of computations such as
in the processing loop or were restricted to domains that summation, average, or maximum. Finally, output steps
may not be amenable to a general case, such as creation of describe where the program will send its output. Notice
menus and linear algebra. It is envisioned that the that input and output steps describe the “where” while the
approach taken by ACAI can extend to a great number of operation steps describe the “how”. Each step of a plan is
applications and domains, although currently ACAI only described in terms of goals to be fulfilled. The goals are a
solves database-type problems. Specifically, the initial list of attributes that describe the code that should be used
implementation of ACAI was constructed to tackle the to implement the given plan step.
queries listed below. These queries were identified by data Figure 1 provides an example of the input portion of a
analyst at a hospital, citing that software which could solve plan. This section contains two types of inputs. First are
such tasks would greatly reduce their workload. the generation inputs. This input allows ACAI to query
 Average, maximum, minimum patient length of the user who is generating a program, not the end user.
stay, by diagnosis, age, department Such input might, for instance, obtain information about
 Average amount of time patients waited between the functionality of the intended program. For example,
arrival and first procedure, first lab test, first the user might input a specific type of aggregate function
physician visit, first triage such as average or maximum. This input helps specialize a
 Search for all patients who meet a given mode of plan step, for instance altering the goal [Utilities –
arrival (ambulance, car, walk-in, air-transport) Aggregate – Property] into [Utilities – Aggregate –
sorted by arrival time Maximum] or [Utilities – Aggregate – Maximum - String].
 Average, maximum, minimum time to get lab The second type of inputs is the running inputs. This input
results over all patients and lab requests consists of actual prompting messages that will appear in
 Average, total, mean number of patients the generated program so that, when run, the program will
with/without insurance by day, week, month, year be able to ask the end user for additional details. One
 Most common diagnoses by time of day, example might be a pathname and filename for the input
weekday, month or season file of the program.
 Number of patients by doctor, unit, nurse,
diagnosis, location, age <UserInputs>
<GenerationInputs>
 Average, mean amount of time between <Input RefineGoal="[Utilities –
preliminary finding and final lab result Aggregate – Property]"
The restriction to the medical domain was made because Prompt="Which aggregate function
of the interest in the topic. The limitation to handling (Max, Min, Avg, Total)?"/>
database-type operations was made to ensure that a <Input RefineGoal="[IO - Out]"
Prompt="Where to output (Console,
prototype system could be constructed. See section 5 for File)?"/>
comments on future work. </GenerationInputs>
ACAI accepts two forms of user input, the goal (i.e., the <RunningInputs>
query or queries to be answered) and specifications for <Input Name="AggregateUserInput1"
how to achieve the goal (e.g., computational complexity, Prompt="What is your data file?"/>
<Input Name="AggregateUserInput2"
memory and disk usage, form of input, form of output). Prompt="What is the name of the
The output of ACAI is a working Java program. property you would like to
Given user input, the first step that ACAI undertakes is aggregate?"/>
similar to that of CBR. A case must be retrieved from the </RunningInputs>
library of cases. In ACAI, cases are plans, described using </UserInputs>
XML.
ACAI selects a plan through simple matching of user’s Figure 1: Example Input Portion of a Plan
stated goal for the program. ACAI contains plans for such
activities as sorting, filtering, computation, and reasoning The heart of a plan is the list of plan steps. Figure 2
illustrates two plan steps of an aggregate plan. The first
plan step is used to declare a variable. In this case, the Three example code components are listed here. First is
variable is a collection of maps. The second plan step an inline statement that declares a collection and initializes
performs an aggregate computation operation on a it. Notice the use of ^^ symbols. When surrounding an
declared collection. Notice how the type of operation is item, these symbols represent a placeholder to be filled in
not specified. This piece of information is required before later.
a specific piece of code can be generated, and the type of  Component index: [Variables – Declaration –
operation is obtained via the user specification. Initialize and Declare – ArrayList]
 Component: Java.Util.ArrayList ^^Name^^ =
<Step Name="records" StepType="Input"> new ArrayList( );
<Description>
 Type of component: inline declaration
Declare a collection.
</Description> Second is another inline statement, in this case a loop.
<Goals> Notice the use of placeholders to flesh out the portions of
[Variables - Declaration - Declare – the for-loop that depend on user specifications, such as
Collection - Of Maps] data type, or an already generated identifier name that
</Goals>
</Step>
replaced a previous placeholder. Replacing placeholders is
described below.
<Step Collection="records"  Component index: [Utilities – Iteration –
PropertyName="AggregateUserInput2"> Collection - Map ]
<Description>  Component: for ( java.util.Map <String,String>
Apply an aggregate to a ^^CurrentItem^^ : ^^Collection^^ ) { ^^Body^^ }
collection.
</Description>  Type of component: inline code
<Goals> Third is a method to compute event duration. Only the
[Utilities - Aggregate - Property] header is shown here.
</Goals>  Component index: [Utilities – Event –Duration –
</Step>
Find Even Duration – int]
 Component: int findEvenDuration
Figure 2: Two Sample Plan Steps (^^StartTimeStamp^^ ^^Name^^);
 Type of component: method
Now that ACAI has a plan, with its steps, ACAI must
locate code segments to fulfill each of the plan step goals. Now, ACAI replaces the component placeholders to
ACAI contains a library of Java code components. The construct final component code. In some cases,
code components come in two different forms. First are placeholders represent data types. The selected data type
fully written methods, each available to handle a type of then is used for all matching placeholders. In other cases,
goal or situation (e.g., an input routine, a sort routine, a names must be generated. For instance, parameter names
search routine). Second are inline or partial pieces of for methods and variable names replace placeholders.
code. These include, for instance, variable declarations, Similarly, method names and method calls must match.
method calls, control statements and assignment ACAI fills in the placeholders and adds the names to
statements. All code components are indexed in a similar complete the component code.
strategy to ICRT’s attributes. In this case, code indexes Once ACAI has complete component code, the next step
are described by: is to fill in the program template. The template comes
 Type: variables, collections, I/O, control flow, with the necessary code to make up a Java program. For
utilities instance, the template contains proper import statements, a
 Function: declaration (for variables), filter, main method, try and catch blocks, as well as additional
aggregate operation, event, input/output, placeholders.
assignment statement Another step, which will not be described in detail here,
 Operation: initialization, criteria for filtering or occurs when multiple plans were initially selected. Recall
sorting, type of loop, duration of event, location that ACAI contains only a few basic plans. For a simple
of input or output problem, only one plan would be retrieved. For instance,
 Data type operated upon if the user requires a program to simply sort a collection of
As noted above, every step of a plan is described by a patient records by age, only the sorting plan will be
list of goals. Every goal is a generic version of required. However, a more complicated problem might
information that can be found in the component library. involve first filtering records to find patients that meet a
For instance, a goal might be to declare a collection type of particular criterion (e.g., a diagnosis or arrival time), an
variable. The goal might be expressed as [Variables - aggregate computation involving length of stay between
Declaration - Declare - ArrayList]. Code components are events, and finally a sort. Such a problem would require
selected based on how well they match the goal list of the three different plans. In such a case, ACAI would have to
plan step. Additionally, user specifications that include, combine the three selected plans together. To date, ACAI
for instance, whether speed or space is more critical, help has only performed modest forms of plan combination.
select between matching code segments.
 The code generation process carried out by ACAI routine, and an output step. The goals of these steps are
results in a program that fits the user specifications to listed here:
solve the selected problem. Aside from the generated  Declare Input Collection: [Variables –
program, if plan combination was performed, the new plan Declaration – Declare – Collection – Of Maps –
is indexed and stored for future use. ArrayList]
In summary, ACAI uses CBR to retrieve a solution plan.  Store Input: [Variables – Assignment]
The system uses RD to select appropriate code  Obtain Input: [IO – In – File – ArrayList]
components and generate the concrete plan steps required  Declare Sorted Data Collection: [Variables –
to solve the problem. ACAI uses TBP in that it uses a Declare – Declare – ArrayList]
template of a Java program, filling in the details and  Store Sorted Data: [Variables – Assignment]
replacing the placeholders. The overall architecture for  Sort Data: [Utilities – Sort – ArrayList]
ACAI is shown in figure 3.  Output Sorted Data: [IO – Out]
Now, ACAI must identify code components for each of the
steps listed above and insert them into appropriate
locations of the program template. The template is shown
in figure 4.
package edu.nku.informatics.thesis.acai;

^^Program Comments^^

public class ProgramSkeleton

{
public static void main ( String [] args
)
{
^^User Inputs^^

^^User Prompts^^

getUserInputs(userInputs,
userPrompts);

^^Inline Code^^
}

// Get the inputs from the user

^^Method Code^^
}

Figure 4: The Java Program Template

The first code component sought is that of the declaration

Figure 3: ACAI Architecture of input. ACAI selects the following inline statement:
java.util.ArrayList <java.util.Map <String,
String>> ^^Name^^;
A Brief Example Here, ^^Name^^ is a placeholder. ACAI now
Here, a brief example is presented to demonstrate how specializes the instruction to the given program by
ACAI carries out its code generation task. The user has replacing the placeholder with an actual identifier:
specified a goal of sorting over integer data and requested java.util.ArrayList <java.util.Map <String,
the output to be sent directly to the console. Further, the String>> records;
user specifies that speed is of a greater concern than The inline code above is inserted into the template under
memory space usage. the ^^Inline Code^^ placeholder. As ACAI continues to
Based on the input, ACAI retrieves the sort plan. The find code components to fulfill the given plan step goals,
sort plan contains generation inputs and running inputs. the inline code (whether declaration, assignment or method
These help specialize some of the goals in the plan steps call) are inserted in order based on the original list of plan
and provide end user with prompts. The plan steps consist steps.
of a declaration of the input collection, an assignment With the identifier records in place in the program,
statement to assign a variable to the source of input, a ACAI will continue to use this name whenever it must
declaration of the sort operation collection variable, a sort replace other placeholders that reference this same datum.
For instance, the first assignment statement step is handled replaced with the proper value. In this case, ^^Data^^
by the inline code: becomes list.
^^Variable^^ = ^^Body^^; Once methods are put into place, the program is
which becomes complete. ACAI now provides the program as output. An
records = ^^Body^^; end user can now run the program to solve the desired
The placeholder ^^Body^^ will be replaced by a method problem. Running inputs are used to obtain the run-time
call which will obtain the input and return it as an information required for the program to fulfill the given
ArrayList to be stored in records. In this case, the selected task.
method is named readCSVFileIntoArrayList, which
contains the code to read data from a file and return it as an printDataToFile ( ^^Data^^ );
ArrayList. This method call is used to replace ^^Body^^.
In many cases, the choice of code component to fulfill a private static void printDataToFile ( Object
plan step goal is a one-to-one mapping. That is, at least objData )
presently, there are few options because of the limited {
domain that ACAI is working in. However, there are some try
{
component options. For instance, there are several // Declare variables
different sort routines available. For ACAI to select the java.io.BufferedWriter out = new
best code component for the given goal, user specifications java.io.BufferedWriter ( new
may come into play. java.io.FileWriter( "Data.txt"));
The sort step of this example could be fulfilled by any of // Write the specified string to the file
out.write ( objData.toString() );
six different sort methods. The sort code breaks down into // Flushes and closes the stream
two dimensions: the data type to be sorted and the sorting out.close ( );
algorithm. Data types are restricted to numeric, date and System.out.print("Result is stored in: "
string. Since numeric types can be handled generically in + System.getProperty("user.dir"));
Java, Float, Integer, and Double are all sorted by the same }
catch ( java.io.IOException e )
routine. As a different type of operation is required to {
compare two Date objects or two String objects, there is a e.printStackTrace ( );
need for three distinct sorting methods. There are currently }
two sorting algorithms used in ACAI, Quick Sort and }
Selection Sort. As Quick Sort uses more space but is
guaranteed to be as fast as or faster than Selection Sort, the Figure 5: Sample Method Call and Method for Output
user specification of speed over memory space causes
ACAI to select Quick Sort in this example. The result is
that the plan step goal is fulfilled by the following method Conclusions
call:
quickSortNumbers(^^Source^^, ^^Criteria^^); ACAI, Automated Coder using Artificial Intelligence,
The ^^Source^^ placeholder is replaced by the combines the case base, case selection and case storage of
aforementioned records variable. The ^^Criteria^^ CBR with plan decomposition of RD to fill in a template
placeholder references the need for the program to obtain program using TBP. In this case, ACAI succeeds in
from the end user the criteria by which the sort should automated code generation (ACG). Unlike other attempts
operate. This will be the type of data to be compared (e.g., at ACG, ACAI operates without human intervention other
a test result, patient’s age, number of visits). The than high level input specification.
placeholder is replaced by code generated based on the In ACAI, plans represent generic solutions to given
running input. The following is the method call inserted database type problems. Each plan describes its solution
into the program. through plan steps. A plan step describes the action
quickSortNumbers(records, required in terms of a goal. Goals provide such
userInputs.get(“SortUserInput2”)); information as the type of operation, specific criteria for
The program’s methods must also be inserted into the the operation, and data types.
template. Methods are largely self-contained and require Given a plan with plan steps, ACAI then selects specific
little change. However, they also contain placeholders, code components from a separate code library. Code
such as variable types, identifier names, and other method components are themselves indexed using attribute lists
calls. The example from this section called for output to which match or overlap the goals from plan steps. These
console. Assume instead that the output was to be sent to a code components combine both inline Java code and Java
disk file. Figure 5 contains the stored method selected by methods. The code components are inserted into a Java
ACAI for such an output plan step. Recall that the plan program template. Placeholders in the code are replaced
step has the generic goal of [IO – Out]. This must be by specific identifiers, types, method calls and other
specialized to fit the user specifications, output to disk file. programming units as needed.
The ^^Data^^ placeholder in the method call must be In order to provide variability, each plan tackles a
specific type of operation, such as sort or search. In
 complex problems, multiple plans are selected and refined Fahmi, S. A. and Choi H. 2009. A Study on Software
into a single solution plan. Plan merging, although not Component Selection Methods, in Proceedings of the 11th
discussed here, provides a seamless transition from one international conference on Advanced Communication
plan to another. The result is a new, more complex plan, Technology, p. 288-292, Gangwon-Do, South Korea.
which is stored back into the case base for future use.
ACAI has successfully generated programs to solve a Fernandez, M. F., Kernighan, B. W., and Schryer, N. L.
number of medical database domain queries and 1993. Template-driven Interfaces for Numerical
subqueries from the list given in Section 3. ACAI is Subroutines, in ACM Transactions on Mathematical
currently limited to the domain of medical record queries. Software (TOMS) TOMS p. 265-287.
Although this overly restricts ACAI’s abilities, it is felt
that the approach is amenable to a wide variety of
Fouqut, G., and Matwin, S. 1993. Compositional Software
problems.
Reuse with Case-based Reasoning, in 9th Conference on
It is important to note that the advantage of using ACAI,
as oppose to solving the same medical record queries using Artificial Intelligence for Applications. P. 128-134, IEEE
SQL, is that ACAI’s architecture is not restricted to any Computer Society Press.
specific programming language. The ACAI system can be
used to tackle a much wider range of problems that would Fox, R. and Cox, M. 2000. Routine Decision Making
be difficult or inappropriate to address with SQL. Applied to Nutritional Meal Planning, in the Proceedings
Additionally, ACAI allows end users with no of the International Conference on Artificial Intelligence,
programming knowledge to obtain desired results, while IC-AI'2000, Volume II, p. 987-993, H. R. Arabnia editor,
SQL would require learning the SQL language as well as CSREA Press.
having knowledge of programming concepts to accomplish
the same task. Goel, A., Bhatta, S., and Stroulia, E. 1997. Kritik: An
Due to ACAI's expandable architecture, theoretically, Early Case-based Design System, in Issues and
the only limitation of applying the system in other domains Applications of Case-Based Reasoning in Design, by M
is the availability of associated plans and code Maher and P Pu, 87-132. Mahwah, NJ: Erlbaum.
components. All that is required to expand ACAI is a
greater variety of plans and code components that can Hammond, K. J. 1986. CHEF: A Model of Case-based
implement any new plan steps. Expanding ACAI is a Planning, in Proceedings of the Fifth National Conference
direction for future research along with an examination of on Artificial Intelligence, p 267-271, AAAI.
additional forms of plan step merging and case reusability.
Another direction for future research is increasing the Hsieh, M., and Tempero, E. 2006. Supporting Software
number of criteria that a user might specify for code Reuse by the Individual Programmer, in Proceedings of
selection beyond the speed versus space tradeoff
the 29th Australasian Computer Science Conference, p 25-
mentioned here.
33, Australian Computer Society, Inc.

References Jiang, Y., and Dong, H. 2008. A Template-based E-

Brown, D. C, and Chandrasekaran, B. 1989. Design commence Website Builder for SMEs, in Proceedings of
Problem Solving: Knowledge Structures and Control the 2008 Second International Conference on Future
Strategies. Research Notes in Artificial Intelligence Series, Generation Communication and Networking Symposia -
Morgan Kaufmann Publishers, Inc. Volume 01. IEEE Computer Society.

Brown, D. C. 1996. Knowledge Compilation in Routine Jones, C. 2010. Software Engineering Best Practices. The
Design Problem-solving Systems, Artificial Intelligence McGraw-Hill Companies.
for Engineering, Design, Analysis and Manufacturing, p.
137-138, Cambridge University Press. Joshi, S. R., and McMillan, W. W. 1996. Case Based
Reasoning Approach to Creating User Interface
Chandrasekaran, B, and Josephson, J. R. 2000. Function Components, in Proceedings CHI '96 Conference
in device Representation, Engineering with Computers, companion on Human factors in computing systems:
162-177, Springer. common ground, p. 81-82.

Vazquez, G., Pace, J., and Campo M. 2008. A Case-based

Danilchenko, Y. (2011). Automated Code Generation
Reasoning Approach for Materializing Software
Using Artificial Intelligence. M.S. thesis, Dept. of
Architectures onto Object-oriented Designs, in Proceeding
Computer Science, Northern Kentucky University,
SAC '08 Proceedings of the 2008 ACM symposium on
Highland Heights, KY.
Applied Computing, p 842-843, ACM.

View publication stats