Author and noted computer scientist Timothy Budd has been at the cutting edge of multiparadigm programming research. He has developed a single programming language--Leda-- which can be used to illustrate the benefits of four different programming paradigms. Using Leda, Budd shows in his new book how the unique features of each paradigm can be learned and applied simultaneously through one multiparadigm tool.

Multiparadigm programming languages are a recent development in the realm of programming languages. A multiparadigm programming language allows the use of multiple, differing programming paradigms without departing from a single, unified linguistic framework. Multiparadigm programming languages are claimed to have benefits to both pedagogy and complex application creation. The beneficial claims of multiparadigm languages have yet to be validated. The availability of a programming environment would encourage and expedite academic and industrial validation. Creating a programming environment is considered an extremely labor intensive activity. Further complications arise from the fact that programming environment creation is an experimental activity: the component mix that best expedites program development in a new programming language cannot be predicted in advance. As a result, few new languages are ever verified in the context of a supportive programming environment. Leda, a unique programming language that includes the functional, imperative, logic and object-oriented paradigms, is at this juncture. This thesis describes the structure of an environment framework that allows for experimental study of the necessary components of a multiparadigm programming language environment. New tools and techniques, as well as changes to traditional tools and techniques are required to allow programmers to abstract effectively across paradigms. This research examines the topic by creating LacEDAemon, a testbed programming environment for the multiparadigm programming language Leda, within the framework of a variety of integrated, cohesive tools. LacEDAemon relies on a hypertool-based toolkit integration framework architecture that affords both loose and tight control integration, as well as data integration, using existing, off-the-shelf tools written in a variety of programming languages. Along with demonstrating the viability of hypertool integration as a low-cost approach for constructing programming environments, LacEDAemon provides a vehicle for: determining an effective multiparadigm programming toolset, studying multiparadigm program design, conducting studies of multiparadigm program visualization, exploring different strategies for software reuse, and examining the merits of conducting all programming activity within the database-centered environment approach. This environment also provides support for investigations in the areas of multiparadigm algorithms, multiparadigm software metrics, and multiparadigm program comprehension. Various techniques for evaluating integrated environments are also applied to LacEDAemon.

Multiparadigm programming is a term used to describe a style of software development that makes use of facilities originally designed in support of a number of different programming language paradigms. In this paper we illustrate our conception of multiparadigm programming, by describing how various data structures can be implemented in the programming language Leda. Leda is a strongly-typed compiled multiparadigm programming language that we have been developing over the past several years. Our exposition serves both to illustrate the idea of multiparadigm programming, and to describe the features of the language Leda.

Multiparadigm languages are languages that are designed to support more than one style of programming. Leda is a strongly-typed multiparadigm programming language that supports imperative, functional, object-oriented, and logic programming. The constraint programming paradigm is a declarative style of programming where the programmer is able to state relationships among some entities and expect the system to maintain the validity of these relationships throughout program execution. The system accomplishes this either by invoking user-defined fixes that impose rigid rules governing the evolution of the entities, or by finding suitable values to be assigned to the constrained entities without violating any active constraint. Constraints, due to their declarative semantics, are suitable for the direct mapping of the characteristics of a number of mechanisms including: consistency checks, constraint-directed search, and constraint-enforced reevaluation, among others. This makes constraint languages the most appropriate languages for the implementation of a large number of applications such as scheduling, planning, resource allocation, simulation, and graphical user interfaces. The semantics of constraints cannot be easily emulated by other constructs in the paradigms that are offered by the language Leda. However, the constraint paradigm does not provide any general control constructs. The lack of general control constructs impedes this paradigm's ability to naturally express a large number of problems. This dissertation presents the language Electra, which integrates the constraint paradigm into the language Leda by creating a unified construct that provides the ability to express the conventional semantics of constraints with some extensions. Due to the flexibility of this construct, the programmer is given the choice of either stating how a constraint is to be satisfied or delegating that task to the constraint-satisfier. The concept of providing the programmer with the ability to express system-maintained relations, which is the basic characteristic of constraints, provided a motivation for enhancing other paradigms with similar abilities. The functional paradigm is extended by adding to it the mechanism of condition-based dispatching which is similar to argument pattern-matching. The object-oriented paradigm is extended by allowing feature exclusion which is a form of inheritance exception. This dissertation claims that the integration provided by the language Electra will enable Leda programmers to reap the benefits of the paradigm of constraints while overcoming its limitations.

Multiparadigm programming languages have been envisioned as a vehicle for constructing large and complex heterogeneous systems, such as a stock market exchange or a telecommunications network. General-purpose multiparadigm languages, as opposed to hybrid multiparadigm languages, embody several prevalent programming paradigms without being motivated by a single problem. One such language is Leda, which embodies the foundational paradigms of imperative, functional, logic, and object-oriented programming. We explore aspects of solving complex problems using Leda, in order to illustrate the benefits of using a multiparadigm language in expressing solutions to complex systems. We claim that general-purpose multiparadigm programming languages like Leda greatly expedite solutions to a variety of complex problems.

In 1995 my students and I developed Leda, a multiparadigm language based on the Pascal model. Leda allowed programmers to create abstractions in an object-oriented, functional, or logic programming style. More recently we have been interested in recreating this work, but this time using Java as the language basis. The objective to to add as few new operations as possible, and to make these operations seem as close to Java as possible, so that they seem to fit naturally into the language. To date we have proposed facilities for breaking apart composed objects (sometimes called unboxing), for functions as first-class values, for pass-by-name parameters, and for relational (or logic) programming.

In this research, we have captured, in pattern form, key elements of programming and design in four programming paradigms (imperative, object-oriented, functional and logical) as well as multiparadigm programming. These pattern sets have formed a foundation upon which we were able to build a deeper understanding of multiparadigm programming and design. For each paradigm, we identified sets of programming patterns. We then identified design patterns for those paradigms that already have design methodologies (imperative and object-oriented). For those that do not (functional and logical), we created design pattern sets that may yet play a seminal role in formal design methodologies for those paradigms. From the relationships between programming and design patterns, we were able to identify and record methodological patterns that provide generative mappings between programming patterns and design patterns. From the sets of programming patterns, we were able to derive a pattern set for multiparadigm programming. We were also able to perform a critical analysis of the multiparadigm programming language Leda using this pattern set. Finally, we were able to apply the methodological patterns to this multiparadigm programming pattern set to aid in our search for multiparadigm design patterns. We were also able to derive insight into multiparadigm design patterns by studying the pattern sets for each of the four paradigms studied. Armed with this rich pattern system, we then created and presented a new pattern-based methodology for multiparadigm design. Finally, we applied our methodology and our pattern sets to three common design problems. We found that this new methodology lent new insights into software design, and suggested the role that multiparadigm programming and design can play in many aspects of software creation.

CLEDA is a new programming language descended from the multiparadigm, strongly typed, compiled programming language LEDA. In addition to the four paradigms supported by LEDA, which are imperative, functional, object-oriented, and relational, CLEDA supports the constraint logic programming paradigm. CLEDA is intended to be used to write applications that involve constrained search problems. Constructs provided to support constraint logic programming include: [1] Built-in inference engine: All boolean expressions are "predicates" in the logic programming sense. Built-in operators " & " and "l" support left-most depth first search and automatic backtracking. Logical expressions can be used in any programming paradigms. [2] User definable constraint solver: Constrained variables of a domain are represented in terms of objects of the corresponding class. Operations and predicates for the domain are written as methods of the class. To restore the necessary information upon backtracking, CLEDA introduces a new built-in operator "

"This report describes the revised definition of the multiparadigm programming language Leda. The first section provides an introduction to Leda and a history of its development. Section 2 covers Leda preliminaries, section 3 details the overall structure of Leda programs. Declarations are discussed in section 4, expressions are the topic of section 5. Section 6 examines Leda statements, with relational programming being the subject of section 7, and section 8 comprises of a very short discussion of constraint logic programming. Leda predefined classes are briefly described in section 9, with a short note on scoping presented in section 10 and libraries in section 11. Compiler usage is touched upon in section 12. Appendices listing reserved words, compile-time errors, run time errors, and a bibliography conclude this report."--Summary.

Computer-based mathematical modeling - the technique of representing and managing models in machine-readable form - is still in its infancy despite the many powerful mathematical software packages already available which can solve astonishingly complex and large models. On the one hand, using mathematical and logical notation, we can formulate models which cannot be solved by any computer in reasonable time - or which cannot even be solved by any method. On the other hand, we can solve certain classes of much larger models than we can practically handle and manipulate without heavy programming. This is especially true in operations research where it is common to solve models with many thousands of variables. Even today, there are no general modeling tools that accompany the whole modeling process from start to finish, that is to say, from model creation to report writing. This book proposes a framework for computer-based modeling. More precisely, it puts forward a modeling language as a kernel representation for mathematical models. It presents a general specification for modeling tools. The book does not expose any solution methods or algorithms which may be useful in solving models, neither is it a treatise on how to build them. No help is intended here for the modeler by giving practical modeling exercises, although several models will be presented in order to illustrate the framework. Nevertheless, a short introduction to the modeling process is given in order to expound the necessary background for the proposed modeling framework.