- Email: [email protected]
Preface to the special issue on advances in Smalltalk based systems
Science of Computer Programming 96 (2014) 1–3
Contents lists available at ScienceDirect
Science of Computer Programming www.elsevier.com/locate/scico
Preface
Preface to the special issue on advances in Smalltalk based systems 1. Editorial Smalltalk is not only a simple and pure dynamic object-oriented language, but is also a programmable system with processes, its own user interface and a complete Interactive Development Environment (IDE). Smalltalk is a reflexive system and all its elements are implemented in Smalltalk. This means that they can be extended, customized or adapted according to particular contexts and that the Smalltalk IDE itself can be used to implement, validate and debug the Smalltalk system extensions. The adaptability of Smalltalk is the main common keyword of all research articles presented in this special issue of Elsevier Science of Computer Programming (SCP) journal, devoted to “Advances in Smalltalk based systems, from high level environment to hardware devices”. As mentioned in the CFP, relevant topics included Smalltalk support for the entire life cycle of software systems, ranging from high-level active specifications to low-level hardware support:
• • • • • • •
requirements, specification, design, coding, testing, maintenance, metrics and renovation of software; validation, verification, debugging; design, implementation and evaluation of domain specific languages; programming environments, development tools, visualization and animation; virtual machines; mobile devices; software aspects of hardware design.
The CFP was released on 2012, with a submission deadline on October, 15. Although the call was made open, a special focus was set on inviting submissions of extended and updated versions of papers published at IWST (International Workshop on Smalltalk Technologies) on 2012 or earlier. 2. Contents This special issue contains ten papers that explore topics in the Smalltalk design of tools and environments that promote good software engineering properties, e.g., with respect to analyzability, predictability, expressiveness, evolvability, and semantic interactions. Four out of these ten papers are closely related to some former IWST publications. 2.1. Interoperability and interchange The history of computing is marked by lots of languages. It is very rare for a single language to be the best possible choice for everything, and the optimal trade between many concerns such as ease of development, raw performances, adaptability to changes, durability against target platform evolutions. All these languages carry a bit of legacy, that one might reasonably want to reuse without budgeting development costs. Specifically, domain-oriented languages offer a very efficient paradigm (e.g. SQL) to address a bounded concern. It would make no sense to extend these languages to support programming in the large, nor to redevelop in a common programming language all these functionalities. In parallel, a language that gains wide acceptance, captures a large development effort because the developers know that the value lies partially in the community scale (support, ability to open positions with high skilled candidates, etc.). As a result, many domain specific languages survive while popular common programming languages remain few. http://dx.doi.org/10.1016/j.scico.2014.07.004 0167-6423/© 2014 Elsevier B.V. All rights reserved.
2
Preface
A key issue then lies in combining several languages into a single application but this opens new issues such as interoperability and semantic preservation. As an example, Smalltalk is a language that along with its environment (debugger, etc.) promotes agile programming and supports high productivity. However, sometimes the higher productivity simply comes from reusing existing pieces of software and as there are lots of legacy C programs, many efforts have been reported to promote C code encapsulation of C libraries calls (e.g. DLLCConnect). Besides, as Java became the prevalent object-oriented language, many efforts through the world are devoted to developing new Java models and programs. As a consequence, the ability to call a Java code from Smalltalk became important. Two papers address this topic. “Smalltalk in a C World” focuses on C-Smalltalk integration and presents an interoperable framework for allowing code written in C (potentially with inline assembly), Objective-C, Smalltalk, and higher-level domain-specific languages to coexist with very low cognitive or performance overhead. As a result, a single object can have methods implemented in any of the supported languages. “On the Integration of Smalltalk and Java” steps beyond a classical low-level communication between separate Java and Smalltalk virtual machines and presents stx:libjava – an implementation of a Java virtual machine within Smalltalk/X. 2.2. Reuse and refactoring Productivity also comes from efficient refactoring. Refactoring is a crucial activity in agile software development, and simplicity (the simpler, the better), clarity and maintainability depend on it. As a consequence, automated tools are expected to support refactoring, both to reduce the developer’s effort as well as to avoid errors due to manual changes. In this context, the chosen programming language has a major impact on the level of support that an automated refactoring tool can offer. As a late-binding language, Smalltalk opens wide the refactoring opportunities. This is generally very valuable, but on the opposite, when declarative programming comes to be mandatory, the refactoring mechanisms are not suitable. The following paper promotes a declarative approach for GUI Builder to favor reuse. “Seamless Composition and Reuse of Customizable User Interfaces with Spec” models the domain of GUIs design and introduces Spec, a UIBuilder for Pharo with a focus on reuse. With Spec, widget properties are defined declaratively and attached to specific classes known as composable classes. A composable class defines its own widget description as well as the model-widget bridge and widget interaction logic. Another meaningful example is when typing is under consideration. Then comes the need to ensure type consistency, while ideally preserving the native flexibility of the environment. Smalltalkers often see types as static declarations that annotate variables and would constitute a major hindrance for reuse. But refactoring also applies to typing, and one important aspect of a programming language concerning the automation of refactoring is the type system. Two approaches are presented in this special issues that consider injecting typing information in the system. “Gradual Typing for Smalltalk” presents Gradualtalk, a practical approach to gradual types in Smalltalk, with a novel blend of type system features that accommodate most programming idioms. Gradualtalk enables incremental typing of existing programs. The main design goal of the type system is to support the features of the Smalltalk language, like metaclasses and blocks, live programming, and to accommodate the programming idioms used in practice. “Improving Refactoring Tools in Smalltalk Using Static Type Inference” addresses one of the limitations of Smalltalk though supporting static type inference. While a static type system, present in languages such as Java, provides information about dependencies in the program, the dynamic type system of the Smalltalk programming language offers little information that can be used by automated refactoring tools. 2.3. Versioning, documentation and integration Along with refactoring tools, version control systems (VCS) have become indispensable software development tools. The version snapshots they store to provide support for change coordination and release management, effectively track the evolution of the versioned software and its development process. There exists little support for assessing which other changes a particular change depends on have to be integrated. Consequently, integrators have to perform a manual and tedious comparison of the changes within the sequence of their branch and to successfully integrate them. Managing evolution requires to capture and restore states on demand, but further on, to support visiting the evolution tree, and querying it to expose points of interest. Besides, software is not limited to code and programs. Evolution also affects the quality of documentation, all the more so as agile programming is considered. Writing documentation about software internals is highly time-consuming and the resulting documentation is fragile when the software is continuously evolving in a multi-developer setting. As a result, minimalism in technical documentation has often been advocated, with code generation mechanisms to produce working documentation that complements working software at the end of short iterations. Three papers address this issue, by offering a structured view of changes integration.
Preface
3
“Supporting Streams of Changes during Branch Integration” presents an approach that analyzes changes within a sequence of changes (stream of changes) hence it identifies and characterizes dependencies between the changes. This approach supports important queries that an integrator otherwise has to perform manually. “A Logic Foundation for a General-Purpose History Querying Tool” provides a comprehensive description of a logic-based, general-purpose history query tool called Absinthe. Absinthe supports querying versioned Smalltalk system using logic queries in which quantified regular path expressions are embedded. These expressions lend themselves to specifying the properties that each individual version in a sequence of successive software versions ought to exhibit. “Verifiable Source Code Documentation in Controlled Natural Language” shows that using a controlled natural language with a reasoner and a query engine is a viable technique for verifying the consistency and accuracy of documentation and source code. Using ACE, a state-of-the-art controlled natural language, the authors present positive results on the comprehensibility and the general feasibility of creating and verifying documentation. 2.4. Going beyond traditional limits Integrating changes happens after changes arose. This means than the system is subject to changes and evolution. However, depending on how deep the changes impact the system itself, this becomes very challenging. Changes may affect system classes and objects, internal representation of objects, memory allocation policies, ... and these are issues. This is reinforced in environments based on images rather than files based systems. In such systems, the actual state is always snapshot, and this can become an inhibiting factor for future evolution. One solution is presented in the following paper. “Bootstrapping Reflective Systems: The Case of Pharo” proposes a definition of bootstrap for object-oriented reflective systems, along with describing the architecture and components it should contain. The article presents a reference bootstrap process for a reflective system and Hazelnut, its implementation for bootstrapping the Pharo Smalltalkinspired system. Such systems are also known as non-suitable for addressing real time (RT) applications and systems. Late binding leads to unpredictable results, at least in term of execution time. High-level features for memory allocation are useless (memory allocation is static and computed at design time), and system unavailability (e.g. during garbage collect) is prohibited. Instead, high level languages are pretty much suited for modeling RT systems which constantly increasing complexity makes reuse mandatory in order to keep development costs and time-to-market acceptable. Reuse happens at different levels: libraries, code, classes, models, languages. One paper focuses on modeling reconfigurable hardware (FPGAs), along with reusing design tools. It aims at offering a one stop shopping point for hardware designers looking for innovative supports of RT system as well as for software programmers, looking for hardware acceleration. “Model-driven Toolset for Embedded Reconfigurable Cores: Flexible Prototyping and Software like Debugging” presents Biniou, a model-driven toolset for embedded reconfigurable-core modeling written in Smalltalk. In Biniou, the designspace is broadened with reconfiguration modeling aspects, and the exploitation tools support multi-level simulation and high-level debugging facilities of Smalltalk environments. 3. Conclusion The selection of papers covers several common issues in Smalltalk systems. First, interoperability and interchange, with a specific focus on typing issues. Second, sustaining the agility – which remains one of the key features of smalltalk systems – by offering smart mechanisms for safe changes integration, as well as supporting generators, based on query engines, that automate version tracking and documentation consistency check. Then the two extremes of systems generation are considered with a bootstrap mechanism on one hand, that incrementally refactors the system, and the fast prototyping of embedded reconfigurable cores on the other hand, that produces execution platforms. We would like to thank the authors for their scientific contribution. Also, we are grateful to all reviewers who devoted their time and expertise to provide meaningful feedback to the contributors hence improving the papers.
Loïc Lagadec a,b Alain Plantec a,c a Lab-STICC MOCS, CNRS 6285, France c
b ENSTA-Bretagne, France Université de Bretagne Occidentale, France
12 May 2014 Available online 4 September 2014
Contents lists available at ScienceDirect
Science of Computer Programming www.elsevier.com/locate/scico
Preface
Preface to the special issue on advances in Smalltalk based systems 1. Editorial Smalltalk is not only a simple and pure dynamic object-oriented language, but is also a programmable system with processes, its own user interface and a complete Interactive Development Environment (IDE). Smalltalk is a reflexive system and all its elements are implemented in Smalltalk. This means that they can be extended, customized or adapted according to particular contexts and that the Smalltalk IDE itself can be used to implement, validate and debug the Smalltalk system extensions. The adaptability of Smalltalk is the main common keyword of all research articles presented in this special issue of Elsevier Science of Computer Programming (SCP) journal, devoted to “Advances in Smalltalk based systems, from high level environment to hardware devices”. As mentioned in the CFP, relevant topics included Smalltalk support for the entire life cycle of software systems, ranging from high-level active specifications to low-level hardware support:
• • • • • • •
requirements, specification, design, coding, testing, maintenance, metrics and renovation of software; validation, verification, debugging; design, implementation and evaluation of domain specific languages; programming environments, development tools, visualization and animation; virtual machines; mobile devices; software aspects of hardware design.
The CFP was released on 2012, with a submission deadline on October, 15. Although the call was made open, a special focus was set on inviting submissions of extended and updated versions of papers published at IWST (International Workshop on Smalltalk Technologies) on 2012 or earlier. 2. Contents This special issue contains ten papers that explore topics in the Smalltalk design of tools and environments that promote good software engineering properties, e.g., with respect to analyzability, predictability, expressiveness, evolvability, and semantic interactions. Four out of these ten papers are closely related to some former IWST publications. 2.1. Interoperability and interchange The history of computing is marked by lots of languages. It is very rare for a single language to be the best possible choice for everything, and the optimal trade between many concerns such as ease of development, raw performances, adaptability to changes, durability against target platform evolutions. All these languages carry a bit of legacy, that one might reasonably want to reuse without budgeting development costs. Specifically, domain-oriented languages offer a very efficient paradigm (e.g. SQL) to address a bounded concern. It would make no sense to extend these languages to support programming in the large, nor to redevelop in a common programming language all these functionalities. In parallel, a language that gains wide acceptance, captures a large development effort because the developers know that the value lies partially in the community scale (support, ability to open positions with high skilled candidates, etc.). As a result, many domain specific languages survive while popular common programming languages remain few. http://dx.doi.org/10.1016/j.scico.2014.07.004 0167-6423/© 2014 Elsevier B.V. All rights reserved.
2
Preface
A key issue then lies in combining several languages into a single application but this opens new issues such as interoperability and semantic preservation. As an example, Smalltalk is a language that along with its environment (debugger, etc.) promotes agile programming and supports high productivity. However, sometimes the higher productivity simply comes from reusing existing pieces of software and as there are lots of legacy C programs, many efforts have been reported to promote C code encapsulation of C libraries calls (e.g. DLLCConnect). Besides, as Java became the prevalent object-oriented language, many efforts through the world are devoted to developing new Java models and programs. As a consequence, the ability to call a Java code from Smalltalk became important. Two papers address this topic. “Smalltalk in a C World” focuses on C-Smalltalk integration and presents an interoperable framework for allowing code written in C (potentially with inline assembly), Objective-C, Smalltalk, and higher-level domain-specific languages to coexist with very low cognitive or performance overhead. As a result, a single object can have methods implemented in any of the supported languages. “On the Integration of Smalltalk and Java” steps beyond a classical low-level communication between separate Java and Smalltalk virtual machines and presents stx:libjava – an implementation of a Java virtual machine within Smalltalk/X. 2.2. Reuse and refactoring Productivity also comes from efficient refactoring. Refactoring is a crucial activity in agile software development, and simplicity (the simpler, the better), clarity and maintainability depend on it. As a consequence, automated tools are expected to support refactoring, both to reduce the developer’s effort as well as to avoid errors due to manual changes. In this context, the chosen programming language has a major impact on the level of support that an automated refactoring tool can offer. As a late-binding language, Smalltalk opens wide the refactoring opportunities. This is generally very valuable, but on the opposite, when declarative programming comes to be mandatory, the refactoring mechanisms are not suitable. The following paper promotes a declarative approach for GUI Builder to favor reuse. “Seamless Composition and Reuse of Customizable User Interfaces with Spec” models the domain of GUIs design and introduces Spec, a UIBuilder for Pharo with a focus on reuse. With Spec, widget properties are defined declaratively and attached to specific classes known as composable classes. A composable class defines its own widget description as well as the model-widget bridge and widget interaction logic. Another meaningful example is when typing is under consideration. Then comes the need to ensure type consistency, while ideally preserving the native flexibility of the environment. Smalltalkers often see types as static declarations that annotate variables and would constitute a major hindrance for reuse. But refactoring also applies to typing, and one important aspect of a programming language concerning the automation of refactoring is the type system. Two approaches are presented in this special issues that consider injecting typing information in the system. “Gradual Typing for Smalltalk” presents Gradualtalk, a practical approach to gradual types in Smalltalk, with a novel blend of type system features that accommodate most programming idioms. Gradualtalk enables incremental typing of existing programs. The main design goal of the type system is to support the features of the Smalltalk language, like metaclasses and blocks, live programming, and to accommodate the programming idioms used in practice. “Improving Refactoring Tools in Smalltalk Using Static Type Inference” addresses one of the limitations of Smalltalk though supporting static type inference. While a static type system, present in languages such as Java, provides information about dependencies in the program, the dynamic type system of the Smalltalk programming language offers little information that can be used by automated refactoring tools. 2.3. Versioning, documentation and integration Along with refactoring tools, version control systems (VCS) have become indispensable software development tools. The version snapshots they store to provide support for change coordination and release management, effectively track the evolution of the versioned software and its development process. There exists little support for assessing which other changes a particular change depends on have to be integrated. Consequently, integrators have to perform a manual and tedious comparison of the changes within the sequence of their branch and to successfully integrate them. Managing evolution requires to capture and restore states on demand, but further on, to support visiting the evolution tree, and querying it to expose points of interest. Besides, software is not limited to code and programs. Evolution also affects the quality of documentation, all the more so as agile programming is considered. Writing documentation about software internals is highly time-consuming and the resulting documentation is fragile when the software is continuously evolving in a multi-developer setting. As a result, minimalism in technical documentation has often been advocated, with code generation mechanisms to produce working documentation that complements working software at the end of short iterations. Three papers address this issue, by offering a structured view of changes integration.
Preface
3
“Supporting Streams of Changes during Branch Integration” presents an approach that analyzes changes within a sequence of changes (stream of changes) hence it identifies and characterizes dependencies between the changes. This approach supports important queries that an integrator otherwise has to perform manually. “A Logic Foundation for a General-Purpose History Querying Tool” provides a comprehensive description of a logic-based, general-purpose history query tool called Absinthe. Absinthe supports querying versioned Smalltalk system using logic queries in which quantified regular path expressions are embedded. These expressions lend themselves to specifying the properties that each individual version in a sequence of successive software versions ought to exhibit. “Verifiable Source Code Documentation in Controlled Natural Language” shows that using a controlled natural language with a reasoner and a query engine is a viable technique for verifying the consistency and accuracy of documentation and source code. Using ACE, a state-of-the-art controlled natural language, the authors present positive results on the comprehensibility and the general feasibility of creating and verifying documentation. 2.4. Going beyond traditional limits Integrating changes happens after changes arose. This means than the system is subject to changes and evolution. However, depending on how deep the changes impact the system itself, this becomes very challenging. Changes may affect system classes and objects, internal representation of objects, memory allocation policies, ... and these are issues. This is reinforced in environments based on images rather than files based systems. In such systems, the actual state is always snapshot, and this can become an inhibiting factor for future evolution. One solution is presented in the following paper. “Bootstrapping Reflective Systems: The Case of Pharo” proposes a definition of bootstrap for object-oriented reflective systems, along with describing the architecture and components it should contain. The article presents a reference bootstrap process for a reflective system and Hazelnut, its implementation for bootstrapping the Pharo Smalltalkinspired system. Such systems are also known as non-suitable for addressing real time (RT) applications and systems. Late binding leads to unpredictable results, at least in term of execution time. High-level features for memory allocation are useless (memory allocation is static and computed at design time), and system unavailability (e.g. during garbage collect) is prohibited. Instead, high level languages are pretty much suited for modeling RT systems which constantly increasing complexity makes reuse mandatory in order to keep development costs and time-to-market acceptable. Reuse happens at different levels: libraries, code, classes, models, languages. One paper focuses on modeling reconfigurable hardware (FPGAs), along with reusing design tools. It aims at offering a one stop shopping point for hardware designers looking for innovative supports of RT system as well as for software programmers, looking for hardware acceleration. “Model-driven Toolset for Embedded Reconfigurable Cores: Flexible Prototyping and Software like Debugging” presents Biniou, a model-driven toolset for embedded reconfigurable-core modeling written in Smalltalk. In Biniou, the designspace is broadened with reconfiguration modeling aspects, and the exploitation tools support multi-level simulation and high-level debugging facilities of Smalltalk environments. 3. Conclusion The selection of papers covers several common issues in Smalltalk systems. First, interoperability and interchange, with a specific focus on typing issues. Second, sustaining the agility – which remains one of the key features of smalltalk systems – by offering smart mechanisms for safe changes integration, as well as supporting generators, based on query engines, that automate version tracking and documentation consistency check. Then the two extremes of systems generation are considered with a bootstrap mechanism on one hand, that incrementally refactors the system, and the fast prototyping of embedded reconfigurable cores on the other hand, that produces execution platforms. We would like to thank the authors for their scientific contribution. Also, we are grateful to all reviewers who devoted their time and expertise to provide meaningful feedback to the contributors hence improving the papers.
Loïc Lagadec a,b Alain Plantec a,c a Lab-STICC MOCS, CNRS 6285, France c
b ENSTA-Bretagne, France Université de Bretagne Occidentale, France
12 May 2014 Available online 4 September 2014