Deprecated: Assigning the return value of new by reference is deprecated in /var/www/ on line 512

Deprecated: Assigning the return value of new by reference is deprecated in /var/www/ on line 527

Deprecated: Assigning the return value of new by reference is deprecated in /var/www/ on line 534

Deprecated: Assigning the return value of new by reference is deprecated in /var/www/ on line 570

Strict Standards: Declaration of Walker_Page::start_lvl() should be compatible with Walker::start_lvl(&$output) in /var/www/ on line 1199

Strict Standards: Declaration of Walker_Page::end_lvl() should be compatible with Walker::end_lvl(&$output) in /var/www/ on line 1199

Strict Standards: Declaration of Walker_Page::start_el() should be compatible with Walker::start_el(&$output) in /var/www/ on line 1199

Strict Standards: Declaration of Walker_Page::end_el() should be compatible with Walker::end_el(&$output) in /var/www/ on line 1199

Strict Standards: Declaration of Walker_PageDropdown::start_el() should be compatible with Walker::start_el(&$output) in /var/www/ on line 1244

Strict Standards: Declaration of Walker_Category::start_lvl() should be compatible with Walker::start_lvl(&$output) in /var/www/ on line 1391

Strict Standards: Declaration of Walker_Category::end_lvl() should be compatible with Walker::end_lvl(&$output) in /var/www/ on line 1391

Strict Standards: Declaration of Walker_Category::start_el() should be compatible with Walker::start_el(&$output) in /var/www/ on line 1391

Strict Standards: Declaration of Walker_Category::end_el() should be compatible with Walker::end_el(&$output) in /var/www/ on line 1391

Strict Standards: Declaration of Walker_CategoryDropdown::start_el() should be compatible with Walker::start_el(&$output) in /var/www/ on line 1442

Strict Standards: Redefining already defined constructor for class wpdb in /var/www/ on line 306

Deprecated: Assigning the return value of new by reference is deprecated in /var/www/ on line 103

Strict Standards: Redefining already defined constructor for class WP_Object_Cache in /var/www/ on line 431

Deprecated: Assigning the return value of new by reference is deprecated in /var/www/ on line 61

Deprecated: Assigning the return value of new by reference is deprecated in /var/www/ on line 1109

Strict Standards: Declaration of Walker_Comment::start_lvl() should be compatible with Walker::start_lvl(&$output) in /var/www/ on line 1266

Strict Standards: Declaration of Walker_Comment::end_lvl() should be compatible with Walker::end_lvl(&$output) in /var/www/ on line 1266

Strict Standards: Declaration of Walker_Comment::start_el() should be compatible with Walker::start_el(&$output) in /var/www/ on line 1266

Strict Standards: Declaration of Walker_Comment::end_el() should be compatible with Walker::end_el(&$output) in /var/www/ on line 1266

Strict Standards: Redefining already defined constructor for class WP_Dependencies in /var/www/ on line 31

Strict Standards: Redefining already defined constructor for class WP_Http in /var/www/ on line 61
books « Serverdude

Archive for the ‘books’ Category

The Nature of Software Development

søndag, september 21st, 2014

Great book on a difficult topic: What software development should be like for the best possible outcome for both developers, company, and customers.

When you have tasted freedom, and revered the respect that you probably know what you’re doing. When you have tried the true aspects of autonomous teams it is the more detrimental to have to work with a micromanaging and secretive project management hierarchy.

But what are the odds that such companies will actually read, understand, and implement the insights in the book?

Hopefully this book will instill trust in the rigid companies insisting that waterfall process with a single release is the only way. In that sense software remains invisible as the clothes in The Emperor’s New Clothes or The Emperor’s New Software.

ISBN: 978-1-94122-237-9

This is in regards to the Beta 1.0 release of the e-book  release on 2014-09-08 (in ISO 8601 format)

The Essence of Software Engineering: Applying the SEMAT Kernel

tirsdag, juni 4th, 2013

The book, “The Essence of Software Engineering: Applying the SEMAT Kernel”, is written by Ivar Jacobson, Pan-Wei Ng, Paul E. McMahon, Ian Spence, and Svante Lidman. Published by Addison-Wesley, January 2013, ISBN: 978-0-321-88595-1

I am a bit confused. I had the notion that this was about improving software quality through the application of a rigorous set of rules. Section 1.1 “Why is developing good software so challenging?” seems like we’re on the right track. But I find that it has not that much to do with Software, nor Engineering. It seems it is a method for applying rules and visual indications for the progress of tasks by people for people. Which means that to me at least, this book is more about general project management than anything near software or engineering.

I found the tone of the book to be rather preaching and praising of this new found holy grail, the Kernel, all praise the Kernel, apply it to anything and everything. A common phase throughout is: “How can the kernel help you.” The kernel consist of just about 57 cards, but can be extended. Seems like the marketing managers choice for gamification Yu-gi-oh!-style.

I’m all for simple and concise ways of working. I do believe that visual aids can support collaboration and communication as well as bring a quick overview, and that these are needed for projects to succeed, but they are not all which is needed.

I believe in the “as simple as possible, but no simpler.” - as Einstein put it. As well as Antoine de Saint-Exupéry’s “You have achieved perfection not when there is nothing left to add, but when there is nothing left to take away.”

Throughout the book the Kernel will simply help do everything, it’s a veritable Swiss Army knife. I don’t think I’ve seen any professional choose the Swiss Army knife above their own set of tools. While the Kernel is lightweight - at least compared to RUP - then there are alternatives, which are even more lightweight, e.g. Impact Mapping.

To me it seems that applying the Kernel kind of looks like Kanban with a “work in progress”-board. But then it also looks a bit like a concurrent waterfall, which could be due to the fact that I read RUP and UML into the stuff that Ivar writes. Both of which were praised. In my opinion wrongly so. UML is great for back of the napkin illustration of concepts, a variant worked wonders in the Design Patterns book, but UML in the latest incarnation seems overly verbose as a modelling language - under the notion that a model is a simplified abstraction of the real thing.

Perhaps Ivar is biased from electronic engineering with all their symbols and glyphs (Try looking for IEC 60617 on Google). But what he fails to realize is that those symbols are really their programming language. For software development, we have our own programming languages, and we don’t need a modelling language to go into minute details - at least not as a document. If you generate the model from the source code you can apply as much details as you want, but believing that a change is applied both to the model and to the source code is betting against the DRY principle: Don’t Repeat Yourself.

Why do have a sense of concurrent waterfall? Well, the cards follow 7 aspects, called alphas: Opportunity, Stakeholders, Requirements, Software System, Team, Work, and Way of Working. While I agree to these, and their connections noted in the graphs, e.g. Figure 2-1 on page 15 (not shown here), then there is a notion of the 5 or 6 steps, and seemingly you can only progress, e.g. from Opportunity :: Identified to Opportunity :: Solution Needed. And while that might be true for opportunities, then I don’t see why Way of Working :: Working Well will stay there until the project is done.

Some of the praise in the book is from academia, and while it is easier to teach a rigorous system, it may still not be the right thing to do - at least it hasn’t helped adding UML, RUP, etc. to the curriculum.

In the praise section, Ed Seymour notes that: “This book represents a significant milestone in the progression of software engineering.” I’m sure that any book is a milestone in its domain, I just feel that this book is a milestone along a different road going in the, not quite right, not quite wrong, direction.

Uncle Bob - one of the three to write a foreword - wrote: “After reading the book, I found myself wanting to get my hands on a deck of cards so that I could look through them and play with them.” I felt the same at the beginning of the book, but now I’m thinking more about which game to play, and how many expansion packs will be published in the future.

All in all I’m quite disappointed with the contents of the book, though I’m sure it’ll get wide adoption, and we will be off course for another 10 years. Some of the contents is true and solid, the rest - apart from the intentionally left blank pages (all 34 of them approximately 10% of the book) - seems to me to be more of an academic solution to something which is only half the problem. It is easy to prove me wrong though - apply the Kernel to 12 or more different and average teams and have them develop successful software solutions on time and on budget for projects around the $5-10 million budget. Public projects seem to fare really poorly, that would be an interesting case to follow. If more than 1 project fails, then the Kernel is not the holy grail, depending on the success rate, we could argue whether or not the method is helpful at all.

I’m more disappointed with this book than I was reading Impact Mapping, which at 86 pages is about 25% of The Essence of Software Engineering, but with more information about applying the method, which is far easier if you can remember the correct order: Why, Who, How, What.


Java Application Architecture

tirsdag, oktober 2nd, 2012

Kirk Knoernschild’s book, Java Application Architecture: Modularity Patterns with Examples Using OSGi, ought to be made superfluous, but as it stands it is direly needed.

At least the first two parts: “The Case for Modularity” and “The Patterns” should be known by heart by any Java developer. It should be second nature for disciplined and professional developers.

In “The Case for Modularity” Kirk goes over the definition of what a module is, whether architecture is a phase carved in stone in the beginning of a project, or whether it is pervasive and should be attended to all the time.

How growing complexity must be countered by disciplined maintenance.

Why Technical Debt and Design Rot must be cleared to keep the source code from succumbing to the development death spiral.

Why cyclic dependencies must be rooted at all costs.

And what the benefits of modular structures are.

While you may think that a given piece of software is not ripe for modular extraction, because it will never be replaced or reused elsewhere. This is not the right attitude, as the first or second use of the source code is the test cases preferably developed in sync with the source code, either in a TDD or BDD way. It is simply easier to unit test a unit, no matter how big that unit is.

Finally – just to prove that this is not hot air preached from the pulpit – Kirk refactors a small application in 7 steps each a tiny isolated step improving on the overall structure. This is how software should evolve once it has fallen prey to design rot.

The second part of the book, The Patterns, describes 18 patterns in 5 chapters, which Kirk has made available here:

The Base Patterns:

  • Manage Relationships
  • Module Reuse
  • Cohesive Modules

Dependency Patterns:

  • Acyclic Relationships
  • Levelize Modules
  • Physical Layers
  • Container Independence
  • Independent Deployment

Usability Patterns:

  • Published Interface
  • External Configuration
  • Default Implementation
  • Module Façade

Extensibility Patterns:

  • Abstract Module
  • Implementation Factory
  • Separate Abstractions

Utility Patterns:

  • Colocate Exceptions
  • Levelize Build
  • Test Module

The third part concludes with examples in OSGi, covering Java, Scala, and Groovy implementations.

The book is a must read and must understand for (Java) developers and architects.

I highly recommend the book for anyone interested in modularity, especially developers looking at an existing code base resembling a big ball of mud who wants to disentangle it.

Pragmatic version control using Git

tirsdag, september 20th, 2011

Written by Travis Swicegood published by The Pragmatic Bookshelf, 2008, ISBN-13: 978-1-934356-15-9

At 184 pages this is a short book on Git, but it does cover the bare necessities and then some. Apart form 3 appendices the information is added in 11 chapters:

  1. Version control the Git way
  2. Setting up Git
  3. Creating your first project
  4. Adding and committing: Git basics
  5. Understanding and using branches
  6. Working with Git’s history
  7. Working with remote repositories
  8. Organizing your repository
  9. Beyond the basics
  10. Migrating to Git
  11. Running a Git server with Gitosis

While Git is more complex than the book can explain - and it doesn’t try to explain everything, it is pragmatic after all - I would say it covers the Pareto 80% of the standard user’s needs.

Following the Pragmatic tenor the book does the job of demystifying Git without attacking Subversion or CVS - or any of the other distributed version control systems. Chapter 10 handles the issue of migrating from SVN or CVS (via SVN) to Git.

As a side note to this, I would add that I think filesystems are stupid in the sense that they ought to have changed to transaction based systems at the time disk space was sufficient for this kind of storage, and that the ’save’ button in every application ought to simply do something akin to a Git commit. IMHO the snapshot way we currently use is simply stupid.

While there are some nifty tricks you can do with Git with regards to the history I think it should be mentioned that these tricks are better left only for your personal branches and not for a shared commit. That is, it is okay to modify the order and squashing branches before you push or allow others to pull.

It’s kind of funny that the single biggest benefit of using Git - as I see it - is the personal revision control, and that isn’t mentioned in greater terms, though Travis does mention the benefit when he was working with a Subversion repo - see the box “Being the Git: Using Git in a Subversion Company” on page 141.

I would have liked to have seen some recommended workflows for different setups as well as some developer discipline guides, i.e. branch before you do anything new, have a working solution you’d like to be able to return to? Commit! Even after a working unit test.

The book is a fast and okay-to-good read.

Building and testing with Gradle

onsdag, september 7th, 2011

Written by Tim Berglund and Matthew McCullogh published by O’Reilly, ISBN: 9781449304638

The only book out there on Gradle, and it is relatively new published July 2011. At 110 pages it is rather short, and doesn’t cover everything about Gradle - it’s not a ‘Complete guide to Gradle’, but the 6 chapters cover the basics in the obvious ways:

  1. Hello, Gradle!
  2. Gradle Tasks
  3. Ant and Gradle
  4. Maven and Gradle
  5. Testing with Gradle
  6. Multiproject Builds

The book does provide pointers for migrating from e.g. Maven to Gradle. As I’m not intimately familiar with neither Maven nor Gradle, I can’t really say if it is sufficient to jump from Ant directly into Gradle, or if a quick pit-stop in the Maven (3?) camp is beneficial.

There are a few kind of typos in the book, e.g. Example 1-5 the src directory seems to be a subdirectory of the build.gradle file, this is fixed in Example 1-6 though.

There’s also a minor issue with the doFirst() method - I’d suggest saying that this would prepend or prefix the closure to the existing block as opposed to saying appending to the beginning.

The book is more concise and better organized than the Gradle user guide which seems to do a halfbaked description, then referring to a later chapter.

Running some modified examples from the book - not from the github repository - I experienced a rather detrimental blow up when applying the plugins for Scala and Groovy. The compiler dependencies need to be added to the build file.

Being the only book on the subject it’s sad that it’s not a Complete Guide, but it does fulfill what the title promises, it’s just not enough. An okay read though.

Drive: The surprising truth about what motivates us

søndag, juli 24th, 2011

Finally I got to read Daniel Pink’s book: Drive.

It’s a good book, but as someone mentioned you could get a long way with just the talks he has been giving. Nevertheless, the book tells a few truths on the problems with the conventional wisdom popularized by Taylor early in the 1900’s. Assuming that Taylor was wrong - and I must say that I didn’t need Pink to convince me of that, but it’s good to know that I’m not alone in this assumption - what could be a more fitting motivational approach for the 21st century’s workers, the creative minds?

Autonomy, Mastery, and Purpose.

Autonomy in what you do, when you do it, who you do it with, and how you do it. As long as you do whatever is needed and in a timely fashion.

Mastery - you will never achieve it, as you can always grow and become better at what you’re doing. Mastery requires the pursuit of the better self.

Purpose - we need a reason beyond Maslow’s needs for doing what we’re doing.

Pink tells us about the Intrinsically motivated (I) and the Extrinsically motivated (X) people. Which kinds of tasks can be seen as fit for extrinsic motivation, e.g. payment, and why something may be better with an intrinsic motivation.

I’m not quite sure, how you’ll go by and ignite the intrinsic motivation for everything, but it sure sounds like a good idea to drill down to the core and find the intrinsic motivation to get going.

Of course, we get the mention of Mark Twain and Tom Sawyer’s whitewashing of Aunt Polly’s fence.

Who should read it?

Anyone! But especially parents, teachers, leaders, and managers.


søndag, juli 24th, 2011

Gamestorming is a really nice collection of different games to play during a brainstorming session, or any other meeting requiring some different attack vectors - sometimes just to keep the meetings fresh and interesting.

The collection is a diverse set of different games ranging from short time, few people to long time, a lot of people.

Most of the games don’t require more than pens, post-its, and flipovers or whiteboards.

If I was to have more meetings than I’m currently involved in, and if those meetings were with collocated participants, then I’d love to use some of the games listed in the book.

Some of the games make me think of ‘The back of the napkin’ by Dan Roam (an excellent and inspiring book), and some of the games make me think of Esther Derby and Diana Larsen’s book: ‘Agile Retrospectives’ Needless to say that some of the Gamestorming games would fit a retrospective perfectly.

In this digital age, it puzzles me that I haven’t seen a plethora of utility software for this kind, e.g. a best match for meeting and games. But then, I may not have been looking.

The book is organized into 8 chapters:

  1. What is a game?
  2. 10 essentials for Gamestorming
  3. Core Gamestorming skills
  4. Core Games
  5. Games for Opening
  6. Games for Exploring
  7. Games for Closing
  8. Putting Gamestorming to work

So, who should read it?
Well, anyone participating in sufficiently many meetings where people tend to get stuck or wants to try a different approach. There are different ways to hold meetings.
Meeting leaders looking for a different way to motivate people, or perhaps to get a different kind of action.
Consultants, project managers, …

Gamification by Design

fredag, juni 17th, 2011

The book starts out with what has become Gabe Zichermann’s
standard take on Gamification, and with good reason, as it covers
the basic introduction to the subject, as well as some of the
conundrums, thus we pass by:

  • Broccoli
  • Where in the World is Carmen San Diego
  • Greenstamps
  • 10:1
  • SAPS
  • Project Runway vs. Deal/No Deal

We get a short introduction to Flow by Mihaly Csikszentmihalyi,
operant conditioning, Skinner boxes, Bartle player types, and why
people play. These are fundamental things for people in games not
just for people interested in gamification.

I don’t quite get the linear level description:
[PDF] Page 49 “In game design, level difficulty is not linear. In
other words, level one is not half as complex as level two, which is
not half as complex as level three, and so on. Instead, difficulty
increases in a curvilinear form.”

As I read this, then the description says:
lvl1 = 1/2 lvl2
lvl2 = 1/2 lvl3
but then lvl1 = 1/4 lvl3 - this is not linear but a power function:
lvl n = 2^(n-1) lvl1

Which is quite similar to the D&D and AD&D level progression tables, and curvilinear to boot. That said, it is an ‘Early Release’ and it could be fixed.

Then we get to Leaderboards and Badges - the “ooh, I think we can do that”-slap-on and call it Gamification that a lot of people are saying is “the only way” of doing gamification for anything and everything. That is not Gabe’s way of doing it, but as the book is a sort of cookbook, it seems stupid not to touch upon the subject.

The Ruby implementation of a point scoring forum I could live without, but - again - it would seem weird to have a cookbook without examples.

There’s an introduction to Bunchball integration including some rather useful tips on what to be aware of when designing.

The big hit, I would say, is the sadly brief coverage of the virtual economy, this time using BigDoor as an existing API vendor.

All in all: Yet another “required read” by Gabe Zichermann and Christopher Cunningham

Gamebased Marketing

lørdag, marts 12th, 2011

One of the ‘need to read’ books on gamification. The book may seem average and simple, but it is nonetheless worth a read. For anyone serious in the gamification business it is a required read.

The book provides a set of steps for starters into gamification under the premise that gamification should not have to cost the provider any money.

While some of the advice given seems elementary it is still important to follow or at the very least be aware of, e.g. Barrier to entry.

There are a few elements which seem rather American - and I don’t see a way to make this generally acceptable for any culture.

There is - in my mind - no doubt that Gamification will influence our lives in the future. I can’t wait for it to be introduced at a political level.

Gamebased marketing is not about sugaring marketing campaigns, it’s about making playable games first, then tie in the thing you want end users to do.

Cows in the Maze

mandag, januar 31st, 2011

- and other mathematical explorations

21 chapters of mathematical recreation. Usually I find the professors books rather entertaining, but I must say I’m feeling a bit disappointed about this volume.

It’s off to a good start with “the Lore and Lure of Dice” - the context specific reflection on the question of probability, and the non-transitive dice. Then quickly passing Piet Hein’s board game Hex.

Why we’re introduced to Tarzan and Jane in the midst of an otherwise interesting subject, “Walking with quadropeds” - the patterns of the gaits of four legged animals, I have no idea.

Chapters 7, 8, and 9 touches upon time travel, which - as I recall it - is much more physics and sci-fi than mathematics. Luckily though chapter 10 serves a nice gem - Cone with a Twist - the sphericon.

Chapter 11 touches upon the shape of a drop, and in chapter 12 we’re back to probability and fallacies in The Interrogator’s Fallacy, where we now use Bayes’ theorem and Mathews’s formula. There’s an error in the formula printed on page 173 at the top though, it should be:
P(A|C) = P(C|A) * P (A)/ P(C)

Then we get to the title chapter: Cows in the Maze. And while it has cows and is kind of a maze - it’s not a standard maze, it’s a maze of logic statements.

Leaving the maze on a Knight’s Tour into Cat’s Cradle over Klein bottles (and Möbius bands) into Voronoï celled craters into knots, which again I found a bit disappointing.

The construction of Most Perfect Squares are matched up with Mathematical impossibilities.

The final chapter of the book regards dancing with strings forming regular solids.