50 research outputs found
Recommended from our members
Multiparadigm data structures in Leda
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
Recommended from our members
General-purpose multiparadigm programming languages : an enabling technology for constructing complex systems
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
Recommended from our members
LacEDAemon : a programming environment for the multiparadigm language leda
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
Logic programming in the context of multiparadigm programming: the Oz experience
Oz is a multiparadigm language that supports logic programming as one of its
major paradigms. A multiparadigm language is designed to support different
programming paradigms (logic, functional, constraint, object-oriented,
sequential, concurrent, etc.) with equal ease. This article has two goals: to
give a tutorial of logic programming in Oz and to show how logic programming
fits naturally into the wider context of multiparadigm programming. Our
experience shows that there are two classes of problems, which we call
algorithmic and search problems, for which logic programming can help formulate
practical solutions. Algorithmic problems have known efficient algorithms.
Search problems do not have known efficient algorithms but can be solved with
search. The Oz support for logic programming targets these two problem classes
specifically, using the concepts needed for each. This is in contrast to the
Prolog approach, which targets both classes with one set of concepts, which
results in less than optimal support for each class. To explain the essential
difference between algorithmic and search programs, we define the Oz execution
model. This model subsumes both concurrent logic programming
(committed-choice-style) and search-based logic programming (Prolog-style).
Instead of Horn clause syntax, Oz has a simple, fully compositional,
higher-order syntax that accommodates the abilities of the language. We
conclude with lessons learned from this work, a brief history of Oz, and many
entry points into the Oz literature.Comment: 48 pages, to appear in the journal "Theory and Practice of Logic
Programming
Using non-functional requirements in component-based software construction
The main concern of this paper is to present the author's approach to support software development in the component programming framework taking functional and non-functional requirements into account. Functional requirements are written as algebraic specifications, while non-functional information is bound to specifications and implementations by means of ad hoc modules: the nonfunctional information is used to select automatically the most appropriate implementations of software components (the selection algorithm is not presented here). The existence of multiple type implementations is supported by a process model based on the prototyping paradigm. Prototyping is achieved by means of a mixed execution mechanism being able to operate in the context of incremental software development process allowing the execution of incomplete (partially implemented) systems. The ideas we present here are not bound to any particular programming language, giving rise to a method of wide applicability.Peer ReviewedPostprint (published version
Proceedings of the Resolve Workshop 2006
The aim of the RESOLVE Workshop 2006 was to bring together researchers and educators interested in: Refining formal approaches to software engineering, especially component-based systems, and introducing them into the classroom. The workshop served as a forum for participants to present and discuss recent advances, trends, and concerns in these areas, as well as formulate a common understanding of emerging research issues and possible solution paths
Recommended from our members
Implementation of first class functions and type checking for a multiparadigm language
A multiparadigm language is one which combines features of different language paradigms. Leda is a strongly typed, compiled, multi.paradigm language with facilities for imperative, functional, object oriented and relational programming. This report describes the type checker of the Leda compiler and the implementation of first class functions required for functional programming. Closure analysis is done to determine if a function can outlive its defining context. If the defining context is not on the activation stack at the time of the function invocation, the context is allocated on the heap. Type checking rules for Leda are presented. These rules illustrate the interaction between the different paradigms. The report also describes the development of the Leda compiler using an object oriented paradigm
Recommended from our members
Implementing Leda : objects and classes
Leda is a strongly typed, compiled, multiparadigm programming language. This paper describes various implementation concerns which arose from the experience of writing a Leda compiler as part of the Leda research team. These include aspects of run-time representation, symbol-table information, and code generation. The paper concentrates on objects and classes. An overview of the object-oriented features of the language is given, including our semantic view of parameterized classes
Recommended from our members
Multiparadigm extensions to Java
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