About Best Practice Software Engineering (BPSE)

This site introduces a set of techniques, patterns and paradigms, which are used for developing our Best Practices examples.
It also presents the used architecture, external libraries and technologies.

These examples including the documentation is open source and can be used under Open Source / Creative Commons licenses. So anyone can use the examples but we ask you to inform us whether you plan to work with our examples. The sources for this site including all examples, downloadable content and license details are available on Google Code

The Book

Book-Cover

In March 2010 our book with the title

"Best Practice Software-Engineering, Eine praxiserprobte Zusammenstellung von komponentenorientierten Konzepten, Methoden und Werkzeugen."

is released. The publisher is "Spektrum Akademischer Verlag (Springer)". The book is in German.

Find more information at the publishers website or on Amazon.de.

Please also visit the dedicated book-page on this website to get more information on examples mentioned in the book, errata and more.

Introducing Best Practices

What are best practices? Developing solid and well-designed Software is a challenge. Systems and environments become more complex every year and technologies change fast. Developers with years of experience have the advantage over younger colleagues of having made many mistakes over the time. Mistakes they used to learn and write better applications next time.

Clearly, we cannot "teach" unexperienced developers experience, but what we can do is provide so called "best practices". Some of the good and bad decisions from concrete projects can be abstracted to scenarios. E.g., how to implement a persistence solution for a business application, how to implement a robust GUI that is also easy to maintain and so on.

This "abstract" experience can be explained on two levels: The first level is called Software Patterns: Software Patterns describe how to solve typical problems that appear in many application scenarios in similar ways. These patterns can be seen as abstracted knowledge, that guides you in better solving your concrete problems.

The second level is: technical-implementation best-practices. Let's introduce the idea with a quotation from a leading Apple developer in the late 80s: "Reusing other people's code would prove that I don't care about my work. I would no more reuse code than Ernest Hemingway would have reused other authors' paragraphs.?"

Hardly two decades later this quotation is a funny curiosity from a long forgotten past ;-) Actually systems nowadays are so complex and demand such a wide spectrum of functionality that such an attempt is literally unthinkable. In developing a modern application the "pure code hacking" is only one small part of the undertaking, the development effort at least needs to deal with:

  • As most development efforts are done in teams, often even distributed: Setup and configure various groupware applications (sourcecode management, bug-tracking, mailing lists, other collaboration tools)
  • Select a good build automation strategy that automatically prepares the build, generates code when necessary, compiles, excutes test-cases, generates various documentation artefacts, packages and distributes the application
  • Define the dependencies of the applications: which libraries or subsystems are needed, what are the connections between these, how are they initialised and configured and what libraries are the libraries depending on
  • Install and setup a proper integrated development environment and let this work together with the build automation tool and all other required components (e.g., Servlet container, modeling tools, ...)
  • Figure out and setup the best suited platform and basic environment for the application (component management and configuration, logging, testing, other development-related tools)
  • Find a fitting persistence technology, setup the development, test and production system including all configuration options
  • Select the UI technology ("fat client", Web, Web 2.0, ...) and get all required additional libraries and environements working together (e.g., Servlet environment)
  • ...
  • Get all these mentioned components working properly together and understand how they interact correctly

These are just some of the problems to take into consideration. We can see, that the pure "setup" of a working environment to start from needs a lot of experience and knowledge. Select the proper tools and libraries to start with, getting them running together and so on. Precisely at this point our technical best-practices start:

We prepared a set of examples that can be downloaded and used as start-point for own applications. Currently we provide examples for a "fat client" application, a web-application and a distributed application with web-frontend. The complexity of the applications (the functional requirements) are simple for not confusing the actual goal, that is showing a clean and well-written example for the application scenario. For designing these applications we tried to use established best-practices, patterns and libraries to give a good foundation to start from. We consulted literature, followed best-practice suggestions from various library documentations and discussed details with various experiences developers.

However, if you should find bad-design, missing tests, bugs, typos in the documentation: in short words mistakes of whatever kind, please do not hesitate to contact us!

Where to find...

This 'fingerpost' will help you finding the needed information if you get lost in reading.

In section Development Setup you will find - on the one hand - the information how to set up the best practice examples and make them work, on the other hand a sneak tutorial how to make your own project build environment (catchword: Maven)

Section The sample apps provides information about functional requirements, architecture and technologies used in Basic, Medium or Advanced Sample.

Technology is a listing of all used technologies. There you get a short description about each technology, what our motivation was to implement it, the usage of the technology (examples and tricks) and references to other ressources.

Software Patterns will help you 'speed up' your development process by providing information about 'What does' this pattern, the general structure, examples and references.

Javadoc, Source and Test Source provide the opportunity to browse through the source code, test source or Javadoc

General References shows a selection of ressources (e.g.: Java, Maven).

Finally the ToDo give an overview of actual standings in developing the examples and the documentation.

Who we are?

This example-and-documentation project is an effort from a team around the Quality-Software-Engineering group of the Vienna University of Technology. The project initiator was Alexander Schatten.

A big thanks to all contributors! Please have a look at the team page!!.