These are my unstructured notes on ACCU2009:

• I was asked to participate in the C++0x standardization committee (process startet)
• I was further asked, if HSR could host the European meeting in 2010 or 2011?

• A chat with Russel Winder revealed that
  • shared memory will not scale, but CSP like architectures will be needed
  • Debugging and Testing CSP/Dataflow architectures will be a big research question

• Francis Glassborow said, we should look at MIT's scratch language and the user provided examples. Children who grow up with that will be our next challenge to get them back to the basics of programming.

• Alisdiar Meredith asked for some new Refactorings towards C++0x
  • old-style C++ towards C++0X
  • substitute loop by algorithm (with lambda extraction)
  • using X=Y; instead of typedef Y X;
  • auto for variable types
  • lambda/auto new function decl style auto f() -> int
  • subst bind1st/bind2nd with bind/lambda ?
  • consistent {} initializer lists
  • + introduce PIMPL

• Books to get:
  • ID (Susan Greenfield) -> bought at conference
  • Beautiful Architecture
  • Beautiful Teams
  • Code Quality (Spinellis)
    • Steht bei mir im Regal --Mirko
  • Systematics. How Systems really work (J. Gall)
  • Longitude (David Sibel)
  • Subject to Change (Peter Merholz, et al)
  • Changing Software Development (Allan Kelly)

1st day ^

tutorial Alisdair Meredith

• concept compilers >5years
• gcc 4.4 has a lot of new stuff (auto, initializer lists, variadic templates) but not concepts, new for loop, etc.

  #include <memory>
  template <typename ... Typelist>
  struct VariadicTemplate {};
  using namespace std;
  template < typename T >
  unique_ptr<T> factory() {
  	unique_ptr<T> c(new T());
  	return c;
  }
  int moveit(){
  	std::unique_ptr<int> p =factory<int>();
  	std::unique_ptr<int> q=move(p);
  	int i=5;
  	return i;
  }
  void testOnlyOne() {
  	one theOne;
  	auto x = VariadicTemplate<one, int, two>();
  	auto two=theOne;
  	ASSERT_THROWS(one(),std::logic_error);
  	ASSERT_THROWS(one(theOne),std::logic_error);
  }
  

2nd day ^

keynote Bob Martin

• "we now have the chance of becoming a profession"
• SCRUM crossed the chasm, but lacks essential technical practice:
  • TDD, Refactoring, CI, Pair Programming
  • we now now what to do.
• article Martin Fowler on the fallacies of SCRUM (research link)
• very entertaining
• there is hope for a change, because of SCRUM showing the declining productivity to management
• sign the Software Craftsmanship Manifesto http://manifesto.softwarecraftsmanship.org

Fresh Paint - Alisdair Meredith

• use of new C++ 0x features to improve existing code
• auto (available from gcc 4.4)
• initializer lists (available from gcc4.4)
• new for loop with initializer list (not available, requires concepts)

  int main(){
     for (auto i : { 1,2,3,4,5,6}){
         cout << i*i << endl;
     }
  }
  

• lambda (not available from gcc4.4)
• string literals for unicode and raw
• "chaining" ctors and member initializers (like java)

Parallel Pixie Dust - Jason McGuiness

• innovative library for "auto-parallelization" with thread-trees -> no deadlocks, optimal schedules
• doesn't compile with current compilers --> too much template trickery (pixie dust :)

Evening Keynote Nico Josuttis: Welcome Crappy Code

• there will be bad code throughout, triviality not simplicity
• forget that you can get clean code at all
• controllers actually run projects, so there is no time for quality
• majority of developers are bad
• copy-paste versions instead of refactoring
• refactor only asynchronously
• very contrasting to Bob Martin

3rd day ^

Linda Rising Keynote on patterns

• exmplained the pattern community and what happened

Simplicity Workshop

• too many participants
• results on http://wiki.hsr.ch/SimpleCode
• audience wrote simplicity patterns (20+ patterns, ~50 pattern names)
• next year: more focus, e.g. small (code) simplicity patterns

Antony Williams: C++0x concurrency

• futures, etc. thread objects start with creation and join with destruction
• mutexes, shared queue, etc.
• unique_future, shared_future for single values with exception propagation

Mark Dalgarno - Reverse Engineering Patterns- I wouldn't start here if I were you

• bailed out to

Andrej Alexandrescu - Iterators are out, Ranges are in

• gives reasoning that C++ iterators are broken and introduces Ranges
  • 3 operations: is empty, get first element, drop first element
• iterator doesn't know when done (only corresponding end() helps with that)
• safe iterators hard to implement
• implemented ranges for D
• ranges allow infinite or indetermined ranges
• ranges allow easy combination (concatenation, n ranges in parallel)
• C++ 0x should adopt them

Lightning talks - very inspiring and short time-boxed

• Kevlin Henney
• ...

day 4 (friday) ^

Keynote about women in science (susan greenfield)

• brain
• important "Get a Mentor who believes more in you than you do!"

Steve Love

• good example for the broken 3-tier architecture with too close coupling
• portable code == testable code

Olve Maudal - BoF

• refactor/change bad C++ in very small steps
• didn't agree with all proposed refactorings
• still using no IDE (only EMACS) what a shame Eclipse CDT would have made some refactorings simpler.

Andrej Alexandrescu

• Policy-based design revamped
• Scott Meyers article "Red Code - Green Code"
• orthogonal features as types: combinable, transitive, contravariant

Lightning talks (5 min each)

• Olve Maudal: your code is like your kitchen - keep it clean for professionals + Semmelweis story for washing hands before treating patients
• ?? : new features of git (git stage, ...)
• one fat guy from Zühlke (I forgot what his slides where about)
• Schalk Cronje: Security and botnets are really a threat to the individual (explained the connection between botnet "owners" and the mafia where I was playing the role of the Security expert publishing a vulnerability)

day 5 (Saturday) ^

Allan Kelly

• keynote on agile management (need to get book)

Dietmar Kühl

• Programming the Cell processor
• demonstrated architecture of the Cell vector processor
• can get 6 available Cell cores with a Playstation 3 (plus IBM Power PC core)
• a bit retro, since each Cell runs 1 thread (without MMU) and has a limited amount of 265k memory (no memory protection, interrupts, DMA)
• library for accessing the Cell cores is a bit too complicated to use (Dietmar didn't show much wrapping though)
• interconnection through a set of DMA memory interfaces with some kind of "global address space"
• a Cell program can only use the 256k Bytes
• each instruction 128 bit vector instruction -> 2 doubles, 4 ints/floats, 16 bytes
• Linux on PS3 available for free (no access to the GPU)

Peter Sommerlad

• my talk in the afternon, low attendance, but went well

got home safely.