testdriven.com Wrangling quality out of chaos

Marty Andrews is embarking on a demonstration of Continuous Integration, to illustrate its concepts and techniques with a comprehensive example.

Marty has been working together with Jason Yip to collect all of the information they can about Continuous Integration. The simple Web application showcased will serve as a means to share that information with all those interested in Continuous Integration and the tools involved in it (CVS, Java, Ant, JUnit, JCoverage, Simian, Tomcat, JWebUnit, FIT, FatCow, Cruise Control, etc.).

Marty writes: "There’s no real code to speak of yet, just a HelloWorld class and an associated test, but most of the surrounding tools are set up in a directory structure that I like. You can download the application template if you like to see how it works. It’s about 2MB in size, as the tools for all jars are included. You’ll need Ant 1.6 to build it."

The Continuous Integration demonstration is here.

The Silicon Valley Pattern Group holds regular meetings on computer programming and methodologies. Its next meeting will introduce a new track on Test-First Programming.

Date: Tuesday February 10, 2004
Time: 7:00 pm
Site: Hobee’s Restaurant (directions)
Topic: Test-First Programming (I)

Some notes from the meetings are available at Silicon Valley Patterns.Russ Rufer writes:

"We’ll be tackling the subject of Test-First Programming at our next meeting. I consciously avoided the synonym "Test-Driven Development" for this track’s title, in part to avoid confusion with the previous track "Domain-Driven Development" since these are not necessarily competing techniques. I expect that what it means when we say something "drives" development will be a topic of discussion at the meeting.

Some regular participants have extensive experience with Test-First Programming, while others have none. We’ll start this track with an open discussion where those of us with experience can share what we’ve learned. I have no doubt that even those of us who have done quite a bit of test first programming will learn from our peers at this meeting.

There are several directions future meetings in this track might go, including a focus on some specific published material, a study of UI testing techniques, or revisiting Mock Objects. Personally, I’d like to see us get hands-on with this track, with some pair test-first programming during the meetings. We’ll choose a direction at the upcoming session."

To Prepare For This Meeting

If you have no direct experience with Test-First programming, some useful ways to prepare for the meeting might include:

Get Some Experience

A key to understanding this is to know the technical side of testing. If you haven’t actually used one of the test harnesses in the xUnit family, this is the time to give it a try! JUnit is a good choice (if you know java, as most of our participants do). JUnit comes integrated with Eclipse, making it a very simple combination to try. Here’s a two-page article that will have you up and running tests in Eclipse in no time:
http://www.onjava.com/pub/a/onjava/2004/02/04/juie.html

Test First Bowling

Read the "bowling example" by Robert C. Martin and Robert S. Koss. This is a short programming session which many of the regular participants are familiar with from our pre-publication review of Bob’s book, Agile Software Development: Principles, Patterns and Practices". If you don’t have this book, you can find a version of the session described online at:
http://www.objectmentor.com/resources/articles/xpepisode.htm

Visit TestDriven.com

This is a portal that two of our active members (Jeff Miller and David Vydra) are major forces behind. It will give you a sense of the scope of discussion around Test First programming. You may want to read the brief FAQ listed on the left side of the page.

http://testdriven.com

Parasoft has announced that its Jtest 5.0, the first development product of its type to automate all aspects of Java unit testing and coding standards compliance, is built on the Eclipse platform and fully integrated into the Eclipse workbench.

Read the [url=http://www.parasoft.com/jsp/products/release.jsp?articleId=1350&product=Jtest]Press release[/url].
Try the Free evaluation.
From Parasoft:

"Jtest is an Automated Error Prevention product that automates Java unit testing and coding standard compliance to help developers produce reliable code in record time. Jtest analyzes classes, then generates and executes JUnit-format test cases designed to achieve maximum coverage, expose uncaught runtime exceptions, and verify requirements that were expressed using Design by Contract. Additional tests can be added by extending the generated test cases and using new or legacy JUnit test cases. Jtest also checks whether code follows over 380 coding standard rules (plus any number of custom rules) and automatically corrects most rule violations. With the click of a button, developers can identify and prevent problems such as uncaught runtime exceptions, functional errors, memory leaks, performance problems, and security vulnerabilities."

FatCow, a tool to provide Functional Acceptance Testing for the Confluence Wiki, was released along with Confluence 1.0b4. Styled after Ward Cunningham’s FIT and Bob Martin’s Fitnesse, FatCow allows you to define web-based acceptance tests in wiki notation, and then run them from inside Confluence.

Read all about it at http://opensource.atlassian.com/fatcow/index.html

Read a sample FatCow test at http://opensource.atlassian.com/fatcow/fatcowMacro.html

FatCow is Open Source, and also serves as example code for anyone who wants to extend Confluence by writing their own macros.

Confluence, a commercial J2EE wiki, is a knowledge management tool designed to make it easy for a team to share information with each other, and with the world.

Jamie Cansdale writes:

I have recently put up a site that anyone into test driven development in C# may enjoy.  The idea is you edit, build and execute C# source code online against a fixed set of NUnit tests.  When your source builds and all tests pass, you are given the opportunity to post your entry to the Code Blog.  At the moment the tests are for a simple sorting algorithm.  I am looking for some more interesting challenges to put up.  If you have some suitable NUnit tests, please send them to me.
 
You can edit and run your tests here…
http://www.testdriven.net
 
The following feed will contain only C# source with NUnit tests that pass…
http://www.testdriven.net/rss.xml
 
You might find more information at my weblog here…
http://weblogs.asp.net/nunitaddin
 
Have fun, Jamie.

PS. If you can see a specific security vulnerability, I would be very grateful for some example code.

The Combinatorial Test Services (CTS) is a software library for generation and manipulation of testing input data or configurations. CTS enables the user to generate small test suites with strong coverage properties, choose regression suites, and perform other useful operations for the creation of systematic software test plans.

from [domaindrivendesign] yahoo group:

On Jan 29, 2004, at 4:04 AM, Johan Nilsson wrote:
> I was thinking that TDD:ers could make a neural network program for
> them. Just write the test and let the neural network fix the rest. It
> will be guided by compiler errors and green/red lights. Without any
> domain model, programming is pure text manipulation anyway, right?

Ralph Johnson’s answer:

I am amazed that people took this comment seriously. It was clearly a joke. He was poking fun at TDD. The fact that people took it seriously indicates that someone (me) should make a more direct attack on TDD.First, I think TDD is a great idea, and my programming has improved a lot since I started it. However, it is not the end-all and be-all of programming, and the people who advocate it (i.e., the XP crowd) over-sell it. It needs to be over-sold, because the state of the practice of testing is so wretched. The vast majority of programmers do no systematic testing. If they get convinced that TDD is a magic elixir that will radically change their life, they might start testing.

But TDD is not a magic elixir.
You are not going to get good programs by using a neural net to make the tests pass. The reason that TDD works is because programmers are intelligent and creative, and because they eventually develop a domain model. When programmers are stupid and lazy, TDD will fail, like anything else.

Developing good software is hard. It requires knowing about programming languages, algorithms, the problem domain, testing, design, documentation (at the very least, how to name things), how to communicate with other people, how to get along with other people. Any statement of the form "follow this practice and you will be successful" is wrong. Sometimes I can look at what someone is doing and tell them "if you follow this practice you will be more successful", but no advice is universally applicable, and no practice, even TDD, is a silver bullet.

This applies to domain modeling, of course. Most groups that decide to model their domain fail miserably. That is because they think that a domain model is a UML diagram, not a language. They don’t follow the advice of DDD to start with a language that is shared by developers and customers, and then to figure out how to make the program reflect that language. They think that they will produce the domain model, and then others, less enlightened, will use it.

We are more likely to be successful when we do not underestimate the problem.

-Ralph Johnson

In this article, Mike Clark describes 12 practical ways to start writing tests, and keep writing tests, regardless of your development process.

From the author: "The first two techniques play off of things you’re probably already doing, so you don’t have to move too far out of your comfort zone. The next two challenge you to wade deeper into the pool to realize the benefits of test-driven development. The remaining techniques round out the regimen to keep you testing effectively all year. You’ll be well on your way to fulfilling your new year’s resolutions. Caution: contents have been known to be infectious!"

Read the article at http://today.java.net/pub/a/today/2004/01/22/DozenWays.html

Contents:
1. Let Your Computer Do the Boring Stuff
2. Stop Debugger Testing
3. Assert Your Expectations
4. Think of It as Design
5. Build Safety Nets
6. Learn by Checked Example
7. Corner Bugs
8. Expand Your Toolbox
9. Make It Part of Your Build Process
10. Buddy Up
11. Travel With a Guide
12. Practice, Practice, Practice

testdriven.com’s RSS feed includes both our latest news items and web links. To syndicate this site’s contents, you can either enter the RSS links appearing at the bottom-right of this page into your favorite aggregator, or use http://www.testdriven.com/rss.php?news=10&links=10 to combine both feeds.

If you have a xoops site and would also like to provide your users with syndication for the Web links module, instructions to implement this alternate RSS solution are provided [url=http://www.testdriven.com/modules/newbb/viewtopic.php?topic_id=562&forum=5]here[/url].

Still unsure how to write unit tests? How about learning to become a unit-tester by exercising your coding skills on already-existing unit tests? Pragmatic Programmer offers a series of articles inviting developers to learn best programming practices through simple drills involving common data structures and/or algorithms.

The latest article discusses simple lists:
http://www.pragprog.com/pragdave/Practices/Kata/KataTwentyOne.rdoc

The philosophy, and the complete list of drills is at:

http://www.pragprog.com/pragdave/Practices/Kata/Index.rdoc

The Agile Development Conference is an integrated, 4-day conversation about techniques and technologies, attitudes and policies, research and experience, the management and development sides of agile software development. The agile approach focuses on delivering business value early in the project lifetime and being able to incorporate late breaking requirements changes by accentuating the use of rich, informal communication channels and frequent delivery of running, tested systems, and attending to the human component of software development.

The Agile Development Conference gives attendees access to the latest thinking in this domain and bridges communities that rarely get a proper chance to exchange ideas and thoughts, bringing together researchers from labs and academia with executives, managers, and developers in the trenches of software development. The Agile Development Conference is not about a single methodology or approach, but rather provides a forum for the exchange of information regarding all agile development technologies.

We invite you to share your knowledge and experience via the submission of papers. The Agile Development Conference will be held in Salt Lake City, Utah, June 23-26, 2004.We are soliciting contributions in four areas:

- Experience reports relate the author’s experiences in a real situation, using a particular technique, tool, or approach.
Experience Reports proposals due February 15

- Peer to peer gives participants the chance to learn from each other.
Peer to Peer proposals due January 12

- Research papers relate the outcome of a study on the selected topic, and possible extrapolations from those studies.
Research Papers Proposals due January 31

- Tutorials are an independent instruction on a self-contained topic of relevance to conference attendees.
Tutorials Proposals due January 5

Have you done TDD? What were your experiences like? Do you use JUnit, NUnit or one of the other unit testing frameworks? If we have time, we’ll try to have a chat about FIT testing as well. Join the Denver Pragmatic Practitioners for a round-table discussion with your peers about what has worked and hasn’t worked.

We look forward to seeing you there.

Topic: Unit Testing and Test-Driven Development
Date: Monday December 15, 2003 5:30PM – 8:00PM
Location: Interlink Group Offices, 98 Inverness Drive East, Suite 150, Englewood CO 80112
Contact: peter.provost@ilg.com

testdriven.com newsletter #1

We’ll be e-mailing the first installment of the monthly newsletter on Thursday, December 4, to all testdriven.com users. It will summarize the latest and most interesting pages of the past month, and announce major upcoming events.

You need to be registered to receive the newsletter.

Back issues of the newsletter will be available here.

Net Objectives Presents Scott Bain, in a free seminar in Palo Alto, CA, December 9, 2003 (6:30-9:00pm): Unit Testing for Emergent Design — JUnit Fundamentals and a Practical Demonstration of Test-First Design.

Emergent Design is the disciplined process of evolving strong designs through the process of testing, coding, and refactoring within an iterative, agile development process.

One key tool that is needed to maximize the efficiency of Emergent Design is automated unit testing. For Java developers, JUnit is a perfect solution.

More information at: NetObjectivesTopics to be discussed include:
- obtaining and installing JUnit
- creating a test case for an existing class
- creating a test and then creating a class to satisfy it
- creating suites of tests
- unit testing and exception handling (testing for expected exceptions and handling unexpected exceptions)

Learn about:
- the JUnit tool
- test-first design
- the role of testing in Emergent Design

Who should attend:
This seminar is intended for java developers and technical managers who want to investigate unit testing and test-first design. A good comfort level with Java is essential.

About the Presenter:
Scott Bain is a 24-year veteran in computer technology, with a background in development, engineering, and design. He has also designed, delivered, and managed training programs for certification and end-user skills, both in traditional classrooms and via distance learning. Scott teaches courses and consults on Design Patterns, XML, Refactoring and Unit Testing, and Test-Driven Development. Scott is a frequent speaker at developer conferences such as JavaOne and SDWest. He is the co-author (with Alan Shalloway) of "An Introduction to XML and its Family of Technologies" (ISBN: 0971363005; August 10, 2001) and is currently co-authoring Emergent Design: Refactoring and Design Patterns for Agile Development, also with Alan Shalloway.

When:
Tuesday, December 9, 2003.
6:30-7:00 networking and pizza
7:00-9:00 the talk

Where:
Cubberley Community Center, Theatre
4000 Middlefield Road
Palo Alto, CA
94303-4739

Registration: Although this seminar is free, you must [url=http://www.netobjectives.com/reg_freesem_stcode_sendmail.htm?SemCd%3Duted0312can%26SemNm%3DUnit%20Testing%20for%20Emergent%20Design%2C%20Dec%209%20%2703%2C%20Palo%20Alto%20CA%26SemSt%3DCAn%26EFNm%3Duted0312can]register[/url] to Attend.

Contribution: A charitable contribution to the San Francisco Ronald McDonald House of $1-3 is requested for food and drink.

[The following is a re-post of a message by David Corbin to the Yahoo! Group TDD mailing list:]

In mid-October of 2003, "Philip" posted a message on the XP mailing list — "If IDE makers focused on tests…" where he outlined a number of potential features that would really demonstrate an IDE that was focused on testing.

In late October of 2003, Carl Manaster posted a conceptual prototype of "Zero Button Testing" to the TDD and XP mailing lists.

In November of 2003, J. B. Rainsberger mentioned he had Eclipse configured to run his tests everytime he saves a file.

All this has insprired me to form the Test Driven Eclipse (TDE) project.TDE is a project dedicated to making Eclipse the ideal environment for test infected developers. Right now, all that exists is a few ideas swirling in my head, a SourceForge project with one mailing list. Not one byte of code has been written yet to support this. This is a call for other participants (developers, idea people, writers, webmaster, etc.) to explore what this project should be, and build it.

In case some of you need some more inspiration, here’s a starting list of possible ideas (mostly from the above great minds):

* Automatically Execute tests on Save
* Automatically Execute tests edits
* Easy rollback to the last green-bar
* Color-code code based on test status
* Automatically create test rig with production code
* Quick-link between test code and corresponding production code and back again
* Easy to browse tree of Test suites/cases/methods
* Color code stack traces to seperate test-rig from production code
* Quick/more-automatic integration
* Integration runs tests
* If post-integration test fail, rollback automatically
* Identify what code lines are covered by what tests
* Language Independent Test Runner
* Cross Language Test Suites

http://www.sourceforge.net/projects/tde

Subscribe to the mailing list at http://lists.sourceforge.net/mailman/listinfo/tde-general and then offer your suggestion, comments, or even better, volunteer.

David Corbin
[email]dcorbin@users.sourceforge.net[/email]

[url=http://safari.oreilly.com/JVXSL.asp?x=1&mode=section&sortKey=title&sortOrder=asc&view=&xmlid=0-321-14653-0&open=false&g=&srchText=BOOK+AND+%28AUTHOR+beck%29&code=&h=&m=&l=1&catid=&s=1&b=1&f=1&t=1&c=1&u=1&r=&o=1&page=0]Test-Driven Development: By Example on Safari[/url]

The XP Day Benelux is a one day conference about all aspects of Extreme Programming and other agile software development methods like DSDM, Scrum, Feature-driven development, and Crystal. See the agile manifesto (Agile Manifesto) for the principles of agile software development.

The Agile Inside Out track examines agile from the perspective of developers:

- refactoring, unittesting, test-driven development using 4GL, OOP, J2EE, .NET, databases…
- automation of the build and release processes
- the developer role in a multidisciplinary team, pair programming, collective code ownership
- confessing to your manager you’re doing XP
- "guerilla XP"The XP Day Benelux conference is aimed at software developers, project leaders, IT managers, testers, architects, and coaches. It will provide a good opportunity for exchanging ideas and sharing experiences, and is suited for both experienced participants and beginners in Agile Software Development. The focus of this conference is on practical knowledge, real-world experience and active participation of all attendees. We aim at 50-100 participants.

Organising a session is the best way to learn from such a conference. It provides an opportunity to share your experiences, to get feedback on your ideas, to try new ideas and sessions. Session organisers will get discount off the conference fee (which will be about €100).

Where: Breda, The Netherlands
When: November 21, 2003
Information: http://www.xpday.be
Contact: [email]xpdayinfo@xpday.be[/email]

Overview of Agile Development Methodologies using .NET technologies, including continuous integration via nAnt and test-driven development practices. This presentation will be delivered by a professional developer working with these tools on a daily basis, NOT by a vendor pitching products. The presentation will be focused on practical best practices and directly targets the professional software developer who is looking for new ways to get more productive software code written faster and with higher quality.

When: Tuesday, Nov 11, 2003 at 07:00 PM
Where: Johnson Bank, Madison, WI 53717
Information: http://www.wi-ineta.org/
Contact:[email]president@wi-ineta.org[/email]

MockEjb is the lightweight framework for running EJBs outside of the container for unit testing. With MockEjb developers can instantly run EJBs and their test classes directly from IDE without having to deal with the complexity of EJB deployment.

MockEjb supports most of javax.ejb interfaces. MockEjb allows for testing of EJBs that rely on JNDI and require transaction support. MockEjb comes with the simple API that allows for fully configuring it in setUp method of a test class. Additionally, MockEjb can be easily extended using its implementation of the interceptor pattern.

Alexander Ananiev

www.mockejb.org

Learn the Techniques, Deliver the Results
Software Quality Engineering is proud to bring together a select group of industry experts combined with leading tools and service providers to show you how to deploy your resources to better achieve your organization’s test automation goals.

See below, list of conferences in the [url=http://www.cmpevents.com/SDxE/a.asp?option=C&V=1&CPid=24&Regid=0&scTKs=130&SB=4]Testing and Quality track[/url] which pertain to test-driven development.

Dates: August 19-22, 2003
Location: Boston, MA

Software Test Automation Conference and EXPOApplying Continuous Integration and Automated Testing to J2EE
Speaker: Richard Hightower
Date: Thursday, 9:45 am – 11:00 am, 11:15 am – 12:30 pm
This session is designed for developers who want to apply the Extreme Programming (XP) practices of Automated Testing and Continuous Integration to Java and J2EE using Ant, XDoclet, JUnit, HttpUnit, JMeter, Cactus, JunitPerf to automatically build, deploy, configure and test J2EE applications. This class includes examples and tutorials on each tool. The examples cover building, deploying and testing Java and J2EE applications. The focus is how to use these tools to assemble and test components that can be assembled into many different applications that can be deployed on many application servers, operating systems and RDBMS. The class will show how to create an environment that supports the rapid construction of quality Java/J2EE software.

Test-Driven Development using Java and JUnit
Speaker: David Astels
Date: Tuesday, 3:45 pm – 5:00 pm
Test-driven Development (TDD) is a cornerstore of eXtreme Programming (XP). Without TDD in place, most of the other practices are difficult or impossible (e.g. refactoring, continuous integration. While writing a complete suite of programmer tests for your software is good, writing them first is better. However, the benefits of practicing TDD are not limited to XP, and can be realized in any Agile, and even some non-Agile, contexts. TDD helps make our code better, regardless of what amount of design or modeling has been done before programming begins. It’s a generally useful technique to have in our bag of tricks. This class will provide an introduction to TDD showing how it works and what benefits it provides. The class will be conducted using Java and JUNIT. You will gain an understanding of how writing tests can drive development, resulting in cleaner, simpler, more correct, extendable, maintainable, and robust code. You will also get a chance to do some TDD, allowing you to get a feel for the flow of it.

Topics of the one-day seminar:

Quality Development
On average, 30% of total project cost is spent on rework. Attempts at reducing project cost focus on improving developer productivity and all too often forget the critical issues of improving quality and maintainability. This session will cover some of the techniques and tools that can allow the developer to improve quality, maintainability and productivity.

Agile Modelling with collaborativeAID

CollaborativeAID was designed to overcome specific issues faced by a lack of tooling in the Agile Development space. The design principles behind the product development, gives an insight into to the uniqueness of CollaborativeAID Tooling.

Date: Tuesday July 29 2003 12:00-14:00
Location: London, UKSubjects covered include:

Profiling: Look inside the JVM & J2EE black boxes and regain control.
Unit Testing: Integrate Unit Testing earlier into the development cycle.
Visualisation: Multiple ways to visualise runtime and static behaviour
Communication: Effective communication between development and testing teams.
Code Analysis: Static analysis of code to enforce coding standards and collect metrics.
Design & Documentation: Realistic ways to get design & documentation up to date and maintain it.
Project Visibility: Developers need to be able to understand the requirement and reasoning behind a piece of code.

High Collaboration: Pure updateable access from any Internet browser.
Virtual Wall Of Wonder (WOW): A virtual canvas to draw and design ideas.
Lightweight Communication: No client software required.
Open & Extendable Architecture: Internally developed or open source compilers to be included into the cAID architecture.
Wiki Wiki Metaphor: Updateable from anywhere by anyone.

If you would like to attend this seminar please send your name and company name, e.g. John Smith-ACME Corp, in the body of the message to london-seminars@jsig.com with the title: Quality-Agile July 29 2003.

http://209.235.197.109/seminars/2003/London/29July2003.html

Smalltalk Solutions is the premier forum for bringing together Smalltalk users, developers, and enthusiasts. A number of conferences will cover test-driven development using Smalltalk; they are indicated below.

Last day to register by fax or online: Monday, 7 July 2003. Past this date, you can register only at the Conference.

Location: Toronto, Canada
Dates: July 14-16
e-mail: jjones@stic.org
Phone: (919) 789-8549
Fax: (919) 789-8615Theme: Test-Driven Development (Tutorial)
Speaker: Dave Astels (Adaption Software, Inc.)
Date: Wednesday 2:00:00 pm to 5:30:00 pm

This will be a very pragmatic tutorial, with a mix of lecture, demonstration, and hands-on exercises. Background, tools, and techniques of TDD would be covered, as well conceptual topics such as refactoring tests, building tests around fixtures, what makes for a good test, approaches to writing tests to maximize the benefit, etc. Hands-on means programming, so make sure to bring a laptop and be prepared to pair-up.

Theme: An open-source acceptance testing application
Speaker: Sean Morrison (OTPP)
Date: Tuesday 9:15:00 am to 10:00:00 am

The development environment at OTPP includes a large number of non-technical business analysts who validate the correctness of applications developed in-house. These businesspeople use an internally developed testing application named BRITE to run acceptance level tests against our applications to validate new features and to guard against regression. Traditionally, BRITE was used to test applications written in Smalltalk. It has recently been extended to include the ability to testapplications written in other languages and applications that run within a server environment (as opposed to on client PCs).

Theme: Unit-testing Web Applications
Speaker: Colin Putney (Whistler.com)
Date: Wednesday 2:00:00 pm to 2:45:00 pm

The talk describes the templating system we’ve been using at Whistler.com and the testing methodology we use with it. The templating system follows an MVC pattern where templates are parsed into a DOM-like tree of views, which are manipulated by the component using LISP-like macros. The first part of the talk describes the framework and explore the motivations behind its design. The second part describes the requirements for testing web-based UIs, how this template system has allowed us to write testable UIs and the test patterns we’ve found effective.

Theme: VWUnit – An Open Source Framework for Unit Testing VisualWorks GUIs
Speaker: David Buck (Simberon)
Date: Tuesday 8:30:00 am to 9:15:00 am

This workshop will focus on Programmer Tests as defined in Test-Driven Development and the XP literature. Such tests are written by programmers to drive the development of software, demonstrate step-by-step progress towards the completion of a task and provide a safety net for refactoring.

We will explore specific strategies and techniques that participants can apply in their work, in addition to considering the "big picture" of testing.

Location: XP Universe 2003 Conference, New Orleans, Louisiana
First half-day of workshop: Monday 11th August, 1.30 – 5.00pm
Submissions due: 10th July 2003

Organizers: J. B. Rainsberger, Ron Jeffries & Rick Mugridge The goal of the workshop is to advance the art of writing programmer tests through the sharing of experience, practical advice and techniques.

Enthusiasts and practitioners of test-oriented programming are invited to participate to explore issues related to programmers writing tests. Participants will share their experiences and learn through multiple group discussions on the topics that interest them most.

Here is a list of possible topics to help define the workshop’s mandate:

Programmer Tests for "non-functional” concerns: execution speed, response time, security, scalability, memory footprint, logging, etc.
Let’s write some tests!

Feel free to propose additional topics in your submissions and at the workshop.

The European Conference on Object-Oriented Programming Conference Committee invites researchers, practitioners, educators, and students interested in object technology to actively participate and contribute to ECOOP 2003. The conference is hosted by the Software Technology Group, Department of Computer Science, Darmstadt University of Technology, supported by the Association Internationale pour les Technologies Objets (AITO).

Dates: July 21-25, 2003
Location: Darmstadt, Germany

http://www.ecoop.tu-darmstadt.de/index.phtml

ThoughtWorks’ new Open Source site makes available many useful projects.

http://opensource.thoughtworks.com/index.html