In this paper, we present INDIGO, an interest-driven data dissemination framework that enables to predict the performance of data dissemination. INDIGO computes a tight upper bound of data dissemination time under (i) heterogeneous mobility patterns of people and, (ii) interests-driven dissemination strategy. INDIGO automatically learns the interests of people from their browsing history and also captures their heterogeneous mobility patterns.

One of the challenges in teaching a first programming course is that in the same course, the students must learn basic programming techniques and high level abstraction abilities, and the application of those techniques and concepts in problem solving and (engineering) design. To confront this challenge, in previous years, we have included a project-based learning phase at the end of our course to encourage the acquisition of high level design and creativity. To address some of the shortcomings of our previous editions, we have recently included a mastery phase to the course. While project-based learning is suitable for teaching high-level skills that require design and creativity and prepare the students for the study of software engineering, mastery-based learning is suitable for concrete skills such as basic programming tasks. Our particular innovation is to allow students into the project phase only if they have demonstrated a minimum predefined competency level in programming. The combination of the two approaches seems to address most of the requirements of a first programming course. We present our motivation for combining the two pedagogical techniques and our experience with the course.

Educational game design environments have long been employed as an engaging medium for teaching computer programming and software engineering concepts such as objects, agents, instances, behavior, and interaction. However, in contrast to the collaborative nature of programming, in particular among novice programmers, existing game design environments are solitary desktop-based applications with no or very limited support for sharing and collaboration. We have taken advantage of Web 2.0 technologies and its participative culture to develop a collaborative platform around game design activities that encourages social learning and integrates into the students' online social presence and lifestyle. We have employed open-Web technologies to build a game design environment using only HTML5 and JavaScript that lets users practice the game design and programming activities right inside their browser. Game design and game playing run on the client while an associated website hosts the created games and supports collaboration. This paper reports on the design, implementation, and evaluation of the game design environment. The preliminary evaluation of Agent Web's usability and performance demonstrates that not only does Agent Web meet its design goals, but also that the current Web is a hospitable environment for end-user game programming both on desktop and mobile devices.

Game design environments are traditionally used as means for engaging non-programmers in the learning process. However, these environments lack specific support for teaching computational thinking to novices. Typically, such skills are acquired in ad hoc practical sessions with supervision provided by teachers or peers. The usual scenario is where a teacher guides the students in solving these problems during a game design session. In informal learning settings, step-by-step tutorials for creating existing games are used to compensate for the lack of computer support for solving design and computational problems. In this paper we suggest a game design process that combines support for computational thinking with tool usage, by identifying the most common computational thinking problems and providing a generic solution to them. We have evaluated our solution in the context of AgentWeb, an online cloud-based game design environment for novices. We discuss how to incorporate suggested computational thinking solutions as computer assistant into the game design user interface.

We have designed a novel computer science curriculum at the University of Lugano in Switzerland. The curriculum is based largely on software engineering principles. We have been teaching the curriculum since 2004. Following the European standards, the curriculum consists of a 3-year bachelor program and a 2-year master's program. With 6 years of experience, we are in a position to draw some conclusions about the curriculum and offer lessons to others who are interested in designing or evolving a software engineering-based curriculum. The principles apply whether one wants to design a bachelor's curriculum or a master's curriculum. They apply to both US and European systems.

Dynamically adaptive systems propose adaptation by means of variants that are specified in the system model at design time and allow for a fixed set of different runtime configurations. However, in a dynamic environment, unanticipated changes may result in the inability of the system to meet its quality requirements. To allow the system to react to these changes we propose a solution for automatically evolving the system model by integrating new variants and periodically validating existing ones based on updated quality parameters. To illustrate our approach we present a BPEL based framework using a service composition model to represent the system functional requirements. Our framework estimates Quality of Service (QoS) values based on information provided by our monitoring mechanism, ensuring that changes in QoS are reflected in the system model. We show how the evolved model can be used at runtime to increase the system's autonomic capabilities and delivered QoS.

Semantic Web technologies have been applied to many aspects of learning content authoring including annotation, dynamic assembly, and personalization of learning content as well as authors' collaborative activities. Whether Semantic Web technologies improved the authoring process and to what extend they make authors' life easier, however, remains an open question that we try to address in this paper. We report on the results of an empirical study based on the experiments that we conducted with the prototype of a novel document architecture called SDArch. Semantic Web technologies and social networking are two pillars of SDArch, thus potential benefits of SDArch naturally extend to them. Results of the study show that the utilization of SDArch in authoring improves user' performances compared to the authoring with conventional tools. In addition, the users' satisfaction collected from their subjective feedback was also highly positive.

As software engineering advances, new software engineering programs continue to emerge in universities around the world and existing ones are continually being updated. These programs face myriad challenges such as incorporating new software engineering technologies, recruiting and retaining qualified faculty, attracting students, leveraging new technologies for remote teaching, integrating related disciplines such as systems engineering, and, of course, deciding what basic content to include in their courses. The recently published Graduate Software Engineeing 2009 (http://www.gswe2009.org) presents a model and guidelines to help faculty address those challenges. Both ACM and IEEE approved and endorsed GSwE2009 in 2009.The panel will debate approaches to developing master's programs in software engineering in general and GSwE2009 in particular. It will consider experiences, challenges, and criticisms of GSwE2009.

Teaching wireless sensor networks (WSNs) at the undergraduate level is both challenging and rewarding. WSNs include low-level programming and debugging, power-aware operations, novel communication paradigms and interdisciplinary applications in real world environments. These characteristics enable the students to learn how to cope with complete systems, starting with hardware design and low-level programming throughout applications and data processing. They learn to recognize complex software-hardware cross-dependencies and to manage them successfully.In this paper we share our experience from a new course on Introduction to Wireless Sensor Networks at the undergraduate level. The most important characteristic of the course is its hands-on approach. We believe this is crucial for fully understanding the complex nature of WSNs and their interdependencies with the environment in which they operate. The students were able to build a solid set of skills and expertise in WSNs by designing and implementing their own small-size real-world WSN deployment.

The rapid development of wireless sensor networks (WSNs) and the increasing complexity of the deployed applications force researchers to turn to testbeds to test their communication and application related algorithms and protocols. On the other side, industries' demand for young professionals with WSN expertise is growing too. These two factors motivated us to develop a highly modular and extensible testbed, called Atelier, as part of our bachelor level course on WSNs. In this paper we share our testbed design and describe its main requirements and challenges.

In this paper, we propose the use of semantic documents as learning objects. The core part of our solution is a semantic document model that allows for unique identification of document content units (CUs) and their annotation with different types of metadata. On the top this model, we have developed the semantic document management system (SDMS), which enables efficient collaborative authoring of learning objects within a social network of content authors, by reusing document CUs based on the accumulated metadata.

In this paper, we present an extension to MS Office that enables users to search and retrieve document content units (e.g., paragraphs, images, tables, slides, etc.) from documents, which are stored on user’s indi-vidual desktops organized in a peer-to-peer fashion. We first introduce the Semantic Document Model (SDM) that turns MS Office documents (i.e., MS Word and MS PowerPoint) into Semantic Web resources, making document content to be accessible and query-able as RDF data. Then we describe the developed tools, which extend Office applications with support for ontology-based, distributed search of semantic documents stored in local RDF repositories over Se-mantic Web protocols.

Provides notice of upcoming conference events of interest to practitioners and researchers.

In this paper, we propose the use of Semantic Web technologies to bridge the gap between authoring systems and authors. The core part of our solution is the ontology-based framework that captures the information about the interaction between learning objects (LOs) and four main roles in the educational process (content author, instructional designer, teacher, and learner), and then according to this information proposes the most relevant learning content to the author. The central part of the framework is the Request- Recommendation ontology that formalizes the author's request along with a set of learning content proposals (recommendation), as a response to that request. Furthermore, we propose the use of a weighting scheme to calculate the weight of the content proposals and thus enable their ranking within the recommendation.

The paper presents Abstract Compound Content Model (ACCM), a generic content model which we have devel-oped aiming to facilitate interoperability, repurposing and integration of diverse platform specific content models. Based on this model we have developed the ACCM ontology in order to turn the ACCM's elements (i.e., content units and content aggregations) into resources that can be directly accessed and thus reused. The paper also presents our current work on the implementation of an ACCM-based content management system that enables efficient storage, indexing, search and retrieval of content units as they are defined in the ACCM ontology.

The goal of the State-of-the-Art sessions of ESEC/FSE 2007 is to present an in-depth introduction to, and survey of, some topics that we believe will play a significant role in the future developments of software engineering. The presentations are designed for an audience of researchers in software engineering who may have some basic knowledge about the topic and would enjoy hearing a broad perspective on the state-of-the-art in the topic in greater technical depth.

The attendees of ICSE comprise some of the top researchers in software engineering and also many educators of software engineering. Traditionally, however, these two groups do not talk to each other about educational issues. Then there are the practitioners who attend ICSE who have their own opinions about the relevance, strengths, and shortcomings of current software engineering education offered in universities. The goal of this year's track on Software Engineering Education and Training at ICSE is to bring these three communities together to discuss some urgent questions that have profound effect on how we structure our educational programs. Considering the tremendous changes taking place in the software engineering industry, and in the industrial world in general, it seems appropriate to confront the needs of the software engineering educators.Consider just the following increasingly common developments:Outsourcing of software projectsPervasiveness of software in all areas of commerce, industry, and societyIncreasingly distributed platformsOpen-source developmentGlobalization, leading to international (multi-cultural) distributed software teamsHow should these developments change the way we teach software engineering? Should textbooks be updated? Should software engineering play a different role in the computer science curriculum, that is, be more pervasive? How are professors in universities handling these issues?These are some of the questions we address in this track. In particular, we consider current challenges, current solutions, and future challenges. We are pleased to have six distinguished researchers to present their views and fifteen presenters from universities around the world presenting their innovative approaches in their classrooms. We expect lively and active discussion between the speakers and the audience.

The success of the Semantic Web crucially depends on the existence of Web pages that provide machine-understandable meta-data. This meta-data is typically added in the semantic annotation process which is currently not part of the Web engineering process. Web engineering, however, proposes methodologies to design, implement and maintain Web applications but lack the generation of meta-data. In this paper we introduce a technique to extend existing Web engineering methodologies to develop semantically annotated Web pages. The novelty of this approach is the definition of a mapping from XML Schema to ontologies, called WEESA, that can be used to automatically generate RDF meta-data from XML content documents. We further show how we integrated the WEESA mapping into an Apache Cocoon transformer to easily extend XML based Web applications to semantically annotated Web application.

We have investigated an approach for abstracting and visualizing software module views from source code: ArchView computes abstraction metrics that are used to filter and provide architectural elements and relationships of major interest. Source code views can, therefore, be reduced in detail and size resulting in more reasonable and comprehensible module views on software architectures. ArchView focuses on modules and their relationships: source level relationships such as inheritance, call structures, or includes are abstracted to a module level to show basic dependency relationships of modules.

The Vienna Component Framework (VCF) supports the interoperability and composability of components across different component models, a facility that is lacking in existing component models. The VCF presents a unified component model-implemented by a facade component to the application programmer The programmer may write new components by composing components from different component models, accessed through the VCF The model supports common component features, namely, methods, properties, and events. To support a component model within the VCF a plugin component is needed that provides access to the component model. The paper presents the VCF's design, implementation issues, and evaluation. Performance measurements of VCF implementations of COM, Enterprise JavaBeans, CORBA distributed objects, and JavaBeans show that the overhead of accessing components through the VCF is negligible for distributed components.

We propose a novel framework logic of event consumption and publication (LECAP) for the development of event-based applications. Our approach offers the following advantages over existing approaches: 1) it supports a while-parallel language, 2) the reasoning allows a dynamic (instead of static) binding of programs to events, 3) it is oriented towards stepwise development of systems, and 4) the underlying logic supports the composition of specifications. The event based architectural style has been recognized as fostering the development of large-scale and complex systems by loosely coupling their components. It is therefore increasingly deployed in various environments such as middleware for mobile computing, message oriented middleware, integration frameworks, communication standards, and commercial toolkits. Current approaches to the development of event-based applications are ad hoc and do not support reasoning about their correctness. The LECAP approach is intended to solve this problem through a compositional and stepwise approach to specification and verification of event-based applications.

As the complexity of applications and therefore of their testing process grows, the importance of automating the testing activity increases. The testing process includes test case generation, test sequencing, oracle construction, test execution and result interpretation. Automatic generation of test cases from formal specifications has received considerable attention. Relatively little work has been reported, however, on constructing oracles for supporting efficient and automatic execution of such test cases. We present a technique for constructing a CORBA-supported VDM oracle for black-box testing starting from a VDM-SL specification. This specification is used to automatically verify the results of operations implemented in a high-level programming language. We present a case study of the technique applied to a Java application for generic access control. The technique is applicable to any CORBA-compliant programming language.

We propose a new P2P network topology that reduces bandwidth consumption and provides complete searches by employing a tree hierarchy of indexing nodes that facilitates the search functionality. Each node consists of a cluster of peers to provide fault tolerance and scalability.

We present an approach to requirements validation in which the formal specification of the requirements is directly, interpreted and the results are visually, presented to the customer through a graphical user interface, relying on the customer to visually, validate the specified requirements. The communication between the user interface and the specification interpreter is accomplished through CORBA. The approach supports the cooperation of customers and developers in eliciting and validating the requirements. We present a case study of the application of the technique to the validation of a generic access control component. The use of CORBA has the advantage that any, CORBA-compliant language can be used for the user interface, independently of the implementation of the specification interpreter The contributions of the paper are 1) the presentation of a case stud), of the visual requirement validation technique, 2) the revision and improvement of a previously presented visual validation technique, and 3) the application of requirements validation to a reusable component.

The World Wide Web Consortium's eXtensible Markup Language (XML) and the eXtensible Stylesheet Language (XSL) are standards defined in the interest of multipurpose publishing and content reuse. XML and XSL have been gaining popularity rapidly both in industry and in academia. Although much has been written on XML/XSL-based solutions, there exists a gap between theory and practice. In this paper we report our experiences in deploying XML/XSL in the implementation of two industry Web sites and summarize nine lessons we drew from our experiences.

The data regarding the components of a software system consists of a large amount of information such as version history, number of lines, defect density, and complexity measures. The ability to quickly grasp a comprehensive view of the evolution and dependencies of such information is the key to making informed decisions about future developments of the system. Managers usually make such decision based only on expert judgement. For help in making such decisions, we can turn to the evolution history of large software systems, which contain a wealth of hidden information. Traditionally, this information is passed on through anecdotes without any supporting analytical data. This paper reports on our attempts to make such information more concrete through information visualization techniques. We present a three-dimensional visual representation for examining a system's software release history. The structure of the system is displayed by 2D or 3D graphs. The historical information is displayed by using time as the third dimension. Colors are used for displaying module properties and their historical changes in the system. A supporting software tool enables not only visualization but also navigation in the 3D space to change the viewpoint, to browse system information, to find interesting patterns and to discover previously unknown relationships among system components.

Code-based metrics such as coupling and cohesion are used to measure a system's structural complexity. But dealing with large systems-those consisting of several millions of lines-at the code level faces many problems. An alternative approach is to concentrate on the system's building blocks such as programs or modules as the unit of examination. We present an approach that uses information in a release history of a system to uncover logical dependencies and change patterns among modules. We have developed the approach by working with 20 releases of a large Telecommunications Switching System. We use release information such as version numbers of programs, modules, and subsystems together with change reports to discover common change behavior (i.e. change patterns) of modules. Our approach identifies logical coupling among modules in such a way that potential structural shortcomings can be identified and further examined, pointing to restructuring or reengineering opportunities.

Component programming is a multiparadigm approach to software construction based on highly generic components. Because component programming is concerned with source-code components, it is assumed by many to be a low-level approach to software development that affects only the development of source code libraries. On the contrary, this paper shows that the concepts of component programming go beyond library and source code issues and define a new conceptual attempt to software development with generic components. We show that component programming is an architectural style that supports the building of classes of software architectures in a specific domain. Component programming can be applied in the early stages of software development when architectural issues are to be determined. All the benefits of using an architectural style, therefore, can also be gained by using component programming: it guides the engineer in the problem decomposition towards the design and implementation of a system. The paper presents the architectural style of component programming and the insights we gained about component programming as we tried to define it as an architectural style.

The idea of building software from existing components is as old as the field of software engineering itself yet there are no accepted solutions. This problem is the key technical challenge in software engineering and deserves a concerted attack. While there are some hopeful signs on the horizon that show that the problem is being addressed, the problem remain difficult. I address some of the difficulties that we face.

Large software systems evolve slowly but constantly. In this paper, we examine the structure of several releases of a telecommunication switching system (TSS) based on information stored in a database of product releases. We tracked the historical evolution of the TSS structure and related the adaptations made (e.g. addition of new features, etc.) to the structure of the system. Such a systematic examination can uncover potential shortcomings in the structure of the system and identify modules or subsystems that should be subject to restructuring or reengineering. Further, we have identified additional information that would be useful for such investigations but is currently lacking in the database

While technology improvements in VLSI favor the building of massively parallel computers, the key obstacle to the widespread adoption of such computers is the lack of a methodology for developing software that achieves both portability and high performance. This paper presents a virtual machine intended to serve as the cornerstone of such a methodology. The PM virtual machine can be mapped efficiently to different physical machines and enables the development of software tools and applications that can be ported across different parallel machines.

A methodology is presented which is aimed at the development of efficient and portable software for general-purpose highly-parallel computers. The methodology has two major components: a programming language that allows the programmer to express the parallelism of an application at a high level and an abstract model of parallel computers that allows programs written for it to be mapped efficiently to different multiple instruction-multiple data (MIMD) parallel computers.>

The recogmtion problem for alternating Turmg machines is reduced to the circularity problem for attnbute grammars, and thus an inherently exponential lower bound for the complexity of the circularity problem is derived Although the result is already known, the use of alternation allows a simpler construction

A space-efficient strategy for storing attributes during evaluation of an attribute grammar is presented.Attributes are classified as either one-pass or multipass.One-pass attributes are stored on a pushdown stack, and their storage is freed when no longer needed.Examination of extant grammars shows that a vast majority of attributes are indeed one-pass, and therefore the scheme presented can greatly reduce the storage requirements of an attribute grammar evaluator.Several approaches to storage management for multipass attributes are also presented.Data for several grammars are collected and used to show the effectiveness of the proposed storage management scheme.

It is shown that both the upper and the lower bounds on the time complexity of the circularity test for Knuth's attribute grammars are exponential functions of the size of the grammar description. This result implies the "intractability" of the circularity test in the sense that the implementation of a general algorithm is not feasible. Another significance of this result is that this is one of the first problems actually arising in practice which has been proven to be of exponential time complexity.