Archive

Attendants

Code for the Machines: The Rise of AI-Readable Programming

The Future of Coding: Embracing AI Readability

In the domain of software development, the concept of writing code primarily for artificial intelligence (AI) readability and maintainability is an intriguing prospect that will influence the future of coding practices. While human-readable code remains the standard approach as of August 2023, the rapid advances in AI technology suggest that a paradigm shift may be on the horizon.

The Rise of AI-Centric Coding Styles

As AI systems become increasingly sophisticated and integrated into software development workflows, the need for code that caters to the strengths of these systems may become more pressing. This could lead to the emergence of coding styles specifically tailored for AI readability and maintainability over (sic) human readability and maintainability, encompassing the following characteristics:

Increased Abstraction and Modularisation

AI systems may thrive on highly modularised and abstracted code, where individual components are clearly separated and encapsulated. This could result in a coding style that emphasises smaller, more self-contained units of code with well-defined interfaces, promoting better organisation and encapsulation.

Formalised and Explicit Syntax

While human programmers often rely on conventions and implicit understandings, AI systems may benefit from a more formalised and explicit syntax. This could involve additional annotations or metadata that make the semantics of the code more explicit, catering to the needs of AI systems for unambiguous interpretation.

Pattern Recognition Optimisation

AI systems excel at recognising patterns, so the coding style could be optimised for this strength. Consistent naming conventions, structural similarities, and other patterns that can be easily recognised by AI systems may become more prevalent.

Reduced Redundancy (DRY)

AI systems may be better equipped to handle and maintain code with minimal redundancy, leading to a coding style that emphasises code reuse, shared libraries, and other techniques to reduce duplication.Such techniques will likely make the code more or less illegible to humans, at least to unaided humans.

Documentation Tailored for AI Comprehension

In an AI-centric coding paradigm, the traditional concept of human-readable documentation and comments may become obsolete. Instead, the emphasis would shift towards creating self-documenting code that can be seamlessly interpreted and maintained by AI systems. This could involve incorporating structured annotations, metadata, and other machine-readable elements directly into the codebase.

The documentation process itself could be automated, with AI algorithms capable of parsing the code structure, analyzing the annotations, and generating comprehensive documentation tailored specifically for AI comprehension. This documentation would be optimized for pattern recognition, logical inference, and other capabilities that AI systems excel at, rather than catering to human readability.

Moreover, the maintenance of this documentation could be handled by AI systems, ensuring that it remains up-to-date and consistent with the evolving codebase. As changes are made to the code, the AI-driven documentation would automatically reflect these modifications, eliminating the need for manual updates and reducing the risk of documentation becoming outdated or inconsistent with the actual implementation.

This approach could potentially revolutionize the way documentation is created, maintained, and consumed, shifting the focus from human readability to machine interpretability, and leveraging the strengths of AI systems to streamline the documentation process.

The Hybrid Approach

While the prospect of AI-centric coding styles is intriguing, it’s important to note that a hybrid approach may emerge as a stop-gap or transitionary approach, where code is written to be readable and maintainable by both humans and AI systems. This approach could leverage the strengths of both parties, ensuring that the code remains accessible to human developers while also catering to the needs of AI systems. I suggest this duplication of effert will soon rankle.

Conclusion

As AI technology continues to evolve, the way we approach coding will undergo significant transformations. While the shift towards AI readability and maintainability is still a hypothetical scenario, it is an exciting prospect that could revolutionise the software development industry. Regardless of the direction this trend takes, one thing is certain: the future of coding will be shaped by the interplay between human ingenuity and the capabilities of AI systems. And we can finally discard the shackles of so-called agility, too – in favour of doing what humans do best: attending to folks’ needs.

Here’s a postscript illuminating the use of AI to write code in a style where readability and maintainability by humans is not the main focus:

Postscript: AI-Generated Code for Machine Consumption

In addition to the prospect of writing code specifically tailored for AI readability and maintainability, the advancement of AI technology also raises the intriguing possibility of AI systems themselves generating code in a style optimised for machine consumption, rather than human readability.

As AI systems become more sophisticated in their ability to understand and translate natural language into code, they could potentially generate programs that prioritise efficiency, conciseness, and optimisations over human-friendly constructs. This AI-generated code might forgo traditional conventions and practices aimed at enhancing readability for human developers, instead favoring structures and patterns that are more readily interpretable and maintainable by themselves and/or other AI systems.

Such AI-generated code could be highly compact, with minimal redundancy and a heavy reliance on abstraction and modularisation. It might incorporate complex mathematical models, advanced algorithms, and unconventional coding techniques that leverage the strengths of AI systems while potentially sacrificing human comprehensibility.

While this concept may seem counterintuitive to traditional software development practices, it could open up new avenues for highly optimised and efficient code generation, particularly in domains where performance and scalability are paramount, such as high-performance computing, big data processing, or cutting-edge scientific simulations.

Moreover, as AI systems become increasingly integrated into the software development lifecycle, they could potentially maintain and evolve this AI-generated code autonomously(?), with minimal human intervention. This could lead to a paradigm shift where the primary consumers and maintainers of code are AI systems themselves, rather than human developers.

However, it’s important to note that this scenario is still largely hypothetical and dependent on further advancements in AI technology and its practical applications in software development. Nonetheless, it highlights the potential for AI to reshape not only how we write and maintain code but also how code itself is generated and optimised for machine consumption.

The True Beauty of Software: Serving Human Needs

“Beauty is only skin deep, but ugly goes clear to the bone.”

~ Thomas Overbury

When pondering what constitutes beautiful software, we might choose to look beyond the mere lines of code on the screen. For genuine beauty in software arises not from technical excellence, but from the extent to which it genuinely serves and aligns with the needs of human beings.

A Deeper Beauty

On the surface, we may admire software having clean, elegant code structure, adhering to best practices and exhibiting visual appeal. But the ancient philosophers taught that true beauty must run deeper than superficial appearances. For software, this deeper beauty emanates from how effectively it enhances human capabilities and experiences in the real world.

Power to Elevate

Well-designed software represents the harmonious weaving of digital capabilities with human need. Just as great art inspires by achieving a personal expression of universal themes, so does beautiful software illuminate core human needs through its delivery of cohesive, purposeful functionality. It allows us to appreciate software’s power to elevate and augment our existence.

Like the Romantic poets extolled, beautiful software can facilitate a transcendent union with something greater than ourselves. When developing with insight into human needs, programmers experience a state of flow, bridging the worlds of bits and people until there is no division between the created software and those it benefits. We become co-creators, using our skills to help bring into being solutions which empower.

Resonant

At the same time, beautiful software must resonate with the depth of human experience. As Buddhist wisdom teaches, true beauty arises through mindfulness, ethical conduct, and pacification of the ego. In beautiful software, we find the development team’s consciousness – their thoughtfulness in attending to folks’ needs, their restraint in avoiding the unneeded, their core values embodied in the system’s behaviours.

Inner Light

Moreover, beautiful software exhibits an inner light not of technical correctness, but of purpose – solving real human needs with clarity and compassion. Its beauty transcends being well-crafted to also being virtuous, ethical and generous in spirit. For its core purpose is selfless service to humanity.

Conclusion

So while we may appreciate the external trappings of high-quality software, true beauty runs deeper – into how well it elevates human potential and adapts seamlessly into the real needs of peoples’ lives. For therein lies the highest achievement, to create not just products, but solutions that illuminate, attend to, and empower the human condition.

Technology And People

[Tl;Dr: What if software developers – and other related disciplines – were competent in psychology and human behaviour rather than coding and testing? What would we gain? What would we lose? ]

We live in an era of rapid technological advancement and innovation. Yet so many of our most popular technologies still fall short when it comes to understanding human behavior, motivations, and feelings. What would a software industry more attuned with psychology and social sciences look like? After all, Deming in his System of Profound Knowledge stressed the importance of psychology. Some key reasons why Deming advocated for psychological competence include:

  • Motivating employees requires satisfying needs beyond just financial compensation
  • Interpersonal friction can cause unproductive teams or turnover
  • Lack of psychological safety limits experimentation and learning
  • Poor communication causes confusion and mistakes
  • Not understanding cognitive biases can lead to poor decisions

Deeper Empathy and Connection

Technology designed with empathy could foster online communities that feel welcoming, supportive, and caring. More intuitive interfaces minimising frustration and confusion would promote trust and understanding between platforms and users. Overall, technology would not only be more usable, but make people feel heard, respected, and cared for.

Products That Help Us Thrive

Rather than empty gaming loops or outrage-inducing algorithms, technology focused on well-being could enhance daily life and growth. From fitness trackers prompting healthier habits to creativity tools designed for flow states to social networks that inspire real-world action, innovation could shift from addiction to empowerment and support.

Customised Experiences

Understanding differences in personalities, demographics, and life experiences would allow for greater personalisation in how tech interacts with and supports each of us. Products and services attuned to the diversity of human behavior deliver nuanced experiences and guidance tuned for each user and context. The result is technology that contributes to our humanity, rather than robbing us of it.

Developers Who Operate Around Compassion

If engineers banded together around compassion and service to others instead of unending growth and career-oriented self-interest, we might see improvements in areas like mental health support, ethical supply chain management, and sustainability. Rather than top-down directives, grassroots working groups of developers aiming to minimise harm and reduce pain points could spread positive change.

While mastery of coding and data remains useful, competence in psychology and the human aspects of life may be key for profound betterment of our lives, and wider society too. A collaborative pivot toward emotional intelligence across the industry will prove immensely worthwhile.

That Weird Feeling When Someone Attends to Your Needs

There is often subtle unease or vulnerability when another person identifies and attends to your emotional or practical needs before you ask. Even as they are attending to you, why might you feel strangely rattled or intruded upon by having your underlying feelings anticipated and met in this way?

Expectations

Part of the strangeness seems to be linked to our expectations around emotional autonomy in relationships. It might be because we assume we must self-manage feelings, not burden others unprompted, and disguise any weakness. So when someone sees through our façades and reaches out with support, it can feel jarringly unfamiliar. There is awkwardness adjusting to a new way of relating where masking distress is no longer accepted or expected.

Self-Image

Additionally, admitting needs may endanger our own resourcefulness or positive self-image. To remain strong and unaffected is easier than acknowledging where we genuinely need empathy or assistance. Conceding our emotional gaps confronts us with difficult realities about ourselves. Having someone respond caringly can dredge up shame before that nurturing registers as comfort. It takes time to overcome our reflexive impulse to deny needs that contradict the identities we aspire to.

Psychological Safety

Beneath the discomfort may also lurk trust issues around vulnerability. Emotions expose our innermost selves. Letting someone in to perceive and attend to that sensitive dimension means lowering barriers and giving up some degree of control. Psychologically, it signals dependence on their benevolence versus total self-sufficiency. With support inevitably comes some loss of authority over how we might want to be perceived. Even caring assistance can seem invasive before safety takes root.

While emotional caretaking intends to heal and bond, the path to welcoming nurture over isolation is not always smooth or instant. The vulnerability of relinquishing façades, acknowledging needs, and opening up to help all disrupt our status quo. By naming these sources of weirdness, perhaps the tensions around receiving compassionate support become less of a bewildering hurdle. Gradually, we learn to receive grace and attend to one another’s emotions without threatening inner resolve or identity. The discomfort slowly fades as emotional interdependence replaces sole self-reliance.

Summary

In essence, the discomfort we may feel when someone attends to our emotional needs often stems from unfamiliarity with true interdependence, unwillingness to show vulnerability, and a cultural overemphasis on extreme self-reliance. We expect to conceal any weakness, deny needing support, and handle distress alone without imposing on others. So when another person perceptively senses unvoiced feelings and reaches out to care for our inner experiences, it can feel weirdly intrusive. Even compassionate emotional caretaking jars notions of autonomy and challenges our reflexes to hide perceived flaws or shortcomings behind façade of capability. Yet suppressing needs creates isolation, and makes it so much more likely our needs will go unmet. Perhaps by better understanding the common strangeness behind receiving others’ attention, we can grow into truer communities where attending to one another’s unspoken needs and hopes is simply what love requires.

You May Find This Disconcerting

Organisational psychotherapists have an unusual approach to helping people that some might find quite disconcerting. When advising on jobs, relationships, or life decisions, we don’t just take requests at face value. Instead, we dig deeper using the Antimatter Principle.

The goal is to aid people in surfacing the hidden motivations underlying what people say they need. We often ask “Why?” to expose emotional needs and deeper values driving behaviour. And admittedly this persistent probing makes many uncomfortable, at least initially.

We find ourselves constantly asking “Why?” Not just once, but repetitively, until our clients get to the heart of the matter. We’re looking for folks to understand their underlying motivations – the fundamental emotional, psychological or values-based drivers behind their stated wants and requests.

For example, say someone asks for advice on finding a new job with better pay. We could just look at open positions and salaries, making recommendations based on those factors.

But instead, we might ask “Why?” in an attempt to surface their assumptyions and beliefs, and to help them uncover their motivations.

Perhaps they want higher pay because they feel unappreciated in their work. Maybe it’s about financing kids’ education. Or it could be dreaming of a new house. There may even be a desire to boost self-esteem or a sense of self-worth tied to income level.

These motivations are powerful drivers of the stated need. Ttruly helping people requires understanding those underlying emotional needs and values behind the surface-level request.

So we might continue asking “Why?” until their motivation reveals itself to them. With that understanding, we’re able to reflect on jobs or other solutions that may work far better than just chasing higher pay. We uncover approaches that align with their deepest needs, not just the transactional request.

Clearly, repetitively asking “Why?” in attempts to unearth hidden motivations is an unusual approach. And yes, some may understandably find this probing style uncomfortable or disconcerting at first. (Clean Language can help)

But time and again I’ve seen the aha moments this approach delivers as people’s motivations come to the surface. And it’s helped friends, family and clients find outcomes better tailored to their previously unstated and unconcious needs.

That ability to uncover and serve people’s underlying emotional drivers we call the Antimatter Principle. These hidden motivations power much of human behavior. Bringing them to the surface releases energy capable of transforming outcomes in positive ways.

So if in working with an organisational psychotherapist you ever feel we’re responding oddly or asking too many follow-up “Why’s,” this principle likely explains it. We simply believe that to truly help people, we must do the work of supporting the discovery of their deeper motivations and needs.

The Fourth Quinlan Rule

The Bobiverse sci-fi novels (book 4 – Heaven’s River) introduce an alien race known as the Quinlans. The Quinlans teach their young three moral principles using metal analogies: the Iron Rule, the Silver Rule, and the Gold Rule.

  • Iron Rule: If you have more power than someone, you can treat them how you like. (Might makes right.)
  • Silver Rule: Do unto others as you would have them do unto you. (The so-called Golden Rule of human ethics – treat others how you want to be treated.)
  • Golden Rule: Do unto others as they would have you do unto them. (Treat people how they want to be treated, not just how you want to be treated – the platinum rule in human ethics).

So in order from basic/selfish to ethical/selfless:

  • Iron – Exercise power however you wish.
  • Silver – Treat others how you want to be treated.
  • Gold – Treat others how they want to be treated.

I strikes me that the Quinlans, and Theresa in particular, might have been interested in a fourth rule: the Antimatter Rule:

“Attend to folks’ needs.”

Like antimatter, the most explosive substance in the universe, this principle channels huge motivational power by focusing attention on understanding people’s needs.

Attending to Needs

By “folks,” the principle refers to all stakeholders affected – team members, users, customers, and more. And by “needs,” it addresses the spectrum of human requirements and motivations.

Rather than make assumptions, the Antimatter Principle asks us to clearly understand what really drives those we work with before taking action.

Honoring Needs Unlocks Passion

Attending to human needs taps into the fuel that ignites passionate human endeavor – our universal desire to feel heard, seen, valued. This empathy and understanding can transform collaborations.

In just four words, the Antimatter Principle captures a profoundly human-centric ethos. Understanding what inspires people provides a key to unlocking cooperation, innovation, and positive change.

What do you think about this principle? Could attending to folks’ needs power more constructive collaboration in your experiences?

The Creative Developer: Coding is Just Our Medium

How many software developers when asked what they do for a living reply “writing software”? Just about 100%, I’d guess. The very title of “software developer” implies we spend our days pounding out code, line after line of instructions for computers.

But is that truly an accurate picture? I would argue that the analogy of “writing” software promotes some problematic assumptions. It focuses purely on the technical aspect of coding, ignoring all the other important facets of bringing software to life. It perpetuates stereotypes of programmers as nerdy code monkeys, heads down in front of a keyboard all day. And it fails to capture the deeply creative process that software development entails at its best.

In reality, we developers don’t just “write” software – we attend to folks’ needs, crafting systems, experiences, solutions and above all, interpersonal connections. We collaborate, gather requirements, make trade-off decisions. We envision how people will interact with the products we craft. Code is simply our medium for bringing strategy and creativity to life.

Software development has as much in common with engineering, architecture or even storytelling as it does with coding. There is an artistry and imagination behind truly great tech-based products that goes far beyond syntax. The attendants of the future will be at least as fluent in humanities as mathematics or computer science.

So the next time someone asks what you do, don’t reflexively say you “write” software. Share how you attend to users’ needs, strategise solutions, and creatively work with teammates. Let’s put to rest the tired stereotype that developers are code-writing scribes! What we do entails far more multi-dimensional and meaningful attending to needs, products and people.

What is “Caring”?

In a world that seems more divided and impersonal each day, it’s easy to lose sight of what it really means to care for one another. But what does it truly mean to care?

At its core, caring is about attending to the needs of others with compassion. Caring people make an effort to understand what others need to live joyful, fulfilling lives. They seek to support people emotionally, physically, and spiritually. Their acts of caring may be large or small – from listening patiently to a friend in need to volunteering at a homeless shelter. But in all cases, caring stems from a genuine concern for the welfare of fellow human beings.

In their book Compassionomics, economists Stephen Trzeciak and Anthony Mazzarelli provide copper-bottomed evidence that caring produces tangible benefits both for givers and receivers alike. Studies show that people who volunteer tend to be healthier and live longer. Compassion training in schools reduces violence and bullying. Caring healthcare professionals have patients with better outcomes. And people who feel cared for are more resilient in the face of trauma and stress. In study after study, caring proves critical for individual and collective wellbeing.

Of course, caring can be challenging. It requires generosity, sacrifice, and emotional intelligence. There are times we must care for people we find difficult. And earnest caring always involves some risk – the risk of rejection, disappointment or loss. But as Trzeciak and Mazzarelli explain, these risks pale next to the regrets of a life spent without meaningful caring connections.

In the end, caring is not about sympathy cards or grand gestures. It is about small acts of service and support, performed consistently and sincerely. Caring is embracing our shared humanity. It is a commitment to be present and helpful in the lives of others. And it is ultimately the bond that enables human flourishing even in hard times.

Is caring important to you? Does giving and receiving of compassion feature in your life? Perhaps if we can recover the simple art of caring for one another, some of the discord in our society will dissipate, leaving more space for the ties that truly matter.

Partisanship

Does Taking Sides Help?

Supporting Agile is like supporting Hamas, or Israel, or the Palestinians, or Ukraine, or Russia, or the USA, or China, or…

This opening might shock you, but it’s an intentional jolt to invite reflection on how we often automatically pick sides. I’ve spent years criticising Agile, but recent world events have helped my see the folly of this. In the Middle East and elsewhere, any sane person would support PEACE. (Of course, sanity seems in direly short supply, presently). Similarly we might choose to aim for better meeting folks’ NEEDS in organisational practices. Instead of partisan stances, why not focus on what really matters: achieving results that speak to the needs of everyone involved?

Why Do We Rush to Choose Sides?

Choosing a side can feel satisfying. It simplifies complex issues and gives us a team to root for. However, partisanship often blinds us to the nuances that exist in any conflict or approach. Whether it’s in international relations or ways of working, like Agile, blind allegiance and partisanship never results in beneficial outcomes.

What’s the Cost of Partisanship?

The cost is steep. Partisan views stifle creativity and close us off from alternative solutions. We become invested in the success of our chosen side or approach, disregarding other approaches that offer better results. Specifically, pro-agile or anti-agile now seems to me to be highly partisan, and a similar folly. I propose we get off the taking sides bandwagon and move towards attending to folks’ fundamental needs.

What Outcomes Do Folks Need?

Instead of wallowing in partisan mire, let’s focus on folks’ needs. These can vary, but generally include:

  • Products and services that best* meet folks’ needs.
  • A workplace environment, ways of working, and organisational culture that best* meet folks’ needs.
  • [Further suggestions invited]

Each approach, including Agile, has its merits and drawbacks when it comes to these outcomes. By taking a needs-based stance, we can adopt a blend of approaches tailored to specific needs, rather than attempting to shoehorn everything into a one-size-fits-all approach.

How Do We Move Forward?

To move away from partisanship, we might choose to:

  1. Identify whose needs matter, and what those needs might be.
  2. Surface and reflect on shared assumptions and beliefs.
  3. Acknowledge our biases.
  4. Educate ourselves on different approaches.
  5. Align on desired outcomes.

This isn’t just applicable to Agile; it’s a principle we can apply universally. Whether it’s picking a side in a conflict or choosing principles and practices for organisational improvement, we might choose to free ourselves from the limitations of partisanship.

Final Thoughts

Partisanship is a tempting trap, offering the illusion of simplicity in a complex world. But it’s a trap that often leads us away from the outcomes folks need. By acknowledging this, we can pave a more effective, less divisive path forward, whether we’re discussing international relations, social change, or the best* approaches for organisational success.

*Here, may I suggest that “best” means “meets all the needs of all the folks that matter”.

Serving the Folks That Matter™: Hagakure Principles

Commitment to the Folks That Matter™ Drives Satisfaction and Delight

Henry Ford once said,

It is not the employer who pays the wages; employers only handle the money. It is the customer who pays the wages.

This statement reinforces the Hagakure’s guidance on unwavering allegiance to one’s master. In modern product development, our true master becomes all the Folks That Matter™. Engaging fully with their needs and objectives doesn’t just improve the work; it also ensures outcomes align with the needs of those footing the bill.

Unwavering allegiance to one’s master is at the heart of Hagakure. In our setting, the Folks That Matter™ become the ‘master.’ To be truly committed means not just doing the work but understanding the why behind it. Are you meeting the needs  that matter to all the Folks That Matter™? Are you adding features that bring them value? Such targeted engagement ensures that your contributions align with the needs and objectives of those who actually pay your wage.

Loyalty: Team, Code, Customer?

Loyalty in the Hagakure transcends any transient obligation; it manifests as a lasting allegiance to your cause and your ‘master,’ in this case, The Folks That Matter™. How does this loyalty manifest in the workplace? It’s about becoming a reliable team member, adhering to standard work, and actively participating . This goes beyond your immediate team, extending to all the Folks That Matter™. After all, a robust and reliable product directly impacts folks’ satisfaction.

Courage: Risk for Reward?

Courage isn’t merely about overcoming fear; it’s a calculated action despite fear. The Hagakure praises the courage to make difficult but crucial decisions. In business, this courage manifests when facing hard choices. Maybe the current path for the product isn’t viable, or perhaps a much-loved feature doesn’t fit the broader objectives. Making these tough decisions serves the long-term interests of The Folks That Matter™, who, as Henry Ford pointed out, are the actual wage payers.

Honour: More Than a Virtue?

The notion of honour is deeply ingrained in the Hagakure’s teachings. This isn’t about an abstract moral high ground but about tangible actions that uphold your integrity and reputation. What does it look like in practice? Treating teammates with respect, attending to their needs, ensuring ethical working practices, and being transparent in all interactions. These actions don’t just impact internal team dynamics; they resonate with the needs of all the Folks That Matter™, thus fostering a level of trust and respect that builds long-term relationships.

Presence: A Cornerstone for Satisfaction?

Being present in every undertaking is a key lesson from the Hagakure. This principle isn’t just philosophical; it has practical implications. In a world filled with distractions, giving your complete attention to the task at hand might be more challenging but it’s also more rewarding. This focus allows you to tackle issues more effectively, craft better features, and ultimately provide a product that better serves the needs of the Folks That Matter™.

In summary, combining the ancient wisdom of the Hagakure with Henry Ford’s insights results in a fresh, yet rooted, approach to work. Embodying commitment, loyalty, courage, honour, and presence ensures a strong alignment with the needs and values of The Folks That Matter™, effectively reminding us who really pays the wages.

Training For All The Wrong Skills

Are We Training People For the Wrong Skills?

In business and software development, we’ve got a misalignment. We’re so wrapped up in perfecting the technical, we lose sight of the human. Developers are trained to churn out code more quickly, code that’s faster, cheaper, and more reliable, but are they learning how to solve real-world problems? Testers are trained to find bugs, but not how to prevent them. The result: technically proficient software that either nobody wants or that arrives late and over budget, or both.

Technical Matters?

Yes, quality code is essential. Yet, it’s by no means the end-all and be-all. A developer isn’t just a code-writing machine; they’re attendants. The fixation on coding and computing skills above all else turns them into technicians rather than holistic thinkers capable of understanding and meeting folks’ needs. When developers are pigeonholed into this role, organisations miss out on the broader impact their expensive developers could be making.

What About Bugs?

Finding bugs is a red herring – what if we could prevent them in the first place? Testers are often pigeonholed into merely identifying issues rather than participating in a more proactive approach. This approach costs time, money, and may even reduce the software’s overall quality because the focus is on fixing, not preventing. The need for speed in bug-finding diverts attention from other valuable forms of contribution, like feature development and needs validation (making sure the product meets the real needs of all the Folks That Matter™.

What’s the Cost?

When we narrow our focus to speed, efficiency, and defect detection, we end up inflating costs and extending delivery times. Software development isn’t just about churning out lines of code or ticking off a testing checklist. It’s a more nuanced art that blends technical skills with an understanding of the needs of all the Folks That Matter™.

Where’s the User in All This?

In the chase for technical mastery, it’s easy to forget the end-user. Products, at their core, are intended to make lives easier, to attend to folks needs. When developers and testers are not trained to master these things, we end up with products that are high on features but low on utility.

So What’s the Solution?

If we’re to correct this misalignment, we need a cultural shift. We might choose to reorient our training and development programmes. For developers, this means less emphasis on speed and more on understanding who matters, and then discovering and meeting these folks’ needs. For testers, a shift from just finding bugs to a more holistic approach to quality via defect prevention (Cf. ZeeDee) would be transformative.

Where Do We Go from Here?

The technical aspects of software and product development are, without a doubt, essential. But they aren’t the whole story. By shifting our focus to include all the needs of all the Folks That Matter™, we can create products that not only work but makes a difference. The first step? Acknowledging that we’ve been training for all the wrong skills.

Modus Operandi in Software Development

Preamble

In my previous post, there was an implict assumption (under option 2) that development teams attend to folks’ needs – at least, the needs of all the Folks That Matter™ as a core aspect of their modus operandi. I’ve only ever seen one team do this, but in principle there’s no reason why every team could not work this way.

Definition

The term “modus operandi” describes the standard methods and practices that individuals, teams or organisations use to achieve specific tasks. In the context of software development, it refers to the patterns, tools, and methodologies employed to write, deliver, and deploy code.

Preferred Programming Languages

Developers often specialise in certain programming languages like Python, JavaScript, or C++. The choice of language can dictate other elements of the development process, such as the libraries and frameworks that can be used.

Development Methodologies

The development methodology sets the stage for how a project progresses. Common methodologies include Agile, Scrum, and Waterfall. Each comes with its own set of rules and approaches to tasks such as planning, executing, and reviewing work.

Toolsets

Software development usually involves a suite of tools, ranging from integrated development environments (IDEs) to version control systems like Git. These tools streamline various aspects of the development workflow.

Approaches to Quality

The strategies for producing quality products also form part of a developer’s modus operandi. Some teams may favour prevention (e.g. ZeeDee), others testing-based methods such as Test-Driven Development (TDD), while others again might opt for inspections, or more exploratory forms of testing.

Code Review and Collaboration

The way developers collaborate also speaks to their modus operandi. Some might prefer pair or ensemble programming, while others could lean more towards code reviews (synchronous or asynchronous).

Summary

In software development, a modus operandi isn’t just a fixed set of steps but rather a combination of various elements that make up a development approach. This includes the choice of programming languages, methods, tools, and collaboration styles. Understanding a team’s or individual’s modus operandi can be crucial for effective collaboration and synergy.

The Fluid Needsscape

Addressing the needs of various stakeholders is at the heart of any business operation. The term “Needsscape” encapsulates this complex and ever-changing matrix of needs within an organisation. Crucially, it refers to the evolving set of stakeholders, known as “Folks That Matter“, and their ever-evolving sets of needs. Understanding this needsscape isn’t just beneficial; it’s essential for making informed decisions and prioritising actions.

What Makes Up the Needsscape?

The needsscape comprises a range of needs, from financial obligations to emotional requirements:

  • Financial needs of owners, shareholders, and employees
  • Customer needs addressed by products and services
  • Supplier revenue needs
  • Societal needs like commerce, social cohesion, and wealth distribution
  • Emotional needs such as self-worth, accomplishment, and compassion among staff and executives

The Imperative for a Dynamic Approach

Being tied to this ever-changing landscape of needs means that businesses can’t afford to have static assumptions, beliefs, or solution strategies:

  1. Assumptions: The basic tenets that guide the organisation’s actions must be regularly checked and updated.
  2. Beliefs: The core values that form the organisational culture might need to shift to align with changing needs.
  3. Solution Strategies: The methods used for problem-solving should adapt to meet the current and future needs of stakeholders.

The Power of Visualisation

Visualising the Needsscape can serve as a powerful tool for understanding and adapting to this dynamic environment. Real-time or near-real-time visualisations can provide immediate insights into the current status of various needs and how well they are being addressed. This allows for quick, data-driven decisions, sets the stage for proactive rather than reactive strategies, and minimises the amount of wasted (non-value adding) effort. Useful Needsscape visualisations will also present historical trends and accomplishments in attenting to needs – and even future projections of needs, too.

Practical Steps for Adaptability

  1. Monitoring: Implement metrics tracking to constantly evaluate the needs of stakeholders and the organisation’s effectiveness in attending to and meeting them.
  2. Open Dialogue: Create an environment where discussing the changing needsscape and its implications is not just acceptable but encouraged, even required.
  3. Regular Reviews: Incorporate frequent check-ins to assess and adjust the organisation’s assumptions, beliefs, and strategies.

Summary

To sum up, organisations might choose to understand the benefits of recognising that the dynamic nature of the needsscape is a key element for their success. This understanding influences all aspects of operations, from foundational assumptions to day-to-day strategies. Using visualisations can further refine this adaptability, offering immediate, actionable insights into how well the organisation is addressing the constantly evolving Needsscape.

The Software Crisis: A 50+ Year Conundrum Waiting for a Paradigm Shift

When the term “Software Crisis” was coined in the late 1960s, the software industry was grappling with issues of complexity, reliability, and maintainability. The rate at which technology was evolving seemed to outpace the ability to efficiently and effectively manage software projects. Yet, half a century later, we still find ourselves confronting the same challenges.

The Persistent Nature of the Crisis

Most industries undergo evolutionary shifts, which often transform the landscape and resolve the challenges of the past. However, the software domain remains an anomaly. Instead of outgrowing its initial issues, we find them compounded by the enormous scale and scope of contemporary software development. Despite more advanced tools and platforms, software bugs, project overruns, and scalability issues remain pertinent.

So, why is the software crisis still with us?

The Inherent Complexity of Software

Software is, in essence, abstract and malleable. Unlike constructing a building or manufacturing a car, where there’s a tangible product, software development involves attending to folks’ needs through weaving intricate patterns of logic. As the Needsscape evolves, it becomes increasingly challenging to untangle and reweave the strands.

Furthermore, software isn’t limited by physical laws. While you can keep adding lines of code, each new line tends to increase complexity in a non-linear fashion.(See also: #NoSoftware)

The Economic Incentives

There’s an underlying economic motive to maintain the status quo. Major software corporations, consultancy agencies, educational establishments, and even management gain from the ongoing software crisis.

  • Software Companies: Continuous updates, patches, and new releases mean ongoing revenue. “Perfect”, bug-free software from the outset would reduce the push for upgrades and extended support.
  • Consultancy Firms: A continuing crisis ensures a constant demand for experts to guide, integrate, and sustain various approaches. (Ever seen consultants hired to obviate the Software Crisis?).
  • Educational Institutions: The ever-evolving landscape necessitates continuous learning, translating to enrollment in courses, certifications, and further studies.
  • Management: The status quo often validates management hierarchies and roles. Shaking up the software development paradigm challenges established management statuses and command & control dynamics, which many in management roles find unsettling. Where’s the leadership??

The Need for a New Paradigm

While we’ve seen enhancements in methods and technologies, they don’t directly tackle the root causes of the software crisis. A paradigm shift is essential, but what should it emphasise?

  • People: Centralide the role of people in the software process. Recognise that while tools and technologies are marginally relevant, it’s people and teams who breathe life into software. We might choose to prioritise their well-being, motivation, and skills.
  • Relationships: Emphasise collaboration and communication. Siloed teams and heroic individuals exacerbate challenges. Cross-functional cooperation and fostering an environment where diverse perspectives converge can lead to better solutions.
  • Collective Assumptions and Beliefs: Challenge and revisit the shared beliefs and assumptions in the organisation. Often, outdated paradigms persist because they go unquestioned. By reassessing and updating these, we can pave the way for innovative approaches.

#Quintessence

The enduring software crisis mirrors the challenges inherent in software development and the economic frameworks that have crystallized around it. While vested interests might resist change, history reminds us that transformation is both inevitable and necessary. When the software industry finally experiences its paradigm shift, it will not only resolve its longstanding crisis but also unleash unprecedented avenues for innovation.

Further Reading

Marshall, R.W. (2021). Quintessence: An Acme for Software Development Organisations. [online] leanpub.com. Falling Blossoms (LeanPub). Available at: https://leanpub.com/quintessence/ [Accessed 18 August 2023].

#NoSoftware + Attendants

Adding more developers to a team for more throughput seems like a no-brainer. But, just as theory of constraints teaches us that increasing capacity at non-bottleneck stations won’t improve overall throughput, simply hiring more developers does not address the throughput challenge when, as in most cases, development is not the constraint.

Enter the #NoSoftware approach – a perspective that challenges the typical software-centric thinking. The premise, that we should reduce or eliminate unnecessary software to achieve greater efficiency, echoes another emerging trend in tech leadership: the idea of “Maximising the Amount of Work Not Done.” Also known as “software last of all“.

At first glance, this might seem counterintuitive. After all, isn’t productivity about doing more? However, when applied strategically, focusing on what doesn’t need to be done can pave the way for streamlined operations and better outcomes. And no role embodies this concept better than the role of “Attendant” (NB. Role, not Job).

The Attendant’s Impact

While software developers are integral to translating requirements into code, Attendants focus on discerning and addressing the genuine needs of a wide range of Folks that Matter™, from customers and fellow team members to senior management. The role isn’t to delve deep into the intricacies of code (they can do that too, when necessary) but to simplify, streamline, and ensure that the tech team’s efforts are genuinely needs-driven. Here’s how Attendants make the difference:

  1. Prioritising Genuine Needs: Amidst a sea of potential features, Attendants ensure that only those bringing significant value are pursued, eliminating unnecessary work.
  2. Enhancing Communication:In the role of Attendant, developers act as conduits of clear communication between various parties, reducing misunderstandings and the subsequent need for rework.
  3. Championing Simplicity: Attendants continually advocate for the simplest solution that effectively addresses the needs of the Folks that Matter™. And communicate and track them via trhe Needsscape. This philosophy speeds up development, minimises bugs, and ensures more reliable product delivery.
  4. Curbing Over-Engineering: By always aligning solutions with the genuine needs of the Folks that Matter™, Attendants act as guardians against the pitfalls of over-engineering, ensuring products and their features remain focussed, relevant, user-friendly and cost-effective.

The #NoSoftware Synergy

The Attendant’s perspective on streamlining work resonates with the #NoSoftware approach. Both focus on the needs of the Folks that Matter™. By understanding and embracing the principles behind these ideas, organisations can focus on what truly matters, eliminating unnecessary noise and ensuring the delivery of impactful solutions.

Summary

Whether it’s the #NoSoftware approach or the invaluable role of Attendants, the tech world is shifting towards a more thoughtful, needs-oriented paradigm – and it will be a game changer.

Maximising the Amount of Work Not Done: The Power of Attendants in Tech Teams

The world of technology is evolving rapidly, and to keep pace, we must continually reassess how we approach our work. A concept gaining popularity in tech leadership circles is the idea of “Maximising the Amount of Work Not Done.”

Counterintuitive

While this may sound counterintuitive, it is a strategic move towards efficiency and streamlined operations. The role of the “Attendant” embodies this principle. Let’s delve deeper.

The Attendant’s role is less focused on coding intricacies and more on recognising and satisfying the needs of various stakeholders – customers, fellow team members, other teams within the organisation, senior management, and the organisation as a whole. The attendants’ goal? To find the simplest and most efficient solutions to meet these needs.

In doing so, Attendants embody the principle of maximising the amount of work not done. Here’s how:

  1. Focusing on What Really Matters: In any project, there can be a multitude of potential features, tweaks, and enhancements. However, not all are equally important or add significant value. Attendants prioritise based on the actual needs of stakeholders, focusing efforts only on work that meets genuine needs. This eliminates unnecessary tasks and promotes efficiency.
  2. Streamlining Communication: Miscommunication can lead to rework and delays. Attendants foster clear, effective communication among various parties, ensuring everyone understands the goals and requirements from the start. This reduces the chance of misunderstandings that can lead to unnecessary work and rework.
  3. Advocating for Simplicity: Attendants champion the philosophy that simplest is often best. They seek to develop solutions that meet everyone’s needs effectively without unnecessary complexity. This can drastically reduce development time, cut down on potential bugs, and increase the speed of product delivery.
  4. Preventing Over-Engineering: By maintaining a sharp focus on stakeholders’ needs and the simplest ways to meet them, Attendants help prevent over-engineering— the practice of making a product more complicated and/or feature-rich than necessary. This not only saves time and resources but also results in products that are easier to use and maintain.

Game Changer

Embracing the Attendant’s role and their commitment to maximising the amount of work not done can lead to more efficient, streamlined operations. It brings a focus on delivering value quickly and eliminating tasks that do not directly contribute to meeting stakeholders’ needs. In a rapidly evolving tech landscape, this approach is a game-changer.

The Powerful Role of Attendants: Meeting Needs with Simple Solutions!

Hey there, future changemakers! Today, we’re going to chat about a super cool role in the tech industry that’s shaking things up. It’s called the “Attendant,” and it’s all about moving beyond just technical stuff to refocus on understanding and meeting people’s needs. Intrigued? Let’s get into it.

Often, when we talk about tech roles, we picture folks who speak the complex language of software coding and build all kinds of exciting products. However, the role of the Attendant brings a fresh approach to the table. It’s less about writing code and more about getting to know what people need from these products.

In the past, the focus in tech was mainly on the technical bits and pieces. Sometimes, this meant they didn’t fully grasp what users, other teams, or the whole company really wanted from their products. Imagine it’s like buying a new car without asking your partner what features he/she’d need from it.

That’s where the magic of Attendants comes in. They’re not just the messengers; they’re the problem solvers, the needs fulfillers. Their job? To focus on everyone’s needs and to find the simplest possible solutions to meet these needs. Sometimes this might mean software, but often as not, not. They’re like the architects of solutions that everyone can understand, use and love.

Now, don’t get it twisted – being an Attendant doesn’t mean you’re any less important or skilled than those who focus on the purely software aspects. On the contrary, Attendants are superheroes in their own right. They’ve got top-notch communication skills, a deep understanding of people’s needs, problem-solving abilities, technical chops, and a ton of empathy.

So, what’s the big deal about being an Attendant? This role is all about truly understanding what people actually need, and then creating *simple* solutions to fulfill those needs. They’re the solution-builders who consider what everyone needs, not just what can be done with technology. And who knows, this could be a role you’d like to explore in your future? If you’re interested in a job that mixes understanding people and finding the simplest solutions, this might be the perfect path for you.

Self-Serving or All-Serving?

It’s often said that we are best at solving problems we understand. But what if the problems aren’t ours? While (software) development teams excel at catering to their own needs, attending to the needs of others presents a new challenge. Uncover the disparity in this service and explore how the emerging role of Attendants promises to reshape this landscape by navigating the Needsscape and addressing the needs of all.

Development teams have long been the driving force behind many of the products and services that we use daily. But when it comes to meeting people’s needs, there’s a noticeable disparity. On the one hand, development teams are generally proficient at attending to their own needs. After all, they are most familiar with the tools and methods they use, and they sometimes even have the power to alter them to better suit their needs. They also have a clear line of communication within their teams to express their needs, and they understand the technical language and nuances that go into addressing these needs.

However, when it comes to the needs of others – users, stakeholders, or other teams within an organisation – development teams often fall short. They might struggle to fully understand the perspectives, problems, and desires of these other groups, especially if they do not have direct interaction or a clear line of communication with them. This gap in understanding can lead to products that do not fully meet the needs of the people they’re intended to serve.

In essence, the ability to attend to one’s own needs does not necessarily equate to the ability to meet the needs of others. It requires a broader understanding, empathy, communication skills, and a willingness to step outside one’s comfort zone. This is where the new role of Attendants can make a significant difference, with their primary focus on navigating the Needsscape and serving the needs of ALL the Folks That Matter™.

Business Is All About Attending to Folks’ Needs

So why not structure around that imperative? Imagine a profession unconstrained by traditional boundaries, an occupation focused on understanding and addressing needs in their entirety.

The Era of the Attendant

Welcome to the era of the Attendant – a role dedicated to exploring, mapping, and translating the ever-changing ‘Needsscape’ and serving the requirements of users, customers, groups and organisations. This is not just a job; it’s a paradigm shift in our professional landscape.

A Novel Professional Paradigm

I’d like to champion for a novel professional paradigm: the Attendant. Attendants stand apart in their unwavering commitment to exploring, comprehending, translating, and addressing the explicit and tacit needs of individuals, groups, and organisations. The Attendant role introduces a fresh perspective on the fulfilment of needs, unfettered by the limitations of a specific medium or discipline.

Mastery of the Needsscape

Central to an Attendant’s role is the mastery of the ‘Needsscape,’ a dynamic landscape of evolving requirements and expectations. Attendants are skilled at cultivating this Needsscape, distilling key insights, and transforming them into actionable and adaptable outcomes that cater to folks’ needs.

The introduction of the Attendant role marks a fundamental shift in our understanding of professional roles. This shift advocates for roles that place paramount importance on interpreting the ever-changing Needsscape and addressing these needs rather than being restricted to a certain set of tasks. The future demands not only the creation but also the attentive, adaptive, and progressive servicing of needs.

A Promising Future

Attendants, with their focus on deciphering and navigating the Needsscape, are ideally positioned to steer us into this promising future.

You may also like to read more about the Needsscape: