1055574
BoxScript: a component-oriented language for teaching
As component-oriented approaches become increasingly pervasive in the development of complex software systems, it becomes increasingly important to introduce computing science students to appropriate programming concepts, languages and techniques. This paper describes the design of the component-oriented language BoxScript, which seeks to address the needs of teachers and students for a clean, simple language. This paper first enumerates the principles applied in the language design and then presents the key concepts and features of BoxScript. The paper illustrates the language features by using an example and by comparing it with several other component-oriented programming languages.
1073181
Keeping Secrets within a Family: Rediscovering Parnas
David Parnas wrote several papers in the 1970’s and 1980’s that are now considered classics. The concepts he advocated such as information hiding and use of abstract interfaces are generally accepted as the appropriate way to design nontrivial software systems. However, not all of what he proposed has been fully appreciated and assimilated into our practices. Many of his simple, elegant ideas have been lost amongst the hype surrounding the technologies and methods that have arisen in the past two decades. This paper examines Parnas’s ideas, especially his emphasis on program families, and proposes that college-level computing science and software engineering curricula should renew their attention to these very important principles and techniques and present them in the context of contemporary software development.
11623191
Mapping component specifications to Enterprise JavaBeans implementations
Component-based software development has become an important approach to building complex software systems. Much research focuses on component specification to achieve the advantages of the component-based approach in theory. Most of this research pays little attention to the mappings from component specifications to component implementations. However, the mappings are important because they determine whether the implementations perform satisfactorily to meet the specifications. After presenting a general approach to component specification and the technology of Enterprise JavaBeans (EJB) component model, this paper presents three approaches to mapping from component specification to EJB implementation. This paper uses a course registration system as an example to demonstrate the ideas. The approaches presented will be helpful to those who are working on the realizations of component systems.
39241507
Feature selection using a proximity-index optimization model
Abstract One of the recurring issues in pattern recognition problems has been feature extraction and selection. This paper addresses this issue from a different pespective. Without assuming any particular classificaiton algorithm, it first suggests that one extract as much information as conveniently possible in several pattern-information domains. This paper later suggests applying the proposed Proximity-Index method, to select a significantly smaller, yet optimal feature subset. This method is formally described and is successfully applied to a waveform classification problem. The features selected by the algorithm are used to classify ten signal classes and produce a very encouraging recognition performance of 87.00% on 200 samples. This method is computationally inexpensive and particularly useful for large data set problems.
14608755
CACHET: an interactive, incremental-attribution-based program transformation system for deriving incremental programs
The paper describes the design and implementation of an interactive, incremental-attribution-based program transformation system, CACHET, that derives incremental programs from non-incremental programs written in a functional language. CACHET is designed as a programming environment and implemented using a language-based editor generator, the Synthesizer Generator, with extensions that support complex transformations. Transformations directly manipulate the program tree and take into consideration information obtained from program analyses. Program analyses are performed via attribute evaluation, which is done incrementally as transformations change the program tree. The overall approach also explores a general framework for describing dynamic program semantics using annotations, which allows interleaving transformations with external input, such as user input. Designing CACHET as a programming environment also facilitates the integration of program derivation and validation with interactive editing, compiling, debugging, and execution.
10859249
Making use of population information in evolutionary artificial neural networks
This paper is concerned with the simultaneous evolution of artificial neural network (ANN) architectures and weights. The current practice in evolving ANN's is to choose the best ANN in the last generation as the final result. This paper proposes a different approach to form the final result by combining all the individuals in the last generation in order to make best use of all the information contained in the whole population. This approach regards a population of ANN's as an ensemble and uses a combination method to integrate them. Although there has been some work on integrating ANN modules, little has been done in evolutionary learning to make best use of its population information. Four linear combination methods have been investigated in this paper to illustrate our ideas. Three real-world data sets have been used in our experimental studies, which show that the recursive least-square (RLS) algorithm always produces an integrated system that outperforms the best individual. The results confirm that a population contains more information than a single individual. Evolutionary learning should exploit such information to improve generalization of learned systems.
7399855
Parametric regular path queries
Regular path queries are a way of declaratively expressing queries on graphs as regular-expression-like patterns that are matched against paths in the graph. There are two kinds of queries: existential queries, which specify properties about individual paths, and universal queries, which specify properties about all paths. They provide a simple and convenient framework for expressing program analyses as queries on graph representations of programs, for expressing verification (model-checking) problems as queries on transition systems, for querying semi-structured data, etc. Parametric regular path queries extend the patterns with variables, called parameters, which significantly increase the expressiveness by allowing additional information along single or multiple paths to be captured and relate.This paper shows how a variety of program analysis and model-checking problems can be expressed easily and succinctly using parametric regular path queries. The paper describes the specification, design, analysis, and implementation of algorithms and data structures for efficiently solving existential and universal parametric regular path queries. Major contributions include the first complete algorithms and data structures for directly and efficiently solving existential and universal parametric regular path queries, detailed complexity analysis of the algorithms, detailed analytical and experimental performance comparison of variations of the algorithms and data structures, and investigation of efficiency tradeoffs between different formulations of queries.
15838270
Eliminating Dead Code on Recursive Data
This paper describes a general and powerful method for dead code analysis and elimination in the presence of recursive data constructions. We represent partially dead recursive data using liveness patterns based on general regular tree grammars extended with the notion of live and dead, and we formulate the analysis as computing liveness patterns at all program points based on program semantics. This analysis yields a most precise liveness pattern for the data at each program point, which is significantly more precise than results from previous methods. The analysis algorithm takes cubic time in terms of the size of the program in the worst case but is very efficient in practice, as shown by our prototype implementation. The analysis results are used to identify and eliminate dead code. The general framework for representing and analyzing properties of recursive data structures using general regular tree grammars applies to other analyses as well.