David H Lorenz

• David H. Lorenz
• The Open University of Israel

Management of information is an important aspect of every application. This includes, for example, protecting user data against breaches (like the one reported in the news about 50 million Facebook profiles being harvested for Cambridge Analytica), complying with data protection laws and regulations (like EU's new General Data Protection Regulation...

Application embedding is a technique for developing web applications. It divides the implementation of an application to two artifacts: (1) a host application -- a platform that is agnostic of any particular application, and (2) the application's definition -- a declarative specification one particular application. In this demo we demonstrate appli...

Language-oriented modularity (LOM) is a methodology that complements language-oriented programming (LOP) in providing on-demand language abstraction solutions during software development. It involves the implementation and immediate utilization of domain-specific languages (DSLs) that are also aspect-oriented (DSALs). However, while DSL development...

Language-oriented modularity (LOM) is a methodology that complements language-oriented programming (LOP) in providing on-demand language abstraction solutions during software development. It involves the implementation and immediate utilization of domain-specific languages (DSLs) that are also aspect-oriented (DSALs). However, while DSL development...

Since the early days of the Web, web application developers have aspired to develop much of their applications declaratively. However, one aspect of the application, namely its business-logic is constantly left imperative. In this work we present Application Embedding, a novel approach to application development which allows all aspects of an appli...

Since the early days of the Web, web application developers have aspired to develop much of their applications declaratively. However, one aspect of the application, namely its business-logic is constantly left imperative. In this work we present Application Embedding, a novel approach to application development which allows all aspects of an appli...

We introduce a correspondence between the design space of web applications and that of domain-specific languages (DSLs). We note that while most web applications today are implemented in ways that correspond to external DSLs, very little attention is given to implementation techniques corresponding to internal DSLs. We contribute a technique based...

Consider the task of auditing an application whose main functionality is to execute commands received from clients. One could audit command executions with AspectJ. Alternatively, one could design, implement, and use a domain-specific aspect language for auditing, and then throw the language away. In this paper we argue that such disposable aspect...

Language oriented modularity (LOM) implies the use of multiple domain specific aspect languages (DSALs) simultaneously. The complexity of implementing these DSALs has significant implications on the practicality of LOM. In this paper we describe a transformation-based approach to DSAL implementation that reduces the overall cost of implementing the...

Despite the availability of general purpose aspect languages (GPALs) and the availability of frameworks for creating domain specific aspect languages (DSALs), tangled and scattered code still prevails in modern software projects. Through the prism of a case study of the oVirt open source project we examine the conjecture that it may simply be too c...

We challenge the widely accepted practice that web applications must be trusted with user data. We present an alternative model based on logic programming, where users and applications are equal peers in a shared cloud environment. User data is represented as a set of facts. The application is represented as a set of rules defining how user data is...

Many extensions to AspectJ are proposed and prototyped. However, without a supportive language workbench the proper evaluation and production of these extensions is often prohibitively costly. We demonstrate a novel language workbench for creating such extensions, comprising AWESOME and Spoofax. The implementation of two advanced extensions to Aspe...

Domain specific aspect languages (DSALs) are programming languages that are both domain specific and aspect-oriented. However, DSALs seem to be second-class. On the one hand, language workbenches handle only DSLs that are not aspect-oriented, making it difficult to develop new DSALs. On the other hand, development tools for general purpose aspect-o...

Programming in a domain specific aspect language (DSAL) typically involves some language workbench for transforming the DSAL code and some AOP composition framework for weaving the transformed code. However, DSAL development remains second-class in two respects. Unlike programming in a general purpose aspect language, compiling DSAL code requires p...

NoSQL databases are rapidly becoming the storage of choice for large-scale Web applications. However, for the sake of scalability these applications trade consistency for availability. In this paper, we regain control over this tradeoff by adapting an existing approach, version control (VC), to application state. By using VC, the data model is defi...

Traditionally, Source Code Management (SCM) tools rely on the source code being text. In Projectional Editing (PE), however, the source code is an opaque model, rendering traditional SCM support ineffective. In this work we present an effective approach to enabling SCM for PE.

Large and medium scale software projects often require a source code revision control (RC) system. Unfortunately, RC systems do not perform well with obliviousness and quantification found in aspect-oriented code. When classes are oblivious to aspects, so is the RC system, and the crosscutting effect of aspects is not tracked. In this work, we stud...

In this talk we coin the term language-oriented modularity to refer to the process of constructing and composing DSALs to better support aspect-oriented modularity. Language-oriented modularity strives to keep our aspect language as abstract as possible and our software code as modular as possible. While general purpose aspect-oriented languages of...

DSAL composition frameworks are tools used in the process of composing multiple DSAL mechanisms into a single multi-DSAL weaver. The DSAL composition process starts with specifying the desired interactions between the DSAL mechanisms being composed, and concludes with producing a multi-DSAL weaver which satisfies the composition specification. Howe...

Research in the area of multi-DSAL development has been mainly devoted to enabling the interoperability of multiple aspect mechanisms. Less attention has been given to making programming with multiple aspect languages practical. For domain specific aspect languages (DSALs) to be used in prac-tice, there is a need for tools that make multi-DSAL deve...

We present a meta-metamodel for implementing AOM systems in two languages collaboratively: Ink for structure and Java for behavior. Using two languages rather than one facilitates a style of programming that imposes a strict separation of structure and behavior.

Cedalion is an LOP language designed for hosting internal DSLs while providing projectional editing. We present a case study where Cedalion was used to help colleagues in the field of Biology design a DNA microarray for a protein-binding assay.

Cedalion is a research LOP language designed for hosting internal DSLs but with the look-and-feel of external DSLs. Cedalion demonstrates a novel approach that combines extensible logic programming with projectional editing. We shall demonstrate the ease of realizing a small, yet non-trivial, highly expressive DSL in Cedalion.

Language Oriented Programming (LOP) is a paradigm that puts domain specific programming languages (DSLs) at the center of the software development process. Currently, there are three main approaches to LOP: (1) the use of internal DSLs, implemented as libraries in a given host language; (2) the use of external DSLs, implemented as interpreters or c...

Language Oriented Programming (LOP) is a paradigm that puts domain specific programming languages (DSLs) at the center of the software development process. Currently, there are three main approaches to LOP: (1) the use of internal DSLs, implemented as libraries in a given host language; (2) the use of external DSLs, implemented as interpreters or c...

When building dynamic systems, it is often the case that new behavior is needed which is not supported by the core architecture. One way to vary the behavior quickly is to provide well-defined variation points (hook-points) at different places in the systems and have a means to dynamically lookup and invoke new behavior at runtime when desired. Per...

An aspect encapsulates not only crosscutting behavior, but also crosscutting state. When aspects are stateful, there is a need to specify and control their instantiation. Unfortunately, aspect instantiation is a hard-wired feature in AspectJ. This feature cannot be customized by the application programmer. Specifically, there are six pre-defined in...

There is a gap between our ability to reuse high-level concepts in software design and our ability to reuse the code implementing them. Language Oriented Programming (LOP) is a software development paradigm that aims to close this gap, through extensive use of Domain Specific Languages (DSLs). With LOP, the high-level reusable concepts become reusa...

There is a gap between our ability to reuse high-level concepts in software design and our ability to reuse the code implementing them. Language Oriented Programming (LOP) is a software development paradigm that aims to close this gap, through extensive use of Domain Specific Languages (DSLs). With LOP, the high-level reusable concepts become reusa...

Debugging an application written in multiple domain-specific aspect languages (DSALs), one for each domain, is a com-plex task. Each DSAL introduces its own source level ab-stractions, which should be visible and traceable during the debugging process. A debugging infrastructure for multi-ple DSAL applications should also enhance the viewing and tr...

In the Adaptive Object-Model (AOM) architectural style, user-defined domain entities and their relationships, attributes and behavior are described by externally stored metadata. AOM implementations reify the domain entities at runtime by interpreting the metadata. Users change the object model by editing the metadata to reflect changes in the doma...

Domain-specific language (DSL) utilization comes in three sorts: internal, external, and language workbench. An internal DSL is confined to the hosting language. An external DSL is freed from confinement in the hosting language, but surrenders all native tool support in return. A language workbench incorporates external DSLs into the development en...

ModelTalk's language workbench is an IDE for DSL based development with Java. ModelTalk provides programmers and language designers with a DSL programming experience that has a Java-like look-and-feel and a short edit-execute cycle. The workbench exhibits a seamless integration of the DSLs with Java and with each other.

Large-scale, complex, back-end business applications such as telecommunications software constitute a highly competitive and demanding market. These applications feature deep integration with other business and operational support systems. They must be tailored for each customer, and the customized systems must meet strict extrafunctional requireme...

Developing and maintaining complex, large-scale, product line of highly customized software systems is difficult and costly. Part of the difficulty is due to the need to communicate business knowledge between domain experts and application programmers. Domain specific model driven development (MDD) addresses this difficulty by providing domain expe...

Programming languages and paradigms provide mechanisms by which we can express our own solutions to problems. The way by which one formulates a solution is affected by the medium with which the solution is expressed. Currently, the lack of polymor-phism and the difficulty with which aspect instances can be ac-cessed and used within AspectJ, force p...

Domain specific aspect-oriented language extensions offer unique capabilities to deal with a variety of cross cutting concerns. Ideally, one should be able to use several of these extensions together in a single program. Unfortunately, each extension generally implements its own specialized weaver and the different weavers are incompatible. Even if...

Domain specic aspect-oriented language extensions of- fer unique capabilities to deal with a variety of crosscut- ting concerns. Ideally, one should be able to use several of these extensions together in a single program. Unfortu- nately, each extension generally implements its own spe- cialized weaver and the different weavers are incompatible. Ev...

The simultaneous use of multiple aspect languages has the potential of becoming a significant one, as new aspect-oriented frameworks are developed and existing ones expand to incorporate features of others. A key challenge in combining multiple aspect-oriented languages is identifying and resolving adverse feature interactions. These interactions o...

A plethora of diverse aspect mechanisms exist today, all of which integrate concerns into artifacts that exhibit crosscutting structure. What we lack and need is a characterization of the design space that these aspect mechanisms inhabit and a model description of their weaving processes. A good design space representation provides a common framewo...

Most methods for designing component-based systems and verifying their compatibility address only the syntactic compatibility of components; no analysis of run-time behavior is made. Those methods that do address run-time behavior suffer from state-explosion: the expo- nential increase of the number of global states, and hence the complexity of the...

The manifestation of miscellaneous aspect-oriented extensions raises the question of how these extensions can be used together to combine their aspectual capabilities or reuse aspect code across extensions. While white-box composition of aspect mechanisms can produce an optimal compound mechanism, as exemplified by the merger of AspectJ and AspectW...

A plethora of aspect mechanisms exist today. All of these diverse mechanisms integrate concerns into artifacts that exhibit crosscutting structure. What we lack and need is a characterization of the design space that these aspect mechanisms inhabit and a model description of their weaving processes. A good design space representation provides a com...

An object-oriented framework enables both black box reuse and white box reuse in client applications, serving as an important infrastructural building block. We are refactoring framework-based applications to modularize cross-cutting concerns with aspects. In this paper, we explore implementation issues we encountered while creating non-functional...

Studies of Aspect-Oriented Programming (AOP) usually focus on a language in which a specific aspect extension is integrated with a base language. Languages specified in this manner have a fixed, non-extensible AOP functionality. This paper argues the need for AOP to support the integration and use of multiple domain-specific aspect extensions toget...

Studies of Aspect-Oriented Programming (AOP) usually focus on a language in which a specific aspect extension is integrated with a base language. Languages specified in this manner have a fixed, non-extensible AOP functionality. In this paper we consider the more general case of integrating a base language with a set of domain specific third-party...

Design by Contract (DbC) and runtime enforcement of program assertions enables the construction of more robust software. It also enables the assignment of blame in error reporting. Unfortunately, there is no support for runtime contract enforcement and blame assignment for Aspect-Oriented Programming (AOP). Extending DbC to also cover aspects bring...

Design by Contract (DBC) and runtime enforcement of program assertions enables the construction of more robust software. It also enables the assignment of blame in error reporting. As of yet, no AOP implementation for the provision of DBC exists. We present an aspect-oriented DBC tool for Java named Cona. We also extend the use of DBC and assertion...

AOP is often perceived as a second class reflective mechanism, whereas reflection in OOP is considered first class. However, perceiving AOP as a first class language mechanism is conductive to developing a general AOP model, which can be a basis for an overall theory of AOP. We illustrate this view by comparing AOP with reflection and illustrating...

Aspect-oriented programming (AOP) enables the programmer to mod- ularize concerns that cut across other concerns. Adaptive programming (AP) enables the programmer to practice concern-shy programming. A program is concern-shy if it hides the details of a certain concerns it cuts across, and as a result exhibits adaptive behavior. AP can be viewed as...

Software understanding for documentation, maintenance or evolution is one of the longest-standing problems in Computer Science. The use of "high-level" programming paradigms and object-oriented languages helps, but fundamentally remains far from solving the problem. Most programming languages and systems have fallen prey to the assumption that they...

Software understanding for documentation, maintenance or evolution is one of the longest-standing problems in Computer Science. The use of "high-level" programming paradigms and object-oriented languages helps, but fundamentally remains far from solving the problem. Most programming languages and systems have fallen prey to the assumption that they...

Web application development cuts across the HTTP protocol, the client-side presentation language (HTML, XML), the server-side technology (Servlets, JSP, ASP, PHP), and the underlying resource (files, database, information system). Consequently, web development concerns including functionality, presentation, control, and structure cross-cut, leading...

This paper investigates a fourth approach: novel programming constructs. Specifically, we investigate the intersection of modular programming (MP) [1] and aspect-oriented programming (AOP) [2]. We show, in the context of an illustrative example, how aspectual mechanisms work in AspectJ [3] and Hyper/J [4] and we show how combining modules with aspe...

Complex behavior often resists clean modularization in object-oriented languages. Aspect-oriented programming tackles this problem by providing flexible module boundaries that can span and partition classes. However, in order to achieve this flexibility, valuable modularity mechanisms, such as encapsulation and external composition, are lost. The a...

Aspect-oriented programming (AOP) controls tangling of concerns by isolating aspects that cross-cut each other into building blocks. Component-based programming (CBP) supports software development by isolating reusable building blocks that can be assembled and connected in many different ways. We show how AOP and CBP can be integrated by introducin...

Reflection remains a second-class citizen in current programming models, where it's assumed to be imperative and tightly bound to its implementation. In contrast, most object-oriented APIs allow interfaces to vary independently of their implementations. Components take this separation a step further by describing unforeseeable attributes-the key to...

We define a generic join point model for checking the Law of Demeter (LoD). Join points are trees, pointcuts are predicates over join points, and advice is checked statically similar to how declare warning is checked in AspectJ. We illustrate how the joint point form is mapped to the object and class forms of LoD, and provide an implementation in A...

There are two important points of view on inclusion or subtype polymorphism in object-oriented programs, namely polymorphic access and dynamic dispatch. These features are essential for object-oriented programming, and it is worthwhile to consider whether they are supported in aspect-oriented programming (AOP). In AOP, pieces of crosscutting behavi...

Normally, Aspect-Oriented Programming (AOP) is used for plug-ging and not for unplugging. Aspects (concerns) are weaved into a system, thus providing a modularized way to add crosscutting fea-tures to a base program. For example, given a base program without logging and given a logging aspect, the AOP weaver produces from the untangled code an exec...

Overly regular module interfaces in object-oriented languages hamper modularization of complex applications. Aspect- oriented programming tackles this problem by allowing mod- ule boundaries to span and partition classes in a ∞exible manner. However, not without a cost. In order to achieve this ∞exibility, common modularity mechanisms, such as en-...

A good object oriented design does not necessarily make a good component based design, and vice versa. What design principles do components introduce? The paper examines component based programming and how it expands the design space in the context of an event based component architecture. We present a conceptual model for addressing new design iss...

Execution patterns are a new metaphor for visualizing execution traces of object-oriented programs. We present an execution pattern view that lets a programmer visualize and explore a program's execution at varied levels of abstraction. The view employs visual, navigational, and analytical techniques that accommodate lengthy, real-world traces. By...

A good object-oriented design does not necessarily make a good component-based design, and vice versa. What design principles do components introduce? This paper examines component-based programming and how it expands the design space in the context of an event-based component architecture. We present a conceptual model for addressing new design is...

Changing an existing software architecture is difficult and painful. The typical result is either a poor adaptation to the target architecture or a substantial debasement of the original. Software generators can simplify the transformation process and relieve the pain for certain architectures. We present a component generator that transforms an ob...

In this paper we lay out the design time and space of component assembly in a visual builder, and propose concrete ways of also handling context components seamlessly. We present an environment that allows Java developers to test and evaluate JavaBeans components implementing the extensible runtime containment and services protocol. We enhanced the...

It's only natural to assume that aspect-oriented patterns would one day play the role design patterns play today in the object-oriented technology. This paper strives to declare aspect-oriented the already known object-oriented VISITOR design pattern. The VISITOR describes an aspect-oriented solution to a tangling problem in a particular context. W...

In this paper we lay out the design time and space of component assembly in a visual builder, and propose concrete ways of also handling context components seamlessly. We present an environment that allows Java developers to test and evaluate JavaBeans components implementing the extensible runtime containment and services protocol. We enhanced the...

Not Available

New approaches propose to deal with the tangling of logical units by extending the object-oriented language to support module (de)composition along more than one dimension of concern. The tutorial will briefly survey Aspect-Oriented Programming (@@@@ectJ tool), Adaptive Programming (the Demeter tool), and Hyper-dimensional Separation of Concerns (t...

We present an assembly-design environment that supports the JavaBeans extensible runtime containment and services protocol. The environment provides: a vehicle for demonstrating the Java component model; a third-party client for testing BeanContext and BeanContextChild components; and a prototype illustrating how a visual builder might unify visual...

Aspect-oriented programming (AOP) controls tangling of concerns by isolating aspects that cross-cut each other into building blocks. Component-based programming (CBP) supports software development by isolating reusable building blocks that can be assembled and connected in many d i e r e n t w ays. We show h o w A OP and CBP can be integrated by i...

Programming object interactions is at the heart of object oriented programming. To improve reusability of the interactions, it is important to program object interactions generically. We present two tools that facilitate programming of object interactions. StructureBuilder, a commercial tool, achieves genericity with respect to data structure imple...

This report investigates the relationships between design patterns and programming languages. A comparison is carried out between the usual track of programming languages development and the discovery of patterns. We argue in this that there are fundamental differences between the two. We offer a taxonomy of patterns based on how far they are from...

Despite many similarities, there are important differences between design patterns and programming language mechanisms. Nevertheless, we can classify patterns in terms of how far they are from becoming actual language features. Treating patterns as mechanisms that are candidates for being language features, rather than treating them as what they ar...

This paper explains how patterns can be used to describe the implementation of other patterns. It is demonstrated how certain design patterns can describe their own design. This is a fundamental reflexive relationship in pattern relationships. The process of assembling patterns by other patterns is named pattern tiling. Tiling enables us to interwe...

The class of an object is not necessarily the only determiner of its runtime behaviour. Often it is necessary to have an object behave differently depending upon the other objects to which it is connected. However, as it currently stands, object-oriented programming provides no support for this concept, and little recognition of its role in common,...

The class of an object is not necessarily the only determiner of its runtime behaviour. Often it is necessary to have an object behave differently depending upon the other objects to which it is connected. However, as it currently stands, object-oriented programming provides no support for this concept, and little recognition of its role in common,...

We present a tool for the use of software engineering tool builders. The tool parses programs and synthesizes them into a hierarchy of objectoriented classes and objects. This hierarchy lays the ground for further processing and experimentation with the parsed data. Three grammars are used for configuring the tool: a source parsing grammar , a targ...

. This work deals with the problem of function learning by genetic algorithms where the function is used as a preference predicate. In such a case, learning the exact function is not necessary since any function that preserves the order induced by the target function is sufficient. The paper presents a methodology for solving the problem with genet...

This work studies the application of genetic algorithms to the domain of game playing, emphasising on learning a static evaluation function. Learning involves experience generation, hypothesis generation and hypothesis evaluation. Most learning systems use preclassified examples to guide the search in the hypothesis space and to evaluate current hy...

Recently it has been shown that Design by Contract (DBC) in OOP have been erroneously enforced by existing DBC technologies. The crosscutting nature of DBC and its runtime enforcement, make it an ideal problem for AOSD to solve. In this paper we present an AOSD DBC tool, conaj that provides DBC support by means of aspects, accommodating also pre-an...

We present a methodology for designing component-based systems and verifying their temporal behavior properties. Our verification method is mostly automatic, and is not susceptible to the well-known state-explosion problem, which has hitherto severely limited the practical applicability of automatic ver-ification methods. Our method specifies the e...

With most of today's aspect-oriented language extensions, developers have both aspectual and core reflection mech-anisms available to them. From a software engineering point of view, these mechanisms serve different purposes in different application areas. This paper explores to what extent aspectual and core reflection overlap. Interactions of asp...

A novice's mistake in understanding what makes a language AOP is to equate AOP with a specific implementation of AOP, like As-pectJ [5, 3]. Another misunderstanding is to equate AOP with SOC in general, rather than realizing that AOP is just a specific tool, amongst many others, for SOC. Current AOP models seem to have erred in a similar way. Model...

Crucial to the programming and debugging of complex aspect-oriented programs is the ability to specify and mon-itor temporal ordering amongst join-points. We present a temporal logic specification of such constraints in AspectJ. This provides a formal semantics for join-point occurrences and is a step towards the formal verification of AOP pro-gram...

A good object-oriented design does not necessarily make a good component-based design, and vice versa. What design principles do components introduce? This paper examines component-based programming and how it expands the design space in the context of an event-based component architecture. We present a conceptual model for addressing new design is...

Aspect-oriented programming, component models, and design patterns are modern and actively evolving techniques to improving the modularization of complex software. In particular, these techniques hold great promise for the development of "systems infrastructure" software, e.g., application servers, middleware, virtual machines, compilers, operating...

An aspect encapsulates not only crosscutting behavior, but also crosscutting state. When aspects are stateful, there is a need to specify and control their instantiation. Unfortu-nately, aspect instantiation is a hard-wired feature in AS-PECTJ. This feature cannot be customized by the applica-tion programmer. Specifically, there are six pre-defined...