Skip to main content

Adhoc Over Formal Communication

Context​

Microservices are being adopted. There are multiple teams, each responsible for their certain microservice(s). The teams enjoy full responsible for their microservices, including technological freedom and decision autonomy.

Problem​

  • Formal coordination is inefficient and too slow to cope with the innovation speed of microservices
    • E.g., mailing lists fan out local coordination to parties that not involved

Solution​

Foster ad-hoc communication between microservice teams on topics that are not of global interest.

Efficient coordination between single teams can be utilized via informal chat software, like Slack or Mattermost, or ad-hoc meetings face-to-face or through video calls. Responsibles of the microservices are documented in order to reach the right contact person efficiently. The key to efficient coordination are short communication ways.

Using extensible chat software may offer integration points for parts of the toolchain. For example, creating a new release can automatically notify other teams in the chat software to announce the new releases and its API changes.

However, ad-hoc communication can still be inefficient unless there is agreement on basic things like standards and cultural values.

Maturity​

Proposed, to be evaluated.

Sources of Evidence​

L19:

  • Context: case study
  • agile mothodology, using tools like Waffle, GitHub, Slack, ecetera
  • everytime dev pushes commits to service repo => notification to all majore stakeholders
    • system owner
    • other devs
    • testers
    • and whoever subscribed
  • helps to promote engagement, colaboratiion between stakeholders
  • maximize personal resposibility awareness of developer in every line of code

L43:

  • Context: case study - how situational factors influence software process
  • Table 4
    • small org size => information exchange and communications can occur efficiently thu video conferences or calls or face-to-face meetings
    • enables more agile/lean software approaches

Interview A:

  • during home office times benefitted from previous introduction mattermost as chat system
    • mattermost = open source alternative to slack => data privacy of org secrets => on-premise hosted
    • main tool /channel for communication
      • much more advantageous than smoker talks or at the coffee machine
      • more transparent, reread things, etc.
  • use webhooks of chat system for fully automated feedback
    • when deployment breaks => pushed into a channel
    • not implemented yet, but do the same for container monitoring, kubernetes resources, or ELK stack
      • error in production => automated ticket creation at devs with high priority
    • notify testers when deployment succeeded
  • chat => surprisingly important tool
    • fast and efficient communication inherent to microservices
    • previous solution: emails with changing exchanges => would have slowed them down when introducing microservices

Interview C:

  • Context: error tracing to its roots
  • I see the error message, break down
    • in best case: locate in a microservice
    • not often the case, most often interaction of microservices involved
  • trivial questions => which issue tracker is used for those overarching issues?
    • in practice: it differs
    • in least cases some structured process, more informal communication over Slack channel or so
    • their suggestion: synchronize issues to save these information
  • normal communication is favored over formal communication over clear specifications
    • keep communication pathways as short as possible
    • best: put them into one team

Interview D:

  • coordination every time adhoc and agree every time
    • after identifying with which other team and its technical artifacts I collaborate with
    • not particularly efficient
    • => motivation for finding common agreements / standards

Interview F:

  • coordinate details of service interaction between the involved teams
    • goal (use cases) and the boundary conditions given from above (by architects)
    • not: every team vanishes in their cave
    • but: work together to add something new by devs of the teams collaborating
  • Context: additional suppliers next to development teams
    • collaboration via video chat since they were distributed
    • cut teams so that a team is in one location