Extending Attribute Grammars to Support Programming-in-the-Large

Attribute grammars add specification of static semantic properties to context-free grammars, which in turn describe the syntactic structure of program units. However, context-free grammars cannot express programming-in-the-large features common in modern programming languages, including unordered collections of units, included units and sharing of included units. We present extensions to context-free grammars, and corresponding extensions to attribute grammars, suitable for defining such features. We explain how batch and incremental attribute evaluation algorithms can be adapted to support these extensions, resulting in a uniform approach to intra-unit and inter-unit static semantic analysis and translation of multi-unit programs

"Programming in the large" and the need for professional discrimination

A common goal in teaching capone project and software engieering type courses is to develop in students the capabilities required of a professional software developer. Unfortunately, their prior educational experiences in the computing discipline may have done anything but prepare them for professional practice. Although the situation may vary considerably from country to country and institution to institution, there are several common deficiencies to address

How Scale Affects Structure in Java Programs

Many internal software metrics and external quality attributes of Java programs correlate strongly with program size. This knowledge has been used pervasively in quantitative studies of software through practices such as normalization on size metrics. This paper reports size-related super- and sublinear effects that have not been known before. Findings obtained on a very large collection of Java programs -- 30,911 projects hosted at Google Code as of Summer 2011 -- unveils how certain characteristics of programs vary disproportionately with program size, sometimes even non-monotonically. Many of the specific parameters of nonlinear relations are reported. This result gives further insights for the differences of "programming in the small" vs. "programming in the large." The reported findings carry important consequences for OO software metrics, and software research in general: metrics that have been known to correlate with size can now be properly normalized so that all the information that is left in them is size-independent.Comment: ACM Conference on Object-Oriented Programming, Systems, Languages and Applications (OOPSLA), October 2015. (Preprint

Refactoring Legacy JavaScript Code to Use Classes: The Good, The Bad and The Ugly

JavaScript systems are becoming increasingly complex and large. To tackle the challenges involved in implementing these systems, the language is evolving to include several constructions for programming- in-the-large. For example, although the language is prototype-based, the latest JavaScript standard, named ECMAScript 6 (ES6), provides native support for implementing classes. Even though most modern web browsers support ES6, only a very few applications use the class syntax. In this paper, we analyze the process of migrating structures that emulate classes in legacy JavaScript code to adopt the new syntax for classes introduced by ES6. We apply a set of migration rules on eight legacy JavaScript systems. In our study, we document: (a) cases that are straightforward to migrate (the good parts); (b) cases that require manual and ad-hoc migration (the bad parts); and (c) cases that cannot be migrated due to limitations and restrictions of ES6 (the ugly parts). Six out of eight systems (75%) contain instances of bad and/or ugly cases. We also collect the perceptions of JavaScript developers about migrating their code to use the new syntax for classes.Comment: Paper accepted at 16th International Conference on Software Reuse (ICSR), 2017; 16 page

Programming in the Large based on the Business Process Modeling Notation

A software application is related to the processes it supports. Today, UML diagrams esp. use case diagrams and activity diagrams are often used to model the relevant aspects of the processes within the analysis phase. In the design phase the models are manually mapped to the business layer of the software application. In the context of Service-oriented Architectures (SOA) Programming in the Large takes a different approach: Business processes are described in a programming language, i.e. a process language which can be automatically mapped to an execu-tion language and executed by a process engine. In this article we show how Programming in the Large can be practically applied in a software engineering process. We use the Business Process Model Notation (BPMN) as process pro-gramming language. A BPMN description can be mapped to the Business Process Execution Language (BPEL) which is a widely accepted standard to compose Web services

Reusability in software engineering

This paper surveys recent work concerning reusability in software engineering. The current directions in software reusability are discussed, and the two major approaches of reusable building blocks and reusable patterns studied. An extensive bibliography, parts of which are annotated, is included

Documentation and agile methods: striking a balance

I have written previously about the need for students to develop discrimination as part of their preparation for professional practice during their undergraduate capstone courses. But nowhere is this need for discrimination more problematic than in the area of software documentation. Perhaps the only consolation is that professional developers are equally challenged. Yet in migrating students from the set of beliefs and practices that may have worked for them in programming-in-the-small, to those required for programming-in-the-large, sound documentation practices are critical to effective development and delivery of a professional product