Dr. Cem Kaner
Professor of Software Engineering, Florida Institute of Technology
online: website
Fundamental Issues in Software Metrics
What are we measuring when we collect and compute software metrics?
What gives us confidence in these measurements? What are the risks
of taking them or using them?
Measurement is very important for software projects. How else can we
tell whether we are likely to meet a schedule, ship an acceptable
product, overrun the budget? How else can we tell that this
programmer needs help and that programmer is far enough ahead to
provide it? What else could provide a basis for estimating the size
and difficulty of a project and plan the staffing, schedule and cost
accordingly?
Measurement is very important for software projects. And so, when I
say that many of the popular metrics in use today have little
theoretical basis, that software engineering is decades behind other
fields in its application of basic measurement theory, and that
measurement programs are probably so rare in industry because so
many have been abandoned after doing more harm than good—some
people respond the way they’d respond to someone who argues that
because doctors sometimes commit malpractice, you should never seek
medical services.
That’s not what this talk is about. I’m not slamming medicine. I’m
saying, “Don’t buy snake oil. Or if you do, don’t expect it to cure
what ails you.” I’m not slamming metrics. I’m saying, “Don’t use
unsound measures. Or if you do, use them with skepticism and great
care. And work on creating and validating some replacements.”
This tutorial throws down a challenge to students who are preparing to
apply software engineering on the job or research it in their
dissertations. You /will/ take and report measurements. You’ll have
to. The question is, will you know enough about the measures you use
to be credible and add value.
Bio:
Cem Kaner is a Professor of Software Engineering at the Florida Institute of Technology and an attorney focused on the law of software quality. He is senior author of several books, including Testing Computer Software, and of online open courseware at www.testingeducation.org. He undergraduate and doctoral studies were at Brock, McMaster, York and Windsor.
Chris Laffra
Rational Performance Engineering Team, IBM
online: website
Considering Ajax
Lately, there is a lot of interested in Ajax (Asynchronous JavaScript
plus XML).Various Ajax applications demonstrate a much more interactive rich
client experience than traditional web browsing. Using Ajax, new and innovative
aggregration and presentation techniques can be deployed in an unprecedented
fashion. Inspired by Alex Bosworth’s list of Ajax mistakes,
I compiled a list of 20 attention
areas to look at when considering Ajax techniques for a website. Some of
them are potential problem areas, such as breaking the “back” button, causing
unhappy off-line experiences, not showing progress, loosing bookmarkability, and
raising security concerns. Most of them, however, are indicating the high
potential Ajax has. Of course, the presentation itself will be done in a browser, using
Ajax techniques as much as possible. The talk can be found at
http://eclipsefaq.org/chris/ajax. I have experimented a lot with Ajax in
the past, doing things such as enhancing Google maps to find a new home in
Raleigh near a good school, and generating the online version of the Eclipse
FAQs at http://www.eclipsefaq.org/chris/faq/indexb.html.
Bio:
Chris Laffra was born in The Netherlands and obtained his MsC at the
Vrije Universiteit of Amsterdam in 1988 and a PhD at the Erasmus University of
Rotterdam in 1992. At both IBM T.J. Watson Research Center and Morgan-Stanley,
Chris worked on tools for user interfaces, component infrastructures,
program analysis, debugging, visualization, compression, and optimization. He
led the OTI Amsterdam lab for 3.5 years, working on WebSphere Studio Device
Developer(r). At IBM Canada’s lab in Ottawa he worked on the border between Java(tm)
runtime environments and Eclipse (and co-authored The Official Eclipse 3.0
FAQs). Currently, Chris works at IBM RTP to improve RAD/RSA performance.
Laurent Seiter
Software Start-up
What is a startup? Why start one? What are the basic ingredients to
make it successful, or a failure? All startups are not the fairytales
of the Internet Bubble and everybody does not become Google overnight.
This tutorial coming from a real-life experience will offer hints and
directions to answer the above questions.
We will travel through the different layers of the cake, from the
original idea to the motivating impulse, the context, the lifestyle,the
business plan, the funding, the morale, the marketing and PR, the
recruitment, how to deal with customers, bank managers, incubators,
investors and associates, and other delights of the startup experience.
Attendees with a project will come out with a clearer view of what to
expect from a software engineer point of view: the tutorial is closer
to a report from the field than to a theoretical SAPMBA course.
Bio:
Laurent Seiter has 14 years of experience in software development in
several industries (telecoms, logistics, stock exchange, groupware) and
research labs (CERN, CRIM). He has been the co-founder of a software
startup in 2000 and has created other entities in the music industry.
Orlando Marquez
Static Analysis Using the Eclipse Test and Performance Tools Platform (TPTP)
This talk introduces the static analysis framework and code review components
built into the Eclipse Test and Performance Tools Platform (TPTP). The static
analysis framework offers users a consistent interface through which all forms
of analysis can be manipulated. For the developer, TPTP supplies a simple API
for creating analysis providers, developing rules and presenting analysis
results to the user. This session will initially provide a quick walk-through
of the new user interface components including a discussion of the design
considerations that help improve the user experience when analyzing resources in
the Eclipse workspace. This overview will demonstrate the Java and C/C++ code
review providers used to analyze sample source code to generate and view
results. Focus will then shift to an introduction of the supplied API and will
include two examples to illustrate the steps needed to integrate an existing
third-party analysis tool and to create new rule provider from first principles.
This will include detailed information describing which extension points are
available, how to define rule categories, rules, results and viewers. Following
the provider discussion, the focus will shift to the Java code review provider
supplied in TPTP. Though this provider supplies approximately 70 rules for
common J2SE issues, it also offers developers a trivial API for augmenting the
rule set with new custom rules. Examples taken directly from the open source
TPTP code review rules will quickly walk developers through some basic JDT-based
API’s available for Java rule creation. This knowledge will then be used to
write a simple rule that can be plugged into the TPTP Java coded review engine. Finally, this tutorial will describe some of the more advanced features of rule
writing such as rule templates, variables, detail providers and quick fix support.
Bio:
Orlando Marquez is a Software Engineering student from the University of
Waterloo. As part of his last internship, he worked at the IBM Ottawa Lab
developing Application Analysis features for Rational Software Architect and
related products. He also contributed greatly to the Eclipse Test and
Performance Tool Platform (TPTP) Static Analysis tooling. His current main areas
of interest are source code and runtime analysis.
