• If you are citizen of an European Union member nation, you may not use this service unless you are at least 16 years old.

  • You already know Dokkio is an AI-powered assistant to organize & manage your digital files & messages. Very soon, Dokkio will support Outlook as well as One Drive. Check it out today!



Page history last edited by Martin Klose 12 years, 8 months ago Saved with comment

go to schedule



10:00 Sergey Shishkin: Specification by Example (Room "Österreich")

This is a story of a team struggling with traditional specification as a deliverable which divided people into alienated departments of PM, DEV, and QA. We learned the hard way how to focus on only what matters and moreover how to deliver it just in time! Though we have already been "adopting" Scrum for several months, low quality and finger-pointing were still spoiling each sprint.

The key contributing factor to our successful agile transition was specification by example, created as a collaborative effort of all the members of the team during an iteration and serving validation and documentation purposes as well.

This talk is an introduction to specification by example, it covers "why" and "what" of the technique.

10:30 An Example

Specification by example favors expressive examples over extensive and confusing explanation. This interactive workshop is aimed to demonstrate an example of using the technique. Together we collaborate on a specification for an imaginary business problem, distill the examples and outline a validation and a documentation strategies.

About Sergey

Sergey Shishkin is an agile developer and coach working for MT AG in Ratingen, Germany. Continuous learner, clean coder, passionate community activist bringing software craftsmanship and software engineering together, regularly speaking at local user groups and industry conferences, blogging onhttp://shishkin.org and twitting as @sshishkin.




Recordings from Sergeys Introductory Talk (30 min):

Sergey Shishkin.pdf  (includes embedded audio if you open it with Adobe Acrobat)

Sergey Shishkin.m4a  (audio only)



10:00 Nicolas Botzet, Steven Collins: Craftsmen Coding Contest (Room "Ungarn")

- this session will continue the whole day -

This workshop needs your active participation either individually or in a team of two. Your challenge is to create a program, which is able to play poker and compete against the programs of other teams. There is no programming time or playing time - everything is happening at once. The longer you need to create a running poker bot, the greater will be the gap between you and your opponents. When you finished your first version, the fun has only just begun: How do you know whether your bot is successful? How do you react on new versions of your opponents? How do you maximize your profit and win the tournament?

As experience shows, it is necessary to read the documentation and exercise our Kata in advance. The Kata is important, since it is not permitted to use any copy & paste. Everyone starts with a blank editor. The choice of programming language is up to you, but you should be able to send and receive UDP packets. The Kata is available at https://github.com/lomin/ccc-kata

We feel confident, that one can learn a lot about various aspects of software development at the Craftsmen Coding Contest, even though the time is short compared to real world software projects. This will be compensated by serious time pressure and highly skilled competitors.

You will gain new insights into these aspects of software developing at the CCC:

  • continuous integration and continuous deployment
  • latency, throughput, and variance
  • TDD vs. no tests
  • ratio of unit tests to acceptance tests
  • programming under pressure
  • spending time on new features vs. spending time on analyze existing features
  • teams performing pair-programming vs. both team members programming simultaneously

Are you a craftsman and want to show your skills? Then come to our contest!

Session Requirements

Please consult https://github.com/lomin/ccc-kata for information about the rules and protocol used in the kata. Even better: do the kata as preparation for the session!

Important information: This contest will run throughout the whole day -- but you may want to visit other sessions... So if you only want to spend 90 minutes on this contest, it is highly recommended for you to prepare yourself by reading the rules and exercising the kata in advance.

About Nicolas and Steven

Steven is a senior software developer at it-agile GmbH. He often enters into projects which suffer from huge amounts of legacy code. In order to deliver new functionality on time, Steven learned that it is not enough to refactor legacy code comprehensively. It is just as important to do it fast. Therefore Steven created the Craftsmen Coding Contest for developers who want to improve their craft and speed.

Nicolas is a senior software developer with it-agile GmbH in Hamburg. He likes to work in teams and believes pair programming prevents most kinds of mistakes. Nico supports Steven in his Craftsmanship Coding contest since he likes to learn by applying actual skills.




10:30 Uri Lavi: Building Successful Teams (Room "Brasilien")

Would you like to build a highly motivated team which constantly aspires to deliver quality products on time?

Usually Software Craftsmanship values are used to excel as individual or to form a community of professionals.

However, the values can be effectively applied on teams in order to shape highly jelled and very productive team members.

In this talk we will explore, how Software Craftsmanship values can be applied in order to create such a team.

We will discuss: Clean code, deliberate organizational practices and other technical skills that will help us to form great teams.

About Uri

Uri Lavi is the founder and the manger of the Israeli Software Craftsmanship Group where he excels and aspires local development community to deliver great products (business and technology wise).

Acting as a VP R&D at PicScout, an image copyright solutions company, which was recently acquired by Getty Images, he employes a range of Software Craftsmanship values in order to build successful teams.

In addition, Uri specializes in mentoring, coaching and consulting for a variety of topics among which: Clean Code, Refactoring, Software Architecture & Leadership.




12:00 Pierluigi Pugliese: Soft Skill Essentials for Software Craftsmen (Room "Österreich")

One of the most interesting recent evolutions in the agile world is the Software Craftsmanship movement, where a lot of emphasis is put on the skills of each individual programmer.

This presentation makes a case on why, on the top of the programming skills, a software craftsman should also train his soft skills capabilities in order to excel in communicating with colleagues, managers and customers. Some basic techniques coming from various coaching schools (Solution Focused, Transactional Analysis, Improvisational Theatre, ... - this list needs to be trimmed after the actual topic selection - see below...) will be presented in a practical and experiential format so they can be applied to the daily life of software projects.

About Pierluigi

Pierluigi Pugliese started hacking code so long ago that he cannot remember exactly when anymore. He worked many years in the mobile telecommunication business, both as programmer and as a team leader, providing software for several mobile phones of known brands.

Currently he works as a consultant for software organisations and coach for individuals and teams, focusing on software development and software processes, helping them implementing sound and agile solutions.

Pierluigi is based in Munich and operates through his company Connexxo (www.connexxo.com).

Blog: http://blog.connexxo.com

Twitter: @p_pugliese



Recordings from Pierluigis Introductory Talk (30 min):

Pierluigi Pugliese - Teil 1.m4a  (audio only)

Pierluigi Pugliese - Teil 2.m4a  (audio only)

The slides are available at http://www.slideshare.net/ppugliese/soft-skills-essentials-for-software-craftsmen-socrates-2011




12:00 Jens Schauder: Testing with ScalaTest (Room "Mexiko")

Java is one oft the most important programming languages of the last decade and something. While Java is getting a lot of criticism for being outdated pretty much everybody agrees the underlying platform the JVM is very powerful.

Scala is an extremely interesting language for that JVM. Scala is less verbose, supports many of the features missing in Java and is strongly typed. For many Java developers Scala sounds very promising. But how to get some real world experience with a new language? Preferable without risking your project, career or company?

Testing might be an option. ScalaTest is flexible testing framework for Scala. It integrates nicely with JUnit and other testing frameworks and it is perfectly able to test Java code with it. This talk is an introduction to ScalaTest. You'll learn how you can write assertions, structure your Tests in various way, integrate your Tests with your existing Java infrastructure and how to do advanced tricks with your tests, aren't easily possible with JUnit.

You should understand what a closure is and how it works. Basic Knowledge of Scala is helpful but not necessary.

About Jens

Jens Schauder is an experienced software developer, interested in pushing the boundaries and improving his own skills, the process of the team he works with and the collaboration of everybody interested in collaboration. Java is his main language. Scala is the green grass from the other side and PL/SQL an occasional necessity.



12:30 Markus Gärtner: Alternative Paths to Self-Education in Software Testing (Room "Brasilien")

Software Testing is the most controversial profession in computer science. Given the lack of credible classroom training in software testing, successful software testers have to educate themselves, often in their spare time. Because it’s crucial for software testers to know what they are doing, testers have recently evolved several paths to self-education. In this session, Markus Gärtner explains alternative paths to the knowledge a software tester needs. While traditional classroom training provides one way to teach a professional on software testing, several emerging techniques value collaborative learning approaches over certification, thereby forming communities of software testing professionals.

About Markus

Markus Gärtner studied computer sciences until 2005. He published his diploma thesis on hand-gesture detection in 2007 as a book. In 2010 he joined it-agile GmbH, Hamburg, Germany, after having been a testing group leader for three years at Orga Systems GmbH. Markus is the co-founder of the European chapter in Weekend Testing, a black-belt instructor in the Miagi-Do school of Software Testing, contributes to the ATDD-Patterns writing community as well as the Software Craftsmanship movement. Markus regularly presents at Agile and testing conferences, as well as dedicating himself to writing about testing, foremost in an Agile context.



Recordings from Markus' deep dive talk (60 min):

Markus Gaertner.m4a  (audio only)




12:30 Fabian Lange: Performance - a challenging craft (Room "Rumänien")

Software that is well-crafted is better than just working software in many cases. The overall performance of a software system is an important factor. It can differentiate and on top, improved performance also adds value in multiple aspects.

But what exactly is the value of performance? Is it possible to measure the value of performance at all?

And how could we, as craftsmen, ensure good performance of software during its development? Can we actually measure performance itself? This talk will give answers and explain a few ideas on how to value and measure performance taken from real projects. We will discuss the challenges planning and testing for performance creates and how to overcome them.

About Fabian

Fabian is heading the Competence Center Performance at codecentric. In his daily business he helps clients to resolve performance issues in business critical Java applications. Afterwards he usually assists in setting up automated performance monitoring solutions. When helping in customer projects he likes to cleanup code, profile performance or write some automated tests.


Presentation on slideshare


15:00 Uwe Friedrichsen: The agile architect - craftsmanship on a different level (Room "Österreich")

There is a lot of talk about craftsmanship on an implementation level. That's good and that's an important discussion. But unfortunately it's not enough!

The final goal of any real craftsman is not only to do great crafting but also to deliver a big "Wow!" to their customers. Great craftsmen enthuse their customers, and in our case that's a lot more than just being a great developer.

One important missing piece is architectural work, which is most often not covered by the typical craftsmanship discussion. And this architectural work needs an architectural skill, not a developer skill. It's a fundamentally different skillset. It's not important if you call someone an architect or if he or she is simply the architect by having the skill and doing the required work. But if you don't have an architect in your team and you're building a non-trivial system sooner or later you're in deep trouble.

But how can you become, what I call an "agile architect"? Literature doesn't help a lot. Most of the agile folks just don't know how to deal with architects. They try to get around an answer by calling the problem a non-problem. And the old fashioned architectural approaches are often too cumbersome, too much focussed on processes and methodology. Also the craftsmanship movement doesn't help a lot because currently it focusses too much on the development work. So, it's hard to know what to do.

In this session I would like to take you for a short journey towards an agile architect. We will have a short look on the question when and why you need an architect. Then we will examine the work and the required skillset of an agile architect for a while. And we will take a look at the architectural work in an actual project based on a real life case study and figure out what to do and how to do it.

Of course we will only be able to scratch the surface within a sessions time frame. But I think afterwards you will have an idea what it means to be a craftsman on an architectural level and - even more important - you will have everything at hand you need to continue this journey on your own if you like it.

About Uwe

Uwe Friedrichsen is CTO of codecentric AG and has a long track record as architect, developer and project manager. His main focus is on architecture, agile and new technologies. He also is the author of several articles and he loves to share and discuss his ideas by giving presentations on conferences.



Recordings from Uwes Introductory Talk (30 min):

Uwe Friedrichsen.pdf  (includes embedded audio if you open it with Adobe Acrobat)

Uwe Friedrichsen.m4a (audio only)


Presentation on Slideshare

Link to the architecture documentation template I mentioned: http://www.arc42.de/



15:00 Sandro Mancuso: Crafting Object-Oriented code (Room "Mexiko")

In this session developers will work in pairs to solve a given code kata.

BUT WAIT! There are rules. Developers will be presented with a set of rules they need to stick to, driving their design towards object-orientation and crafted code. TDD is mandatory. At the end, a couple of pairs will present their code and we will discuss what we learned. Bring a laptop with your favourite tools installed. Suitable for any Object-Oriented language.

Some of the rules will be based on, but not limited to, Jeff Bay's essay titled "Object Calisthenics". Jeff's rules are: 1. Use only one level of indentation per method. 2. Don’t use the else keyword. 3. Wrap all primitives and strings. 4. Use only one dot per line. 5. Don’t abbreviate. 6. Keep all entities small. 7. Don’t use any classes with more than two instance variables. 8. Use first-class collections. 9. Don’t use any getters/setters/properties.

About Sandro

Software craftsman and co-founder of the London Software Craftsmanship Community (LSCC). Started his career in 1996 and since then he worked for startups, software houses, product companies, international consultancy companies and investment banks. Sandro spent the majority of his career working as a consultant and during this period he had exposure to many different clients, technologies and industries. Currently he is a director at an investment bank and works as a hands-on mentor, with the main responsibility of improving the quality of the systems and helping developers across five countries, in two continents, to be better at their craft. Twitter: @sandromancuso


Slides with kata details




15:30 Matthew Williams: Introduction to touch typing (Room "Brasilien")

We're going to start with a very simple code kata designed to make us focus on how we use the keyboard. We're then going to look at how we could improve our keyboard skills by starting to touch type or by trying to touch type faster. The middle portion will be open to use some freely available tools to practice touch typing. We'll end by competing against each other to see who can get the fastest WPM!

Session Requirements

Please download: http://www.gnu.org/s/gtypist/

About Matthew

Since graduating in 2006 I have been working at Xyratex Ltd on the software for an automation system that tests hard drives. 2008-2009 saw me in Asia supporting the roll out of one of these systems which lead me away from development, so I had to keep my skills sharp by programming out of hours and reading prolifically, which is when I discovered the craftsmanship movement. During a fairly innocent code kata 3 months ago I realised that I kept looking at the keyboard when I was typing. It was this discovery that made me look into touch typing.



15:30 David Evans: What Testers and Developers Can Learn From Each Other (Room "Rumänien")

The rise of cross-functional agile teams has helped to bring a greater sense of collaboration and mutual respect between developers and testers. But many teams still struggle with the basic issues. What is the role of the tester in an agile team? How many testers do we need? What does a team gain from having professional testers? Perhaps there is another way to approach these questions.

In this talk I present a number of lessons that testers intrinsically understand about software that would be valuable to developers, and vice versa. I also look at the lessons that we all need to learn in order to work more effectively together.

About David

David Evans is an independent agile consultant, coach and trainer with over 22 years of IT experience. A thought-leader in the field of agile testing, he has trained and consulted on this topic for clients in the UK, Ireland, Sweden, Germany, Australia, Israel, South Africa and Singapore. A regular speaker at events and conferences across Europe, David has also had several papers published in international IT journals. He currently lives and works in the UK, where he runs his own company “ThinkAlike Consulting”. He can be reached at david@thinkalikeconsulting.com on email and @DavidEvans66 on Twitter.



Recordings from David's deep dive talk (60 min):

David Evans.pdf  (includes embedded audio if you open it with Adobe Acrobat)

David Evans.m4a (audio only)




17:00 Adewale Oshineye: Repair, Improvement and Developer Experience (Room "Österreich")

This session will attempt to introduce people to Richard Sennett's concept of 'repair.' The session will help people to distinguish between repair and refactoring using the notions of skill, improvement and Developer Experience to guide the participants. The primary techniques used will be small-group discussion of open source projects followed by sharing the knowledge unearthed via a short presentation to the whole group.

About Adewale

I'm the co-author of O'Reilly's Apprenticeship Patterns: Guidance for the aspiring software craftsman

I'm also part of the small team behind http://developerexperience.org/ which is an attempt to see if we can successfully apply the techniques of user experience professionals to products and tools for developers. We call it Developer Experience or #devexp for short.

I'm a Developer Advocate at Google in the Social Web Developer Relations team. In general I work on the stack of protocols, standards and APIs that power the social web. In practice that means I look after the Buzz APIs, Google+ APIs and +1 button with a focus on Europe, Middle East and Africa (EMEA).



17:00 Stefan Roock: SOLID for Dynamic and Functional Languages (Room "Mexiko")

The original description of the SOLID principles is based on statically typed languages like Java. But how does it apply to dynamically typed languages like Ruby or even functional languages like Clojure. The session will start with a short presentation of the SOLID principles and a possible application to dynamic languages. The workshop part will start with the discussion of the application to dynamic languages and proceed to the functional languages.


Session Requirements

For the hands-on part you need a JVM or Ruby (preferable both) on your laptop. I will have prepared example code that I will bring with me on USB sticks since I guess that I won't be able to deliver the example code before Friday. The code examples will also be available at https://github.com/stefanroock/SOLID-for-dynamic-and-functional-languages--Sokrates-Germany-2011-. (In the moment the code on GitHub is work in progress.)


About Stefan

Stefan Roock (it-agile GmbH) is passionate about creating innovate products that make a difference. He started with agile software development in 1999 and has used Scrum, eXtreme Programming, Kanban and FDD since then. Working as a developer, ScrumMaster, coach and trainer in dozens of projects in different companies he collected a wealth of experience with Agile and Lean. He regularly shares his experiences by writing books and articles and speaking at conferences.



Recording of Stefan's introductory talk (20 min):

Stefan Roock.pdf  (includes embedded audio if you open it with Adobe Acrobat)

Stefan Roock.m4a (audio only)



17:30 Oliver Ochs & Roland Jülich: BDD with Javascript (Room "Brasilien")

The concept of behavior-driven development (BDD) was introduced by Dan North in 2003 as a reaction to test-driven development. BDD is a method in software development joining the concepts of test-driven development (TDD), domain-driven design (DDD) and acceptance- driven design (ADD). It’s an agile method to improve the collaboration between developers, quality managers and domain specialists.

Specs are covering the testdriven part of BDD, especially focussing documentation and design aspects. The idea of test cases in BDD is to write them in a way that not only developers are able to understand them. Developers write test cases in natural language and combine them with the test specific language of a BDD framework to express the requirements (specs) of the module under test. A test fails if the module under test doesn’t meet the requirements.

Jasmine is based on JSpec. Jasmine as well as JSpec follow the idea of RSpec, the behaviour-driven development framework for Ruby respectively Ruby on Rails which has been developed by Dan North. Jasmine doesn’t depend on a webbrowser as a runtime environment. Thus it can run within a browser and outside of it for example on an continous integration server or in a special server side environment like Node.js.


About Oliver

Oliver Ochs is head of software architecture at Holisticon AG, a management and IT consulting company in Hamburg. During the last years he worked in projects as developer, architect and project leader supporting teams with his comprehensive and detailed knowledge in JavaScript, Content Management Systems and Portals based on Java. Furthermore he’s experienced in giving professional trainings and coachings. He’s been recently focussing on web-application- security and new aspects of JavaScript.


About Roland

Roland Jülich is Java Consultant working for Holisticon AG, a management and IT consulting company in Hamburg. Since the last four years he worked in software projects as developer and scrum master. His knowledge covers methods of agile software development as well as frameworks around Java with a strong emphasis on frontend technologies. He’s been recently focussing on test-driven development and softwarecraftsmanship especially in terms of web-frontends and Eclipse RCP.



17:30 Thomas Krause: The Forgotten Customer (Room "Rumänien")

When doing product definitions, we often attach too less importance on topics like administration, monitoring, integration, troubleshooting, migration, installation etc. If anything, the related requirements are seen through the eyes of a fronted user, although they mostly apply to the administrator role having different needs.

That often leads to the development of some GUI-based point and click tools that are not suited for using them in administration scenarios because implicit requirements are not met. Administration tools should be consistent across sub systems and products, they must be extensible, (de)composable, steps must be easy to repeat, to automate and to track.

It gets increasingly important to focus on management features. Cloud topologies, more complex systems, security and legal aspects, virtualization and mobile applications are changing system administration more than ever. To be able to respond the behavior of all involved roles must change.

The session is for developers, system administrators, requirements experts and people who are busy between these roles (DevOps). Evolving practices and concepts for the collaboration between development and operations will be presented and evaluated. Technical approaches that (also) help to build better manageable systems will be discussed.

About Thomas

Beside being a mainstream software developer using mainstream programming languages (ObjectPascal, C++, .NET/C#) I worked a lot on the 'dark side of SW development' - doing database development (PL/SQL, T-SQL, SQL etc.). Over time, I paid more attention to topics like backup, troubleshooting, configuration, migration, monitoring etc. The interesting triangle between database developers, administrators and 'client' developers became one of my favorite interests. With the advent of PowerShell in 2006 I ramped up finding best practices and procedures to create better manageable SW systems. I'm especially interested in paying more attention to the concerns of system administrators when designing applications. Since a couple of years I'm in a continuous improvement cycle to get better in agile and clean code principles, currently swiping the whole testing topic in another iteration.





go to schedule


Comments (0)

You don't have permission to comment on this page.