Alistair Cockburn

The Agile Methodology is to argue about The Agile Methodology. -- The only durable thing I've learned about methodologies: Alistair Cockburn "Characterizing People as Non-linear, First Order Components in Software Development." Oops. https://alistair.cockburn.us is "under construction". Sorry. Meanwhile, here's a pretty good TL;DR: http://www.johngoodpasture.com/2009/11/people-puzzle-non-linear-device… Anywho. My current position is "just tell me what you want, I'll adapt." As a recovering methodology junkie, I can no longer stand talking about it. If everyone is on the same page (roles, rules, expectations, etc), I'm happy. If someone dictates this ceremony by fiat, minimizing discussion, all the better.

> OOP isn't good or bad, Exceptions aren't good or bad, Scrum isn't good or bad. It makes me mad. It's all true though. Do whatever you want, all that matters is that you do it well - you just can't simplify a good software engineer down to techniques like these. I recommend reading this piece from a guy who studied software development methodology for over 20 years: http://alistair.cockburn.us/Characterizing+people+as+non-linear,+first…

A similar paper: http://alistair.cockburn.us/Characterizing+people+as+non-linear,+first… The book "Peopleware" is also worth reading. Unfortunately it seems that nobody has done any serious anthropology on software production with a view to improving it.

What is it terrible for? I've encountered situations where someone believed it was bad for something and were wrong. Such as user interface code. The solution in that case for example is to make as much of the code testable as possible leaving just a thin layer of untestable stuff (which can still be tested via an integration test of some sort). This idea generally follows the principles of http://alistair.cockburn.us/Hexagonal+architecture or "functional core, procedural IO". Gary Bernhardt expounds on this brilliantly in his https://www.destroyallsoftware.com/talks/boundaries talk, btw.

Experienced project managers multiply by pi ;) http://alistair.cockburn.us/The+magic+of+pi+for+project+managers I think people should start using confidence intervals. Then the upper bounds become more realistic. If you need to estimate roughly with 90% condifence intervals, then a developer can communicate the uncertainity: I think task A will take about a week. At least 2 days. And no more than 3 months. You can immediately see that it's probably best to either a) work with this tasks a few days and make a new estimate based on the acquired knowledge b) or if that's not possible, try to split the task to smaller subtasks to identify which parts are the most uncertain.

A classic, one of the most insightful things ever written about programming, and way ahead of its time (1985). The actual paper is at http://alistair.cockburn.us/ASD+book+extract%3A+%22Naur,+Ehn,+Musashi%… (Edit: that link is broken now, but http://pages.cs.wisc.edu/~remzi/Naur.pdf still works.) What Naur means by "theory" is some combination of what we'd now call "model" and "design". Naur put the N in BNF and played a role in creating Algol.

i've said this before (sorry), but cockburn, in cooperative game, describes shu ha ri - http://alistair.cockburn.us/Shu+Ha+Ri - as three stages of mastering something: following, detaching and fluent. anyway, this post is so second stage it makes me wince.

The truth is that there is a lot of evidence from the field that having good developers and zero formal process is actually fairly workable, and often produces results. For certain kind of organisations yes. Take a look at the research Alistair Cockburn did and his various Crystal [colourname] methodologies. http://alistair.cockburn.us/Crystal+methodologies It's typically not the best system, but it's a strong antidote to the poisonous ideas of SCRUM, which holds that constant micromanaging at every level is strictly necessary otherwise puppies will die. If you've got a team claiming their doing Scrum where you see constant micromanaging - that team is not doing Scrum. At the very core of Scrum is the idea that the team organise their own work (within the very few practices that Scrum enforces). (Obniggle: Scrum is not an acronym you don't need to SHOUT :-)

I presume you haven't read the "blue book"? Because that covers many of what you ask. In addition, the canonical (but not clearest, IMO) source on Hexagonal architecture is by the "inventor" himself: https://alistair.cockburn.us/hexagonal-architecture/. Several links in that article are dead now, but some still work and point to excellent discussions and articles. If you are looking "war stories" or "case studies" especially in a setting where management or colleagues need some convincing, this article of how Netflix employs it might help https://netflixtechblog.com/ready-for-changes-with-hexagonal-architect… I've -depressingly, actually- found that often people are easier convinced by an argument "BigCorp™ does it too" than by "its good because of X". Recently a more practical post landed on HN. It includes CQRS, which might make it more convoluted than what you need, but even with that, it has some really nice "lessons learned" and "best practices": https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexa… (ninja-edit: weird sentence fixed)

> This leads us to my favorite architecture for serverless apps: hexagonal architecture, alternatively called ports and adapters. As it’s creator, Alistair Cockburn, explains, the hexagonal architecture allows an application to equally be driven by users, programs, automated test or batch scripts, and to be developed and tested in isolation from its eventual run-time devices and databases. https://vacationtracker.io/wp-content/uploads/2019/04/hexagonal-archit… This seems like a new buzzword for an existing (but still very good) thing, abstraction layers. The original article (http://alistair.cockburn.us/Hexagonal+architecture) is down though, so it's entirely possible it was was written in the late 90s when these practices started becoming widespread particularly with Java and Gang of Four (https://en.wikipedia.org/wiki/Design_Patterns). Edit: dzone says 'Hexagonal Architecture' was from 2005. https://dzone.com/articles/hexagonal-architecture-what-is-it-and-how-d… Make of that what you will.

A couple of things spring to mind: Naur's "programming as theory building" essay [1]. E.g. > programming properly should be regarded as an activity by > which the programmers form or achieve a certain kind of > insight, a theory, of the matters at hand. This > suggestion is in contrast to what appears to be a more > common notion, that programming should be regarded as a > production of a program and certain other texts This suggests that it might not be a great idea to outsource understanding. The entire essay is worth a read. Yosefk also gave a fairly amusing characterisation of what it is to work for a software company [2]: > Basically the "knowledge worker's" contract is > something like this: > > > We'll give you a precisely defined salary > > and a benefits package. In return, we > > request that you handle some problems that > > we're told we're having. We hope that you'll > > solve them well enough to prevent us from > > having to know what they were in the first > > place. Please help us maintain the feeling > > that we own an asset similar to land or gold > > or something. Please keep the realization > > that we're more like the operator of a > > flying circus than a landowner from > > disturbing us. And certainly, never, ever > > ask us what to do with any of the moving > > pieces of this flying circus, because we > > seriously have no idea. [1] there's a copy here…

Start with the "classics" like "mystical man month" (Brooks) for example, then get many of the books by Tom de Marco and possibly read Richard Gabriel's "Patterns of Software". The book about the "Chandler" project (forgot it's title) is also a particular good read. Those two in particular are interesting reads about why things fail. Go on to reading the Toyota management style in itself, there's a couple of books about it, that's what many IT techiques are getting their ideas from. It's mostly about finding your values so to speak and pinpoint what you really think makes up a good software development company - maybe your focus will be on organization, maybe on other things, so get an overview first. These two articles are hopefully also an interesting nudge to think about many things: http://www.computerworld.com/s/article/9137708/Opinion_The_unspoken_tr… http://alistair.cockburn.us/Characterizing+people+as+non-linear%2c+fir… O'Reilly has a very interesting book with analysis which practices actually work and why/how - sadly I also forget the title. There's for example a chapter about when and why pair programming works and when and why not. Also, just watch carefully and learn to notice "good organization" - happens in surprising corners and niches and try to see WHY it's good.

Well here's the take from the Author itself: https://alistair.cockburn.us/hexagonal-architecture/

This is essentially one stop short of dependency injection[1] (even cited by the original "hexagonal architecture" author back in 2005[2]). I've been writing a lot of Rust this year, and even though part of me really likes it, I do miss Go's dumb simplicity. I have a feeling that you could spend entire sessions just architecting some fancifully-elegant pattern in Rust and not really getting any actual work done (just how I used to in Java). [1] https://www.martinfowler.com/articles/injection.html [2] https://alistair.cockburn.us/hexagonal-architecture/

Hexagonal architecture is the thing you need, then: https://alistair.cockburn.us/hexagonal-architecture/

- Awesome architecture: https://awesome-architecture.com/architectural-style/hexagonal-archite… - Netflix tech blog: https://netflixtechblog.com/ready-for-changes-with-hexagonal-architect… - Wikipedia: https://en.wikipedia.org/wiki/Hexagonal_architecture_(software) - Article by the inventors themselves: https://alistair.cockburn.us/hexagonal-architecture/

> Meaning, why aren't our people studying what works in other industries and figuring out how to apply it to our industry? Some are: http://alistair.cockburn.us/Characterizing+people+as+non-linear,+first… From the abstract: We methodologists and process designers have been designing complex systems without characterizing the active components of our systems, known to be highly non-linear and variable (people). This paper outlines theories and projects I reviewed on the way to making this stupendously obvious but notable discovery and four characteristics of people that most affect methodology design and project outcome. I find these characteristics of people to be better predictors of project behavior and methodology success than other methodological factors.

A user story is basically a feature. It is higher level than a use case. Read Alistair Cockburn http://alistair.cockburn.us/Stop+confusing+use+cases+and+user+stories.

"Multiply by π for small, known teams, doing a new job, by π^2 for unknown teams, and √π for known teams who have already started, know their work and have a good track record." http://alistair.cockburn.us/The+magic+of+pi+for+project+managers

Many of the advantages of microservices can be achieved by refactoring your monolith code to be less monolithic. I would suggest using functional styles wherever possible, plenty of isolated unit testable code, and a hexagonal architecture http://alistair.cockburn.us/Hexagonal+architecture that pushes all the I/O, mutation, side effects, etc. to the very boundary of your code. Also see Gary Bernhardt's "Boundaries" talk for more interesting thought in that vein https://www.youtube.com/watch?v=yTkzNHF6rMs

A tale: http://alistair.cockburn.us/Thinking+before+programming

As it happens, I've been working on something like that. Still pretty half-baked, but send me an email and I'll show you what I have. Email in profile. "There are so many times where, if I could sit down with the original program author for 5 - 10 minutes, I could understand more from that interactive back-and-forth than several hours of reading code in solitude." Peter Naur wrote a paper in 1985 where he conjectured that this seemed to be a universal law. No matter how much documentation authors provided, new programmers still needed to talk to them. http://alistair.cockburn.us/ASD+book+extract%3A+%22Naur,+Ehn,+Musashi%…

It's a reference to Alistair Cockburn's "Ports and Adapters" pattern, also called "Hexagonal Architecture".[1] The only reason I ever heard of it is that it was mentioned in the book "Growing Object-Oriented Software, Guided by Tests", by Steve Freeman and Nat Pryce (a good book in my opinion). [1] http://alistair.cockburn.us/Hexagonal+architecture

How does Obvious relate to Hexagonal Architecture (AKA Ports-and-Adapters, http://alistair.cockburn.us/Hexagonal+architecture)? I'd like to suggest that it's not bad, but others have found the right answer already. Or does Hexagonal leave some important problems unsolved?

I think the 'Layered Architecture' section is all over the place. There are a lot of terms thrown around with pretty loose definitions - in this article and others. I had to look up "layered architecture" to see what other people wrote about it, and it looks like an anti-pattern to me: In a four-layered architecture, the layers are typically divided into: Presentation Application Domain Infrastructure These layers are arranged in a hierarchical order, where each layer provides services to the layer above it and uses services from the layer below it, and each layer is responsible for handling specific tasks and has limited communication with the other layers. [1] It looks like an anti-pattern to be because, as described, each layer depends on the one below it. It looks like how you'd define the "dependency non-inversion" principle. Domain depends on Infrastructure? A BankBalance is going to depend on MySQL? Even if you put the DB behind an interface, the direction of dependencies is still wrong: BankBalace->IDatabase. Back to TFA: > In the end, we gave it all up in favour of the good old dependency inversion principle. OK. DIP is terrific. > No port/adapter terms to learn There is a big overlap between ports/adapters, hexagonal, and DIP: Allow an application to equally be driven by users, programs, automated test or batch scripts, and to be developed and tested in isolation from its eventual run-time devices and databases. [2] That is,…

Great question! I think we're slowly getting there. First we largely had verbs (procedures) that acted on data somehow. OO added a bit more on the noun side, so we could start to form simple sentences. IMHO much of the appeal of OO is due to this richer "sentence structure", with messages sent to objects. Of course you could overdo it (see Yegge's Execution in the Kingdom of Nouns[1]), and the FP guys definitely think we overdid it and verbs were fine all along and who needs anything else. Verbs! Higher Order Messaging[2] adds "adverbs", so we can say something about how those messages are to be delivered. It allows for some very expressive sentences, which you could also describe as crunching architectural patterns. See Sam Adam's great talk[3]. Polymorphic Identifiers[3][4][5] go back to the noun side, adding what you might describe as n noun-phrases, so you can have something more complex that again acts like a noun. Sort of. Then there's Alistair Cockburn's work[6] [1] https://steve-yegge.blogspot.de/2006/03/execution-in-kingdom-of-nouns.… [2] https://en.wikipedia.org/wiki/Higher_order_message [3] https://www.hpi.uni-potsdam.de/hirschfeld/publications/media/WeiherHir… [4] https://link.springer.com/chapter/10.1007/978-1-4614-9299-3_11 [5] https://www.slideshare.net/MarcelWeiher/in-processrest [6]…

I'm glad to hear this works for you. But I think the process emphasizes technical skills over what really matters when hiring: how the person works with the team and within the business. Giving someone a toy project unrelated to the business tells you nothing about how they will perform in the real environment. Letting the candidate take the work home to work on it in isolation tells you nothing about how they will work with your team, or within the company. In his study "People and methodologies in software development" Alistair Cockburn found that “People’s characteristics, which vary from person to person and even from moment to moment, form a first-order driver of the team’s behavior and results." (http://alistair.cockburn.us/People+and+methodologies+in+software+devel… Other studies have come to similar conclusions. In a technical job, actual skills and experience are necessary but not sufficient for success. Programmers fail in their jobs because they can't work with or fit in with the team, and the larger organization. Any competent programmer can learn a new language, framework, or technique like TDD in a week or two. But people who don't pay attention to the business environment and requirements, and can't work with their team, group, etc. will fail, often costing a lot of money. Presumably you have weeded out the unqualified before offering to pay them to work for a few hours, but this seems like offering an unnecessary incentive to learn very little…

I think there are a lot of loaded expectations on what it means to be an ORM. Maybe this is no-true-scotsmaning, but I distinguish between things providing convenient query builders from full ORMs. Generally speaking, I'm happy with anything that handles marshalling / unmarshalling and can generate typesafe (when applicable) queries for me (so long as its happy to get out of the way on those handful of occasions that I'd like to use some handwritten SQL). Things I've used in the past like this include * Knex - http://knexjs.org/ * Slick - http://slick.lightbend.com/ * Opaleye - https://hackage.haskell.org/package/opaleye Generally these don't call themselves ORMs though. The primary distinction I've found is that they don't conflate my domain model with my schema. They don't enforce a 1:1 correspondance to a table or a try to concoct some scheme of representing inheritance with multiple tables and they don't try to take on myriad other unrelated duties like validation, etc. They allow me to build my application in the hexagonal style ( http://alistair.cockburn.us/Hexagonal+architecture ) in an OO language. Abstraction of SQL is not something I have a problem with, its trying to infect my domain model with persistence concerns, or even worse by trying to pull transaction handling out of the domain of the database.

I don't think we are agreeing or disagreeing. I do want tools that make it easier to navigate and understand code and I also want cultural shifts in programmer communities that lead to better software overall. I'm just saying the communal aspect is more important than any given programmer's ability to navigate code but the two are obviously intertwined in complicated ways. That article you linked to (http://alistair.cockburn.us/ASD+book+extract%3A+%22Naur,+Ehn,+Musashi%… connects the dots really well. Programming is really about building theories and then implementing them with computational building blocks and then transferring the understanding of those theories. Short of developing mind reading I think there is an irreducible complexity in that endeavor that is impossible to skirt around. In light of that article I'd like to amend my comment about aesthetically pleasant code. Some programmers are good at structuring things so that the overarching theory is present throughout all code level structures. That kind of code is both aesthetically pleasant and easy to read. I don't know if this is some kind of special talent of if it can be learned but given that most software is a confused mess I'm willing to bet there is a large talent component.