48 research outputs found
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
A visual object-oriented environment for LISP.
by Leong Hong Va.Thesis (M.Phil.)--Chinese University of Hong Kong, 1989.Bibliography: leaves 142-146
A requirements specification for a software design support system
Most existing software design systems (SDSS) support the use of only a single design methodology. A good SDSS should support a wide variety of design methods and languages including structured design, object-oriented design, and finite state machines. It might seem that a multiparadigm SDSS would be expensive in both time and money to construct. However, it is proposed that instead an extensible SDSS that directly implements only minimal database and graphical facilities be constructed. In particular, it should not directly implement tools to faciliate language definition and analysis. It is believed that such a system could be rapidly developed and put into limited production use, with the experience gained used to refine and evolve the systems over time
Recommended from our members
Pattern systems and methodologies for multiparadigm analysis and design
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
A Specification Environment That Supports the Prototyping of Distributed Systems Using an Object-Oriented Model.
High-speed computer networking, interactive service, and incremental growth for computing are some of the motivations for developing a distributed system. Despite the inherent benefits of a distributed system, the development of software support is more difficult for distributed systems than for sequential systems. In either case, difficulties may arise from the communication problems between two groups of people with different backgrounds trying to formulate requirements for the system. This process depends on feedback and may take many iterations to converge. Customers can usually recognize the features they need when they start using a system, which makes prototyping an important tool in requirement analysis. Many prototyping goals, objectives, and approaches are possible. Executable formal specifications are the most attractive ones. This unification of specification and prototyping by having code generators has advantages of providing consistency and prototyping at higher levels of abstraction. Thus, a methodology for executing the DOSL (Distributed Object-based Specification Language) is defined and a prototype system is developed. DOSL is extended as a new formal distributed object-oriented specification language, DOSL-II. DOSL-II is object-oriented rather than object-based, and includes class, inheritance, simple I/O, stream I/O, concurrent I/O, and new constructs for object communication
Semantic definition of a subset of the structured query language (SQL)
Journal ArticleSQL is a relational database definition and manipulation language. Portions of the manipulation language are readily described in terms of relational algebra. The semantics of a subset of the SQL select statement is described. The select statement allows the user to query the database. The select statement is shown to be equivalent to a series of relational and set operations. The semantics are described in terms of abstract data types for relation schemes, tuples, and relations. Certain forms of the union or intersection of two select statements are shown to have equivalent single select statement forms
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
Lisp, Jazz, Aikido -- Three Expressions of a Single Essence
The relation between Science (what we can explain) and Art (what we can't)
has long been acknowledged and while every science contains an artistic part,
every art form also needs a bit of science. Among all scientific disciplines,
programming holds a special place for two reasons. First, the artistic part is
not only undeniable but also essential. Second, and much like in a purely
artistic discipline, the act of programming is driven partly by the notion of
aesthetics: the pleasure we have in creating beautiful things. Even though the
importance of aesthetics in the act of programming is now unquestioned, more
could still be written on the subject. The field called "psychology of
programming" focuses on the cognitive aspects of the activity, with the goal of
improving the productivity of programmers. While many scientists have
emphasized their concern for aesthetics and the impact it has on their
activity, few computer scientists have actually written about their thought
process while programming. What makes us like or dislike such and such language
or paradigm? Why do we shape our programs the way we do? By answering these
questions from the angle of aesthetics, we may be able to shed some new light
on the art of programming. Starting from the assumption that aesthetics is an
inherently transversal dimension, it should be possible for every programmer to
find the same aesthetic driving force in every creative activity they
undertake, not just programming, and in doing so, get deeper insight on why and
how they do things the way they do. On the other hand, because our aesthetic
sensitivities are so personal, all we can really do is relate our own
experiences and share it with others, in the hope that it will inspire them to
do the same. My personal life has been revolving around three major creative
activities, of equal importance: programming in Lisp, playing Jazz music, and
practicing Aikido. But why so many of them, why so different ones, and why
these specifically? By introspecting my personal aesthetic sensitivities, I
eventually realized that my tastes in the scientific, artistic, and physical
domains are all motivated by the same driving forces, hence unifying Lisp,
Jazz, and Aikido as three expressions of a single essence, not so different
after all. Lisp, Jazz, and Aikido are governed by a limited set of rules which
remain simple and unobtrusive. Conforming to them is a pleasure. Because Lisp,
Jazz, and Aikido are inherently introspective disciplines, they also invite you
to transgress the rules in order to find your own. Breaking the rules is fun.
Finally, if Lisp, Jazz, and Aikido unify so many paradigms, styles, or
techniques, it is not by mere accumulation but because they live at the
meta-level and let you reinvent them. Working at the meta-level is an
enlightening experience. Understand your aesthetic sensitivities and you may
gain considerable insight on your own psychology of programming. Mine is
perhaps common to most lispers. Perhaps also common to other programming
communities, but that, is for the reader to decide..