Agile Software Development has different roots, one is the Toyota production line in automotive. These topics show how traditional software development methodologies work (e.g. the waterfall approach) and how agile software development tries to overcome shortcomings of these approaches. This lead to the formulation of the agile manifesto.
Feedback is an essential part in agile software development, it can be given for example through unit tests, process metrics, retrospectives or stand up meetings. This topic shows the influence of feedback on the project quality and the team. Further different kinds of feedback are presented and discussed. References:
- Mary Poppendieck: Lean Software Development: An Agile Toolkit: Chapter 5
- Mary Poppendieck: Implementing Lean Software Development: Chapter 8
- Socio-technical systems: From design methods to systems engineering
- Simulating Kanban and Scrum vs. Waterfall with System Dynamics
Different “styles” of agile software development are for example eXtreme Programming, Scrum and Kanban. This topic critically discusses in detail the Scrum and Kanban approaches on agile software development. Scrum is an iterative and incremental process for project management. Both were originally suggested for managing industrial product development projects. It is presented how Scrum and Kanban evolved and shows the differences.
- Ohno Taiichi: Toyota Production System: Beyond Large-Scale Production
Blogs, Books, etc.: (Not the primary reference, but in case you need more explanations.)
- Mike Beedle und Ken Schwaber: Agile Software Development with Scrum.
- Ken Schwaber responds on his blog to the Project Management Institute's announcements to incorporate agility into its project management program. This response is a helpful clarification about what he considers to be essentially agile.
- Dan Pink about Motivation: RSA Animate - Drive: The surprising truth about what motivates us and there is more from him and you might even look up the research he refers to.
Recent research suggested to analyze how far mathematics game theory ideas on collaboration (e.g. prisoners dilemma) can be adapted to improve software development. This topic presents recent research on this field, discusses future challenges and illustrates possible improvements that may be achieved.
Tests play a major role to ensure product quality in Agile Software Development. This topic explains how Test-Driven Development is used and what different philosophies of TDD exist. Further an analysis on the impact for development quality is shown.
- Kent Beck: Test Driven Development
- Freeman/Pryce: Growing Object Oriented Code Guided By Tests
Pair programming is an development technique in which two programmers work together at one computer, working on the same task. This topic illustrates best practices in pair programming and the impact on code quality.
Mobility is nowadays an essential part of our daily life. The currently mobility is restricted by its power consumption. In topic these sources are identified. Furthermore it presents how development of mobile applications has to tackle this problem.
- Chris Thompson, Douglas Schmidt, HamiltonTurner and Jules White: Analyzing Mobile Application Software Power Consumption via Model-Driven Engineering, PECCS 2011
By designing mobile applications, developers need to handle platform specific restrictions. This talk presents the challenges they have to face and the root causes behind this constraints.
Android as platform for mobile devices is a Linux derivative. In this topic the underlying architectural differences of the original Linux root and Android are presented.
- Anatomy Physiology of an Android at Google I/O 2008
JTransformer is a query and transformation engine for Java source code, available as a plug-in for Eclipse. JTransformer creates a Abstract Syntax Tree representation in Prolog and provides an query API. This topic presents the concepts of JTransformer for Java and illustrates the ideas behind the language independent successor StarTransformer.
- Diploma Thesis Alexis Raptarchis: StarTransformer
During the lab we want to review the quality of the code at hand. We should be able to conduct this review based on a thorough understanding of design principles and principles of good code. The talk presents an overview of the core design principles for object oriented systems. Some general guidelines about how to approach a code review complete the picture. This topic is not about: Metrics, Smells or Refactoring, but about the quality principles which are the foundation “below” these concepts. If you have to decide between depth and breadth of your presentation favor the depth.
- David Parnas, On the Criteria to Be Used in Decomposing Systems Into Modules → “Information Hiding”
- Edward V. Berard, Abstraction, Encapsulation, and Information Hiding
- Betrand Meyer, Object Oriented Software Construction, Ch. 3.3: → “Open Closed Principle” and others
- Karl J, Lieberherr, Adaptive Object-Oriented Software: The Demeter Method. PWS Publishing 1996. → “Law of Demeter”
- Barbara H. Liskov, Jeannette M. Wing: A behavioral notion of subtyping. → “Liskov Substitution Principle”
- To be added: Anticipation vs. Adaptation (BDUF vs Simple Design; Agile Quality Criteria differ!) Could be http://doi.ieeecomputersociety.org/10.1109/AGILE.2007.58
- To be added: A reference about how to review code.
Further readings, if you need more explanation, not(!) required:
- Kent Beck: Implementation Pattern
- Robert C. Martin: Clean Code
- Lanza, Marinescu: Object-Oriented Metrics in Practice, Ch. 5.1, Ch. 6.1, Ch 7.1
- Arthur Riel: Object-Oriented Design Heuristics, (Some lecture slides from Stephan Ducasse about the book)
- Lorenz Kidd: Object-Oriented Software Metrics, Read the chapter about Design Metrics while ignoring the Metrics stuff
- http://www.clean-code-developer.de/ (Links to English papers)
Code quality depends on a variety of factors, starting at coding format guidelines and ending with so called code smells. This seminar topic discusses, what is “bad code” and what is “good code”. It presents the commonly used criteria and their theoretical foundations and demonstrates, how they can be used during development time using the Cultivate eclipse plug-in.
- Lanza, Marinescu: Object-Oriented Metrics in Practice
In the last recent years the complexity of source code has strongly increased. To be able to handle this complexity, different visualization approaches have been designed. This talk presents current methods and tools for software visualization. Furthermore, a comparison and in-depth analysis of the individual concepts is done.
- Diploma Thesis Codegestalt: Christopher Kurtz: Chapter 2 Visualization (References)
As the complexity of software increases modifications to existing structures have to be made. Therefore the concepts behind the structures need to be kept consistent with the original intention (“safeguarded structures”), even if the system evolves. This topic summarizes current approaches in this field.
The foundation of static code analysis relies on relations, e.g. call flow, data flow and dependency graph. This talk gives a simple overview of the methods and discusses future challenges in this area.
- F Nielson, HR Nielson: Principles of Program Analysis