Skip to content. Skip to navigation
McGill Home SOCS Home
Personal tools
You are here: Home → Announcements and Events → Seminars → Seminar History

Seminar Home
Fall 2012 Schedule
Winter 2013 Schedule
Summer 2013 Schedule
Archives

Date
( Summer 2007 )		 Category Seminar Info
2006/08/24 Software Engineering Place: MC103
Time: 10:30 - 11:30
Speaker: Tom Zimmermann
Affiliation: Saarland University, Germany
Title: Mining Usage Pattern from Version Archives
Abstract: When developers change code they insert new method calls.  Typically, method calls that are inserted together, are related to each other.  In this talk, I will present the DynaMine tool that obtains this co-addition relationship from version archives in order to identify usage patterns.  Such patterns describe how methods should be called, for instance a call to addWidget() should be followed by removeWidget().  Besides simple pairs, DynaMine also discovers state machines.  Potential patterns are then validated dynamically and violations are reported to the user.  DynaMine has been evaluated with the history of open-source projects and scales up to industrial-sized projects like Eclipse. Biography of Speaker:

Tom Zimmermann received his diploma degree in computer science from the University of Passau in 2004.  He is currently a PhD student at the Saarland University in Saarbrücken, Germany, supported by a scholarship from the DFG research training group on Quality Guarantees for Computer Systems.  Tom built the eROSE tool, which helps developers navigating through source code.  eROSE leverages the change history of projects and learns recommendations such as "Programmers who changed function f() also changed function g()".  Besides supporting developers, Tom's research interests are in software evolution, program analysis, and data mining.

2006/08/17 Software Engineering Place: MC103
Time: 10:30 - 11:30
Speaker: Isaac Yuen
Affiliation: Software Evolution Research Group
Title: Assembling the scattered code: An overview of aspect-oriented refactoring techniques and challenges
Abstract: Aspect-oriented programming (AOP) enables a modular implementation of crosscutting concerns in a system. Aspect-oriented refactoring is the mechanism that transforms an existing object-oriented system into its AOP equivalent. Nevertheless, there are two questions a developer must answer when he decides to use AO refactorings: what constitute the refactorable crosscutting concerns in the system, and what techniques are required to extract them into aspects. In this presentation, I will describe the applicability of AO refactoring using a case study (jEdit), and introduce some common AO refactoring tech- niques. I will also describe two different approaches that automate the refactoring process and their shortcomings. I will conclude the presentation by describing the current research in this area, and the development of refactoring assessment tool. Biography of Speaker:
2006/06/29 Software Engineering Place: MC103
Time: 10:30 - 11:30
Speaker: Greg Steffan
Affiliation: University of Toronto
Area: Compilers, Concurrency, Software Engineering
 Title: Speculative Multithreading and Probabilistic Pointer Analysis
Abstract: The advent of chip multiprocessors (CMPs) has motivated us to parallelize all of our software. Unfortunately, for general-purpose programs with complex control flow and pointers, parallelization can be extremely difficult for both the compiler and the programmer. One potential solution is Speculative Multithreading, which empowers the programmer or compiler to create parallel threads when they are *likely* to be independent, transforming parallelization from a correctness problem to a performance optimization problem. This promising model of parallel computation motivates new analsyes to assist the compiler and programmer in creating and optimizing speculative threads, including a new form of pointer analysis. Pointer analysis is a critical compiler analysis used to disambiguate the indirect memory references that result from the use of pointers and pointer-based data structures. A conventional pointer analysis deduces for every pair of pointers, at any program point, whether a points-to relation between them (i) definitely exists, (ii) definitely does not exist, or (iii) maybe exists. Most compiler optimizations rely on accurate pointer analysis, and to ensure correctness cannot optimize in the maybe case. In contrast, speculative optimizations (such as speculative multithreading) can aggressively exploit the maybe case, especially if the likelihood that two pointers alias could be quantified. I will present a Probabilistic Pointer Analysis (PPA) algorithm that statically predicts the probability of each points- to relation at every program point. Building on simple control-flow edge profiling, our analysis is both one-level context and flow sensitive---yet can still scale to large programs including the SPEC 2000 integer benchmark suite. We demonstrate that our analysis provides accurate probabilities, even without edge-profile information. Biography of Speaker:

J. Gregory Steffan is currently an Assistant Professor of Computer Engineering at the University of Toronto. He received his B.A.Sc. and M.A.Sc. in Computer Engineering from the University of Toronto in 1995 and 1997 respectively, and his Ph.D. in Computer Science from Carnegie Mellon University in 2003. He has also worked in the architecture groups of MIPS Technologies Inc. and Compaq Computer Corporation. His research interests include computer architecture and compilers, distributed and parallel systems, and reconfigurable computing.

2006/06/22 Software Engineering Place: McConnell 103
Time: 10:30 - 11:30
Speaker: Xun Zhu
Affiliation: McGill University
Area: Software Development Processes
 Title: Design of Concurrent Applications using COMET
Abstract: This talk presents the detailed design phase of COMET (Concurrent Object Modeling and architectural design mEThod), a development process for concurrent applications - in particular, distributed and real-time applications. With COMET, a distributed application is structured into distributed subsystems, where a subsystem is designed as a configurable component and corresponds to a logical node. Each subsystem component can contain a collection of tasks. A task type is an active class and a task is an active object. A task has its own thread of control. An important objective in task and class structuring design is separation of concerns. A task uses information hiding to address concurrency concerns, in particular details of timing, control, sequencing, and communication. To help determine the concurrent tasks, task structuring criteria are provided to assist in mapping an object-oriented analysis model of the system to a concurrent tasking architecture. The presentation will give a detailed description, with the aid of examples, of the criteria within each category, namely I/O task structuring criteria, internal task structuring criteria, task priority criteria, task clustering criteria, and task inversion criteria. Following this there is a detailed description of defining task communication and synchronization interfaces.
2006/06/08 Software Engineering Place: McConnell 103
Time: 10:30 - 11:30
Speaker: Jörg Kienzle
Affiliation: McGill University
Area: Reliable Requirements Elicitation
 Title: Exceptions and the Software Lifecycle: Starting with Requirements
Abstract: Complex computer systems are increasingly built for highly critical tasks, from military and aerospace domains to industrial and commercials areas. Failures of such systems may have severe consequences ranging from loss of business opportunities, physical damage, to loss of human lives. Systems with such responsibilities should be highly dependable. On the software developers part, this involves acknowledging that many exceptional situations may arise during the execution of an application, and providing measures to handle such situations. When using a standard software development process to develop systems, there is no guarantee that such situations are considered during the development.
The talk starts by introducing the concept of dependability, and then presents the need for integrating exceptions into software development processes. In such an exception-aware process, each development phase not only addresses standard application functionality, but focusses the attention of the developer specifically on exceptional situations and corresponding exceptional behavior that a reliable application should provide.
The remainder of the talk presents a first step towards the development of such an exception-aware process: an iterative, model-based requirements elicitation process that systematically guides the developer to consider reliability and safety concerns. After the discovery of normal system behavior by means of use cases, the developer is lead to explore exceptional situations arising in the environment that change user goals and system-related exceptional situations that threaten to fail user goals. The process requires the developer to specify means that detect such situations, and define the recovery measures that try to provide alternate or degraded service in so-called handler use cases. Handling an exception might also involve halting service in situations where safety is the main concern. The use cases, augmented with probability values, are mapped to DA-Charts, a probabilistic extension of statecharts, which makes it possible to calculate the achievable reliability and safety of the system interaction. The analysis may lead to further refinement of the use cases by introducing detection and recovery measures to increase dependability. Biography of Speaker:

Jörg Kienzle is assistant professor in computer science at McGill Universiy in Montreal, Canada, where he is leading the Software Engineering Laboratory. He holds a Ph.D. and engineering diploma from the Swiss Federal Institute of Technology in Lausanne (EPFL). His current research interests include fault tolerance, software development methods, distributed systems and aspect-orientation.
2006/05/25 Software Engineering Place: McConnell 103
Time: 10:30 - 11:30
Speaker: Ekwa Duala-Ekoko
Affiliation: McGill University
Area: Aspect-Orientation
 Title: On the Limitations of AspectJ and Potential Language Improvements
Abstract: Two recurring criticisms of aspect-orientated programming tools are their inflexibility (or deficiency) in language features and the potential performance overhead that maybe incurred from adopting this programming paradigm. In this talk, I substantiate the former criticism in the context of implementing a reusable framework for the ACID properties of transaction in AspectJ. I highlight the need for runtime disabling and re-enabling of pointcuts, stronger and intuitive aspect-to-class binding of reusable static crosscutting behaviours and support for per-object association of aspects. Finally, I discuss the deficiencies of prominent work-around solutions and propose potential language improvements where appropriate. Biography of Speaker:
2006/05/15 Software Engineering Place: MC320
Time: 10:00 - 11:00
Speaker: Andrew Eisenberg
Affiliation: University of British Columbia
Title: Using metadata annotations to control the display of source code
Abstract: Recently Java and C# have introduced annotations and programmers now have fairly good support for using annotations as a hook for open-ended extension of compile- and runtime semantics. There is a growing consensus that using annotations this way makes programs more expressive, by making them more declarative and/or more concise. At the same time, numerous pundits have argued that we are on the verge of 'annotation hell'. We argue that, when used with discretion, annotations are valuable and can make code more expressive. But in their raw form, annotations can be so awkward that they look bad even when their underlying meaning is simple. I will present a prototype tool that enables annotations to serve as an extension point for making programs more visually expressive. The tool works by allowing the annotation to control how the IDE presents and edits code. Examples that we have applied the tool to are JSR 181 webservices, JDBC 4.0, AspectJ, state charts, pre- and post-conditions, and getters and setters. Biography of Speaker:

Andrew Eisenberg is a PhD student at the University of British Columbia in Vancouver.  His current research interests are metaobject protocols and aspect-oriented programming and is supervised by Prof. Gregor Kiczales. After receiving his undergraduate degree from Rice University in 1998, Andrew worked at Morgan Stanley writing client-server applications for traders.  In 2004, he received a Masters degree from University of British Columbia in Computer Science for automating the task of feature location in large software systems.

2006/05/11 Software Engineering Place: MC103
Time: 10:30 - 11:30
Speaker: Martin Robillard
Affiliation: McGill University
Title: Software Evolution: A Historical Perspective
Abstract: I will present an overview of the seminal work on software evolution and place it in its historical context.
2006/05/05 Faculty Candidate Talk Place: SEMINAR CANCELLED
Time: 9:30 - 10:30
Speaker: Pin Zhou
Affiliation: Department of Computer Science, University of Illinois at Urbana-Champaign
Title: Improving Software Dependability with Hardware Support
Abstract: As software permeates our daily life and becomes increasingly complex, software dependability becomes critically important. The main obstacle to building dependable software is software bugs, which often account for 40% of computer system failures and over 50% of security vulnerabilities. Existing dynamic bug detection techniques suffer from high overhead and can greatly benefit from the recent impressive advances in computer architecture. In this talk, I will present my thesis work on using general, novel hardware support for detecting software bugs in production runs. First, I will introduce a simple and general hardware framework called Watcher that enables efficient memory monitoring and can be used to detect a wide variety of bugs with very low overhead, orders of magnitudes smaller than software-only approaches. Next, I will present an innovative bug detection technique called PC-based invariants and an efficient novel hardware implementation of this technique to detect general memory corruptions during production runs. Finally, I will briefly describe my recent work on using the iWatcher hardware support for efficient data structure consistency checks and my future research plan. Biography of Speaker:

Pin Zhou will complete her Ph.D degree soon in summer 2006 from the Department of Computer Science at the University of Illinois at Urbana-Champaign. She holds an M.S. from Tsinghua University, China. Her research interests are hardware and system support for improving software dependability, operating systems, memory management, and storage systems. The work presented in this talk appeared at ISCA, MICRO, IEEE Micro's Top Picks, and ACM TACO. She received the W.J. Poppelbaum Memorial Award in 2004, an honor given to one or two graduate students every year in computer architecture at University of Illinois. Two of her papers were selected in the IEEE Micro Special Issue: Micro's Top Picks from Computer Architecture conferences in 2004. Further information is available at http://opera.cs.uiuc.edu/~pinzhou.

2006/05/04 Software Engineering Place: McConnell 103
Time: 10:30 - 11:30
Speaker: Laurie Hendren
Affiliation: McGill University
Title: Context-senstive points-to analysis: is it worth it?
Abstract: We present the results of an empirical study evaluating the precision of subset-based points-to analysis with several variations of context sensitivity on Java benchmarks of significant size. We compare the use of call site strings as the context abstraction, object sensitivity, and the BDD-based context-sensitive algorithm proposed by Zhu and Calman, and by Whaley and Lam. Our study includes analyses that context-sensitively specialize only pointer variables, as well as ones that also specialize the heap abstraction. We measure both characteristics of the points-to sets themselves, as well as effects on the precision of client analyses. To guide development of efficient analysis implementations, we measure the number of contexts, the number of distinct contexts, and the number of distinct points-to sets that arise with each context sensitivity variation. To evaluate precision, we measure the size of the call graph in terms of methods and edges, the number of devirtualizable call sites, and the number of casts statically provable to be safe. The results of our study indicate that object-sensitive analysis implementations are likely to scale better and more predictably than the other approaches; that object-sensitive analyses are more precise than comparable variations of the other approaches; that specializing the heap abstraction improves precision more than extending the length of context strings; and that the profusion of cycles in Java call graphs severely reduces precision of analyses that forsake context sensitivity in cyclic regions.