- ModelTalk is a model-driven software development framework that supports domain-specific languages (DSLs) pervasively at the core of the development process.
- In ModelTalk, systems are implemented primarily using declarative DSL code, with some localized Java code for behavior. The DSL code governs the Java code.
- ModelTalk uses three principles for DSL development at scale: textual DSLs, an integrated IDE for DSL and Java development, and an interpretive approach where DSL code does not need to be transformed to Java.
Windows Server 2012 on Dell - Great performance and value for the next genera...Principled Technologies
The server and storage solution you choose for your SharePoint workloads can greatly affect the collaborative experience in the workplace. Not only should the servers be powerful enough to deliver a solid experience for the large number of end-users that need to collaborate on documents, the hardware solution should minimize the cost per user to help keep data center costs low. In our tests, we found that we could virtualize SharePoint on two Dell PowerEdge M620 servers and a Dell EqualLogic PS6110XV array and support the same 3,000 users as on the HP ProLiant BL460c Gen8, but at a significantly lower cost. The Dell PowerEdge M620 solution cost only $28.40 per user; 26.0 percent less than the $38.35 per user that the HP ProLiant BL460c Gen8 solution would cost to purchase.
Choosing a server and storage solution that delivers the strong performance your data center requires while providing a lower cost per user can have a positive impact on your IT budget.
PowerSQL Aids Application Developer ProductivityMichael Findling
Embarcadero Technologies is known for its multi-platform tools that assist database
administrators and developers at every point in the database lifecycle. In March, the
company took a bold new step when it debuted PowerSQL, a professional SQL
development tool that dramatically improves productivity for application developers
charged with SQL development.
This material prepared by Calance professionals is intended for Java technologists and IT professionals with some exposure to J2EE. Readers will discover key design considerations, implementation techniques, practicability, and some guiding principles of building an Enterprise Application. To find out what IT solutions and services Calance offers, visit http://www.calanceus.com.
Windows Server 2012 on Dell - Great performance and value for the next genera...Principled Technologies
The server and storage solution you choose for your SharePoint workloads can greatly affect the collaborative experience in the workplace. Not only should the servers be powerful enough to deliver a solid experience for the large number of end-users that need to collaborate on documents, the hardware solution should minimize the cost per user to help keep data center costs low. In our tests, we found that we could virtualize SharePoint on two Dell PowerEdge M620 servers and a Dell EqualLogic PS6110XV array and support the same 3,000 users as on the HP ProLiant BL460c Gen8, but at a significantly lower cost. The Dell PowerEdge M620 solution cost only $28.40 per user; 26.0 percent less than the $38.35 per user that the HP ProLiant BL460c Gen8 solution would cost to purchase.
Choosing a server and storage solution that delivers the strong performance your data center requires while providing a lower cost per user can have a positive impact on your IT budget.
PowerSQL Aids Application Developer ProductivityMichael Findling
Embarcadero Technologies is known for its multi-platform tools that assist database
administrators and developers at every point in the database lifecycle. In March, the
company took a bold new step when it debuted PowerSQL, a professional SQL
development tool that dramatically improves productivity for application developers
charged with SQL development.
This material prepared by Calance professionals is intended for Java technologists and IT professionals with some exposure to J2EE. Readers will discover key design considerations, implementation techniques, practicability, and some guiding principles of building an Enterprise Application. To find out what IT solutions and services Calance offers, visit http://www.calanceus.com.
Developing multithreaded database application using java tools and oracle dat...csandit
In many business organizations, database applicatio
ns are designed and implemented using
various DBMS and Programming Languages. These appli
cations are used to maintain
databases for the organizations. The organization
departments can be located at different
locations and can be connected by intranet environm
ent. In such environment maintenance of
database records become an assignment of complexity
which needs to be resolved. In this paper
an intranet application is designed and implemented
using Object-Oriented Programming
Language Java and Object-Relational Database Manage
ment System Oracle in multithreaded
Operating System environment.
[2015/2016] Collaborative software development with GitIvano Malavolta
This presentation is about a lecture I gave within the "Software systems and services" immigration course at the Gran Sasso Science Institute, L'Aquila (Italy): http://cs.gssi.infn.it/.
http://www.ivanomalavolta.com
BigDataEverywhere conference in Israel
6/22/2014
http://info.mapr.com/index.php/email/emailWebview?mkt_tok=3RkMMJWWfF9wsRoguK7KZKXonjHpfsX67%2B8pWq%2BxlMI%2F0ER3fOvrPUfGjI4ETMZrI%2BSLDwEYGJlv6SgFS7THMaZu1bgFUhA%3D
See the animated version here:
http://prezi.com/qeyffvue7nr3/bigdata-everywhere-2014-annotated/
The slides for my talk at the Annual Meeting of the Academy of Management in Philadelphia, PA. The paper is entitled "Is 'Open' Always Better? An Exploration of Open Innovation Projects"
Developing multithreaded database application using java tools and oracle dat...csandit
In many business organizations, database applicatio
ns are designed and implemented using
various DBMS and Programming Languages. These appli
cations are used to maintain
databases for the organizations. The organization
departments can be located at different
locations and can be connected by intranet environm
ent. In such environment maintenance of
database records become an assignment of complexity
which needs to be resolved. In this paper
an intranet application is designed and implemented
using Object-Oriented Programming
Language Java and Object-Relational Database Manage
ment System Oracle in multithreaded
Operating System environment.
[2015/2016] Collaborative software development with GitIvano Malavolta
This presentation is about a lecture I gave within the "Software systems and services" immigration course at the Gran Sasso Science Institute, L'Aquila (Italy): http://cs.gssi.infn.it/.
http://www.ivanomalavolta.com
BigDataEverywhere conference in Israel
6/22/2014
http://info.mapr.com/index.php/email/emailWebview?mkt_tok=3RkMMJWWfF9wsRoguK7KZKXonjHpfsX67%2B8pWq%2BxlMI%2F0ER3fOvrPUfGjI4ETMZrI%2BSLDwEYGJlv6SgFS7THMaZu1bgFUhA%3D
See the animated version here:
http://prezi.com/qeyffvue7nr3/bigdata-everywhere-2014-annotated/
The slides for my talk at the Annual Meeting of the Academy of Management in Philadelphia, PA. The paper is entitled "Is 'Open' Always Better? An Exploration of Open Innovation Projects"
Adaptive Object Model - IASA IL Meeting on Software Evolution (3/2014)Atzmon Hen-Tov
Lecture on AOM (Adaptive-Object-Model) in the IASA Israel meeting held on April 2, 2014.
The animated version -
http://prezi.com/vjfqz2rth7ct/?utm_campaign=share&utm_medium=copy&rc=ex0share
When talking about modeling, I think there will be a bundle of terms that will come to our mind, UML, domain driven development, DSL, forward/reverse enginerring, MDD, MDA, BPMN. These technology or methodology have been there for years; And obviously, modeling has proven itself to provide value by improving communication, business-alignment, quality, and productivity. Its applicability includes a number of disciplines such as analysis, design, or development. But why aren’t we all doing Model Driven Development yet?
MODIGEN: MODEL-DRIVEN GENERATION OF GRAPHICAL EDITORS IN ECLIPSEijcsit
Domain-specific modeling is more and more understood as a comparable solution compared to classical software development. Textual domain-specific languages (DSLs) already have a massive impactin contrast
tographical DSLs, they still have to show their full potential. The established textual DSLs are normally generated from a domain specific grammar or maybe other specific textual descriptions. And advantage of textual DSLs is thatthey can be development cost-efficient. In this paper, we describe asimilar approach for the creation of graphical DSLs from textual descriptions. We present a set of speciallydeveloped textual
DSLs to fully describe graphical DSLs based on node and edge diagrams. These are, together with an EMF
meta-model, the input for a generator that produces an eclipse-based graphical Editor. The entire project
is available as open source under the name MoDiGen.
DEVELOPING MULTITHREADED DATABASE APPLICATION USING JAVA TOOLS AND ORACLE DAT...cscpconf
In many business organizations, database applications are designed and implemented using
various DBMS and Programming Languages. These applications are used to maintain
databases for the organizations. The organization departments can be located at different
locations and can be connected by intranet environment. In such environment maintenance of
database records become an assignment of complexity which needs to be resolved. In this paper
an intranet application is designed and implemented using Object-Oriented Programming
Language Java and Object-Relational Database Management System Oracle in multithreaded
Operating System environment
A presentation on best practices for J2EE scalability from requirements gathering through to implementation, including design and architecture along the way.
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
Accelerate your Kubernetes clusters with Varnish CachingThijs Feryn
A presentation about the usage and availability of Varnish on Kubernetes. This talk explores the capabilities of Varnish caching and shows how to use the Varnish Helm chart to deploy it to Kubernetes.
This presentation was delivered at K8SUG Singapore. See https://feryn.eu/presentations/accelerate-your-kubernetes-clusters-with-varnish-caching-k8sug-singapore-28-2024 for more details.
2. 40 I E E E S o f t wa r e w w w. c o m p u t e r. o rg /s o f t w a re
written in (meta) DSLs, specializing and containing
instances of other DSLs, all governed by the same
syntactical rules.
A system implementation in ModelTalk consists
of
declarative DSL code containing definitions of■■
stateful instances, classes, and metaclasses that
describe the system’s structure and configura-
tion; and
localized Java code containing methods that■■
define the system’s behavior separate from the
structure and configuration data.
DSL code is the dominant part of the system. For
example, Figure 1 depicts the distribution of DSL
and Java code in a subsystem of an actual com-
mercial business support system for the telecom-
munications market developed with ModelTalk.
The ModelTalk architectural layers—Core, Plat-
form, and Business—contain shared assets. At the
top layer (Customization), where final products are
assembled and customized, 83 percent of the code
is written in DSLs and just 17 percent in Java. The
relatively large amount of DSL code (approximately
200 Kbytes of LOC) reflects large variation among
final products. To achieve similar variability using
only Java would have required many more LOC
without providing the same compact, precise se-
mantics that DSLs offer.
The ModelTalk approach is based on three de-
sign principles that, when combined effectively,
enable programming with DSLs to scale up well:
textual DSLs, an integrated DSL-Java development
environment, and an interpretive approach.
Textual DSLs
In ModelTalk, DSLs are textual rather than graphi-
cal. The concrete syntax for DSL code is XML. The
ModelTalk core provides a general-purpose lan-
guage with abstractions (Class, Property, and so on)
and syntax rules for defining DSLs. A developer
creates a new DSL by adding new and constraining
existing class properties to better describe the do-
main-specific concepts and terminology. In XML,
these are expressed via tag names, which constitute
the domain-specific terminology.
Integrated DSL-Java
Development Environment
ModelTalk comes with a unified IDE for DSL and
Java, implemented over Eclipse (see Figure 2). The
DSL development process in ModelTalk is analo-
gous to the Java development process. By provid-
ing IDE support for DSL scripting with the same
look and feel as for Java programming, Model-
Talk achieves instant productivity in the IDE and
easier assimilation and adoption of DSL-based
development.5
The ModelTalk IDE reflects changes in DSL def-
initions immediately, providing DSL programmers
with full support for autocompletion (during edit-
ing), navigation, and consistency checking. When
developers save their work, the Eclipse IDE auto-
matically invokes the ModelTalk DSL analyzer (a
DSL processor in Figure 2), performing incremental
cross-system validation similar to background com-
pilation in Java.
After the developers have modeled and cap-
tured the domain in a DSL, they implement the
behavior in Java. During this stage, the DSL ana-
lyzer monitors incompatibilities between the Java
and DSL elements and reports violations in the
IDE’s standard Problems view. Additional views
let developers browse and navigate the DSLs
0 50 100 150 200 250
Particular assets (15 final products)
Size (KLOC)
Core
Platform
Business
Customization
Layers
83.34%
59.82%
34.37%
Shared assets
9% Java lines of code
DSL lines of code
DSL: Domain-specific language
DSL and Java integrated
development environment
Runtime
platform
Java
sources
Executable
DSL code
Java
bytecode
DSL execution
engine
Java Virtual
Machine
DSL: Domain-specific language
Feedback
Feedback
Constrains Conforms
Java
processors
DSL sources DSL
processors
Figure 1. The ratio of Java (purple) to DSL (gold) code by architectural
layer in a product line of business support systems. Most of the
assembly and the customization of products is done with DSLs.
Figure 2. An integrated
environment for DSL
and Java development.
DSL development
mirrors Java
development, and DSL
code governs Java code.
3. July/August 2009 I E E E S o f t wa r e 41
(between one DSL element and another, as well
as between DSL elements and their Java counter-
parts). A refactoring tool for DSLs is also avail-
able, and changes are propagated to Java when
necessary.
Interpretive Approach
DSLs in ModelTalk are interpreted; they don’t
need to be transformed into Java (by a code gener-
ator). At runtime, instances of DSL classes are in-
stantiated and used as meta-objects for their corre-
sponding Java instances through a technique called
(model-driven) dependency injection.6 The DSL
execution engine is ModelTalk’s runtime compo-
nent, implemented as an inversion-of-control
container and a dependency injection framework
(in the Spring framework style). It can run either
inside a standard J2EE application server (for ex-
ample, JBoss) or inside a lightweight container.
The execution engine’s primary responsibility is
to maintain the relationships between the DSL and
Java elements. This includes object graph instanti-
ation and a reflection API.7 When a client requests
a DSL instance, the DSL engine finds the corre-
sponding Java class, instantiates it, and injects the
property values into its instance variables. This is
applied recursively for injected values of a complex
type. The DSL-to-Java mapping allows for DSL
classes without a Java counterpart. In such cases,
the DSL engine maps the class to its superclass’s
Java counterpart. Consequently, developers and
even users can change DSL definitions at runtime
without needing to also change the Java code.8
The DSL execution engine eliminates the ab-
straction gap between the rich ModelTalk meta-
model and the one provided in Java, bringing ex-
plicit metaclass9 and other advanced capabilities
into Java.
DSL-Based Software Development
In ModelTalk, the framework developer uses DSLs
to declaratively expose variability points in impera-
tive code. This exposure makes the variation man-
agement explicit and moves application assembly
from the realm of code-level development to that of
declarative composition.
DSL Reuse
In ModelTalk, DSLs are interconnected (see Figure
3). A DSL can specialize another DSL by narrow-
ing the semantics to a more specific domain. A DSL
instance can contain an instance of another DSL.
DSL Supply Chain
Traditionally, developers (programmers) produce
DSLs for use by domain experts (nonprogram-
mers). In ModelTalk, however, developers both
produce and consume DSLs. Each developer
team specializes in a set of domains and shares
its expertise with other teams via DSLs. This cre-
ates a supply chain of DSLs in the development
organization while organizing the DSL artifacts
in layers.
All developers are consumers of DSLs residing
at the Core layer. The technical experts are pro-
ducers (and the application and customization de-
velopers are consumers) of DSLs at the Platform
layer. The application developers are producers
(and the customization developers and business
experts are the consumers) of DSLs at the Busi-
ness layer. The customization developers are pro-
ducers (and the business experts are consumers)
of DSLs at the Customization layer.
Architectural Layers
ModelTalk’s Core layer resembles the Smalltalk
system core. This layer contains the DSL execu-
tion engine and provides the basic capabilities for
defining and executing DSLs. Because all DSLs
in ModelTalk are specializations of a (meta)
DSL defined in Core, they all share the same ba-
sic syntax and semantic characteristics. This is a
key enabler in achieving uniformity in user ex-
perience and tooling; for example, autocomple-
tion (during editing), navigation, and consistency
checking operate generically on all DSLs. Further-
more, ModelTalk’s interpretive nature eliminates
the need for tool regeneration when a metamodel
definition changes, as is commonly required in
other DSL frameworks.10
HappyHour
Meta DSL
Data-modelPersistency
EligibilityPromotionGoods
Subscription
ProductB
…
ProductZ
CustomizationBusinessCorePlatform
Particularassets
Specializes
Product A: IEEE example
Sharedassets
Contains
Figure 3. The ModelTalk
producer-consumer
layered architecture.
The bottommost layer
defines the most
generic Meta DSL.
DSLs at higher layers
specialize DSLs at
lower layers. The
topmost layer contains
the assembled products
(products A through Z).
4. 42 I E E E S o f t wa r e w w w. c o m p u t e r. o rg /s o f t w a re
The Platform layer defines a rich set of DSL
building blocks for creating business applications.
Many of the DSLs defined in the Platform layer
are bridges to third-party technologies, such as the
J2EE standard, the Spring framework, Hibernate,
and Apache Axis. Concrete examples of DSLs in
this layer include Persistency and Data-model. Persistency
wraps the Hibernate framework with a DSL for
handling persistency concerns (for example, que-
ries and object/relational mapping). The Data-model
DSL uses the Persistency DSL to define business enti-
ties. Wrapping a third-party framework in a DSL
hides in effect the technological complexity from
the application developers, enabling them to focus
on their domain’s business logic.
The Business layer is a collection of generic,
reusable DSLs and constitutes the business logic.
Example DSLs residing here for an online mar-
keting system include Goods, Promotion, and Eligibil-
ity. Goods defines the products and services offered
to the customer. Eligibility defines the notion of cus-
tomer segments and a set of operators that can
be applied to them. Promotion specializes Data-model
and uses Goods and Eligibility. It defines the notion
of a product being on sale—that is, the incentive
offered, the targeted segment, and the specific
goods.
At the top resides the Customization layer,
in which the complete customized systems (final
products) are assembled mainly from Business-
layer DSLs. DSLs from the Platform layer are also
used occasionally to customize deep aspects of the
system. The Customization layer is managed sep-
arately for each customer or group of customers,
and customer-specific features are developed here.
In the example, Subscription and HappyHour special-
ize Goods and Promotion, respectively, to the IEEE’s
specific needs.
Variability Management and Evolution
ModelTalk accommodates the evolution of DSLs.
A new DSL is initially implemented in the Custom-
ization layer as a one-off customer-specific effort.
At that stage, the need for variability is limited,
so the DSL exposes only a few variability points.
Gradually, as new requirements accumulate, the
DSL developer identifies and implements new vari-
ability points. When the DSL developer recognizes
a potential for significant reuse, additional develop-
ment effort is put into pushing the DSL upstream
in the supply chain—that is, moving the DSL to a
lower layer. The DSL evolves from being a particu-
lar asset to being a shared asset.
A variability point in ModelTalk is essentially
a DSL class property. When DSLs evolve, the IDE
alerts the developer about inconsistency between
existing DSL instances and their class definition.
Implementing DSLs in ModelTalk
To explain the steps in defining instances, properties,
classes, methods, and metaclasses in ModelTalk,
we’ll use a simplified example of an online market-
ing system that business experts use to launch tar-
geted promotions on specific goods.
Instances
Figure 4a shows a DSL instance named IEEE_HH.
This instance “is kind of” Promotion (in the Smalltalk
sense)—specifically, a member of HappyHour (see the
listing in Figure 4b). It defines a happy-hour dis-
count on subscriptions to IEEE Software targeted
at students: $20 off during October 2009. While
specifying this promotion, the DSL programmer
is constrained by the type HappyHour. All properties
must be assigned a value—that is, who is eligible for
the promotion (Figure 4a, lines 2−6), the campaign
time frame (lines 7−10), the incentive given to buy-
ers (lines 11−14), and the goods participating in the
promotion (line 15).
Properties
When editing a DSL instance, you may assign val-
ues only to properties that are defined in the DSL
class. The assigned value must be of a type that
matches the constraints defined in the DSL class.
For properties of a complex (user-defined) type, you
must specify an explicit type attribute. In the reward
property (Figure 4a, line 11), any subclass of Benefit-
Giver can serve as the type. For example, the menu
in Figure 5e lists FixedAmountDiscount, FixedPercentage-
Discount, and SubscriptionPeriodExtension as subclasses of
BenefitGiver.
Choosing the type of a complex property is
significant. At the semantic level, the type deter-
mines the system behavior. At the mechanical
level, the type determines the inner properties that
the user should fill in. Setting FixedPercentageDiscount
as the type of benefit instead of FixedAmountDiscount
(Figure 4a, line 11) would require the user to
specify the discount percentage instead of the
amount and currency. The ModelTalk IDE au-
tocompletion feature relieves the programmer
from memorizing the valid choices. This compo-
sition process is recursive, supporting the defini-
tion of nested instance graphs. To promote reuse,
ModelTalk also supports references to external
instances as an alternative to inline definitions;
see, for example, the reference to IEEE_Software_
Subscription (denoted by the suffix Ref—that is, by
business:SubscriptionRef in Figure 4a, line 15).
In ModelTalk,
the framework
developer
uses DSLs
to declaratively
expose
variability
points in
imperative
code.
5. July/August 2009 I E E E S o f t wa r e 43
Classes
The syntax for a DSL class definition is the same
as for instances. For example, HappyHour (see Fig-
ure 4b) is an EntityClass (and a “kind of” ModelTalk
class). It extends the Promotion class, thus inheriting
its structure and behavior. It defines an additional
dateOfPurchase property (Figure 4b, lines 10–16) in
which users can set the effective time of the promo-
tion campaign.
Methods
The DSL producer writes the HappyHour behavior di-
rectly in Java (see Figure 6a). The ModelTalk DSL
engine combines on demand the structural and the
behavioral definitions. For example, when a client
code requests a DSL instance, perhaps by invoking
ModelTalk.getInstance(”IEEE_HH”), the HappyHour class in
Figure 6a is instantiated in the Java Virtual Ma-
chine and injected (via dependency injection) with
the values specified in IEEE_HH (see Figure 4a). The
injected values are then readily available to the cli-
ent. For example, the call getDateOfPurchase (see Fig-
ure 6a, line 5) returns a TimeWindow instance (see
Figure 6b), injected with the dateOfPurchase value
(Figure 4a, lines 7−10). This object is then used to
determine whether the end user is eligible for the
promotion.
The HappyHour promotion also exemplifies how
declarative composition controls the system behav-
ior. The specified dateOfPurchase constraint could be
an instance of any subclass of ScheduleDef (Figure 4b,
line 12), including TimeWindow, Weekends, and so on.
The choice is specified by the type attribute in IEEE_
HH (Figure 4a, line 7). The DSL user may configure
different HappyHour instances to have different types
of dateOfPurchase. For example, the user can declare
dateOfPurchase to be of type Weekends, in which case
the isInTimeFrame method of Weekends is invoked.
Metaclasses
The HappyHour listing in Figure 4b is an instance of
a specialized metaclass for persistent classes, called
EntityClass (see Figure 4c). HappyHour specifies the per-
sistency trait using the Persistency DSL (Figure 4b,
lines 2–8). The same rules that apply to instance
composition also apply to classes (and metaclasses).
Evaluation and Discussion
Since ModelTalk’s inception, we’ve been collect-
ing data (duration of edit-execute cycles, compila-
tion times, error logs, and other code metrics) to as-
sess its effectiveness. Figure 7 presents the growth
over time of the code base (net user-written code,
01 Promotion ID=”IEEE_HH” type=”ieee:HappyHour”
02 eligibility type=”business:EligibilityBySegments”
03 includedSegmentsList
04 item type=”business:SegmentRef” ref=”IEEE_Students”/
05 /includedSegmentsList
06 /eligibility
07 dateOfPurchase type=”business:TimeWindow”
08 fromTime2009-10-01T00:00:00/fromTime
09 toTime2009-11-01T00:00:00/toTime
10 /dateOfPurchase
11 reward type=”business:FixedAmountDiscount”
12 amount20/amount
13 currencyUSD/currency
14 /reward
15 product type=”business:SubscriptionRef” ref=”IEEE_Software_Subscription”/
16 /Promotion
(a)
01 Class ID=”HappyHour” type=”platform:EntityClass” extends=”business:Promotion”
02 persistenceSpec type=”platform:ClassPersistencySettings”
03 tableNameHAPPYHOUR/tableName
04 fetchStrategy type=”EagerFetcher”
05 fullDepthtrue/fullDepth
06 retrieveReferencesfalse/retrieveReferences
07 /fetchStrategy
08 /persistenceSpec
09 properties
10 property type=”core:ComplexType”
11 namedateOfPurchase/name
12 typeScheduleDef/type
13 description
14 Schedule in which the happy hour is active
15 /description
16 /property
17 /properties
18 /Class
(b)
01 Class ID=”EntityClass” type=”core:Class” extends=”core:Class”
02 properties
03 property type=”core:ComplexType”
04 namepersistenceSpec/name
05 typePersistenceSettings/type
06 /property
07 /properties
08 / Class
(c)
Figure 4. Three example DSL instances:
(a) a DSL instance named IEEE_HH; (b) a DSL
class named HappyHour; (c) a DSL metaclass
named EntityClass. The ModelTalk metalevel
architecture treats instances, classes, and
metaclasses uniformly.
6. 44 I E E E S o f t wa r e w w w. c o m p u t e r. o rg /s o f t w a re
excluding tool-generated code) per architectural
layer. System evolution, new features, and enhance-
ments account for the growth in shared assets (in
the Core, Platform, and Business layers). New cus-
tomers and customized products account for the ag-
gregated code growth in the Customization layer.
DSL code has both the largest share in our code
base as well as the sharpest growth rate. This in-
dicates that DSLs are at the center of gravity in
the ModelTalk-driven development process. This
Figure 5. The ModelTalk development environment. A set of Eclipse plug-ins offers Java-like programming tool support
for DSL authoring: (a) Eclipse standard navigator view; (b) ModelTalk instance-of hierarchy view; (c) ModelTalk
source code editor; (d) ModelTalk documentation tool tip; (e) ModelTalk autocompletion menu; (f) Eclipse problems
view; (g) ModelTalk toolbar.
01 public class HappyHour extends Promotion {
02 public boolean isEligible() {
03 boolean result = super.isEligible();
04 if (result)
05 result=getDateOfPurchase().isInTimeFrame();
06 return result;
07 }
08 }
(a)
01 public class TimeWindow extends ScheduleDef {
02 public boolean isInTimeFrame() {
03 boolean result = false;
04 Calendar currentTime=Calendar.getInstance();
05 if (currentTime.after(getFromTime()))
06 result=currentTime.before(getToTime());
07 return result;
08 }
09 }
(b)
Figure 6. Java code
samples show the
behavior of (a) HappyHour
and (b) TimeWindow
instances.
7. July/August 2009 I E E E S o f t wa r e 45
observation is reinforced by the near absence of
unmanaged code (Java code not governed by Mod-
elTalk) in the Business layer.
Currently, the framework contains 6,327 classes,
of which 292 are metaclasses. Tens of thousands of
instances are expressed in 381K lines of DSL code.
Users have done most of the customization (83 per-
cent of Customization LOC) declaratively, further
indicating that the ModelTalk approach scales well.
Organization Perspective
An organization considering adopting an approach
similar to ModelTalk should take into account a
substantial initial investment in building the infra-
structure and tools. In ModelTalk, the initial in-
vestment was more than 10 person-years. There’s
also an ongoing cost for maintaining the develop-
ment environment.
From the human-resources and skills-set per-
spective, metaprogramming tends to be highly
abstract and generic, so it requires highly capable
individuals who might also need an adjustment pe-
riod before becoming productive. We also learned
over time that our approach is less effective in do-
mains for which rich graphical tools are mature,
such as user interface design and online analytical
processing.
Nevertheless, once a development approach
such as ModelTalk is in place, the benefits for the
organization are tangible. Specifically, the time-to-
market and the cost of producing individual, cus-
tomized products drop significantly. In a particular
project, we needed to integrate a system with eight
other systems and support up to 200 transactions
per second per machine. We went from kickoff to a
live system in 17 calendar weeks (10 person-weeks
of customization work, see Figure 8).
Developer Perspective
Overall, developers report satisfaction using
ModelTalk and specifically praise the short edit-
execute cycle. Our data corroborate this: the av-
erage incremental build time is less than 10 sec-
onds per build. Customization developers enjoy
especially short build times because changes in
the top layer have less impact on the system. To
maintain these short build times, we periodically
devote development resources to improving the
DSL processors. Developers appreciate the fact
that DSL scripting and Java programming take
place in a unified, integrated environment and
that they can work on incomplete or inconsistent
models. Developers express some dissatisfaction
with the lack of diagramming capabilities or in-
teroperability with UML modeling tools.
D
omain-specific languages aim to im-
prove the development process by rais-
ing the level of abstraction around a
specific area of the problem. Typically, develop-
ers introduce and apply DSLs on a per-case ba-
sis only after identifying a specific component
or concern that might benefit from having a
DSL around it. In large systems, this approach
might result in a number of ad hoc, discon-
nected DSLs. Our work here shows the ben-
efit in embracing DSLs not only for a small
number of components or concerns but also as
building blocks for systematically constructing
large software systems.
(a)
(b)
(c)
(d)
0
50
100
0
50
100
0
50
100
Date
09/06 12/06 03/07 06/07 09/07 12/07 03/08 06/08 09/08
Size(KLOC)Size(KLOC)Size(KLOC)Size(KLOC)
Core
Platform
Business
Customization
0
50
100
150
200
DSL
Java (managed)
Java (unmanaged)
DSL
Java (managed)
Java (unmanaged)
DSL
Java (managed)
Java (unmanaged)
DSL
Java (managed)
Java (unmanaged)
Figure 7. The amount
of different kinds of
code in each layer:
(a) Customization,
(b) Business,
(c) Platform, (d) Core.
The gold lines represent
DSL code, the gray lines
represent managed Java
(Java code governed
by ModelTalk), and the
blue lines represent
unmanaged Java code.
8. 46 I E E E S o f t wa r e w w w. c o m p u t e r. o rg /s o f t w a re
Acknowledgments
We thank Zvi Ravia and the anonymous reviewers for
their helpful comments on the article. ModelTalk was
influenced by the TGP (Type, Generic class, Profile)
methodology developed by Shay Ben-Yehuda. We’re
grateful to Pontis, a leading vendor of online market-
ing automation solutions for the telecommunications
market, for granting us access to their development
process and data. This work was supported partly by
the Israel Science Foundation under grant 926/08 and
by the office of the chief scientist of the Israel Minis-
try of Industry Trade and Labor.
References
1. P. Clements and L. Northrop, Software Product
Lines—Practices and Patterns, Addison-Wesley, 2001.
2. M. Voelter and T. Stahl, Model-Driven Software Devel-
opment: Technology, Engineering Management, John
Wiley Sons, 2006.
3. D.S. Batory et al., “Achieving Extensibility through
Product Lines and Domain-Specific Languages: A
Case Study,” Software Reuse: Advances in Software
Reusability, Proc. 6th Int’l Conf. (ICSR 00), LNCS
1844, Springer, 2000, pp. 117−136.
4. A. Hen-Tov, D.H. Lorenz, and L. Schachter, “Model-
Talk: A Framework for Developing Domain-Specific
Executable Models,” Proc. 8th Ann. OOPSLA Work-
shop Domain-Specific Modeling (DSM 08), ACM
Press, 2008; www.dsmforum.org/events/DSM08.
5. M. Fowler, “Language Workbenches: The Killer-
App for Domain-Specific Languages?” 2005; http://
martinfowler.com/articles/languageWorkbench.html.
6. M. Fowler, “Inversion of Control Containers and
the Dependency Injection Pattern,” 2004; http://
martinfowler.com/articles/injection.html.
7. D.H. Lorenz and J. Vlissides, “Pluggable Reflection:
Decoupling Meta-interface and Implementation,”
Proc. 25th Int’l Conf. Software Eng. (ICSE 03), IEEE
CS Press, 2003, pp. 3−13.
8. R. Razavi et al., “Language Support for Adaptive
Object-Models Using Metaclasses,” Computer
Languages, Systems and Structures, vol. 31, nos.
3−4, 2005, pp. 188−218.
9. J.P. Briot and P. Cointe, “Programming with Explicit
Metaclasses in Smalltalk-80,” ACM SIGPLAN Notices,
vol. 24, no. 10, 1989, pp. 84−96.
10. B. Selic, “A Systematic Approach to Domain-Specific
Language Design Using UML,” Proc. 10th IEEE Int’l
Symp. Object and Component-Oriented Real-Time
Distributed Computing, IEEE CS Press, 2007, pp. 2−9.
0
2
4
6
8
10
Day 1
Development
starts
Day 21
First major
quality assurance
version
Day 46
Ready for integration
Day 89
Integration
tests start
DSL
Java (managed)
Java (unmanaged)
Day 121
Project
goes live
Timeline
Size(KLOC)
72%
26%
(a) (b)
0
2
4
6
8
10
Day 1
Development
starts
Day 21
First major
quality assurance
version
Day 46
Ready for integration
Day 89
Integration
tests start
DSL
Java (managed)
Java (unmanaged)
Day 121
Project
goes live
Timeline
Size(KLOC)
72%
26%
(a) (b)
Figure 8. A case study of a customization project from kickoff to deployment: (a) the growth of customization code;
(b) breakdown into kinds of code. Once an approach such as ModelTalk is in place, the organizational benefit is clear:
a short time to market.
About the Authors
Atzmon Hen-Tov is the chief software architect at Pontis and has led the develop-
ment of ModelTalk since its inception. He’s interested in model-driven development and other
methods for software development industrialization. Hen-Tov is a member of the ACM and
the IEEE. Contact him at atzmon@ieee.org.
Assaf Pinhasi is a senior software architect at Pontis. His interests include domain-
specific languages, Web technologies, and scalable software architecture. Pinhasi has
a BSc in computer science and mathematics from Tel-Aviv University. Contact him at
assafpinhasi@yahoo.com.
David H. Lorenz is an associate professor in the Department of Mathematics and
Computer Science at the Open University of Israel. His research interests include aspect-
oriented software engineering and programming, particularly involving multiple domain-
specific languages. Lorenz has a PhD in computer science from the Technion-Israel Institute
of Technology. He’s a member of the ACM and the IEEE. Contact him at lorenz@openu.ac.il.
Lior Schachter is a senior software architect at Pontis and head of the ModelTalk
Core team. His interests include model-driven development, domain-specific languages, and
adaptive systems. Schachter has a BSc in electrical engineering and computer science from
Tel-Aviv University. He’s a member of the IEEE. Contact him at liors@ieee.org.