This study tackles the online user allocation problem in mobile edge computing (MEC) systems powered by non-orthogonal multiple access. App vendors need to determine a proper wireless channel in a base station/edge server and sufficient transmit power for every user. We consider a stochastic MEC system where users arrive and depart over time. When an edge server runs out of computing resources, some users will have to wait until the resources become available again, which incurs an allocation delay cost. This cost is often not investigated in many studies, which also do not consider a multi-cell, multi-channel system as we do in this work, due to its complexity. We aim to minimize the allocation delay and transmit power costs, increasing the system’s energy efficiency. To achieve this objective while guaranteeing users’ data rate requirements over time, we adopt the Lyapunov framework to convert this long-term optimization problem into a series of subproblems to be solved in every time slot. To solve the aforementioned subproblems efficiently, we present a distributed game theory-based approach. The proposed algorithm is theoretically evaluated and experimentally demonstrated to outperform several baseline and state-of-the-art methods, highlighting the significance of systematic consideration for both computation and communication aspects of this problem.

Mobile edge computing (MEC) is a new distributed computing paradigm where edge servers are deployed at, or near cellular base stations in close proximity to end-users. This offers computing resources at the edge of the network, facilitating a highly accessible platform for real-time, latency-sensitive services. A typical MEC environment is highly stochastic with random user arrivals and departures over time. Here, we address the user allocation problem from a service provider’s perspective, who needs to allocate its users to the cloud or edge servers in a specific area. A user, who has a multi-dimensional resource requirement, can be allocated to either the remote cloud, which incurs a high latency, or an edge server, which results in a low latency but might require the user to wait in a queue. This study aims to achieve a controllable trade-off between performance (throughput) and several associated costs such as queuing delay and latency costs. We model this problem as a stochastic optimization problem, propose SUAC (Stochastic User AlloCation) – an online Lyapunov optimization-based algorithm, and prove its performance bounds. The experimental results demonstrate that SUAC outperforms existing approaches, effectively allocating users with a desired trade-off while keeping the system strongly stable.

There has been a very large growth in interest in big data analytics to discover patterns and insights. A major challenge in this domain is the need to combine domain knowledge – what the data means (semantics) and what it is used for – with advanced data analytics and visualization techniques to mine and communicate important information from the huge volumes of raw data. Many data analytics tools have been developed for both research and practice to assist in specifying, integrating and deploying data analytics applications. However, delivering such big data analytics applications requires a capable team with different skillsets including data scientists, software engineers and domain experts. Such teams and skillsets usually take a long time to build and have high running costs. An alternative is to provide domain experts and data scientists – the end users – with tools they can use to create and deploy complex data analytics application solutions directly with less technical skills required. In this paper we present a survey and analysis of several current research and practice approaches to supporting data analytics for end-users, identifying key strengths, weaknesses and opportunities for future research.

Edge computing is a new distributed computing paradigm extending the cloud computing paradigm, offering much lower end-to-end latency, as real-time, latency-sensitive applications can now be deployed on edge servers that are much closer to end-users than distant cloud servers. In edge computing, edge user allocation (EUA) is a critical problem for any app vendors, who need to determine which edge servers will serve which users. This is to satisfy application-specific optimization objectives, e.g., maximizing users’ overall quality of experience, minimizing system costs, and so on. In this article, we focus on the cost-effectiveness of user allocation solutions with two optimization objectives. The primary one is to maximize the number of users allocated to edge servers. The secondary one is to minimize the number of required edge servers, which subsequently reduces the operating costs for app vendors. We first model this problem as a bin packing problem and introduce an approach for finding optimal solutions. However, finding optimal solutions to the$\mathcal {NP}$-hard EUA problem in large-scale scenarios is intractable. Thus, we propose a heuristic to efficiently find sub-optimal solutions to large-scale EUA problems. Extensive experiments conducted on real-world data demonstrate that our heuristic can solve the EUA problem effectively and efficiently, outperforming the state-of-the-art and baseline approaches.

Mobile edge computing (MEC) allows edge servers to be placed at cellular base stations. App vendors like Uber and YouTube can rent computing resources and deploy latency-sensitive applications on edge servers for their users to access. Non-orthogonal multiple access (NOMA) is an emerging technique that facilitates the massive connectivity of 5G networks, further enhancing the capability of MEC. The edge user allocation (EUA) problem faces new challenges in 5G NOMA-based MEC systems. In this study, we investigate the EUA problem in a multi-cell multi-channel downlink power-domain NOMA-based MEC system. The main objective is to help mobile app vendors maximize their benefit by allocating maximum users to edge servers in a specific area at the lowest computing resource and transmit power costs. To this end, we introduce a decentralized game-theoretic approach to effectively select a channel and edge server for each user while fulfilling their resource and data rate requirements. We theoretically and experimentally evaluate our solution, which significantly outperforms various state-of-the-art and baseline approaches.

Mobile edge computing (MEC) is a new distributed computing paradigm where edge servers are deployed at, or near cellular base stations in close proximity to end-users. This offers computing resources at the edge of the network, facilitating a highly accessible platform for real-time, latency-sensitive services. A typical MEC environment is highly stochastic with random user arrivals and departures over time. Here, we address the user allocation problem from a service provider's perspective, who needs to allocate its users to the cloud or edge servers in a specific area. A user, who has a multi-dimensional resource requirement, can be allocated to either the remote cloud, which incurs a high latency, or an edge server, which results in a low latency but might require the user to wait in a queue. This article aims to achieve a controllable trade-off between performance (throughput) and several associated costs such as queuing delay and latency costs. We model this problem as a stochastic optimization problem, propose SUAC (Stochastic User AlloCation) – an online Lyapunov optimization-based algorithm, and prove its performance bounds. The experimental results demonstrate that SUAC outperforms existing approaches, effectively allocating users with a desired trade-off while keeping the system strongly stable.

We present BiDaML (Big Data Analytics Modeling Languages), an integrated suite of visual languages and supporting tool to help end-users with the engineering of big data analytics solutions. BiDaML, our visual notations suite, comprises six diagrammatic notations: brainstorming diagram, process diagram, technique diagrams, data diagrams, output diagrams and deployment diagram. BiDaML tool provides a platform for efficiently producing BiDaML visual models and facilitating their design, creation, code generation and integration with other tools. To demonstrate the utility of BiDaML, we illustrate our approach with a realworld example of traffic data analysis. We evaluate BiDaML using two types of evaluations, the physics of notations and a cognitive walkthrough with several target end-users e.g. data scientists and software engineers.

As many applications and services are moving towards a more human-centered design, app vendors are taking the quality of experience (QoE) increasingly seriously. End-to-end latency is a key factor that determines the QoE experienced by users, especially for latency-sensitive applications such as online gaming, health care, critical warning systems and so on. Recently, edge computing has emerged as a promising solution to the high latency problem. In an edge computing environment, edge servers are deployed at cellular base stations, offering processing power and low network latency to users within their geographic proximity. In this paper, we tackle the user allocation problem in edge computing from an app vendor's perspective, where the vendor needs to decide which edge servers to serve which users in a specific area. Also, the vendor must consider the various levels of quality of service (QoS) for its users. Each QoS level results in a different QoE level; thus, the app vendor needs to decide the QoS level for each user so that the overall user experience is maximized. To tackle the NP-hardness of this problem, we formulate it as a potential game then propose QoEGame, an effective and efficient game-theoretic approach that admits a Nash equilibrium as a solution to the user allocation problem. Being a distributed algorithm, QoEGame is able to fully utilize the distributed nature of edge computing. Finally, we theoretically and empirically evaluate the performance of QoEGame, which is illustrated to be significantly better than the state of the art and other baseline approaches.

Big data and analytics are increasingly used in different domains to gain insights and to improve decision-making. Developing big data analytics solutions is a complex task involving multidisciplinary teams and users - with no data science and programming background - to professional data scientists and software engineers. Different stakeholders work with a variety of data types, tasks and concepts in different languages from high- level domain concepts to low level programming languages and technical concepts. In order to advance the level of abstraction beyond low-level data analysis technical details, we demonstrate our BiDaML tool. BiDaML brings all stakeholders around one tool to specify, model and document their big data applications using a novel set of domain-specific visual languages (DSVLs).

Most performance engineering approaches focus on understanding the use of runtime resources. However such approaches do not quantify the value being provided in return for the consumption of these resources. Without such a measure it is not possible to compare the efficiency of these components (that is whether the runtime cost is reasonable given the benefit being provided). We have created an empirical approach that measures the value being provided by a code path in terms of the visible data it generates for the rest of the application. Combining this with traditional performance cost data, creates an efficiency measure for every code path in the application. We have evaluated our approach using the DaCapo benchmark suite, demonstrating our analysis allows us to quantify the efficiency of the code in each benchmark and find real optimisation opportunities, providing improvements of up to 36% in our case studies.

Large-scale object-oriented applications consist of tens of thousands of methods and exhibit highly complex runtime behaviour that is difficult to analyse for performance. Typical performance analysis approaches that aggregate performance measures in a method-centric manner result in thinly distributed costs and few easily identifiable optimisation opportunities. Subsuming methods analysis is a new approach that aggregates performance costs across repeated patterns of method calls that occur in the application's runtime behaviour. This allows automatic identification of patterns that are expensive and represent practical optimisation opportunities. To evaluate the practicality of this analysis with a real world large-scale object-oriented application we completed a case study with the developers of letterboxd.com - a social network website for movie goers. Using the results of the analysis we were able to rapidly implement changes resulting in a 54.8% reduction in CPU load and an 49.6% reduction in average response time.

The majority of existing application profiling techniques aggregate and report performance costs by method or calling context. Modern large-scale object-oriented applications consist of thousands of methods with complex calling patterns. Consequently, when profiled, their performance costs tend to be thinly distributed across many thousands of locations with few easily identifiable optimisation opportunities.

Performance is a crucial attribute for most software, making performance analysis an important software engineering task. The difficulty is that modern applications are challenging to analyse for performance. Many profiling techniques used in real-world software development struggle to provide useful results when applied to large-scale object-oriented applications. There is a substantial body of research into software performance generally but currently there exists no survey of this research that would help identify approaches useful for object-oriented software. To provide such a review we performed a systematic mapping study of empirical performance analysis approaches that are applicable to object-oriented software. Using keyword searches against leading software engineering research databases and manual searches of relevant venues we identified over 5,000 related articles published since January 2000. From these we systematically selected 253 applicable articles and categorised them according to ten facets that capture the intent, implementation and evaluation of the approaches. Our mapping study results allow us to highlight the main contributions of the existing literature and identify areas where there are interesting opportunities. We also find that, despite the research including approaches specifically aimed at object-oriented software, there are significant challenges in providing actionable feedback on the performance of large-scale object-oriented applications.

Requirements validation is a crucial process to determine whether client-stakeholders' needs and expectations of a product are sufficiently correct and complete. Various requirements validation techniques have been used to evaluate the correctness and quality of requirements, but most of these techniques are tedious, expensive and time consuming. Accordingly, most project members are reluctant to invest their time and efforts in the requirements validation process. Moreover, automated tool supports that promote effective collaboration between the client-stakeholders and the engineers are still lacking. In this paper, we describe a novel approach that combines prototyping and test-based requirements techniques to improve the requirements validation process and promote better communication and collaboration between requirements engineers and client-stakeholders. To justify the potential of this prototype tool, we also present three types of evaluation conducted on the prototpye tool, which are the usability survey, 3-tool comparison analysis and expert reviews.

Within the era of globalisation that acknowledges differences and diversity, multiple languages have been increasingly used to capture requirements. This practice is particularly prevalent in Malaysia, where both Malay and English languages are used as a media of communication. Nevertheless, capturing requirements in multiple languages is often error-prone due to natural language imprecision being compounded by language differences. Considering that two languages may be used to describe requirements for the same system in different ways, we were motivated to develop MEReq, a tool which uses Essential Use Case (EUC) models to support capturing and checking the inconsistency occurring in English and Malay multi-lingual requirements. MEReq is tablet compatible to minimise time for on-site capture and validation of multi-lingual requirements. This paper describes the MEReq approach and demonstrates its use to capture and validate English and Malay requirements.

Whilst robots are increasingly being deployed as social agents, it is still difficult to program them to interact socially. This is because current programming tools either require programmers to work at a low level or lack features needed to create certain aspects of social interaction. High level, domain specific tools with features designed specifically to meet the requirements of social interaction have the potential to ease the creation of social applications. We present a domain specific application programming interface (API) that is designed to meet the requirements of social interaction. The Cognitive Dimensions Framework was used as a design tool during the design process and the API was validated by implementing an exemplar application. The evaluation of the API showed that programmers with no robotics knowledge were positively impressed by the notation and that its organization, domain specific interfaces and object oriented nature positively affected several Cognitive Dimensions.

Critics have emerged in recent times as a specific tool feature to support users in computer-mediated tasks. These computer-supported critics provide proactive guidelines or suggestions for improvement to designs, code, and other digital artifacts. The concept of a critic has been adopted in various domains, including medical, programming, software engineering, design sketching, and others. Critics have been shown to be an effective mechanism for providing feedback to users. We propose a new critic taxonomy based on extensive review of the critic literature. The groups and elements of our critic taxonomy are presented and explained collectively with examples, including the mapping of 13 existing critic tools, predominantly for software engineering and programming education tasks to the taxonomy. We believe this critic taxonomy will assist others in identifying, categorizing, developing, and deploying computer-supported critics in a range of domains.

Domain-specific visual languages support high-level modeling for a wide range of application domains. However, building tools to support such languages is very challenging. We describe a set of key conceptual requirements for such tools and our approach to addressing these requirements, a set of visual language-based metatools. These support definition of metamodels, visual notations, views, modeling behaviors, design critics, and model transformations and provide a platform to realize target visual modeling tools. Extensions support collaborative work, human-centric tool interaction, and multiplatform deployment. We illustrate application of the metatoolset on tools developed with our approach. We describe tool developer and cognitive evaluations of our platform and our exemplar tools, and summarize key future research directions.

We describe the evaluation of a build awareness system that assists agile software development teams to understand current build status and who is responsible for any build breakages. The system uses ambient awareness technologies, providing a separate, easily perceived communication channel distinct from standard team workflow. Multiple system configurations and behaviours were evaluated. An evaluation of the system showed that, while there was no significant change in the proportion of build breakages, the overall number of builds increased substantially, and the duration of broken builds decreased. Team members also reported an increased sense of awareness of, and responsibility for, broken builds and some noted the system dramatically changed their perception of the build process making them more cognisant of broken builds.

Requirements captured by Requirements Engineers are commonly inconsistent with their client’s intended requirements and are often error prone especially if the requirements are written in multiple languages. We demonstrate the use of our automated inconsistency-checking tool MaramaAI to capture and manage the consistency of multi-lingual requirements in both the English and Malay languages for requirements engineers and clients using a round-trip, rapid prototyping approach.

It is well recognized that visualizing traceability links between software artifacts helps developers to recover, browse, and maintain these inter-relationships effectively and efficiently. However, it is a major challenge for researchers to efficiently visualize traceability links for big software systems because of scalability and visual clutter issues. In this paper we present a new approach that combines treemap and hierarchical tree visualization techniques to provide a global structure of traces and a detailed overview of each trace. These both reduce visual clutter while still being highly scalable and interactive. Our usability study shows that our approach can support comprehension, browsing, and maintenance of traceability links.

Requirements are typically modelled in natural language, leading to inconsistencies, incompleteness and incorrectness due to inherent natural language ambiguities and lack of precise modelling rules. In previous work, we developed a technique and toolset to support extraction of requirements from English text and supporting semi-formal modelling and roundtrip refinement using Essential use cases, helping to mitigate some of these problems. In this paper we describe new work applying this human-centric approach to requirements engineering to the Malay language. We describe an extension of our original Essential Use Cases toolset to support requirements modelling in the Malay language essential interaction modelling, and results of a preliminary experiment to gauge our tool's effectiveness in supporting Malay natural language extraction and round-trip requirements refinement.

We describe a multidisciplinary course introducing Software Engineering, Computer Science and Business students to strategic business planning in IT organizations using technology roadmapping as the focus of instruction. The course has a strong practicum element, where multidisciplinary teams facilitate development of a technology roadmap in fast growth IT organizations guided by experienced mentors. It provides opportunities for a rich set of learnings, of the core content, technology roadmapping, but also: team skills in a multidisciplinary context; consultancy and communication skills; understanding other professionals vocabularies; and practical observation of hi-tech senior managers.

Tracking a variety of traceability links between artifacts assists software developers in comprehension, efficient development, and effective management of a system. Traceability systems to date based on various Information Retrieval (IR) techniques have been faced with a major open research challenge: how to extract these links with both high precision and high recall. In this paper we describe an experimental approach that combines Regular Expression, Key Phrases, and Clustering with IR techniques to enhance the performance of IR for traceability link recovery between documents and source code. Our preliminary experimental results show that our combination technique improves the performance of IR, increases the precision of retrieved links, and recovers more true links than IR alone.

Requirements specifications need to be checked against the 3C's - Consistency, Completeness and Correctness - in order to achieve high quality. This is especially difficult when working with both natural language requirements and associated semi-formal modelling representations. We describe a technique and support tool that allows us to perform semi-automated checking of natural language and semi-formal requirements models, supporting both consistency management between representations but also correctness and completeness analysis. We use a concept of essential use case interaction patterns to perform the correctness and completeness analysis on the semi-formal representation. We highlight potential inconsistencies, incompleteness and incorrectness using visual differencing in our support tool. We have evaluated our approach via an end user study which focused on the tool's usefulness, ease of use, ease of learning and user satisfaction and provided data for cognitive dimensions of notations analysis of the tool.

Robots are useful tools for teaching novices programming as real and immediate outcomes of programs can be seen. However robot software development has unique problems making aspects of programming difficult compared with general software development. These problems include the robot platform, the robot's environment and its interaction in three-dimensional space and the fact that events occur in real time. We describe Ruru, a novel visual language that addresses these difficulties through a principled approach to its design. It also visualizes robot inputs intuitively in real time and allows the intuitive amendment of parameters. This improves its usefulness and user friendliness as a tool for teaching novices programming.

Automatic layout can be a crucial support feature for complex diagramming tools. Adding suitable layout algorithms to diagramming tools is a complex task and meta-tools should incorporate these for reuse. We present MaramaALM, a generalised set of automatic layout mechanisms. This has been incorporated in the Eclipse-based Marama meta-toolset to support automatic layout in Marama diagrams. It provides an easy-to-use mechanism for tool developers to add such layouts to their generated tools. We describe our motivation for MaramaALM, our approach to its implementation and an example case study of using these tool extensions.

Navigating and understanding complex software architecture documentation is often challenging. To support finding relevant information in architecture documents (ADs), we propose a semi-automated approach based on the actual usage of ADs by previous users, i.e. by capturing users' exploration paths through ADs and making these paths available for future retracing and analysis. To do this, we have built a prototype tool (KaitoroCap) that captures users' AD exploration paths and saves them with contextual metadata. KaitoroCap displays the exploration paths in hierarchical tree views and these exploration paths can be searched. This is helpful for recalling previous navigations and to follow others' useful paths in finding relevant information in AD. Our approach also enables dynamic restructuring of ADs and incorporates user rating, tagging and commenting of the content of ADs. Initial user evaluation shows promising results.

To facilitate the usage of software architecture documents (ADs), we claim the architectural information in the ADs needs to be structured into or presented as chunks. A chunk allows related information to be retrieved collectively as a unit and simplifies information location tasks. We propose a new semi-automated approach based on the actual usage of ADs by previous users, i.e. by capturing users' exploration paths through ADs while engaging in information seeking tasks and making these paths available for future retracing and analysis. As part of our work, we developed KaitoroCap, a document navigation capture and visualisation tool. Its main features are exploration paths capture, retrieval, analysis, hierarchical tree-view visualization of paths, path searching, section rating, tagging, commenting, expanding/collapsing and page model generation to enable dynamic restructuring of ADs. This paper describes the design, implementation and usage examples of KaitoroCap.

Information overload and an abundance of choices create situations where selecting one option becomes extremely difficult or even worse, a guessing game. Collaborative ranking systems are widely used to alleviate this problem by creating intelligent rankings of items based on an aggregation of user opinions. Current ranking systems can still be improved in a number of areas, including accuracy, transparency and flexibility. This paper presents a multi-criteria ranking algorithm that can be used on a non-rigid set of criteria. The system implementing the algorithm fares well with respect to the above qualities.

Consistency checking needs to be done from the earliest phase of requirements capture as requirements captured by requirement engineers are often vague, error-prone and inconsistent with users' needs. To improve such consistency checking we have applied a traceability approach with visualization capability. We have embedded this into a light-weight automated tracing tool in order to allow users to capture their requirements and generate Essential Use Case models of these requirements automatically. Our tool supports inconsistency checking between textual requirements, abstract interactions that derive from the text and Essential Use Case models. A preliminary evaluation has been conducted with target end users and the tool usefulness and ease of use are evaluated. We describe our motivation for this research, our prototype tool and results of our evaluation.

Developers ought to maintain awareness of the status of a software project. However, there are very few recorded best practices for defining what constitutes relevant status information and the appropriate modalities for communicating this information. In this industry case study, we conducted in-depth interviews with members of an agile development team. We found that their daily work practices, while well-defined and regular, were heavily influenced by the status information they integrated from a number of sources. In particular, continuous integration builds had a substantial effect on the team's workflow. Based on our findings, we provide a set of guidelines for build monitoring systems which encourage collective and individual responsibility while working within the established team environment.

This paper presents a new approach to specifying critics for domain-specific visual language tools using a visual and template-based approach. In this paper we describe our approach for specifying critics for domain-specific visual language tools. This allows target end-user tool developers to design and implement critics efficiently in a natural manner. We describe a survey that we conducted to evaluate our new approach and the Cognitive Dimensions approach that was applied in the survey questionnaire design. Survey results are briefly discussed along with the issues raised by some respondents to improve our approach.

With the need to make sense out of large and constantly growing information spaces, tools to support information management are becoming increasingly valuable. In prior work we proposed the "Visual Wiki" concept to describe and implement web-based information management applications. By focusing on the integration of two promising approaches, visualizations and collaboration tools, our Visual Wiki work explored synergies and demonstrated the value of the concept. Building on this, we introduce "VikiBuilder", a Visual Wiki meta-tool, which provides end-user supported modeling and automatic generation of Visual Wiki instances. We describe the design and implementation of the VikiBuilder including its architecture, a domain specific visual language for modeling Visual Wikis, and automatic generation of those. To demonstrate the utility of the tool, we have used it to construct a variety of different Visual Wikis. We describe the construction of Visual Wikis and discuss the strengths and weaknesses of our meta-tool approach.

Capturing software requirements from clients often leads to error prone and vague requirements documents. To surmount this issue, requirements engineers often choose to use UML models to capture their requirements. In this paper we discuss the use of Essential Use Cases (EUCs) as an alternative, user-centric representation which was developed to ease the process of capturing and describing requirements. However, EUCs are not commonly used in practice because, to our knowledge, no suitable tool support has been developed. In addition, requirements engineers face difficulties in finding the correct 'essential' requirements (abstract interactions) in a time efficient manner. In order to overcome these problems, we have developed a prototype tool for automated tracing of abstract interactions. We describe the tool and compare the performance and correctness of the results provided by it to that of manual essential use case extraction efforts by a group of requirements engineers. The results of an end user study of the tool's usefulness and ease of use are also discussed.

Requirements are commonly vague and ambiguous. In this paper, we describe an automated Inconsistency Checker called MaramaAI for checking for high-level inconsistency between textual requirements, abstract interactions and Essential Use Cases. We use concepts of phrase extraction and essential interaction patterns to carry out these checks. We provide further support for checking of requirements quality attributes such as completeness and correctness using visual differencing.

Supply chain modelling and simulation by SMEs (Small-to-Medium Enterprises) is a challenging problem. This is due both to complexity of the supply chain models required and the lack of required expertise among the SMEs. The problem is important since SMEs need to represent and modify their evolving skills and processes to be visible in electronic marketplaces and supply chain design platforms. We demonstrate how this problem can be addressed by developing a suite of novel domain-specific visual languages and a support tool. The challenging setup of our research context motivated us to trial a new approach for the design of our visual languages and to employ a collaborative development process across our distributed research team.

This paper describes a software architecture documentation tool (KaitoroBase) built within the Thinkbase Visual Wiki to provide support for non-linear navigation and visualization of Software Architecture Documents (SADs) produced using the Attribute-Driven Design (ADD) method. This involves constructing the meta-model for the SAD in Freebase which provides the foundation for the graph-based interactive visualization enabled by Thinkbase. The resulting tool displays a graphical, high-level structure of SAD, allows for exploratory search, non-linear navigation, and at the same time connects to low-level details of SADs in a wiki.

Many domain specific textual languages have been developed for generating complex reports. These are challenging for novice users to learn, understand and use. We describe our work developing the prototype of a new visual language tool for a company to augment their textual report writing language. We describe key motivations for our visual language tool solution, its architecture, design and development using Microsoft DSL tools, and its evaluation by end-users.

In recent years, there has been an increasing interest in using computer-based ldquocritic toolsrdquo for supporting the end-users or tool designers in analyzing and proactively improving their design artifacts. Several approaches have been applied to designing and realizing such critics, for example rule-based, pattern-matching and knowledge-based approaches. While many studies have found evidence that critic tools are an efficient feedback-providing mechanism, there is still insufficient knowledge about how to provide an effective critic authoring environment. In this paper we apply a business rule template approach as a mechanism to specify and realize critics for Marama-based domain-specific visual language tools. We describe a visual design critic authoring template approach that supports end-users or tool designers in the construction of critics for any Marama-based tools.

We describe the Marama suite of meta-tools. This Eclipse-based toolset permits rapid specification of notational elements, meta-models, view editors and view-model mappings. It has a novel set of behavioural specification tools for both visual and model level behaviours. An integrated mapping tool provides model transformation and code generation support. The toolset has been applied to several significant application development tasks and has undergone a variety of evaluations.

Personal health care applications on mobile devices allow patients to enhance their health via reminders, monitoring and feedback to health care providers. Engineering such applications is challenging with a need for health care plan meta-models, per-patient instantiation of care plans, and development and deployment of supporting Web and mobile device applications. We describe a novel prototype environment for visually modelling health care plans and automated plan and mobile device application code generation.

MaramaEML is an integrated support tool for the enterprise modelling language (EML) built using the Eclipse based Marama framework. It provides support for multiple visual notations including: the business process modelling notation (BPMN); the EML tree- based, multi-layer hierarchical service representation; fisheye zooming capabilities; automatic BPEL code generation; and inter-notation mapping.

We have developed a domain specific visual language (DSVL) and environment to support the modeling of small business-based dynamic supply networks. We describe our approach to the design of the DSVL, challenges faced, the implementation of a prototype environment, and preliminary evaluation.

Abstract Most visual diagramming tools provide point‐and‐click construction of computer‐drawn diagram elements using a conventional desktop computer and mouse. SUMLOW is a unified modelling language (UML) diagramming tool that uses an electronic whiteboard (E‐whiteboard) and sketching‐based user interface to support collaborative software design. SUMLOW allows designers to sketch UML constructs, mixing different UML diagram elements, diagram annotations, and hand‐drawn text. A key novelty of the tool is the preservation of hand‐drawn diagrams and support for manipulation of these sketches using pen‐based actions. Sketched diagrams can be automatically ‘formalized’ into computer‐recognized and ‐drawn UML diagrams and then exported to a third party CASE tool for further extension and use. We describe the motivation for SUMLOW, illustrate the use of the tool to sketch various UML diagram types, describe its key architecture abstractions and implementation approaches, and report on two evaluations of the toolset. We hope that our experiences will be useful for others developing sketching‐based design tools or those looking to leverage pen‐based interfaces in software applications. Copyright © 2007 John Wiley & Sons, Ltd.

Plugin-based application design has become increasingly popular in recent years, and has contributed to the success of a range of very different applications including Mozilla Firefox and the Eclipse development environment. Using plugins is a promising approach to build complex systems that have to be reconfigured at runtime, and several plugin based general purpose runtime environments are currently under development. Plugin-based design is based on the idea that plugins provide additional functionality extending the capabilities of a core product. While this is often understood as providing services by implementing abstract classes or interfaces defined in the core product, modern plugin-based systems like Eclipse use a much wider definition of service. We propose to consider these services as typed resources and introduce a contract language that can be used to define contracts between plugins providing and consuming services. This language is based on the Semantic Web Rule Language (SWRL) that has a well-defined syntax and semantics. These contracts can then be used in order to validate complex, plugin-based applications.

Software engineers often use hand-drawn diagrams as preliminary design artefacts and as annotations during reviews. We describe the addition of sketching support to a domain-specific visual language meta-tool enabling a wide range of diagram-based design tools to leverage this human-centric interaction support. Our approach allows visual design tools generated from high-level specifications to incorporate a range of sketching-based functionality including both eager and lazy recognition, moving from sketch to formalized content and back and using sketches for secondary annotation and collaborative design review. We illustrate the use of our sketching extension for an example domain-specific visual design tool and describe the architecture and implementation of the extension as a plug-in for our Eclipse-based meta-tool.

Accurate web application performance testing relies on the use of loading tests based on a realistic client behaviour load model. Unfortunately developing such load models and associated test plans and scripts is tedious and error-prone with most existing web performance testing tools providing limited client load modelling capabilities. We describe a new approach and toolset that we have developed, MaramaMTE+, which improves the ability to model realistic web client load behaviour, automatically generates complex web application testing plans and scripts, and integrates load behaviour modelling with a generic performance engineering tool. MaramaMTE+ uses a stochastic form chart as its client loading model. A 3rd party web crawler application extracts structural information from a target web site, aggregating the collected data into a crawler database that is then used for form chart model generation. The performance engineer then augments this synthesized form chart with client loading probabilities. Realistic web loading tests for a 3rd party web load testing tool are then automatically generated from this resultant stochastic form chart client load model. We describe the development of our MaramaMTE+ environment, example usage of the tool, and compare and contrast the results obtained from our generated performance load tests against hand-built 3rd party tool load tests

In this tutorial we present an overview of Domain-specific visual languages (DSVLs), DSVL-based software engineering tools and meta-tools for constructing DSVL-based tools. We present a motivation for DSVL usage in software engineering; examine several DSVL exemplar tools; illustrate the design of DSVLs including meta-model, notation and view type design; and compare and contrast several tools to realizing DSVLs. Included are three short group exercises in DSVL design.

Current approaches to modelling complex business processes fail to scale to large organizations. Key issues are cobweb and labyrinth problems exhibited by conventional box and line metaphors and large numbers of hidden dependencies introduced by compartment-based modularity. We have been developing a new approach, Enterprise Modelling Language, based on trees, overlays and fish-eye viewers to overcome these shortcomings of existing workflow notations. EML utilizes several visual metaphors to enhance the representation, navigation and management of large organizational hierarchies and process flows. We describe a prototype support tool, MaramaEML, that provides support for multiple visual notations including the business process modelling notation (BPMN), the EML tree-based, multi-layer hierarchical representation, fisheye zooming capabilities, automatic BPEL code generation, and inter-notation mapping. We describe our experiences using EML to model large business processes and initial evaluation results.

It is increasingly common to use metatools to specify and generate domain specific visual language tools. A common problem for such metatools is specification of model level behaviours, such as constraints and dependencies. These often need to be specified using conventional code in the form of event handlers or the like. We report our experience in integrating a declarative constraint/dependency specification mechanism into a domain specific visual language metatool, focussing on the tradeoffs we have made in the notational design and environmental support used. The expressive power of the mechanism developed is illustrated by a substantial case study where we have redeveloped a complex visual tool for architectural modelling, eliminating conventional event handlers.

Abstract Diagram‐centric applications such as software design tools, project planning tools and business process modelling tools are usually ‘thick‐client’ applications running as stand‐alone desktop applications. There are several advantages to providing such design tools as Web‐based or even PDA‐ and mobile‐phone‐based applications. These include ease of access and upgrade, provision of collaborative work support and Web‐based integration with other applications. However, building such thin‐client diagram editing tools is very challenging. We have developed several thin‐client diagram editing applications realized as a set of plug‐in extensions to a meta‐tool for visual design environment development. In this paper, we discuss key user interaction and software architecture issues, illustrate examples of interacting with our thin‐client diagram editing tools, describe our design and implementation approaches, and present the results of several different evaluations of the resultant applications. Our experiences will be useful for those interested in developing their own thin‐client diagram editing architectures and applications. Copyright © 2007 John Wiley & Sons, Ltd.

WISER is a series of international workshops that focus on identifying and transferring techniques from other disciplines that might usefully be applied to software engineering research and practice.The workshops address this topic through presentations and discussions of both actual case studies and of ways in which potentially useful approaches can be identified, adapted and adopted within software engineering.

Domain-specific visual language editors are useful in many areas of software engineering but developing such editors is challenging and time-consuming. We describe an approach to generating a wide range of these graphical editors for use as plug-ins to the Eclipse environment. Tool specifications from an existing meta-tool, Pounamu, are interpreted to produce dynamic, multi-view, multiuser Eclipse graphical editors. We describe the architecture and implementation of our approach, examples of its use realizing domain-specific modelling tools, and strengths and limitations of the approach

Hand-drawn designs and annotations are a common, human-centric approach frequently used during software design and code inspection. We describe our research experiences of adding support for hand-drawn design and annotation to three Integrated Development Environments (IDEs): a software design tool; a user interface design tool; and a programming tool. The aim of this work is to provide users with more natural interaction techniques seamlessly integrated into their IDEs through the use of hand-drawn diagrams, layouts and code mark-ups.

Currently there are no concurrent versioning systems (CVS) designed to properly support agile software development. The existing CVS lacks user friendliness and it requires users to be fully experienced with the system before they can adequately use it. Also its asynchronous style of merging often leads to code loss. In this paper, we describe a novel CVS system, called the aspect-oriented CVS (AOCVS) and our newly derived agile software development methodology, extreme aspect-oriented component engineering (extreme AOCE). Unlike the general CVS which is used for a vast variety of projects, AOCVS was designed and developed specifically for extreme AOCE. Our CVS tool merges the changes in a synchronous/real time fashion; this in turn removes the hassle for the developers on having to resolve merging conflicts. We also describe how our implemented AOCVS can be used to provide functionalities that can assist developers to produce and distribute reusable code and to communicate and manage aspect-oriented agile projects more efficiently and effectively. Our novel agile approach and tool allows software developers to use the rich cross-cutting systemic concerns, their behaviour and properties in aspect-oriented components to refactor, maintain, add functionalities and test complex software systems more easily, rapidly and accurately.

Implementing complex web service-based systems requires tools to effectively describe and co-ordinate the composition of web service components. We have developed a new domain-specific visual language called ViTABaL-WS and built a prototype design tool to support modelling complex interactions between web service components. ViTABaL-WS uses a "Tool Abstraction" metaphor for describing relationships between service definitions, and multiple-views of data-flow, control-flow and event propagation in a modelled process. The tool supports the generation of Business Process Execution Language (BPEL) definitions from a model, directly deploys a generated model to a workflow engine, and supports dynamic visualisation of a running BPEL process.

Differentiation tools enable team members to compare two or more text files, e.g. code or documentation, after change. Although a number of general-purpose differentiation tools exist for comparing text documents very few tools exist for comparing diagrams. We describe a new approach for realising visual differentiation in CASE tools via a set of plug-in components. We have added diagram version control, visual differentiation and merging support as component-based plug-ins to the Pounamu meta-CASE tool. The approach is generic across a wide variety of diagram types and has also been deployed with an Eclipse diagramming plug-in. We describe our approach's architecture, key design and implementation issues, illustrate feasibility of our approach via implementation of it as plug-in components and evaluate its effectiveness.

We describe SDL, an integrated suite of visual languages aimed at supporting the process of designing statistical surveys. SDL comprises four diagrammatic notations: survey diagrams, survey data diagrams, survey analysis diagrams and survey process diagrams. A proof of concept environment supporting SDL is also presented, together with a cognitive dimensions evaluation of that environment and a cognitive walkthrough evaluation with a target end user - a professional statistician. These demonstrate the utility of SDL and lead us to propose development of a more comprehensive environment supporting the entire statistical survey process.

We describe a new visual language for event handling specification and its incorporation into Pounamu, a meta-tool for building diverse visual design environments. Our visual language provides end users ways to express event handling mechanisms via visual specifications.

We have introduced zoomable user interfaces into Pounamu, a visual language meta-tool, providing enhanced view navigation and management features. The zoomable user interfaces provide the user with support for flexible and dynamic design overviews and view element focus, and help address problems of lack of screen space and display capability in complex views

We describe a meta tool for specification and generation of multiple view visual tools. The tool permits rapid specification of visual notational elements, the tool information model, visual editors, the relationship between notational and model elements, and behaviour. Tools are generated on the fly and can be used for modelling immediately. Changes to the meta tool specification are immediately reflected in tool instances.

A good software architecture design is crucial in successfully realising an object-oriented analysis (OOA) specification with an object-oriented design (OOD) model that meets the specification's functional and non-functional requirements. Most CASE tools and software architecture design notations do not adequately support software architecture modelling and analysis, integration with OOA and OOD methods and tools, and high-level, dynamic architectural visualisations of running systems. We describe SoftArch, an environment that provides flexible software architecture modelling using a concept of successive refinement and an extensible architecture meta-model. SoftArch provides extensible analysis tools enabling developers to analyse their architecture model properties. Run-time visualisation of systems uses dynamic annotation and animation of high-level architectural modelling views. SoftArch is integrated with a component-based CASE tool and run-time monitoring tool, and has facilities for 3rd party tool integration through a common exchange format. This paper discusses the motivation for SoftArch, its modelling, analysis and dynamic visualisation capabilities, and its integration with various analysis, design and implementation tools.

Software components are becoming increasingly popular design and implementation technologies that can be plugged and played to provide user-enhanceable software. However, developing software components with user interfaces that can be adapted to diverse reuse situations is challenging. Examples of such adaptations include extending, composing and reconfiguring multiple component user interfaces, and adapting component user interfaces to particular user preferences, roles and subtasks. We describe our recent work in facilitating such adaptation via the concept of user interface aspects, which support effective component user interface design and realisation using an extended, component-based software architecture.

Abstract Many software applications require co‐operative work support, including collaborative editing, group awareness, versioning, messaging and automated notification and co‐ordination agents. Most approaches hard‐code such facilities into applications, with fixed functionality and limited ability to reuse groupware implementations. We describe our recent work in seamlessly adding such capabilities to component‐based applications via a set of collaborative work‐supporting plug‐in software components. We describe a variety of applications of this technique, along with descriptions of the novel architecture, user interface adaptation and implementation techniques for the collaborative work‐supporting components that we have developed. We report on our experiences to date with this method of supporting collaborative work enhancement of component‐based systems, and discuss the advantages of our approach over conventional techniques. Copyright © 2002 John Wiley & Sons, Ltd.

Electronic data interchange (EDI) systems are used in many domains to support inter-organisational information exchange. To get systems using different EDI message formats to communicate, complex message translations (where data must be transformed from one EDI message format into another), are required. We describe a visual language and support environment which greatly simplify the task of the systems integrator by using a domain-specific visual language to express data formats and format translations. Complex message translations are automated by an underlying transformation engine. We describe the motivation for this system, its key visual language and transformation engine features, a prototype environment, and experience translating it into a commercial product.

Developers need tool support to help manage the wide range of inconsistencies that occur during software development. Such tools need to provide developers with ways to define, detect, record, present, interact with, monitor and resolve complex inconsistencies between different views of software artifacts, different developers and different phases of software development. This paper describes our experience with building complex multiple-view software development tools that support diverse inconsistency management facilities. We describe software architectures that we have developed and user interface techniques that are used in our multiple-view development tools, and we discuss the effectiveness of our approaches compared to other architectural and HCI techniques.

A new software architecture for supporting inter-object consistency management is described. Objects with interdependent data values are kept consistent by propagating descriptions of object state changes along inter-object relationships. Response to and storage of these change descriptions supports the implementation of consistency management techniques in a more homogeneous way than existing models. Such techniques include efficient attribute recalculation and constraint schemes, multiple view consistency, and undo-redo, versioning and cooperative work facilities. Applications of the new architecture to user interface, graphical editor and programming environment construction are described.

Formal program development has gained widespread academic interest as a rigorous software engineering technique. One of the main hurdles for the wider IT industry in adopting these formal techniques is a lack of tools to support their use in combination with more traditional development techniques. This paper describes an integrated environment for object-oriented software development which incorporates formal Object-Z specifications for classes. These formal specification views are kept consistent with more traditional design and implementation views, allowing software developers to design, refine, implement and document their software utilising integrated formal techniques.