Sketching facilitates design in the exploration of ideas about concrete objects and abstractions. In fact, throughout the software engineering process when grappling with new ideas, people reach for a pen and start sketching. While pen and paper work well, digital media can provide additional features to benefit the sketcher. Digital support will only be successful, however, if it does not detract from the core sketching experience. Based on research that defines characteristics of sketches and sketching, this paper offers three preliminary tool examples. Each example is intended to enable sketching while maintaining its characteristic experience.

Tables are an important tool used by business analysts engaged in early requirements activities (in fact it is safe to say that tables appeal to many other types of user, in a variety of activities and domains). Business analysts typically use the tables provided by office tools. These tables offer great flexibility, but no underlying model, and hence no consistency management, multiple views or other advantages familiar to the users of modeling tools. Modeling tools, however, are usually too rigid for business analysts. In this paper we present a flexible modeling approach to tables, which combines the advantages of both office and modeling tools. Freeform information can co-exist with information managed by an underlying model, and an incremental formalization approach allows each item of information to transition fluidly between freeform and managed. As the model evolves, it is used to guide the user in the process of formalizing any remaining freeform information. The model therefore helps users without restricting them. Early feedback is described, and the approach is analyzed briefly in terms of cognitive dimensions.

Modeling tools are often not used for tasks during the software lifecycle for which they should be more helpful; instead free-from approaches, such as office tools and white boards, are frequently used. Prior workshops explored why this is the case and what might be done about it. The goal of this workshop is to continue those discussions and also to form an initial set of challenge problems and research challenges that researchers and developers of flexible modeling tools should address.

When developers join a software development project, they find themselves in a project landscape, and they must become familiar with the various landscape features. To better understand the nature of project landscapes and the integration process, with a view to improving the experience of both newcomers and the people responsible for orienting them, we performed a grounded theory study with 18 newcomers across 18 projects. We identified the main features that characterize a project landscape, together with key orientation aids and obstacles, and we theorize that there are three primary factors that impact the integration experience of newcomers: early experimentation, internalizing structures and cultures, and progress validation.

Modeling tools are often not used for tasks during the software lifecycle for which they should be helpful; more free-from approaches, such as office tools and white boards, are frequently used instead. Why is this? What might be done to make modeling tools more suitable? What key research challenges must be overcome to achieve this? The goal of this workshop is to bring together people who understand the activities and needs of developers and other stakeholders throughout the software lifecycle, user interface design and tool infrastructure to explore these questions.

A serious tool gap exists at the start of the software lifecy-cle, before requirements formulation. Pre-requirements analysts gather information, organize it to gain insight, en-vision possible futures, and present insights and recom-mendations to stakeholders. They typically use office tools, which give great freedom, but no help with consistency management, change propagation, or information migration to downstream tools. Despite these downsides, office tools are still favored over modeling tools, which are constrain-ing and difficult to use. We introduce the notion of flexible modeling tools, which blend the advantages of office and modeling tools. We propose a conceptual architecture for such tools, and outline research challenges to be met in realizing them. We briefly describe the Business Insight Toolkit, a prototype tool embodying this architecture.

Diagrams play a key role in the information systems domain. However to be meaningful, the diagrams are understood by interpreting visual cues in specific, conventionalized ways, termed conceptual models. One of the major pain points of conceptual models, specified as visual languages, is the inability to capture these visual languages effectively in conventional modeling tools. Instead, conceptual models are drawn using drawing tools and sometimes even by hand. We propose an automatic procedure to derive the syntactic building blocks of graph-based conceptual models. This high-level specification of the visual language can then serve as input for the automatic construction of syntax-aware diagram editors. Our aim is to achieve minimum effort on the part of the users when they eventually work with the graphical editor to produce a new diagram using the proposed syntax.

Using and extending a framework is a challenging task whose difficulty is exacerbated by the poor documentation that generally comes with the framework. Even in the presence of documentation, developers often desire implementation examples for concrete guidance. We propose an approach that automatically locates implementation examples from a code base given lightweight documentation of a framework. Based on our experience with concern-oriented documentation, we devised an approach that uses the framework documentation as a template and that finds instances of this template in a code base. The concern instances represent self-contained and structured implementation examples: the relationships and the roles of parts composing the examples are uncovered and explained. We implemented our approach in a tool and conducted a study comparing the results of our tool with results provided by Eclipse committers, showing that our approach can locate examples with high precision.

No abstract available

This note presents an overview of this ICSE 2002 tutorial.

Hyper/J supports a new approach to constructing, integrating and evolving software, called multi-dimensional separation of concerns. Developers can decompose and organize code and other artifacts according to multiple arbitrary criteria (concerns) simultaneously - even after the software has been implemented - and synthesize or integrate the pieces into larger-scale components and systems. Hyper/J facilitates several common development and evolution activities non-invasively, including: adaptation and customization, mix-and-match of features, reconciliation and integration of multiple domain models, reuse, product line management, extraction or replacement of existing parts of software, and on-demand remodularization. Hyper/J works with standard Java software, not requiring special compilers or environments. This demonstration shows it in action in a number of software engineering scenarios at different stages of the software life-cycle.

Hyper/J™ supports flexible, multi-dimensional separation of concerns for Java™ software. This demonstration shows how to use Hyper/J in some important development and evolution seenarios, emphasizing the software engineering benefits it provides.

Separation of concerns has been central to software engineering for decades, yet its many advantages are still not fully realized. A key reason is that traditional modularization mechanisms do not allow simultaneous decomposition according to multiple kinds of (overlapping and interacting) concerns. This workshop was intended to bring together researchers working on more advanced modularization mechanisms, and practitioners who have experienced the need for them, as a step towards a common understanding of the issues, problems and research challenges.

No abstract available.

Done well, separation of concerns can provide many software engineering benefits, including reduced complexity, improved reusability, and simpler evolution.The choice of boundaries for separate concerns depends on both requirements on the system and on the kind(s) of decompositionand composition a given formalism supports.The predominant methodologies and formalisms available, however, support only orthogonal separations of concerns, along sdngle dimensions of composition and decomposition.These characteristics lead to a number of well-known and difficult problems.This paper describes a new paradigm for modeling and implementing software artifacts, one that permits separation of overlapping concerns along multiple dimensions of composition and decomposition.This approach addresses numerous problems throughout the software lifecycle in achieving wellengineered, evolvable, flexible software artifacts and traceability across artifacts.

article Free Access Share on Subject-oriented design: towards improved alignment of requirements, design, and code Authors: Siobhán Clarke School of Computer Applications, Dublin City University, Dublin 9, Republic of Ireland School of Computer Applications, Dublin City University, Dublin 9, Republic of IrelandView Profile , William Harrison IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NY IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NYView Profile , Harold Ossher IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NY IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NYView Profile , Peri Tarr IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NY IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NYView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 34Issue 10Oct. 1999 pp 325–339https://doi.org/10.1145/320385.320420Online:01 October 1999Publication History 94citation1,710DownloadsMetricsTotal Citations94Total Downloads1,710Last 12 Months24Last 6 weeks3 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 SiteeReaderPDF

Subject-oriented programming supports composition of object-oriented programs or program fragments called subjects. This paper presents an approach to the composition rules used to specify composition details. Rules can be generic, allowing different subrules to be "plugged into" higher-level rules, and they include a means of specifying exceptions to general rules. We give definitions of a number of useful, generic rules, including merge and override, as a first step towards a generally-useful composition rule library. We also outline an object-oriented framework for implementing rules, which we are currently building as part of our support for subject-oriented programming in C++.

Object-Oriented technology is often described in terms of an interwoven troika of themes: encapsulation, polymorphism, and inheritance.But these themes are firmly tied with the concept of identity.If object-oriented technology is to be successfully scaled from the development of independent applications to development of integrated suites of applica-tions, it must relax its emphasis on the objecf.The technology must recognize more directly that a multiplicity of subjective views delocalizes the concept of object, and must emphasize more the binding concept of identity to tie them together.This paper explores this shift to a style of objectoriented technology that emphasizes the subjective views: Subject-Oriented Programming.

Making extensionsto existing systems is a critically important activity in object-oriented pro-existing application.We are in full agreement with Lieberman [7] that one wants a small extension to behavior to require just a small extension to code, and that adding new code is good, whereas modifying existing code is bad.We call this approach "extension-by-addition" [16].gramming.This paper proposes an approach in which extensions of all kinds are clearly separated from the base hierarchy upon which they are built, for ease of distribution and combination.Extensions, including extensions to existing classes, are written in separate, sparse extension hierarchies.The entire system is obtained by combining the extension hierarchies with the base hierarchy.Sequences of successive extensions can be combined using an extension operator, and parallel extensions can be combined using a merge operator, which might identify conflicts that must be reconciled.System building takes place at two levels: combining existing extensions from a library using these operators, and building new extensions when existing ones are not adequate.New extensions built in this way are added to the library, and so should be written to be as general and reusable as possible.

No abstract available.

Development of any large system or artifact requires the coordination of many developers. Development activities can occur concurrently. The goal of coordination is to enhance, not restrict, developer productivity, while ensuring that concurrent development activities do not clash with one another.

A mechanism, called views, that allows programmers to specify multiple interfaces for objects and to control explicitly access to each interface is described. This mechanism provides a simple and flexible means of specifying enforceable access restrictions at many levels of granularity. It also results in system organization that supports browsing based on a number of different criteria. Views is defined, some examples of its uses are given, the impact of views on system organization is discussed, and five approaches to implementing views are outlined.>

The author describes a case study in which the grid mechanism was used to describe the structure of Scribe, a document-processing system in widespread use. The structure description is presented and explained in some detail, and the effectiveness of the grid for specifying the important structural features of Scribe is discussed. It is shown that the grid succeeds in its objective of presenting complex structures clearly. A grid specification forms a suitable basis for a narrative explanation of system structure. It is further noted that some detailed improvements would further enhance the expressiveness of the grid, and that environment support is essential for serious use of the grid.>

Article Grids: A new program structuring mechanism based on layered graphs Share on Author: Harold L. Ossher Computer Science Department, Stanford University, Stanford, CA Computer Science Department, Stanford University, Stanford, CAView Profile Authors Info & Claims POPL '84: Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languagesJanuary 1984 Pages 11–22https://doi.org/10.1145/800017.800512Online:15 January 1984Publication History 16citation269DownloadsMetricsTotal Citations16Total Downloads269Last 12 Months5Last 6 weeks0 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 SiteGet Access