David Gardiner - Books

Summer holiday reading

2021-12-28T15:00:00.000+10:30

It's Summer holidays, Christmas was a few days ago, there's sunny, warm weather on the forecast. Perfect days for lazing around home and reading a good book or two.

I happen to be passing Blackwood Books recently (we were actually visiting an adjacent shop but I thought I'd have a quick look). I asked to see their 'local history' section and was taken along some winding corridors to a couple of bookcases full of books. I didn't have that long to browse, but two books looked interesting.

Not Only in Stone

(Affiliate link)

Not Only In Stone by Phyliss Somerville was first published way back in 1942. It tells the story of Mary (Polly) Thomas and her family, who emigrated to South Australia from Cornwall, England in 1865. It caught my attention as parts of the story are based in Wallaroo, Moonta and Kadina - towns on the Yorke Peninsula that I have some family connections of my own. It is a fascinating snapshot of early colonial life.

I'm two thirds through the book as I write this. So far Polly has endured numerous hardships, but is not deterred in providing for and making a home for her family. I'll be interested to see how it ends.

A Sacred Trust: The Uniting Churches in the Mitcham Hills

At first glance a possibly unusual pick. I grew up in the Mitcham Hills area, and have been involved in the Methodist and then Uniting Church my entire life. This book, written by Rosemary Mitchell and published back in 2000, traces the history of the many Uniting Churches that were and continue to be in the Mitcham Hills area. I have a vague recollection of being aware of the book, possibly around the time it was launched, but I didn't have a copy and a few people I've talked to since also had either forgotten or didn't know about it.

The old history is fascinating, and just the effort (especially in the early days) that people put into ensuring that they had worship services was inspiring. Take this quote from page 6 (discussing the travelling preachers did in the 1850s)

Later Mr Illman who lived at Unley would walk to Cherry Gardens in the morning, walk on to Clarendon for the evening service and walk back to Unley

That's a decent drive in a car today, let alone walking on foot. Google Maps suggests that's around 50kms! Possibly in the 1850s you might have been able to take a more direct shortcut across the hills from Cherry Gardens to Clarendon, but that's still astounding.

In the latter sections, there are lots of familiar names. Families and people I knew when I was growing up (and some I'm still connected to). Fun fact, I'm actually mentioned in the book too! (via my volunteering with the Blackwood Youth Project back in the 1990s). That was a pleasant surprise.

There's a few passing mentions of indigenous people living in the area in the early days. It would be interesting to find out more about that - might need to see if there's any other books that cover Aboriginal history of the area in more detail.

I don't know if the book is still available anywhere. I'll make some enquiries to see if it's still for sale, otherwise I might have to lend my copy out to friends and family that found it interesting.

Get programming in F#

2018-06-11T20:35:00.000+09:30

I’m really interested in learning more about functional programming. It isn’t something I knew much about, but the benefits of reducing mutability (and shared state) promoted by functional languages and functional style are enticing.

To that end, I recently bought a copy of Isaac Abraham’s new book “Get programming in F#. A guide for .NET Developers”.

I have no background in functional languages at all, so I was looking for a “gentle” introduction to the F# language, without getting hung up on a lot of the functional terminology that seems to make learning this stuff a bit impenetrable for the newcomer. This book delivers.

The structure of the book is in 10 “units”, which in turn are broken down into separate “lessons” (each lesson is a separate chapter).

Here's my notes from each unit:

Unit 1 – F# and Visual Studio

Introduces using the Visual Studio IDE for F# development, and recommended extensions. Surprisingly for a book published in 2018, most of the book is based on using Visual Studio 2015. I can only presume this is an artifact of the time it takes to write a book. I understand the initial release of 2017 did have some tooling regressions for F# but I am under the impression those are now resolved, seeing at my time of writing the 7th update for 2017 has just been released, including specific enhancements for F#.
Throughout the book, comparisons are made to equivalent C# language constructs, and here too, the text is already a bit dated. An unfortunate downside of a printed book I guess.
One thing to note that is different from many other languages – the file order in F# projects is significant. You can’t reference something before the compiler has seen it, and the compiler processes files in project order.
The REPL is also a big part of F# development.

Unit 2 – Hello F#

The ‘let’ keyword is introduced. It’s more like C#’s const than var, seeing as F# defaults to things being immutable rather than mutable.
Scoping is based on whitespace indentation rather than curly braces.
Diving into how the F# compiler is much stricter because of the way the F# type system works, and how that can be a good thing.
A closer look at working with immutable data, and how you can opt in to mutable data when absolutely necessary, and how to handle state.
C# is statement based, whereas F# likes to be expression based.
The ‘unit’ type is introduced. It’s kind of like void, but is a way for expressions to always return a value (and means the use of those expressions is always consistent).

Unit 3 – Types and functions

Tuples, records
Composing functions, partial functions, pipelines,
How do you organise all these types and functions if you’re not using classes? Organising code through namespaces and modules

Unit 4 – Collections in F#

Looking at the F#-specific collection types – List, Array and Seq, the functions you can use with those collections. Immutable dictionaries, Map and Sets. Aggregation and fold.

Unit 5 – The pit of success with the F# type system

Conditional logic in F#, pattern matching
Discriminated unions

Unit 6 – Living on the .NET platform

How to use C# libraries from F#. Using Paket for NuGet package management
How to use F# libraries from C#

Unit 7 – Working with data

Introducing Type Providers. Specific use cases with JSON, SQL and CSV.

Unit 8 – Web programming

Asynchronous language support
Working with ASP.NET WebAPI 2
Suave – F#-focussed web library
Consuming HTTP data

Unit 9 – Unit testing

The role of unit testing in F# applications
Using common .NET unit testing libraries with F#
Property-based testing and FsCheck
Web testing

Unit 10 – Where next?

Further reading and resources to take your next steps.

Book review: Why

2016-02-14T23:06:00.001+10:30

As part of their support for user groups, O’Reilly sent me a free copy of “Why: A Guide to Finding and Using Causes” by Samantha Kleinberg to review.

Kleinberg is an Assistant Professor of Computer Science, so I was interested to see what she had to say about finding “causes”. It probably wouldn’t be the first book I chose if I was browsing, but I’m always interested in learning new things.

What I liked about this book was the use of written examples and illustrations. The first chapter opens with the story of Sally Clark. A tragic miscarriage of justice that resulted in Clark serving 3 years in prison for the murder of her babies. One of the significant pieces of evidence that was used to convict Clark was the suggestion that the probability of two babies dying of SIDS was 1 in 73 million. This is wrong, because the witness (a medical expert) didn’t understand statistics and probability. The expert witness believed Clark was the cause of death the two babies.

The Clark story isn’t the only one told. I’m glad for the generous sprinkling of those examples – without which it would be pretty dry going. It is very helpful to bring things back to something you can relate to.

A warning, this is a pretty in-depth book. I can’t say I found it an easy read, but there’s plenty of detail there.

Before reading this book I guess I assumed that finding the cause for something was a pretty straight forward. Turns out the correct method is “it depends”.

Trying to identify the real cause of an event is not always easy. Kleinberg takes us on a journey to better understand ways (and there are more than one) of finding causes – Beginnings (concepts), Psychology (how do we learn about causes), Correlation (correlation and causation aren’t the same thing), Time, Observation (watching to learn), Computation (automating the process), Experimentation (experiments and research), Explanation (this caused that), Action (making decisions).

The writer comes from the Computer Science field but she writes in a generally accessible (if a little bit academic) way. There are plenty of references (the notes and bibliography take up a not insignificant amount of the book). I noticed a lot of examples were medically-related, so if you work in the medical field, then I think you would get a lot out of it too.

Finally, a suggestion for the title of the sequel – “Just Because” 😀

Extending WinForms controls

2014-02-02T15:58:00.001+10:30

I've been looking at ways to extend and enhance .NET WinForms controls recently and thought I'd summarise what I've found/learned so far.

Inheritance

The most obvious way to extend a control is to create a new class that inherits from the existing class. You then have full access to add new properties and methods and access any protected methods from the base class.

It does mean that if you've already used the control in your application, you're going to have to replace references to the base class with your new class – not always easy.

IExtenderProvider

Another option is to create a class that implements the IExtenderProvider interface. You can then create a component that can be added to a form or user control that extends specific types. An example of this that ships in the framework is the ToolTip class. When you drag this control onto a form it doesn't add a visible control to the design surface. Instead it adds a new ToolTip property to appropriate controls on the same form.

Custom ComponentResourceManager

A more specific area of WinForms controls that you might want to customise is the localisation support. Localisation for controls on a form is enabled by setting the Localizable property of the form to true. This also alters the designer-generated InitializeComponent method to add a new resources variable of type System.ComponentModel.ComponentResourceManager. This allows you to use .resx resource files to load locale-specific values for properties. This is the standard way that you would provide alternate language translations for your application.

A question on Stack Overflow asked about replacing this implementation with another that could load resources from an alternate location (such as an XML file or a database). The accepted answer pointed to some samples from Guy Smith-Ferrier's book, .NET Internationalization: The Developer's Guide to Building Global Windows and Web Applications.

Impressively, even though the book was published in 2006 Guy has been releasing regular updates to the code samples at http://www.dotneti18n.com/Downloads.aspx. His sample for a custom ComponentResourceManager includes a ResourceManagerSetter class that has the DesignerSeralizer attribute. This was new to me, but it turns out this is the mechanism that generates the code that appears in a forms's .Designer.cs file. This uses the CodeDom to generate code that inserts the replacement ComponentResourceManager instance.

private void InitializeComponent() { System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(UserControl1)); this.resourceManagerSetter1 = new Internationalization.Resources.ResourceManagerSetter(); this.label1 = new System.Windows.Forms.Label(); this.SuspendLayout(); Internationalization.Resources.ResourceManagerProvider.GetResourceManager(typeof(UserControl1), out resources); // // label1 // resources.ApplyResources(this.label1, "label1"); this.label1.Name = "label1"; //

Using CodeDom means that the code is generated for the appropriate language automatically. The only requirement is that this component must be the first one added to the form. If you're adding this to an existing form with controls, just go to the Designer.cs file and move the line calls the constructor to the top of the InitializeComponent method. (The order of the calls to the constructors seems to determine the order in which the serialized code generators are called)

You can see from the code sample above that the original instantiation is still there, but is effectively replaced by the call to the GetResmourceManager method.

MSDN has more info on Globalizing Windows Forms.

Lean from the Trenches by Henrik Kniberg

2013-05-23T22:55:00.001+09:30

I was introduced to "Lean Thinking" by my friend Jane, who's been involved in applying the "Toyota Production System" principles in a major public hospital setting (not the first place you'd think of finding something that was created by a car manufacturer). After learning about Lean and considering that it seemed to have some overlap with the Agile software development processes that have become more popular in the last 10 years, I then discovered the work of Tom and Mary Poppendieck who had published Lean Software Development: An Agile Toolkit, the first of 3 books on the subject.

Reading their work is still on my 'to do' list, but it was while I was reviewing their recommended reading list that I decided to purchase Kniberg's book.

Lean from the Trenchesis an fascinating case study in applying Lean and Kanban to the development of a software application for the Swedish Police. Kniberg worked as a coach part-time on the project for about 7 months before publishing this book. As I understand it, this was a 'greenfield' application (which might explain how they could do the 30 bug limit).

I found this book very interesting. In particular, the following stood out for me:

the regular Process Improvement Workshops – initially a weekly cross-team meeting to look at implementing change quickly
the way they used Kanban and the changes made over time to the board to make it work better.
Identifying recurrent bugs with root-cause analysis
Having limits for work in progress (which doesn't include bugs)
Not using story points (though features are estimated with Small/Medium/Large T-shirt sizes)
The "Next 10 features"
Balancing features and 'tech stories' (technical debt)
Limit list of bugs to be fixed at 30!
Testers working in development teams
Many bugs get fixed immediately if possible
Importance of visualisation and communication

I'm most familiar with Scrum, so there was a reasonable amount of familiarity with some of their practises. The focus on the Kanban board was interesting. I do like the fact that it is so visible. Kniberg feels having a physical board is important, though I wonder how that would work if he had to manage distributed teams.

In summary, a great read with some thought-provoking ideas.

Book ordering from Borders

2010-09-14T11:40:00.001+09:30

I was looking for a book on learning about Excel pivot tables to give as a gift recently (makes a change from chocolates or a gift voucher – I know!) I found Pivot Table Data Crunching For Microsoft Office Excel 2007 on Amazon for $AU37.14 (25.93 + 11.21P&P).

Figuring it would be quicker to get it from a real bookshop, I dropped into the Adelaide Borders bookshop, but they didn't have it on the shelf 😢

I then tried the Borders website - their online price for the same book is just $AU35.95, and they also happen to have an online price guarantee that they'll beat Amazon's standard price + shipping (not required in this case).

It would have been interesting to compare Borders online price to in-store price to see if they were the same. In any case, I ordered from them so we'll see how quickly they deliver.

This all does make me wonder with the advent of Kindle eBook readers and downloadable movies what the future is for traditional book shops and video rental stores. Not particularly bright I suspect.

Update 3pm

BenMc suggested I have a look at The Book Depository. They have the same book for $AU25.33 with free shipping. Might try them next time!

The art of Unit Testing with Examples in .NET

2009-07-14T22:49:00.001+09:30

The Art of Unit Testing: with Examples in .NET by Roy Osherove

I recently bought a copy of The Art of Unit Testing: with Examples in .NET by Roy Osherove, taking advantage of a discount being offered by Manning.

Already owning xUnit Test Patterns: Refactoring Test Code (Addison-Wesley Signature Series) by Gerard Meszaros and Working Effectively with Legacy Code (Robert C. Martin Series) by Michael Feathers, I was interested to see what new insights Osherove would bring, especially as he would be focussing purely on the .NET platform (code samples are in C#).

The book is divided into 4 sections.

Part 1 (which I skimmed through) was an introduction to unit testing. Osherove uses NUnit for his examples which is reasonable considering it is probably the most popular unit testing framework for .NET at the moment.

His preferred naming convention for test methods is interesting – "[MethodUnderTest]_[Scenario]_[ExpectedBehaviour]". It contrasts with the "natural sentence" style I currently favour (which I'd trace back to Jean-Paul Boodhoo's unit testing episodes on dnrTV).

He also recommends naming test classes with a "Tests" suffix. I've always used the singular "Test", but I take his point that each test class does contain multiple tests so plural may be more accurate.

Part 2 introduces stubs, mock objects and isolation frameworks (aka mock object frameworks). Following a poll held on Osherove's blog, Rhino Mocks was chosen to demonstrate how a framework can simplify creating mock objects. I could be wrong, but you almost get a sense that this was done somewhat grudgingly considering Osherove himself works for TypeMock (who sell a commercial mocking framework). Curiously whilst including a link to the Rhino Mocks download site, he doesn't even mention Ayende's name at all.

Osherove makes the following recommendations about stubs and mocks:

Use nonstrict mocks when you can
Use stubs instead of mocks when you can
Avoid using stubs as mocks

I found this interesting, as we've been writing a lot of unit tests lately, and one of the things we're coming to realise is that brittle tests can be annoying. Tests that still test your code, but are more flexible about exactly how the code under test works (rather than setting strict expectations for each and every method call) are going to be more useful and less effort to maintain.

Part 3 looks at various strategies for organising tests and a number of patterns and anti-patterns to follow when creating tests.

Part 4 covers how to make unit testing the norm in an organisation, and how to work with legacy code.

Having some experience writing unit tests, I did find this book a bit light on. Osherove references Meszaros and Feather's books regularly. I would also consider both of these works cover the topic in a more detailed and thorough manner. However they are probably not necessarily as good a starting point for someone new to unit testing, especially someone who's main experience lies in developing for the .NET platform.

I finished the book surprisingly quickly – pleased that I'd learned a few new things, but left feeling that it would have been nice to learn a few more.

42% discount from Manning

2009-06-20T20:20:00.001+09:30

I saw today on Jeffery Palermo's blog that Manning are offering a limited time discount on "Alt.Net" books if you use the discount code "alt42" before June 25th. I've taken up the offer and ordered the following:

Building Domain Specific Languages in Boo by Ayende Rahien
The Art of Unit Testing: with Examples in .NET by Roy Osherove
ASP.NET MVC in Action by Jeffrey Palermo

Some good reading, and just in time to claim for a tax deduction too.

Dr Dobb's Journal, 1976 - 2009

2009-03-08T23:54:00.001+10:30

Back in the golden days of computer magazines (I’m talking the mid-80’s to mid-90’s), I could spend ages in the newsagent browsing all the different available issues. You remember – when the US PC Magazine was as big as a phone book, and it seemed like every brand of computer had their own magazines – BBC Micro, Commodore 64 and Amiga, Sinclair ZX Spectrum, MicroBee and the rest. One particular periodical that caught my eye was Dr Dobb’s Journal (DDJ for short) – probably because it wasn’t so much aligned with a particular brand, but that it was about computer programming in general.

The first issue I bought was March 1990, which had an assembly language theme. For old times sake, let’s take a trip down memory lane and see what those 160 pages included. Descriptions are as printed on the contents page.

The following feature articles:

Assembly language lives (Michael Abrash) – Assembly language isn’t the be-all and end-all of PC programming, but as Michael states, it’s sometimes the only game in town when performance program size are important

Assembly language tricks of the trade (Tim Paterson) – Every programmer collects a personal bag of programming tricks. Tim’s been 13 years in the making, and he shares some of his favourites with you.

68040 programming (Stephen Satchell) – The newest member of the 680x0 family provides some challenges for programmers at all levels, particularly when it comes to caching.

Homegrown Debugging – 386 style! (Al Williams) – Use the 80386’s hardware to debug your programs by including Al’s assembly language code to establish breakpoints.

Managing multiple data segments under Microsoft Windows: Part II (Tim Paterson and Steve Flenniken) – Last month, Tim and Steve presented a method for managing multiple data segments under MS Windows using the segment table. This month, the provide a sample Windows program that puts the segtable library to work.

Object-oriented programming with assembly language (Randall Hyde) – Randy makes a case that the object-oriented paradigm isn’t completely the domain of high-level programming languages. He believes that OOP techniques can be applied, and are worth considering for ASM programs too.

Inside Watcom C 7.0/386 (Andrew Schulman) – Andrew suspects that Watcom’s C 7.0/386 has launched the opening salvos in a 32-bit 386 development tool ware. he also looks at how Novell has implemented the compiler for its C Network Compiler/386.

Mixed-language programming with ASM (Karl Write and Rick Schell) – As Karl and Rick point out, it’s not only practical but often advisable to mix languages and memory models in order to achieve the best results. Assembly language is a vital part of this mix.

the following columns:

Programming paradigms (Michael Swaine) – List has been codified, gentrified, and now objectified. Michael looks at how the Common Lisp data-type system underlies the object system, and how Lisp functions have been extended in the object world.

C Programming (Al Stevens) – TEXTSRCH, Al’s text retrieval project, continues to grow. Now you can select and view one of the files from within the TEXTSRCH program itself. he then uses this feature to explore the CURSES function library.

Structured programming (Jeff Duntemann) – There really were some neat ideas at last fall’s Comdex, you just had to search them out. Jeff describes the jewels he discovered, then delves into sets in Modula-2.

plus the following:

Editorial (Jonathan Erickson)

Letters

Swaine’s Flames (Michael Swaine)

Of Interest (compiled by Janna Custer)

Wow! A bit of a blast from the past! At $AU5.95 it wasn’t the cheapest thing on the shelf, but you certainly got your money’s worth. And yes folks, that’s THE Tim Paterson.

A few years later I started to subscribe and began my collection. What I’ve really enjoyed was the variety of articles. Whilst there was almost always something of direct relevance, it was the exposure to other languages, hardware platforms and specialty areas that I really liked. And you never know when sometimes something might actually be useful in your own field too.

Here’s almost all of my collection that I’ve accumulated over the years. Funny how other magazines and journals dated quickly and weren’t that hard to throw out, but I always felt that inside most issues there’d be something, if not timeless then at least worth keeping around for a while yet.

So the years passed, some things changed, but DDJ continued on. I did notice some differences – the page count slowly dropped, some of the columnists changed or finished, but Jonathan continued to be the editor and Michael’s “Swaine’s Flames” continued to be on the last page. Actually now that I look more closely, it does look like Jonathan and Michael ended up carrying most of the work towards the end.

I’d previously seen the same happen to BYTE magazine (to which I’d also subscribed to until its demise just over 10 years ago), and I suspected DDJ was heading in the same direction. February 2009 and my fears were confirmed by Jonathan Erickson’s editorial – DDJ’s time had finished, it was to become a monthly insert to Information Week. Ironically I received the early-January edition of Information Week in late February (not that handy for a weekly publication to arrive that late!) and the DDJ inclusion turned out to be nothing more than a column written by Jonathan. Information Week is aimed at “IT professionals and business managers”. Somehow I don’t think they’re going to be running to many assembly language articles anymore.

So let’s compare the final issue. From 160pages down to just 48. You can tell when a magazine or journal is getting smaller when they no longer print the title on the spine of the publication, because there isn’t a spine anymore (just staples). I’d guess the art budget must have also been slashed, as instead of clever/thought-provoking covers, for the last few issues we’ve been greeted with with photos of one of the subjects of the “Developer Diaries” page.

It contains the following feature articles:

Computing in the Clouds (Dana Moore and John Hebeler) - Cloud computing offers virtually unlimited, on-demand computing resources. Our authors examine how you can you can create cloud applications through Amazon Web Services and the Google Application Engine.

Software Development in the Cloud (Nick Gulrajani and Darryl Bowler) - Software development in the cloud brings adaptability and flexibility to any size project team.

Videos and Oracle Forms 10g (Greg Williams) - Greg shows how you can take advantage of unstructured data in the database - video, in this case - and access this data from Oracle Forms.

Parallel LINQ (Paul Kimmel) - Parallel LINQ, which is part of the Parallel FX extensions for .NET, lets you use basic LINQ keywords to tap into the extra power that multicore systems provide.

Decoupling C Header Files (R. Samuel Klatchko) - One issue with the common C compilation model is that it can easily lead to unnecessary coupling between files. But decoupling those files isn't necessarily easy either.

the following columns:

Effective Concurrency (Herb Sutter) - When it comes to lock-free programming, volatile is a volatile subject - no matter what name it goes by.

Disciplined Agility (Scott W. Ambler) - Package implementations look great from a business point of view but can easily run into trouble if the bureaucracy gets out of hand.

plus the following:

Friday Night Fish Fry (Jonathan Erickson) - Change happens as Dr. Dobb's steps up to the next level.

Alia Vox (Tieren Zhou) - Specification Driven Development is an agile development methodology with two deliverables: working software and product design.

Developer Diaries (edited by Michael Swaine) - Profiles of programmers, descriptions of developers.

Conversations (Jonathan Erickson) - According to Lori McVittie, cloud computing is a deployment model leveraging on-demand computing to scale and serve applications through a shared resource model.

Swaine’s Flames (Michael Swaine) - Michael wonders why if Twitter is so great, why do they have to promote it by e-mail?

Still some interesting stuff, but a shadow of its former self. Most of these articles are only one or two pages, contrasting with the detailed content from 1990. I see we also lost the “Letters” section at some stage. I reckon I finished reading the whole thing in 30 minutes.

I don’t know why it died, but you would have to guess that online media has a big part to play. There’s so much information online (a lot of rubbish, but some good quality too) that it’s probably hard for a paper-based medium that you’re charging customers for to compete against anything free. DDJ have been pushing their online content for a while, but

Farewell DDJ. Thanks for helping me be a better informed programmer. You’ll be missed.

Death March by Edward Yourdon

2008-11-12T08:30:00.002+10:30

Death March (2nd Edition) (Yourdon Press Series - published by Prentice Hall, 1997

When I first began reading this book, I thought it would be all about the team that came before us… the one that spent a lot of time delivering something that didn’t work. But the more I read, the more I found myself identifying our current team with the descriptions in each chapter. Curious as the title doesn’t sound that positive! As Wikipedia defines it, a death march project is one that is destined to fail.

One point that comes out repeatedly is that while in some ways “Death March” projects are not intended to be the norm, more often than not they end up being the de facto way that many IT projects are run.

In Ch. 1, characteristics of a “Death March” project are listed as including:

Tight schedules
Small team
Limited budget
More features
Smaller scale

Hmm.. that sounds familiar!

In subsequent chapters he goes on to cover topics such as Politics, Negotiations, People, Processes, Tools & Technologies and finally the idea of “Death March” projects as a way of life.

In Ch. 3, the topic of Estimation is examined, and the value of having an experienced project manager who can estimate slightly better than just “gut feeling”, and that there are software estimation tools that can improve forecasting accuracy. I reckon Steve McConnell’s Software Estimation: Demystifying the Black Art (Best Practices (Microsoft)) could be worth a read to learn a bit more about this topic. I’ll add that to my wish list!

People can make all the difference, and our team certainly bears this out. I can’t agree with the comment that 80 hours a week is ok though.

Yourdon also espouses the importance of good workplace conditions – in particular quietness and privacy (eg. separate offices). There’s certainly empirical evidence to reinforce the productivity benefits, which flies in the face of the current trend of “open” office space, cramming as many people into tiny cubicles as possible.

Triaging tasks/bugs are critical, and allows you to prioritise what is important.

When this book was first published, there wasn’t much in the way of “Agile” development practises, but I think Yourdon is alluding to this when he makes mention of using RAD tools (refactoring), mini-milestones (iterations) and daily builds (continuous integration).

One thing I did find annoying was Yourdon’s use of a monospace font when listing the emails in each chapter’s list of references. This made them very hard to read and I mostly ended up skipping over them as a result.

Overall I came away inspired by this book. Yourdon highlighted the many pitfalls that await a team who are engaged in a “Death March” project, but does offer hope that under the right conditions, you can achieve success.