Responsibilities and Rewards: Specifying Design Patterns

Total Page:16

File Type:pdf, Size:1020Kb

Responsibilities and Rewards: Specifying Design Patterns Responsibilities and Rewards: Specifying Design Patterns Neelam Soundarajan and Jason O. Hallstrom Computer and Information Science Ohio State University, Columbus, OH 43210 e-mail: neelam, hallstro @cis.ohio-state.edu Abstract Second, when a new designer joins the design team, he or she will be able, given prior knowledge and understanding Design patterns provide guidance to system designers on of the specific patterns involved, to get a quicker and more how to structure individual classes or groups of classes, as thorough grasp of how the system is structured, why it be- well as constraints on the interactions among these classes, haves in particular ways, etc. to enable them to implement flexible and reliable systems. But if we are to fully realize these benefits, we must have Patterns are usually described informally. While such in- precise ways to reason about these design patterns that we formal descriptions are useful and even essential, if we want can apply to understand and predict the behavior of systems to be sure that designers precisely and unambiguously un- built using them. Our goal in this paper is to investigate such derstand the requirements that must be met when applying reasoning techniques. In our approach, the specification of a given pattern, and be able to reliably predict the behav- a pattern will consist of two components. The responsibili- iors the resulting system will exhibit, we also need formal ties component will consist of the conditions that a designer characterizations of the patterns. must ensure are satisfied with regards to the structures of the In this paper, we develop an approach to formalizing de- classes, the behaviors of particular methods of the classes, sign patterns. The requirements that a designer must meet and the interactions among various classes. The rewards with respect to the structures of the classes, as well as with component will specify the particular patterns of behavior respect to the behaviors exhibited by the relevant methods, that the resulting system will be guaranteed to exhibit if all are captured in the responsibilities component of the pat- the requirements contained in the responsibilities compo- tern’s specification; the benefits that will result by applying nent are satisfied. the pattern, in terms of specific behaviors that the result- In specifying a pattern, we will start by listing the roles ing system will be guaranteed to exhibit, are captured in the that make up the pattern. For example, in the case of the rewards component. One important aspect of many design Observer pattern [5], which we will use as the running ex- patterns is their flexibility; our approach is designed to en- ample throughout the paper, there are two roles, Subject sure that this flexibility is retained in the formalization of and Observer. This information is already clear from the the pattern. We illustrate the approach by applying it to a standard UML representation of the pattern (Fig. 1). Also standard design pattern. clear from the diagram is the fact that the Notify() method of Subject will invoke the Update() method on each of the observers1. What is not clear is when Notify() will be 1 Introduction called and by whom. This question is addressed in the com- mentary (under “Collaborations”) in the description of the Design patterns [1, 2, 5, 8, 15] are widely regarded as Observer pattern in [5], “. subject notifies its observers one of the most powerful tools in designing OO systems. whenever a change occurs that could make its observers’ Specific patterns provide precise guidance on how to struc- state inconsistent with its own.” But it is not clear how the ture individual classes or groups of classes, as well as the 1We use names starting with uppercase letters such as Subject for interactions among these classes, to implement flexible and roles; and the corresponding lowercase names such as subject to refer reliable solutions in specific contexts. Using design patterns to the individual objects that play these roles. We also use names starting helps system designers in two ways: First, design patterns with uppercase letters for patterns, classes, and methods; member variables represent the collective wisdom and experience of the com- will have names starting with lowercase letters. In some cases the name of a pattern is also used for one of the roles in that pattern, as in the case of munity, so the application of the relevant patterns should the Observer role of the Observer pattern. In such cases, the context will lead to higher quality systems with predictable behavior. make clear whether we are talking about the role or the pattern. Proceedings of the 26th International Conference on Software Engineering (ICSE’04) 0270-5257/04 $20.00 © 2004 IEEE subject will know when its state has become inconsistent Most previous work on patterns has focused on identify- with that of one or more observers. Indeed, what does it ing patterns and specifying them informally, usually in the mean to say that the subject state has become inconsistent style introduced by [5]. There has been some work related with that of an observer? How is this to be determined? to formal aspects of patterns; these have dealt with such Perhaps more to the point from the point of view of a de- things as modeling patterns using temporal action systems, signer, what exactly are the requirements that the designer categories, etc. To our knowledge, there has not been much must ensure are met in order to apply the pattern as in- work that has tried to specify patterns by formally defin- tended? And what exactly can the designer expect in re- ing the exact program properties that the use of the pattern turn for meeting these requirements? For the Observer pat- will ensure, or the requirements that a system adopting a tern, the return is that if the pattern is applied as intended, given pattern should meet. We will briefly address indi- the view of each observer will remain consistent with the vidual items of related work later in the paper but one im- subject’s state – again consistent in what sense? As we will portant notion that we should mention here is Reenskaug’s see, the kind of formal specifications that we develop in this [13] role models. Role models allow us to focus on the in- paper will provide precise answers to these questions. teractions among the various objects participating in what area of concern There is an inherent risk in formalizing design patterns he calls an . For example, an area of con- [14] in that flexibility, which is the hallmark of many de- cern for a system could be the question of how a group of observer subject sign patterns, may be lost. For example, in the case of objects keep track of the changes in a . Observer, if we adopt one definition for the notion of in- An important point here is that a given object playing the Observer consistency, the pattern may not be usable in systems that role of an may have many other aspects to it that have a different notion of this concept. As we will see, our are not relevant to this area of concern. Although Reen- approach, while requiring us to provide a precise character- skaug’s work is not concerned with formal specifications, ization of the pattern, also enables us to retain the flexibility his ideas on role models have heavily influenced our ap- contained in the pattern. proach to specifying patterns formally. As we will see, the major part of the pattern’s specification is the precise speci- There is a similarity between our approach to specifying fication of the various roles in that pattern. design patterns and the standard design-by-contract (DBC) In the next section, we develop the basic ideas of our ap- approach [9, 10, 11] using pre/post-conditions and invari- proach. We analyze the different components that must be ants to specify classes and methods. In DBC, the meth- included in the specification of a pattern and some possi- ods of each class have a precisely defined pre-condition and ble variations. In Section 3, we apply our approach to the post-condition, and the class as a whole has an invariant as- Observer pattern and develop a specification for this pat- sociated with it. Whenever invoking a method of a class, tern. In Section 4 we consider related work. In the final it is the caller’s responsibility to make sure that the corre- section, we summarize our approach, reiterate the advan- sponding pre-condition is satisfied. In return, the caller is tages of having formal specifications of patterns, and con- assured that when control returns, the post-condition will sider pointers for future work. be satisfied (assuming that the method is implemented cor- rectly). In our formalization of patterns, the specification will specify a set of requirements that the system designer 2 An Approach to Specifying Patterns wishing to use this pattern must meet; in return, the designer is assured that the invariant associated with the pattern will Consider the Observer pattern [5] in Fig. 1. This pat- be satisfied (as long as the ‘pattern instance’ –a notion to tern is intended to be used when one or more (“observer”) be defined shortly– continues to exist). In a sense, pat- objects are interested in the state of a (“subject”) ob- terns are a natural extension of classes; while classes fo- ject. When an object wishes to become an observer of a cus on how individual objects should behave, patterns are subject,itinvokestheAttach() method of that object; and concerned with interactions among a group of objects and when it is no longer interested in that subject, it invokes its relations between their respective states.
Recommended publications
  • Dissertation a Meta-Modeling Approach to Specifying
    DISSERTATION A META-MODELING APPROACH TO SPECIFYING PATTERNS Submitted by Dae-Kyoo Kim Department of Computer Science In partial fulfillment of the requirements for the Degree of Doctor of Philosophy Colorado State University Fort Collins, Colorado Summer 2004 COLORADO STATE UNIVERSITY June 21, 2004 WE HEREBY RECOMMEND THAT THE DISSERTATION PREPARED UNDER OUR SUPERVISION BY DAE-KYOO KIM ENTITLED A META- MODELING APPROACH TO SPECIFYING PATTERNS BE ACCEPTED AS FULFILLING IN PART REQUIREMENTS FOR THE DEGREE OF DOCTOR OF PHILOSOPHY. Committee on Graduate Work Committee Member: Dr. James M. Bieman Committee Member: Dr. Sudipto Ghosh Committee Member: Dr. Daniel E. Turk Adviser: Dr. Robert B. France Department Head: Dr. L. Darrell Whitley ii ABSTRACT OF DISSERTATION A META-MODELING APPROACH TO SPECIFYING PATTERNS A major goal in software development is to produce quality products in less time and with less cost. Systematic reuse of software artifacts that encapsulate high-quality development experience can help one achieve the goal. Design patterns are a common form of reusable design experience that can help developers reduce development time. Prevalent design patterns are, however, described informally (e.g., [35]). This prevents systematic use of patterns. The research documented in this dissertation is aimed at developing a practical pattern specification technique that supports the systematic use of patterns during design modeling. A pattern specification language called the Role-Based Metamod- eling Language (RBML) was developed as part of this research. The RBML specifies a pattern as a specialization of the UML metamodel. The RBML uses the Unified Modeling Language (UML) as a syntactic base to enable the use of UML modeling tools for creating and evolving pattern specifications.
    [Show full text]
  • Diploma Thesis in Informatics
    Munich University of Technology Department of Informatics Diploma Thesis in Informatics Development of a programming-language-like temporal logic specification language Jonathan Streit Date: April 12th, 2006 Supervisor: Instructors: Prof. Dr. Dr. h.c. Manfred Broy Andreas Bauer Dr. Martin Leucker Acknowledgements I would like to express my gratitude to my project instructors, Andreas Bauer and Martin Leucker, for fruitful discussions, fast and detailed answers to my questions, their honesty and time. Furthermore I would like to thank Elmar J¨urgens and Friedemann Gerster- Streit for reading and commenting on this thesis, as well as Gerhard Dirlich for both comments on this thesis and advice on statistics. Abstract This thesis presents the high-level temporal specification language Salt (Struc- tured Assertion Language for Temporal Logic), designed for the comfortable creation of concise specifications to be used in model checking and runtime ver- ification. Unlike other specification languages, Salt does not target a specific domain. Besides the common temporal operators, Salt provides exception operators, counting quantifiers and support for simplified regular expressions, as well as scope operators, allowing to express that a property has to hold before, after or in between some events. Frequently occurring patterns can be defined as parameterisable macros and can be used in a similar way as operators of the language. A timed extension allows to express real-time constraints. In contrast to many proprietary specification languages, Salt can be trans- lated into Ltl—or in the case of real-time properties into Tltl—and thus be used as a front end to existing verification tools. A compiler performing this task has been implemented and is presented in this thesis.
    [Show full text]
  • ESWP3 - Embedded Software Principles, Patterns and Procedures Release 1.0
    ESWP3 - Embedded Software Principles, Patterns and Procedures Release 1.0 ESWP3 contributors September 24, 2015 Contents 1 Human Relation Patterns 3 1.1 Categorization of human relation patterns................................3 2 Principles 5 2.1 Categorization of principles.......................................5 2.2 All principles in alphabetic order....................................5 3 Build Patterns 7 3.1 Categorization of build patterns.....................................7 3.2 All build patterns in alphabetic order..................................8 4 Release Antipatterns 11 5 Requirement Patterns 13 5.1 Standardized Textual Specification Pattern............................... 13 5.2 Perform Manual Review Pattern..................................... 13 6 Design Patterns 15 6.1 Categorization of “design” patterns................................... 15 6.2 Pattern Selection Procedure....................................... 21 6.3 Legend to the design pattern sections.................................. 21 6.4 All design patterns in alphabetic order.................................. 21 7 Idioms in C 29 7.1 Classification of idioms......................................... 29 7.2 Add the name space........................................... 29 7.3 Constants to the left........................................... 29 7.4 Magic numbers as variables....................................... 30 7.5 Namend parameters........................................... 30 7.6 Sizeof to variables............................................ 30 8 Unit Test Patterns
    [Show full text]
  • Specification and Verification of Encapsulation in Java Programs
    Specification and Verification of Encapsulation in Java Programs Andreas Roth Institut f¨urLogik, Komplexit¨at und Deduktionssysteme Universit¨atKarlsruhe, Germany E-mail: [email protected] Abstract. Encapsulation is a major concept in object-oriented designs as design pattern catalogues, approaches for alias control, and the need for modular correctness of components demonstrate. The way encapsu- lation can be formally specified in existing approaches has several short- comings. We show how encapsulation in sequential Java programs is specified by means of a new concept, called encapsulation predicates, in a clearly defined and comprehensible way, well fitting into the concept of design by contract. Encapsulation predicates extend existing functional specification languages. There are two kinds: basic predicates, which pro- vide the actual extension, and convenience predicates, which are abbre- viations for often used specification patterns. With encapsulation pred- icates, encapsulation properties in design patterns can be modelled and approaches to control aliasing can be simulated. Specifications contain- ing encapsulation predicates are deductively checkable, but can also be tackled by static analysis methods which are similar to alias control ap- proaches. 1 Introduction Encapsulation plays a major role in object-oriented software development for at least one important reason: Without it, the complexity of inter-object relations would become uncontrollable, and one of the most basic concepts of computer science, the division of tasks into subtasks, indispensable to master complex problems, would be impossible. It is thus quite striking that formal methods for software development have discovered only relative lately this problem for real-world object-oriented lan- guages, and have so far provided solutions that are only partially satisfactory (Sect.
    [Show full text]
  • Composite Design Patterns
    Composite Design Patterns Dirk Riehle Ubilab, Union Bank of Switzerland, Bahnhofstrasse 45, CH-8021 Zurich Phone: +41-1-234-2702, fax: +41-1-236-4671 E-mail: [email protected] or [email protected] WWW: http://www.ubs.com/ubilab + staff/riehle Abstract Software design patterns are the core abstractions from successful recurring problem solutions in software design. Composite design patterns are the core abstractions from successful recurring frameworks. A composite design pattern is a pattern that is best described as the composition of further patterns the integration of which shows a synergy that makes the composition more than just the sum of its parts. This paper presents examples of composite patterns, dis- cusses a role-based analysis and composition technique, and demonstrates that composite patterns extend the pattern idea from single problem solutions to object-oriented frameworks. 1 Introduction into a composite pattern, if and only if (a) a relevant synergy be- tween the pattern interactions arises, and (b) this synergy can be A developer versed in software design patterns might explain the observed as a recurring design theme. Model-View-Controller paradigm (MVC, [KP88, Ree96a]) for designing interactive software systems like this: “(a) MVC helps This paper discusses the notion of composite pattern. It introduces you design applications with graphical user interfaces. Its core are a notation based on roles to better describe and compose patterns. three collaborating objects: a Model object which represents an It presents an analysis and composition technique to better cope instance of a domain concept, a View object which realizes a with the complexity of composite patterns.
    [Show full text]
  • Php|Architect's Guide to PHP Design Patterns
    php|architect’s Guide to php|architect’s PHP Design Patterns Design patterns are comprehensive, well-tested solutions to common problems Guide to that developers everywhere encounter each day. Although designed for solving general programming issues, some of them have been successfully adapted to the specific needs of Web development. PHP Design Patterns php|architect’s Guide to PHP Design Patterns is the first comprehensive guide to the application of design patterns to the PHP development language. Designed to satisfy the need of enterprise-strength development, you will find this book both an excellent way to learn about design pattern and an A Practical Approach to Design Patterns irreplaceable reference for your day-to-day programming for the PHP 4 and PHP 5 Developer With coverage of more than XXX different types of patterns, including BLAH, BLAH, BLAH, BLAH and much more, this book is the ideal resource for your Jason E. Sweat enterprise development with PHP 4 and PHP 5. NanoBooks are excellent, in-depth resources created by the publishers of php|architect (http://www.phparch.com), the world’s premier magazine dedicated Guide PHP Design to Patterns php|architect’s to PHP professionals. NanoBooks focus on delivering high-quality content with in-depth analysis and expertise, centered around a single, well-defined topic and without any of the fluff of larger, more expensive books. USA $21.99 From the publishers of Canada $29.99 U.K. £16.99 Net Shelve under PHP/Web Development/Internet Programming Jason E. Sweat Jason E. 7.50 x 9.25 .309 7.50 x 9.25 PHP|ARCHITECT’S GUIDE TO PHP DESIGN PATTERNS by Jason E.
    [Show full text]
  • Designpatternsphp Documentation 1.0
    DesignPatternsPHP Documentation 1.0 Dominik Liebler and contributors 2015 04 12 Contents 1 Patterns 3 1.1 Creational................................................3 1.1.1 Abstract Factory........................................3 1.1.2 Builder............................................. 10 1.1.3 Factory Method......................................... 17 1.1.4 Multiton............................................. 22 1.1.5 Pool............................................... 24 1.1.6 Prototype............................................ 28 1.1.7 Simple Factory......................................... 31 1.1.8 Singleton............................................ 35 1.1.9 Static Factory.......................................... 37 1.2 Structural................................................. 40 1.2.1 Adapter / Wrapper....................................... 40 1.2.2 Bridge.............................................. 45 1.2.3 Composite............................................ 49 1.2.4 Data Mapper.......................................... 53 1.2.5 Decorator............................................ 60 1.2.6 Dependency Injection...................................... 65 1.2.7 Facade.............................................. 69 1.2.8 Fluent Interface......................................... 73 1.2.9 Proxy.............................................. 76 1.2.10 Registry............................................. 79 1.3 Behavioral................................................ 81 1.3.1 Chain Of Responsibilities...................................
    [Show full text]
  • A UML Profile for Domain Specific Patterns: Application to Real-Time 33
    A UML-Profile for domain specific patterns: Application to real-time Saoussen Rekhis1, Nadia Bouassida2, Rafik Bouaziz1, Bruno Sadeg3 1,2 MIRACL-ISIMS, Sfax University, BP 1088, 3018, Sfax, Tunisia. 3LITIS, UFR des Sciences et Techniques, BP 540, 76 058, Le Havre Cedex, France. 1{saoussen.rekhis, raf.bouaziz}@fsegs.rnu.tn [email protected] [email protected] Abstract. The design of Real-Time (RT) applications is a difficult task since it must take into account the specification of time-constrained data and time- constrained transactions. The design of these applications can be facilitated through the reuse of RT design patterns that improve software quality and capture RT domain knowledge and design expertise. However, the difficulty of RT design patterns comprehension reinforces the need for a suitable design language. This language has to express concepts modeling RT features and distinguishing the commonalities and differences between RT applications. This paper presents new UML notations that take into account the design of both RT specific concepts and the variability of domain specific patterns. The UML extensions are, then, illustrated in the RT context using an example of a controller pattern. Keywords: UML notation, domain specific patterns, instantiation, real- time applications. 1 Introduction A design pattern [1] is a description of a solution to a common problem in software design. It captures the design expertise necessary for developing applications and allows the reuse at both the design and code levels. Design patterns can be general and cover different domains of application (e.g. patterns of GoF [1]) and they can, also, be intended for a particular domain, in this case they are called domain-specific patterns [24].
    [Show full text]
  • Security Patterns
    Security Patterns Ronald Wassermann and Betty H.C. Cheng¤ Software Engineering and Network Systems Laboratory Department of Computer Science and Engineering Michigan State University East Lansing, Michigan 48824, USA Email: fwasser17,[email protected] Abstract Design patterns propose generic solutions to recurring design problems. Commonly, they present a solution in a well-structured form that facilitates its reuse in a di®erent context. Re- cently, there has been growing interest in identifying pattern-based designs for the domain of system security termed Security Patterns. Currently, those patterns lack comprehensive struc- ture that conveys essential information inherent to security engineering. This paper describes research into investigating an appropriate template for Security Patterns that is tailored to meet the needs of secure system development. In order to maximize comprehensibility, we make use of well-known notations such as the Uni¯ed Modeling Language (UML) to represent structural and behavioral aspects of design. Furthermore, we investigate how veri¯cation can be enabled by adding formal constraints to the patterns. ¤Please contact B. Cheng for all correspondences. i Contents 1 Introduction 1 2 Background 2 2.1 Viega's and McGraw's ten principles . 2 2.1.1 Principle 1: Secure the weakest link. 3 2.1.2 Principle 2: Practice defense in depth. 3 2.1.3 Principle 3: Fail securely. 3 2.1.4 Principle 4: Follow the principle of least privilege. 4 2.1.5 Principle 5: Compartmentalize. 4 2.1.6 Principle 6: Keep it simple. 4 2.1.7 Principle 7: Promote privacy. 5 2.1.8 Principle 8: Remember that hiding secrets is hard.
    [Show full text]
  • Patterns of Object Creation
    Patterns of Object Creation Dirk Riehle, [email protected], www.riehle.org Brian Foote, [email protected] James Noble, [email protected] Abstract This paper puts a set of well-known and some new patterns together to form a pattern language of object crea- tion. The object creation patterns presented are Creation Method , Factory Method , Conversion Method , Clon- ing Method , Trading Method , Object Factory , Abstract Factory , Builder and Prototype . Language context is provided by the Initialization Method , Finalization Method , Cascaded Delete , Default Implementation , Class Object , Exemplary Instance , and Specification patterns. The purpose of this presentation is to separate out the different patterns rather than to provide an introduction to Object Creation to the novice reader. The pattern language is aimed at intermediate and expert developers. 1 Overview This pattern language presents nine object creation patterns and a number of related patterns. The nine object creation patterns form the core of the language. This core has two parts: method patterns and object patterns. The method patterns talk about how to design and implement a method that creates an object, and the object patterns talk about how to have a dedicated factory object that creates other objects. Figure 1 shows these pat- terns and their relationships. Figure 1: Outline of pattern language, showing pattern relationships Copyright 2005 by Dirk Riehle. All rights reserved. Needs to be updated, I don’t have visio. Logical Expression -> full spec. 1.1 Audience The language is aimed at moderately experienced software developers; it is helpful if you already know and are familiar with the common creational patterns, such as Factory Method and Abstract Factory [Gamma+95].
    [Show full text]
  • Design Patterns Creational Patterns Structural Patterns Behavioural Patterns Concurrency Patterns Questions
    Outline Design Patterns Creational Patterns Structural Patterns Behavioural Patterns Concurrency Patterns Questions Design Patterns SE3A04 – Tutorial Jason Jaskolka Department of Computing and Software Faculty of Engineering McMaster University Hamilton, Ontario, Canada [email protected] November 14, 2011 Jason Jaskolka Design Patterns 1 / 35 Outline Design Patterns Creational Patterns Structural Patterns Behavioural Patterns Concurrency Patterns Questions Outline 1 Design Patterns 2 Creational Patterns Builder Pattern Singleton Pattern 3 Structural Patterns Adaptor Pattern Decorator Pattern 4 Behavioural Patterns Observer Pattern Strategy Pattern 5 Concurrency Patterns 6 Questions Jason Jaskolka Design Patterns 2 / 35 Outline Design Patterns Creational Patterns Structural Patterns Behavioural Patterns Concurrency Patterns Questions Design Patterns Suppose that you wish to build a wooden fence in your back yard What kind of fence are you going to build? The answer may depend on the purpose of the fence Perhaps you want privacy Perhaps you want the fence to give the house a particular look and feel The list can go on and on . For fences, there are typical design patterns which can be used to meet different requirements or to fit a particular purpose Jason Jaskolka Design Patterns 3 / 35 Outline Design Patterns Creational Patterns Structural Patterns Behavioural Patterns Concurrency Patterns Questions Design Patterns Jason Jaskolka Design Patterns 4 / 35 Outline Design Patterns Creational Patterns Structural Patterns Behavioural Patterns
    [Show full text]
  • Arxiv:2101.04938V1 [Cs.SE] 13 Jan 2021 Scratch, One Can Simply Put Together Prefabricated Pieces of Code
    Designing Machine Learning Toolboxes: Concepts, Principles and Patterns A Preprint Franz J. Király ∗ Markus Löning Anthony Blaom Ahmed Guecioueur Raphael Sonabend UCL UCL University of Auckland INSEAD UCL January 14, 2021 Abstract Machine learning (ML) and AI toolboxes such as scikit-learn or Weka are workhorses of contemporary data scientific practice – their central role being enabled by usable yet powerful designs that allow to easily specify, train and validate complex modeling pipelines. However, despite their universal success, the key design principles in their construction have never been fully analyzed. In this paper, we attempt to provide an overview of key patterns in the design of AI modeling toolboxes, taking inspiration, in equal parts, from the field of software engineering, implementation patterns found in contemporary toolboxes, and our own experience from developing ML toolboxes. In particular, we develop a conceptual model for the AI/ML domain, with a new type system, called scientific types, at its core. Scientific types capture the scientific meaning of common elements in ML workflows based on the set of operations that we usually perform with them (i.e. their interface) and their statistical properties. From our conceptual analysis, we derive a set of design principles and patterns. We illustrate that our analysis can not only explain the design of existing toolboxes, but also guide the development of new ones. We intend our contribution to be a state-of-art reference for future toolbox engineers, a summary of best practices, a collection of ML design patterns which may become useful for future research, and, potentially, the first steps towards a higher-level programming paradigm for constructing AI.
    [Show full text]