This is an important textbook on artificial intelligence that uses the unifying thread of search to bring together most of the major techniques used in symbolic artificial intelligence. The authors, aware of the pitfalls of being too general or too academic, have taken a practical approach in that they include program code to illustrate their ideas. Furthermore, code is offered in both POP-11 and Prolog, thereby giving a dual perspective, highlighting the merits of these languages. Each chapter covers one technique and divides up into three sections: a section which introduces the technique (and its usual applications) andsuggests how it can be understood as a variant/generalisation of search; a section which developed a low'-level (POP-11) implementation; a section which develops a high-level (Prolog) implementation of the technique. The authors also include useful notes on alternative treatments to the material, further reading and exercises. As a practical book it will be welcomed by a wide audience including, those already experienced in AI, students with some background in programming who are taking an introductory course in AI, and lecturers looking for a precise, professional and practical text book to use in their AI courses. About the authors: Dr Christopher Thornton has a BA in Economics, an Sc in Computer Science and a DPhil in Artificial Intelligence. Formerly a lecturer in the Department of AI at the University of Edinburgh, he is now a lecturer in AI in the School of Cognitive and Computing Sciences at the University of Sussex. Professor Benedict du Boulay has a BSc in Physics and a PhD in Artificial Intelligence. Previously a lecturer in the Department of Computing Science at the University of Aberdeen he is currently Professor of Artificial Intelligence, also in the School of Cognitive and Computing Sciences, University of Sussex.

Program synthesis is a solution to the software crisis. If we had a program that develops correct programs from specifications, then program validation and maintenance would disappear from the software life-cycle, and one could focus on the more creative tasks of specification elaboration, validation, and maintenance, because replay of program development would be less costly. This monograph describes a novel approach to Inductive Logic Programming (ILP), which cross-fertilizes logic programming and machine learning. Aiming at the synthesis of recursive logic programs only, and this from incomplete information, we take a software engineering approach that is more appropriate than a pure artificial intelligence approach. This book is suitable as a secondary text for graduate level courses in software engineering and artificial intelligence, and as a reference for practitioners of program synthesis.

Automatic Re-engineering of Software Using Genetic Programming describes the application of Genetic Programming to a real world application area - software re-engineering in general and automatic parallelization specifically. Unlike most uses of Genetic Programming, this book evolves sequences of provable transformations rather than actual programs. It demonstrates that the benefits of this approach are twofold: first, the time required for evaluating a population is drastically reduced, and second, the transformations can subsequently be used to prove that the new program is functionally equivalent to the original. Automatic Re-engineering of Software Using Genetic Programming shows that there are applications where it is more practical to use GP to assist with software engineering rather than to entirely replace it. It also demonstrates how the author isolated aspects of a problem that were particularly suited to GP, and used traditional software engineering techniques in those areas for which they were adequate. Automatic Re-engineering of Software Using Genetic Programming is an excellent resource for researchers in this exciting new field.

Case-based reasoning means reasoning based on remembering previous experiences. A reasoner using old experiences (cases) might use those cases to suggest solutions to problems, to point out potential problems with a solution being computed, to interpret a new situation and make predictions about what might happen, or to create arguments justifying some conclusion. A case-based reasoner solves new problems by remembering old situations and adapting their solutions. It interprets new situations by remembering old similar situations and comparing and contrasting the new one to old ones to see where it fits best. Case-based reasoning combines reasoning with learning. It spans the whole reasoning cycle. A situation is experienced. Old situations are used to understand it. Old situations are used to solve a problem (if there is one to be solved). Then the new situation is inserted into memory alongside the cases it used for reasoning, to be used another time. The key to this reasoning method, then, is remembering. Remembering has two parts: integrating cases or experiences into memory when they happen and recalling them in appropriate situations later on.The case-based reasoning community calls this related set of issues the indexing problem. In broad terms, it means finding in memory the experience closest to a new situation. In narrower terms, it can be described as a two-part problem: * assigning indexes or labels to experiences when they are put into memory that describe the situations to which they are applicable, so that they can be recalled later; and * at recall time, elaborating the new situation in enough detail so that the indexes it would have if it were in the memory are identified. Case-Based Learning is an edited volume of original research comprising invited contributions by leading workers. This work has also been published as a special issues of MACHINE LEARNING, Volume 10, No. 3.

This book presents the thoroughly refereed and revised post-workshop proceedings of the 17th Monterey Workshop, held in Oxford, UK, in March 2012. The workshop explored the challenges associated with the Development, Operation and Management of Large-Scale complex IT Systems. The 21 revised full papers presented were significantly extended and improved by the insights gained from the productive and lively discussions at the workshop, and the feedback from the post-workshop peer reviews.

This book shows readers how to get the most out of C# using Object Orientation. The author takes a hands-on approach to learning C# and object orientation, using lots of worked examples. The text provides an ideal base from which to start programming. After introducing the C# language and object orientation, John Hunt goes on to explain: how to construct a user interface for a simple editor; how to obtain information on files and directories and how objects can be stored and restored using serialization... -Presents C# and object-orientation as a coherent whole, using one to strengthen the presentation of the other -Includes lots of complete and worked examples to clarify readers'understanding -The source code for the examples is available at: http://www.guide-to-csharp.net -Hunt is a successful Springer author, and this book is written in the same style as his Java for Practitioners

Recent developments in computer science clearly show the need for a better theoretical foundation for some central issues. Methods and results from mathematical logic, in particular proof theory and model theory, are of great help here and will be used much more in future than previously. This book provides an excellent introduction to the interplay of mathematical logic and computer science. It contains extensively reworked versions of the lectures given at the 1997 Marktoberdorf Summer School by leading researchers in the field.
Topics covered include: proof theory and specification of computation (J.-Y. Girard, D. Miller), complexity of proofs and programs (S. R. Buss, S. S. Wainer), computational content of proofs (H. Schwichtenberg), constructive type theory (P. Aczel, H. Barendregt, R. L. Constable), computational mathematics, (U. Martin), rewriting logic (J. Meseguer), and game semantics (S. Abramski).

"Introduction to Computational Science" was developed over a period of two years at the University of Utah Department of Computer Science in conjunction with the U.S. Department of Energy-funded Undergraduate Computation in Engineering Science (UCES) program. Each chapter begins by introducing a problem and then guiding the student through its solution. The computational techniques needed to solve the problem are developed as necassary, making the motivation for learning the computing alwasy apparent. Each chapter will introduce a single problem that will be used to motivate a single computing concept. The notes currently consist of 15 chapters. The first seven chapters deal with Maple and the last eight with C. The textbook will contain 20 to 30 chapters covering a similar mix of concepts at a finer level of detail.

This book constitutes the refereed proceedings of the Fifth International Symposium on Search-Based Software Engineering, SSBSE 2013, held in St. Petersburg, Russia. The 14 revised full papers, 6 revised short papers, and 6 papers of the graduate track presented together with 2 keynotes, 2 challenge track papers and 1 tutorial paper were carefully reviewed and selected from 50 initial submissions. Search Based Software Engineering (SBSE) studies the application of meta-heuristic optimization techniques to various software engineering problems, ranging from requirements engineering to software testing and maintenance.

Language, Compilers and Run-time Systems for Scalable Computers contains 20 articles based on presentations given at the third workshop of the same title, and 13 extended abstracts from the poster session. Starting with new developments in classical problems of parallel compiler design, such as dependence analysis and an exploration of loop parallelism, the book goes on to address the issues of compiler strategy for specific architectures and programming environments. Several chapters investigate support for multi-threading, object orientation, irregular computation, locality enhancement, and communication optimization. Issues of the interface between language and operating system support are also discussed. Finally, the load balance issues are discussed in different contexts, including sparse matrix computation and iteratively balanced adaptive solvers for partial differential equations. Some additional topics are also discussed in the extended abstracts. Each chapter provides a bibliography of relevant papers and the book can thus be used as a reference to the most up-to-date research in parallel software engineering.

This book constitutes the refereed proceedings of the 10th Asian Symposium on Programming Languages and Systems, APLAS 2012, held in Kyoto, Japan, in December 2012. The 24 revised full papers presented together with the abstracts of 3 invited talks were carefully reviewed and selected from 58 submissions. The papers are organized in topical sections on concurrency, security, static analysis, language design, dynamic analysis, complexity and semantics, and program logics and verification.

Distributed and Parallel Systems: From Instruction Parallelism to Cluster Computing is the proceedings of the third Austrian-Hungarian Workshop on Distributed and Parallel Systems organized jointly by the Austrian Computer Society and the MTA SZTAKI Computer and Automation Research Institute. This book contains 18 full papers and 12 short papers from 14 countries around the world, including Japan, Korea and Brazil. The paper sessions cover a broad range of research topics in the area of parallel and distributed systems, including software development environments, performance evaluation, architectures, languages, algorithms, web and cluster computing. This volume will be useful to researchers and scholars interested in all areas related to parallel and distributed computing systems.

This book constitutes the thoroughly refereed post-conference proceedings of the 18th International Conference on Principles and Practice of Constraint Programming (CP 2012), held in Quebec, Canada, in October 2012. The 68 revised full papers were carefully selected from 186 submissions. Beside the technical program, the conference featured two special tracks. The former was the traditional application track, which focused on industrial and academic uses of constraint technology and its comparison and integration with other optimization techniques (MIP, local search, SAT, etc.) The second track, featured for the first time in 2012, concentrated on multidisciplinary papers: cross-cutting methodology and challenging applications collecting papers that link CP technology with other techniques like machine learning, data mining, game theory, simulation, knowledge compilation, visualization, control theory, and robotics. In addition, the track focused on challenging application fields with a high social impact such as CP for life sciences, sustainability, energy efficiency, web, social sciences, finance, and verification.

Object relationships in modern software systems are becoming increasingly numerous and complex, and program errors due to violations of object relationships are difficult to detect. Programmers need new tools that allow them to explore objects in a large system more efficiently and to detect broken object relationships instantaneously. Such tools incorporate approaches used in such areas as data visualization, pattern matching and extraction, database querying, active databases, and rule-based programming. The query-based debugging approach developed by the author of this book is another powerful yet efficient tool to be added to the developer's tool chest. Advanced Debugging Methods presents practice and tools for debugging computer programs. This book proposes new powerful approaches that simplify the daunting task of debugging complex software systems. Although debugging has been addressed in numerous research papers, many of its methods have yet to be explored in a book-length format. This book helps to fill this gap by presenting an overview of existing debugging tools with motivating examples and case studies, as well as presenting new, state-of-the-art debugging methods. Advanced Debugging Methods will be of use to software developers looking for tools to be applied in cutting edge practice; system architects looking at the relationship between software design and debugging; tools and programming language researchers looking for new ideas in run-time tool implementation as well as detailed descriptions of advanced implementations; and university professors and graduate students who will use this book as supplementary reading for graduate courses in programming tools, language implementation, and advanced object-oriented systems. Advanced Debugging Methods is also a handy reference of currently existing debugging methodologies as well as a springboard for cutting-edge research to simplify the difficult task of debugging and to facilitate the development of more robust software systems.

In brief summary, the following results were presented in this work: * A linear time approach was developed to find register requirements for any specified CS schedule or filled MRT. * An algorithm was developed for finding register requirements for any kernel that has a dependence graph that is acyclic and has no data reuse on machines with depth independent instruction templates. * We presented an efficient method of estimating register requirements as a function of pipeline depth. * We developed a technique for efficiently finding bounds on register require ments as a function of pipeline depth. * Presented experimental data to verify these new techniques. * discussed some interesting design points for register file size on a number of different architectures. REFERENCES [1] Robert P. Colwell, Robert P. Nix, John J O'Donnell, David B Papworth, and Paul K. Rodman. A VLIW Architecture for a Trace Scheduling Com piler. In Architectural Support for Programming Languages and Operating Systems, pages 180-192, 1982. [2] C. Eisenbeis, W. Jalby, and A. Lichnewsky. Compile-Time Optimization of Memory and Register Usage on the Cray-2. In Proceedings of the Second Workshop on Languages and Compilers, Urbana l/inois, August 1989. [3] C. Eisenbeis, William Jalby, and Alain Lichnewsky. Squeezing More CPU Performance Out of a Cray-2 by Vector Block Scheduling. In Proceedings of Supercomputing '88, pages 237-246, 1988. [4] Michael J. Flynn. Very High-Speed Computing Systems. Proceedings of the IEEE, 54:1901-1909, December 1966.

This book constitutes the refereed proceedings of the 2nd International Conference on Model and Data Engineering, MEDI 2012, held in Poitiers, France, in October 2012. The 12 revised full papers presented together with 5 short papers were carefully reviewed and selected from 35 submissions. The papers are cover the topics of model driven engineering, ontology engineering, formal modeling, security, and data mining.

Despite its highly adaptable and flexible nature, C++ is also one of the more complex programming languages to learn. Once mastered, however, it can help you organize and process information with amazing efficiency and quickness.

The "C++ Cookbook" will make your path to mastery much shorter. This practical, problem-solving guide is ideal if you're an engineer, programmer, or researcher writing an application for one of the legions of platforms on which C++ runs. The algorithms provided in "C++ Cookbook" will jump-start your development by giving you some basic building blocks that you don't have to develop on your own.

Less a tutorial than a problem-solver, the book addresses many of the most common problems you're likely encounter--whether you've been programming in C++ for years or you're relatively new to the language. Here are just some of the time-consuming tasks this book contains practical solutions for: Reading the contents of a directoryCreating a singleton classDate and time parsing/arithmeticString and text manipulationWorking with filesParsing XMLUsing the standard containers

Typical of O'Reilly's "Cookbook" series, "C++ Cookbook" is written in a straightforward format, featuring recipes that contain problem statements and code solutions, and apply not to hypothetical situations, but those that you're likely to encounter. A detailed explanation then follows each recipe in order to show you how and why the solution works. This question-solution-discussion format is a proven teaching method, as any fan of the "Cookbook" series can attest to. This book will move quickly to the top of your list of essential C++ references.

Since the first edition of this book was written in 1977, there has been a tremendous increase in the use of Pascal. This increased use has had two significant effects. (1) It has produced a bett er understanding of the facilities of Pascal and their use. (2) It has fostered the production of the ISO standard for Pascal. This second edition reflects both this better understanding and the clarifications and changes to Pascal which have resulted from the production of the BSljlSO Pascal standard. The standard (BS 6192, which supplies the technical content for ISO 7185) is the definitive document on Pascal. My work on the Pascal standard has convinced me that the description of a programming language may be tutorial, or it may be definitive, or it may be neither! The chapters of this book do not constitute a definitive description of Pascal. They are essentially tutorial. The book is based on an introductory lecture course given at Manchester. In addition to lectures, the course consists of two kinds of practical work. The first is based on the solution of short pencil-and-paper exercises. The second requires the student to write complete programs and run them using interactive computer terminals. Each chapter of the book concludes with exercises and problems suitable forthese purposes. Although solutions to all of these are not presented in the book, teaching staff may obtain them by application to the authors.

Parsing technology traditionally consists of two branches, which correspond to the two main application areas of context-free grammars and their generalizations. Efficient deterministic parsing algorithms have been developed for parsing programming languages, and quite different algorithms are employed for analyzing natural language. The Functional Treatment of Parsing provides a functional framework within which the different traditional techniques are restated and unified. The resulting theory provides new recursive implementations of parsers for context-free grammars. The new implementations, called recursive ascent parsers, avoid explicit manipulation of parse stacks and parse matrices, and are in many ways superior to conventional implementations. They are applicable to grammars for programming languages as well as natural languages. The book has been written primarily for students and practitioners of parsing technology. With its emphasis on modern functional methods, however, the book will also be of benefit to scientists interested in functional programming. The Functional Treatment of Parsing is an excellent reference and can be used as a text for a course on the subject.

This book constitutes the refereed proceedings of the 15th International Conference on Model Driven Engineering Languages and Systems, MODELS 2012, held in Innsbruck, Austria, in September/October 2012. The 50 papers presented in this volume were carefully reviewed and selected from a total of 181 submissions. They are organized in topical sections named: metamodels and domain specific modeling; models at runtime; model management; modeling methods and tools, consistency analysis, software product lines; foundations of modeling; static analysis techniques; model testing and simulation; model transformation; model matching, tracing and synchronization; modeling practices and experience; and model analysis.

It is recognized that formal design and verification methods are an important requirement for the attainment of high quality system designs. The field has evolved enormously during the last few years, resulting in the fact that formal design and verification methods are nowadays supported by several tools, both commercial and academic. If different tools and users are to generate and read the same language then it is necessary that the same semantics is assigned by them to all constructs and elements of the language. The current IEEE standard VHDL language reference manual (LRM) tries to define VHDL as well as possible in a descriptive way, explaining the semantics in English. But rigor and clarity are very hard to maintain in a semantics defined in this way, and that has already given rise to many misconceptions and contradictory interpretations. Formal Semantics for VHDL is the first book that puts forward a cohesive set of semantics for the VHDL language. The chapters describe several semantics each based on a different underlying formalism: two of them use Petri nets as target language, and two of them higher order logic. Two use functional concepts, and finally another uses the concept of evolving algebras. Formal Semantics for VHDL is essential reading for researchers in formal methods and can be used as a text for an advanced course on the subject.

If you need to parse or process text data in Linux or Unix, this classic book explains how to use flex and bison to solve your problems quickly - whether you're interpreting code, configuration files, or any other structured format. "Flex and Bison" is the long-awaited sequel to the classic O'Reilly book, "Lex and Yacc". In the nearly two decades since that book was published, the "Flex and Bison" utilities have proven to be more reliable and more powerful than the original Unix tools. This book covers the same core functionality vital to Linux and Unix program development, along with several important new topics. This thoroughly updated edition will help you: address syntax crunching that regular expressions tools can't handle; build compilers and interpreters, and handle a wide range of text processing functions; learn key programming techniques, including syntax trees and symbol tables; implement a full SQL grammar, with complete sample code; and, use new features such as pure (reentrant) lexers and parsers, powerful GLR parsers, and interfaces to C++. This book includes revised tutorial sections for novice users and reference sections for advanced users, with chapters that explain each utility's basic usage and simple, stand-alone applications. Dive into "Flex and Bison" and discover the wide range of uses these flexible tools provide.

The theory of constructive (recursive) models follows from works of Froehlich, Shepherdson, Mal'tsev, Kuznetsov, Rabin, and Vaught in the 50s. Within the framework of this theory, algorithmic properties of abstract models are investigated by constructing representations on the set of natural numbers and studying relations between algorithmic and structural properties of these models. This book is a very readable exposition of the modern theory of constructive models and describes methods and approaches developed by representatives of the Siberian school of algebra and logic and some other researchers (in particular, Nerode and his colleagues). The main themes are the existence of recursive models and applications to fields, algebras, and ordered sets (Ershov), the existence of decidable prime models (Goncharov, Harrington), the existence of decidable saturated models (Morley), the existence of decidable homogeneous models (Goncharov and Peretyat'kin), properties of the Ehrenfeucht theories (Millar, Ash, and Reed), the theory of algorithmic dimension and conditions of autostability (Goncharov, Ash, Shore, Khusainov, Ventsov, and others), and the theory of computable classes of models with various properties. Future perspectives of the theory of constructive models are also discussed. Most of the results in the book are presented in monograph form for the first time. The theory of constructive models serves as a basis for recursive mathematics. It is also useful in computer science, in particular, in the study of programming languages, higher level languages of specification, abstract data types, and problems of synthesis and verification of programs. Therefore, the book will be useful for not only specialists in mathematical logic and the theory of algorithms but also for scientists interested in the mathematical fundamentals of computer science. The authors are eminent specialists in mathematical logic. They have established fundamental results on elementary theories, model theory, the theory of algorithms, field theory, group theory, applied logic, computable numberings, the theory of constructive models, and the theoretical computer science.

This book constitutes the proceedings of the 16th Brazililan Symposium on Programming Languages, SBLP 2012, held in Natal, Brazil, in September 2012. The 10 full and 2 short papers were carefully reviewed and selected from 27 submissions. The papers cover various aspects of programming languages and software engineering.

This book constitutes the thoroughly refereed proceedings of the 10th International Symposium on Automated Technology for Verification and Analysis, ATVA 2012, held at Thiruvananthapuram, Kerala, India, in October 2012. The 25 regular papers, 3 invited papers and 4 tool papers presented were carefully selected from numerous submissions. Conference papers are organized in 9 technical sessions, covering the topics of automata theory, logics and proofs, model checking, software verification, synthesis, verification and parallelism, probabilistic verification, constraint solving and applications, and probabilistic systems.