Skip to main content

Posts

Showing posts with the label Agile

Balancing Present Needs and Future Growth

In software development, traditional project planning often emphasizes immediate needs and short-term goals. However, Bentoism, which stands for "Beyond Near-Term Orientation," provides a multidimensional framework that can improve software project planning. It advocates for a balance between short-term achievements and long-term sustainability, considering both individual and collective impacts. Technical debt and architectural debt are inevitable challenges that teams must navigate. If managed properly, these debts can help long-term sustainability and growth. Bentoism, with its forward-looking and holistic perspective, offers a nuanced framework for handling these challenges while promoting continuous improvement.  Understanding Bentoism  Bentoism, inspired by the structure of a bento box that contains a variety of foods in separate compartments, encourages a broader perspective in decision-making. It promotes consideration of 'Now Me' (current self-interests), ...

Yearly Educational Goals vs. Agile Team Learning

At this time of the year, employees often have their yearly reviews and set goals for the following year. From an agile point of view, this is an antipattern. The Agile methodology promotes continuous improvement and adaptation. This philosophy often needs to match this traditional approach of setting fixed yearly educational goals for developers. This discrepancy can be analyzed regarding how these educational strategies align with the interests of labour and management within the industry (as opposed to the orchard)  and how they contribute to or alleviate the alienation and class dynamics inherent in the tech workforce. Yearly educational goals in software development typically involve predefined objectives that developers are expected to achieve within a set timeframe. While this approach provides clear targets and a sense of structure, it can be rigid and limiting in a field known for rapid technological changes and evolving project needs. Such goals may become quickly outdate...

Software Projects as an Orchard

This blog is named The Sourcerers Orchard. The title is intended as a pun about source code and the orchard as an analogy between software development and handling an orchard. Creating a new orchard is an endeavour that blends the art of gardening with science. The same could be true for software development. We often talk about software as an industry, and this mindset harms our work. We are not an industry; we do not repetitively produce the same unit at an assembly line. We grow new things in a partly unpredictable world. Systems like SAFe are born in industrial thinking, like modern mercantilism, focused on numbers, not growth. We need a new way of thinking, to make high quality software instead of failing production lines. Planning Your Orchard Embarking on creating a new software project is akin to cultivating a thriving orchard from the ground up. It’s a journey that requires patience, dedication, and a strategic approach to nurturing growth and overcoming challenges. Let’s expl...

Analyzing Power Structures in Software Development Workplaces: A Bourdieuian Perspective

The last blog post was about how Agile fails due to the power structure in software development companies. The analysis used Karl Marx's framework to discover. A more modern analysis of power structures can be gained using Bourdieu's capital analysis. The world has evolved from ownership of land via ownership of machinery to ownership of knowledge. Understanding the underlying power structures that shape interactions and outcomes is crucial in the software development industry. By applying Pierre Bourdieu's theories of capital—cultural, social, economic, and symbolic—we can uncover more nuanced forces at play within these workplaces. This analysis explores how Bourdieu's concepts provide a lens through which to examine the software development industry's complex hierarchy and power dynamics. Economic Capital: The Foundation of Power In software development, economic capital refers not just to the financial resources available to individuals and organizations but als...

Agile as a Recipe: Navigating Through Success, Alienation, and the Shadows of 'Dark Agile'

Agile methodologies have been heralded as a beacon of efficiency, adaptability, and team collaboration in the constantly evolving landscape of software development. Originally designed to break down the silos of traditional waterfall methodologies, Agile aimed to foster environments where rapid iteration, customer feedback, and team dynamics lead to better products and satisfied team members. However, as Agile principles have permeated various organizational structures, their implementation has not been without challenges, sometimes veering into what is now being termed 'Dark Agile'. This blog post explores Agile as a double-edged sword in the context of alienation, power structures within companies, the means of production, and the emergence of 'Dark Agile'. Agile: A Recipe for Success?   At its core, Agile offers a recipe for managing software development projects that prioritize flexibility, continuous delivery, and stakeholder satisfaction. By breaking down projects...

Alienation in the Software Industry

Marxist concepts of alienation can be applied to the tech industry, particularly in the context of software programmers. Alienation, as defined by Karl Marx, refers to a sense of estrangement or detachment that workers may experience from their labour, the products they create, their fellow workers, and even themselves. Here's how these concepts might apply to programmers in the tech industry: Alienation from the Product: Fragmentation of Work: Programmers in large tech companies often work on small, specialized tasks within more significant projects. This specialization can lead to a sense of detachment from the final product. They may need to fully grasp or appreciate their work's broader context or impact, as they are primarily focused on their specific coding tasks. Lack of Ownership: In some cases, programmers might need a stronger sense of ownership over the software they create, especially if the project is vast and involves numerous contributors. This can result in redu...