MontiCore: a framework for compositional development of domain specific languages

Domain specific languages (DSLs) are increasingly used today. Coping with complex language definitions, evolving them in a structured way, and ensuring their error freeness are the main challenges of DSL design and implementation. The use of modular language definitions and composition operators are therefore inevitable in the independent development of language components. In this article, we discuss these arising issues by describing a framework for the compositional development of textual DSLs and their supporting tools. We use a redundance-free definition of a readable concrete syntax and a comprehensible abstract syntax as both representations significantly overlap in their structure. For enhancing the usability of the abstract syntax, we added concepts like associations and inheritance to a grammar-based definition in order to build up arbitrary graphs (as known from metamodeling). Two modularity concepts, grammar inheritance and embedding, are discussed. They permit compositional language definition and thus simplify the extension of languages based on already existing ones. We demonstrate that compositional engineering of new languages is a useful concept when project-individual DSLs with appropriate tool support are defined.     

Hierarchical development of programming languages

The experience in designing large software systems shows that even the definitions of a programming language can be seen as the application of specific implementation and formalization techniques rather than as the result of a «designing art». In this context, a formalism is proposed here as a tool for defining conventional high level programming languages. The formalism is an algebraic model supporting the definition of representational entities such as types. A Type is a set of data and operations on them. An isomorphism between language components and types realizes an isomorphism between the language and its specification on the model. Then, the definition of a language can be performed by stepwise definitions of the types representing the language components. So the model is also a language development tool. Stepwise definition methodologies are also investigated and two are the proposed ones: the horizontal, methodology and the vertical methodology. In particular, the vertical methodology defines languages by the development of a hierarchy of abstraction levels, each corresponding to one class of languages: The last class only contains the language being defined.     

The Alamo Execution Monitor Architecture

Future programming environments will incorporate a tighter coupling between language runtime systems and the monitoring tools that are used to debug, tune, visualize, and understand them. Many innovations that are developed first in higher level programming language environments will migrate into mainstream languages once their properties are understood and generalized.

The Alamo execution monitor architecture was developed to facilitate rapid development of execution monitors, especially visualization tools that are instrumental in understanding complex runtime system interactions in higher level languages. Alamo simplifies the development of such tools by solving the low-level access, control, and intrusion problems inherent in monitoring.

Alamo was implemented first for the very high-level imperative goal-directed language Icon. The architecture was then implemented for ANSI C in order to broaden the impact of the work. This paper describes the ANSI C implementation of Alamo and the monitoring services it provides.     

Ruby Extensions

Using languages such as Ruby for middleware integration projects is straightforward when developers can create pure dynamic language applications that access preexisting services, even though such services (often considered "legacy") are typically implemented in "traditional" middleware languages such as Java, C++, or C. Are dynamic languages like Ruby still useful in situations that require directly coupling the dynamic code to the legacy code? Here, Vinoski explores what it takes to cleanly integrate Ruby into an existing C++ middleware system.     

Urdu language processing: a survey

Extensive work has been done on different activities of natural language processing for Western languages as compared to its Eastern counterparts particularly South Asian Languages. Western languages are termed as resource-rich languages. Core linguistic resources e.g. corpora, WordNet, dictionaries, gazetteers and associated tools being developed for Western languages are customarily available. Most South Asian Languages are low resource languages e.g. Urdu is a South Asian Language, which is among the widely spoken languages of sub-continent. Due to resources scarcity not enough work has been conducted for Urdu. The core objective of this paper is to present a survey regarding different linguistic resources that exist for Urdu language processing, to highlight different tasks in Urdu language processing and to discuss different state of the art available techniques. Conclusively, this paper attempts to describe in detail the recent increase in interest and progress made in Urdu language processing research. Initially, the available datasets for Urdu language are discussed. Characteristic, resource sharing between Hindi and Urdu, orthography, and morphology of Urdu language are provided. The aspects of the pre-processing activities such as stop words removal, Diacritics removal, Normalization and Stemming are illustrated. A review of state of the art research for the tasks such as Tokenization, Sentence Boundary Detection, Part of Speech tagging, Named Entity Recognition, Parsing and development of WordNet tasks are discussed. In addition, impact of ULP on application areas, such as, Information Retrieval, Classification and plagiarism detection is investigated. Finally, open issues and future directions for this new and dynamic area of research are provided. The goal of this paper is to organize the ULP work in a way that it can provide a platform for ULP research activities in future.     

Multilanguage Programming

Knowing and using multiple programming languages for normal day-to-day development can yield significant benefits. No single language is a great fit for all problems. A programming language usually owes its existence to one simple fact: its designer felt it could address a set of problems - perhaps even just one problem - better than other available languages. This belief is apparently not uncommon: thousands of languages have come and gone and thousands more will follow. Numerous trade-offs are involved in programming language design and development, so there's room for many different approaches and variants. Unsurprisingly, monolingual developers tend to choose general-purpose rather than specialized programming languages. General-purpose languages perform adequately for a wide variety of problems, but they generally yield predominantly middle-of-the-road solutions - neither great nor terrible. Of course, some monolingual developers possess extremely deep and thorough knowledge of their programming languages, and so know how to exploit them to the fullest.     

Developers Shift to Dynamic Programming Languages

Software developers are always looking for ways to boost their effectiveness and productivity and perform complex jobs more quickly and easily, particularly as projects have become increasingly large and complex. Programmers want to shed unneeded complexity and outdated methodologies and move to approaches that focus on making programming simpler and faster. With this in mind, many developers are increasingly using dynamic languages such as JavaScript, Perl, Python, and Ruby. Although software experts disagree on the exact definition, a dynamic language basically enables programs that can change their code and logical structures at runtime, adding variable types, module names, classes, and functions as they are running. These languages frequently are interpreted and generally check typing at runtime     

An approach to high-level language bindings to XML

Values of existing typed programming languages are increasingly generated and manipulated outside the language jurisdiction. Instead, they often occur as fragments of XML documents, where they are uniformly interpreted as labelled trees in spite of their domain-specific semantics. In particular, the values are divorced from the high-level type with which they are conveniently, safely, and efficiently manipulated within the language.We propose language-specific mechanisms which extract language values from arbitrary XML documents and inject them in the language. In particular, we provide a general framework for the formal interpretation of extraction mechanisms and then instantiate it to the definition of a mechanism for a sample language core L. We prove that such mechanism can be built by giving a sound and complete algorithm that implements it.The values, types, and type semantics of L are sufficiently general to show that extraction mechanisms can be defined for many existing typed languages, including object-oriented languages. In fact, extraction mechanisms for a large class of existing languages can be directly derived from L's. As a proof of this, we introduce the SNAQue prototype system, which transforms XML fragments into CORBA objects and exposes them across the ORB framework to any CORBA-compliant language.     

An intermediate language to define dynamic semantics

An instruction set is given for an abstract machine which uses a pushdown stack as its principal memory. The proposed instructions serve the similar purposes of (1) defining the dynamic semantics of programming languages by describing the operations of programs on the abstract machine and (2) describing an intermediate language to be used in compiling programming languages into machine language. It is shown how the intermediate language can be used in the translation of the programming languages ADA, FORTRAN and PASCAL into IBM 360 assembly language and advantages over other intermediate languages such as three-address code and P-code.     

Comments, with reply on `Third-generation versus fourth-generationsoftware development'' by S. Misra and P. Jalics

The computer argues that the conclusion to be drawn from the above mentioned article (see ibid., vol.5, no.4, p.8-14, July 1988), that there is no need for fourth-generation languages and no advantage in using them is questionable. He considers the experimental setup in the July article questionable and raises a number of substantive questions about it. The authors reply that there is no suggestion in their article that fourth-generation languages are not needed, but that they are not prepared to accept any tool as a fourth-generation language just because it is labeled as such. They respond to each of the commenter's points and propose a necessary condition of a fourth-generation language     

Context free languages in biological systems

A set of definitions is proposed which places a dynamic model of growth and stabilization in biological systems in a formal language framework. The language of stable adult strings achievable in a system without cellular interactions is studied. It is shown that o if every string is considered to be a possible initial string in development, then the class of languages defined is properly included in the class of regular languages. However if, as is biologically reasonable, development can only start from strings drawn from a finite initial set, then the class of languages defined is exactly the class of context free languages.     

Variables as Stacks

The development of the dynamic semantics of natural languagehas put issues of variable control on the agenda of formal semantics. Inthis paper we regard variables as names for stacks of values and makeexplicit several control actions as push and pop actions on stacks. Weapply this idea both to static and dynamic languages and compare theirfinite variable hierarchies, i.e., the relation between the number ofvariable stacks that is available and the expressivity of the language.This can be compared in natural languages with relating the number ofpronouns available to the expressivity of the language.The results are obtained using techniques from static and dynamic modeltheory: model theoretic games, transition systems and bisimulation.     

Generational analysis of tension and entropy in data structures: impact on automatic data integration and on the semantic web

The move toward automatic data integration from autonomous and heterogeneous sources is viewed as a transition from a closed to an open system, which is in essence an adaptive information processing system. Data definition languages from various computing eras spanning almost 50 years to date are examined, assessing if they have moved from closed systems to open systems paradigm. The study proves that contemporary data definition languages are indistinguishable from older ones using measurements of Variety, Tension and Entropy, three characteristics of complex adaptive systems (CAS). The conclusion is that even contemporary data definition languages designed for such integration exhibit closed systems characteristics along with open systems aspirations only. Plenty of good will is insufficient to make them more suitable for automatic data integration than their oldest predecessors. A previous report and these new findings set the stage for the development and proposal of a mathematically sound data definition language based on CAS, thus potentially making it better suited for automatic data integration from autonomous heterogeneous sources.     

Visual Basic and the future of Web-application development

For the past decade, Microsoft's Visual Basic has been the programming language of choice for Windows-application developers. And recently, Microsoft has made the popular language available for Web-based applications. However, as a growing amount of application development targets the Web, other languages, such as Sun Microsystems' Java, appear to be challenging VB's dominance. VB has remained popular despite prior changes to the language. However, there may not have been as many viable alternatives as there are now today, other languages such as Java and C++ have become Web-development tools of choice. Developers may decide to use these languages because they are more mature and because VB.Net will be more complex to learn and use     

同步数据流语言可信编译器Vélus与L2C的比较

同步数据流语言（如Lustre、Signal）在航空、高铁、核电等安全关键领域得到广泛应用.例如,适合这些领域实时控制系统建模和开发的Scade工具就是基于一种类Lustre语言.这类语言相关开发工具,特别是编译器的安全性问题也自然受到高度关注.近年来,基于形式化验证实现可信编译器构造成为程序设计语言领域的研究焦点之一,也取得了瞩目的成果,如CompCert项目实现了产品级的可信C编译器.同样,人们也采用这种方法开展了同步数据流语言可信编译器的研发工作.主要关注从事这一工作的两个长线项目,二者均研发面向基于Lustre的同步数据流语言编译器,分别以Vélus和L2C代称.对Vélus和L2C从多个重要的角度进行较为深入的分析与比较.