Visual programming is widely adopted in learning, usually with jigsaw-style blocks that may be freely placed on a canvas. While grammatical correctness is forced by the allowed compositions, syntactic information is not communicated to learners, causing the underlying language grammar to be experientially assimilated. But grammars are crucial for the deeper understanding of languages, since syntax reflects all important semantic aspects and elements. We present a general-purpose syntax-directed visual editor with syntactic tooltips, accepting as input the grammar of the subject language. It adopts a block-based visual style for program elements. However, contrasting to the typical canvas layout, it supports a row-based grid for spatial organization, enabling newlines and indentation. It also allows users view the production chain of any program element for a better understanding of the language. Our early evaluation findings indicate that such a combination of interactive syntax and visual code blocks is very positively received by learners.

The increasing need for programming tasks performed by non-programmers has resulted in various end-user development tools. In this context, visual programming is currently the prevalent paradigm. However, comprehensive collaboration facilities are missing, although necessary, especially in the domains such as teaching and learning. In this paper, we present an integrated workspace supporting collaborative visual programming. Our system allows end-users to easily cooperate on shared visual programming projects. Peer roles, access and edit privileges for project items are supported. Additional features include: personal project items, toggling live syncing during editing and viewing peer action history. Finally, the workspace's supported collaboration models are discussed.

Summary Compile‐time metaprograms are programs executed during the compilation of a source file, usually targeting to update its source code. Even though metaprograms are essentially programs, they are typically treated as exceptional cases without sharing common practices and development tools. Toward this direction, we identify a set of primary requirements related to language implementation, metaprogramming features, software engineering support, and programming environments and elaborate on addressing these requirements in the implementation of a metaprogramming language. In particular, we introduce the notion of integrated compile‐time metaprograms, as coherent programs assembled from specific metacode fragments present in the source code. We show the expressiveness of this programming model and illustrate its advantages through various metaprogram scenarios. Additionally, we present an integrated tool chain, supporting full‐scale build features and compile‐time metaprogram debugging. Copyright © 2013 John Wiley & Sons, Ltd.

The importance of planning and management skills in software development is very difficult to convey in software engineering courses. We present the synopsis of an assignment whose purpose is to demonstrate the significance of such skills, including effective communication, team coordination and collaboration, and overall project planning. The assignment is organized in the context of a distributed software engineering course carried out in collaboration with 12 universities in South America, Europe and Africa. The assignment is a globally distributed contest issued before most development activities related to the course's software project are performed, aiming at favoring the collaboration between students prior to project development. The contest does not involve any programming, and is not related to the project development activities. Instead, it consists of making teams in different countries compete in collaboratively solving a set of very simple tasks. The complexity of the activity is in team collaboration and coordination, and their lack is evident when the tasks are not correctly solved, or not solved in time. Despite the simplicity of the as-signment, students have found it useful in helping them understand the significance of management and planning challenges in distributed software development. Moreover, the assignment helped in team building, by creating a better team atmosphere and contributing in identifying team members better suited for management.

We focus on MDE tools generating source code, entire or partial, providing a basis for programmers to introduce custom system refinements and extensions. The latter may introduce two maintenance issues once code is freely edited: (i) if source tags are affected model reconstruction is broken; and (ii) code inserted without special tags is overwritten on regeneration. Additionally, little progress has been made in combining sources whose code originates from multiple generative tools. To address these issues we propose an alternative path. Instead of generating code MDE tools generate source fragments as abstract syntax trees (ASTs). Then, programmers deploy metaprogramming to manipulate, combine and insert code on-demand from ASTs with calls resembling macro invocations. The latter shifts responsibility for source code emission from MDE tools to embedded metaprograms and enables programmers control where the produced code is inserted and integrated. Moreover, it supports source regeneration and model reconstruction causing no maintenance issues since MDE tools produce non-editable ASTs. We validate our proposition with case studies involving a user-interface builder and a general purpose modeling tool.

Adaptive user-interfaces are capable of: (a) composing themselves at runtime according to a given deployment profile typically encompassing user and usage-context information and (b) possibly dropping user-interface components and activate better alternatives in their place in response to dynamic profile modifications. While adaptive behavior increasingly gains interest for a wide range of software products and services, its support is very demanding requiring adoption of user-interface architectural patterns from the very early software design phases. While previous research addressed the issue of engineering adaptive interactive applications right from scratch, there is an important methodological gap as we lack processes for the systematic evolution of existing non-adaptive applications to adaptive ones. We present a stepwise transformation process of the user-interface source code by incrementally upgrading all relevant implementation structures towards user-interface adaptivity. Because all transformation actions have been chosen to be standard refactorings the conduct of the process is well-defined while adoption preserves the original application architecture and quality of the source code. RESEARCH HIGHLIGHTS • Provide a systematic software update process for user-interface adaptivity

Abstract Operator overloading, a popular mechanism in the C++ language, is a form of ad hoc polymorphism on operator functions, allowing alternative implementations for different argument types. Classless languages with untyped objects are languages that lack classes and treat all objects as compliant to a common Object type. Languages in this category are flexible, dynamic, and easy‐to‐use, with popular examples being JavaScript, Lua, and ActionScript (the latter being hybrid by also offering classes). This paper presents an integrated implementation of untyped operator overloading which enable users to handle dynamically the full range of operators on objects. The focus is on features not supported by other languages, such as (i) arithmetic and relational operators allowing to separately handle caller lhs and rhs positions; (ii) an assignment operator with an untyped analogy of type casting; (iii) a slot access operator allowing user‐defined policies for editing object slots; and (iv) a function‐call operator to support functors. Operators are treated as first‐class object slots, distinguished by reserved indices that match the respective operator lexemes. All reported techniques have been applied in implementing the operator overloading features of the Delta language. Copyright © 2010 John Wiley & Sons, Ltd.

This paper presents a novel software platform for developing and interacting with multimodal interactive electronic textbooks that provide a Dual User Interface, i.e., an interface concurrently accessible by visually impaired and sighted persons. The platform, named Starlight, comprises two sub-systems: (a) the "Writer", facilitating the authoring of electronic textbooks, encompassing various categories of interactive exercises (Q&A, multiple choice, fill in the blanks, etc.); and (b) the "Reader", enabling multimodal interaction with the created electronic textbooks, supporting various features like searching, book-marking, replay of sentences / paragraphs, user annotations / comments, activity recording, and context-sensitive help. An iterative, user-centered design process was adopted, involving from the very early stages students and educators, resulting in the creation of eight textbooks for the primary and high school that are currently available in the Greek market. The paper discusses the competitive features of the Dual User Interface and of supplied functionality compared to existing accessible electronic books. It also consolidates the key design findings, elaborating on prominent design issues, design rational, and respective solutions, highlighting strengths and weaknesses, and outlining directions for future work.

Abstract We present a heuristic implementation method for programming languages that is appropriate when the following requirements or conditions are met: (a) there is a need for very rapid development of a language with significant performance demands, while exploiting a comprehensive host language and/or library; (b) need of customized runtime execution environment supporting of execution tracing and visualization instruments; (c) the facilitation of hybrid code exists, such as mixing with the native language, and there is the potential for allowing multiple languages to be deployed concurrently in the same program. This may account for a wide range of domain‐specific languages such as learning‐oriented, scripting, assembly style, data manipulation, rule‐based, or event languages. The proposed technique is presented for the C++ language, supporting the development of languages whose source programs compile as C++ code. The software architecture shifts from the tradition of lexical analysis, syntax‐directed translation and code generation, and we propose a complementary, conditionally advantageous, heuristic development paradigm. The method has been applied to the development of a high‐level imperative language, an assembly language and a functional language, which are all currently deployed for teaching purposes. Copyright © 2007 John Wiley & Sons, Ltd.

In the design of user interfaces that adapt automatically to end-users and usage contexts, designers should be prepared to cope with large design spaces; these spaces will be necessary to accommodate design constraints posed by the diversity in the target user population and the various contexts of use. Adaptation-oriented design is considered a powerful design recipe addressing the compelling requirements of customization, accessibility, and high quality of interaction. Under this perspective, it must be carefully planned, designed, accommodated, and conducted within the life cycle of interactive systems, from the early exploratory phases of design and prototyping to evaluation, implementation, and deployment. Despite recent progress, the practice of designing automatic user-interface adaptations remains difficult, due to intrinsic complexity of the task and the current limited expertise of designers and practitioners. Toward overcoming such a difficulty, this article presents MENTOR, a tool providing (a) practical integrated support for all phases of adaptation design, through appropriate editing facilities; (b) practical support for a "smooth transition" from design to development through the availability of automated verification mechanisms for the designed adaptation logic, as well as the automated generation of "ready-to-implement" interface specifications; and (c) support for the progressive accumulation of design cases and of the related design experience and knowledge, in particular regarding adaptation.

The notion of ‘universal access’ reflects the concept of an Information Society in which potentially anyone (i.e. any user) will interact with computing machines, at anytime and anyplace (i.e. in any context of use) and for virtually anything (i.e. for any task). Towards reaching a successful and cost effective realization of this vision, it is critical to ensure that the future interface development tools provide all the necessary instrumentation to support inclusive design, i.e. facilitate inclusive development. In the meantime, it is crucial that both tool developers and interface developers acquire awareness regarding the key development features they should pursue when investigating for the most appropriate software engineering support in addressing such a largely demanding development goal (i.e. universally accessible interactions). This paper discusses a corpus of key development requirements for building universally accessible interactions that has been consolidated from real practice, in the course of six medium-to-large scale research projects, all completed, within a 10 years timeframe.

Abstract Design by Contract is a method for the development of robust object‐oriented software, introducing class invariants as conditions corresponding to the design axioms that should be satisfied by every valid instance of a class. Additionally, the method states formally the way client programs should correctly utilize supplier classes, so that the composition of correct programs may be accomplished. However, the contextual correctness of supplier instances within client programs, only reflected in the client‐specific semantics for supplier‐class deployment, cannot be expressed through Design by Contract. For instance, supplier instances satisfying the supplier class invariant may not constitute plausible supplier instances in the context of a particular client program. In this context, we introduce application invariants as an extension to Design by Contract, for hosting the contextual‐correctness logic for supplier instances, as conditionally defined by client programs. This allows stronger validation of supplier instances, through the dynamic encapsulation of client‐specific acceptance filtering, enabling more intensive defect detection. Application invariants are implemented in the context of client classes as methods utilizing correctness condition expressions, are dynamically hosted within supplier instances, while always called by supplier instances when the basic supplier‐class invariant test is performed. Copyright © 2005 John Wiley & Sons, Ltd.

In automatic user interface adaptation, developers pursue the delivery of best-fit user interfaces according to the runtime-supplied profiles of individual end users and usage contexts. Software engineering of automatic interface adaptability entails: (a) storage and processing of user and usage-context profiles; (b) design and implementation of alternative interface components, to optimally support the various user activities and interface operations for different users and usage contexts; and (c) runtime decision-making, to choose on the fly the most appropriate alternative interface components, given the particular user and context profile. In automatic interface adaptation, the decision making process plays a key role in optimal on-the-fly interface assembly, engaging consolidated design wisdom in a computable form. A verifiable language has been designed and implemented which is particularly suited for the specification of adaptation-oriented decision-making logic, while also being easily deployable and usable by interface designers. This paper presents the language, its contextual role in adapted interface delivery and the automatic verification method. The employment of the language in an adaptation-design support tool is discussed, the latter automatically generating language rules by relying upon adaptation rule patterns. Finally, the deployment methodology of the language in supporting dynamic interface assembly is discussed, further generalizing towards dynamic software assembly, by introducing architectural contexts and polymorphic architectural containment.

Journal Article Unified user interface design: designing universally accessible interactions Get access Anthony Savidis, Anthony Savidis aInstitute of Computer Science, Foundation for Research and Technology—Hellas, Science and Technology Park of Crete, Heraklion, Crete, GR-71110, Greece Search for other works by this author on: Oxford Academic Google Scholar Constantine Stephanidis Constantine Stephanidis ∗ aInstitute of Computer Science, Foundation for Research and Technology—Hellas, Science and Technology Park of Crete, Heraklion, Crete, GR-71110, GreecebDepartment of Computer Science, University of Crete, Greece ∗Corresponding author. Address: Institute of Computer Science, Foundation for Research and Technology—Hellas, Science and Technology Park of Crete, Heraklion, P.O. Box 1385, Crete GR-71110, Greece. Tel.: +30-2810-391741; fax: +30-2810-391740 Search for other works by this author on: Oxford Academic Google Scholar Interacting with Computers, Volume 16, Issue 2, April 2004, Pages 243–270, https://doi.org/10.1016/j.intcom.2003.12.003 Published: 01 April 2004 Article history Received: 07 January 2002 Revision received: 09 December 2002 Accepted: 14 December 2003 Published: 01 April 2004

Abstract Smart pointers denote a well‐known technique for collective resource ownership, e.g. sharing dynamic object instances, while usually supporting automatic garbage collection based on reference counting. The original method has been retargeted to serve as a generic defensive programming method for ‘exhaustive tracking’ of erroneous pointer use in C++. Automatic bug tracking is supported in a unified manner both for pointers to heap memory, i.e. free storage, as well as for pointers to stack or global memory, i.e. auto or static storage. Overall, the presented technique (a) offers a simple contract for memory allocation and use; (b) supports type and indirection depth genericity; (c) implements most operators supported for built‐in pointers with embedded bug defense; (d) offers an alternative way of employing a garbage collection facility for memory leak detection; and (e) provides an appropriate collection of utility macros, through which defensive pointers should be used, with an alternative version re‐targeted to normal native pointers. Copyright © 2004 John Wiley & Sons, Ltd.

Intelligence at the level of the user interface is currently being supported through a number of prevalent strands, including adaptive user interfaces, model-based user interface development and interface agents. Moreover, the term intelligent user interface typically implies the notion of dyna-mically enhancing the interaction with a single implemented artefact to suit different usage patterns, user groups, or contexts of use. This article extends this notion and describes how unified design artefacts can support the development of accessible and high quality user interfaces exhibiting the characteristics of multiple metaphor environments. To this effect, the article outlines the principles of unified user interface development and discusses how it can be used to advance Intelligent

Existing systems which enable accessibility to graphical user interfaces (GUIs) by blind people follow an `adaptation strategy'; each system adopts its own hard-coded policy for reproducing visual dialogues in a non-visual form, without knowledge about the application domain or the particular dialogue characteristics. It is argued that non-visual user interfaces should be more than automatically generated adaptations of visual dialogues. Tools are required to facilitate purposeful non-visual interface construction, allowing iterative design and implementation. Such tools should cater for the construction of `integrated' user interfaces, which are concurrently accessible by sighted and blind users. Thus, the concept of dual user interfaces is introduced, arguably as the most appropriate basis to address this important issue of concurrent accessibility, in order to prevent segregation of blind people in computer-based working environments. A user interface management system (UIMS) has been developed, called HOMER, which facilitates the development of dual user interfaces. HOMER supports the integration of visual and non-visual toolkits of interaction elements; a non-visual toolkit, called COMONKIT, has been also implemented for building non-visual user interfaces, and has been incorporated in HOMER.

Article Free Access Share on Developing dual user interfaces for integrating blind and sighted users: the HOMER UIMS Authors: Anthony Savidis Institute of Computer Science, Foundation for Research and Technology-Hellas (FORTH), Science and Technology Park of Crete, P.O. Box 1385, GR 711 10, Heraklion, Crete, Greece Institute of Computer Science, Foundation for Research and Technology-Hellas (FORTH), Science and Technology Park of Crete, P.O. Box 1385, GR 711 10, Heraklion, Crete, GreeceView Profile , Constantine Stephanidis Institute of Computer Science, Foundation for Research and Technology-Hellas (FORTH), Science and Technology Park of Crete, P.O. Box 1385, GR 711 10, Heraklion, Crete, Greece Institute of Computer Science, Foundation for Research and Technology-Hellas (FORTH), Science and Technology Park of Crete, P.O. Box 1385, GR 711 10, Heraklion, Crete, GreeceView Profile Authors Info & Claims CHI '95: Proceedings of the SIGCHI Conference on Human Factors in Computing SystemsMay 1995 Pages 106–113https://doi.org/10.1145/223904.223918Published:01 May 1995Publication History 48citation811DownloadsMetricsTotal Citations48Total Downloads811Last 12 Months41Last 6 weeks4 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteView all FormatsPDF