Developing Quality Software: Differentiating Factors

Source:- infoq.com

Abstract

The level of software quality attainable is a reflection of an organizational business decision.  There are many factors that influence this decision, including development, build and testing environments effectiveness, resources and their associated skillset, integrity, motivations and experience levels, commercial agreements, and adopted processes and productivity tools.

The effectiveness of development, build and testing environments sets the bar for attainable efficiency and breadth of testing.  The closer test and production environments mirror one another, the greater probability of uncovering dormant and edge-case issues that are otherwise destined to surface in a production environment.

Selected process should surface and mitigate risks while ensuring repeatability.  Processes should not be cumbersome nor contain duplicity.  Processes should undergo periodic review, to ensure that they are optimized and provide organizational value.

Work organizing and planning productivity tools should improve efficiency, support transparency and rollup reporting.  The selected tools should require a minimum amount of team administrative overhead.   Also, the perceived significance of these tools should not overshadow the effort and actions required to produce quality software.

Experience, technical acumen and self-awareness are attributes often associated with software developer effectiveness.   Effective developers have a significant role in the production of quality software.  Their domain knowledge, attention to details and aggressive approach to testing are borne from ingenuity and practical experience. Integrity and self-motivation are traits necessary to sustain consistent and high-levels of productivity during both the exciting and challenging phases of software development. These factors combined with a suitable infrastructure and a set of light-weight processes, are precursors to continuous production of quality software.

Effective developers are not infallible, however their deliberate design and implementation decisions ensure “built-in” quality. Thereby reducing the probability of unexpected and undesired quality related outcomes.  The effective developer relies on critical analytical and deductive reasoning skills, as oppose to rote or surface comprehension to guide them during the software design, implementation and testing stages.

Recognizing the role and contributions made by effective developers, towards the production of quality software, does not diminish the need for light-weight processes nor the contributions of others.  There are many articles that describe software development processes importance and the contributions of others along the software value chain.

This article will resonate most with those that have had exposure to software development environments wherein roadmap development and/or custom/fix bid implementations are the norm.

Therefore, this article describes:

• The significance of continuous delivery and an optimized deployment pipeline to the software value chain.
• Upper management commitment and capital investments required to facilitate production of quality software.
• Observed traits and patterns of behaviors exhibited by effective developers that facilitate “built-in” software quality.

Continuous Delivery and the Deployment Pipeline

Continuous delivery entails sustained incremental development of quality and production ready software.  This workflow facilitates agility during feature implementations and is necessary to maintain valued customer and stakeholder feedback loops.  However, caution must be exercised to ensure technical debt is not incurred unabated, due to implementation short-cuts taken to facilitate quick delivery.  Effective code reviews, consistent use of a static code analysis tool and planned code refactoring periods are deterrents to increasing technical debt.

Continuous Delivery Process

Sustained production of quality software and the effectiveness of applied automation to build and test environments are significant continuous delivery contributors.  Open lines of communication and respectful dialogue among software development, build and release teams must exist.  Inadvertent “broken build” scenarios are destined to occur on occasion, despite best efforts from developers to build their modifications against a replicated and periodically synched main code branch prior to repository submission.   These scenarios should be addressed in a manner benefiting timely resolution with a focus towards future improvements.

When consistent production of quality software is attained, the next logical step entails deploying features and solutions from an internal ecosystem to end-user environments where value can be realized.  An optimized software deployment pipeline:

• Utilizes automation tools to efficiently move software along the deployment pipeline.
• Employs the minimum number of actions and interactions, required to move code from the repository and transform it to a binary form for use by end users.

Consistent production of quality software is a precursor to continuous delivery and an optimized deployment pipeline.

The Journey

Software organizations continuously seek ways to improve software quality. Quality software is another product value proposition which gives a competitive edge.  However, there are no silver bullets nor quick fixes for sustained production of quality software.  Instead a strategic approach should be adopted that facilitates agility and entails milestone tracking and mitigation planning.

A set of core conditions and factors must be in place to facilitate consistent production of quality software.  Journey duration and encountered pain points are affected by the level of commitment and investment in the following:

• Organizational culture
• Infrastructure
• Processes and tools
• Effective Developers

Upper management support for producing and delivering quality software must be a visible and championed value set.  Annual capital investments should be earmarked for training, infrastructure improvements and workflow optimizations associated with the continuous software delivery process and deployment pipeline.  Organizational culture should support a safe environment that encourages constructive feedback, transparency, collaboration and “outside of the box” thinking.

Infrastructure spending should be applied to hardware and software improvements. Investments in training, securing robust and scalable virtualization technologies, continuous integration tools and real-world data modelling should be given priority.  Infrastructure planning reviews, should consider effort and costs associated with creating and maintaining tests environments that closely mirror their production counterparts. Obviously exact cloning could be cost prohibited, however a reasonable facsimile enables a broader range of testing.

Training investments should extend beyond course based offerings and include practical learning opportunities.  Developers should have exposure to activities along the software value chain to gain broad base knowledge. In addition and where possible software developers should be given opportunities, to observe end-users generating business value through usage of product features.  Discussions with customers regarding the use of product features to resolve real-world use cases facilitate software developer growth.

Adopted process should mitigate risks and ensure repeatability.  Processes should not be multi-layered nor contain duplicity.  Processes should also allow flexibility for management of aspects, endemic to teams. Processes should be periodically reviewed to ensure that they are optimized and provide organizational value.

Work organizing and planning productivity tools, should improve efficiency, support transparency and rollup reporting.  Selected tools should require a minimum amount of team administrative overhead. The perceived value derived from these tools should not overshadow, the efforts and actions from various contributors to the production and delivery of quality software.

These factors and conditions are important levers used to attain quality software.  However, effective software developers’ contributions are one of the main levers for ensuring “built in quality”.

Effective Software Developers

There are many notable software development processes and methodologies that facilitate production and delivery of quality features and solutions.  Selected processes, combined with knowledgeable QA staff, automated unit and regression testing provide a formidable arsenal to aid in the delivery of quality software.

However, the role of the effective software developer should be examined.  Their role is comparable in certain respects to that of first responders, with regards to providing first administrations leading to “built-in” quality.  An effective software developer uses technical acumen and business knowledge to consistently create quality features and solutions that provide customer value.

The contributions made by effective developers toward the production of quality software are sometimes overshadowed by successes and failures outcomes from other activities along the value chain.  However, their contributions to the software value chain should not be taken for granted.

Organizational structures vary, however effective software developers often have a sphere of influence extending to the following areas:

Effective Software Developers Sphere of Influence

Based upon first-hand observations, effective software developers are distinguishable by their proficiency and/or practical application of the following:

• Domain and Systems Knowledge
• Design and Big Picture Thinking
• Business Knowledge
• Value Engineering
• Personal Toolbox
• Continuous Learning

Domain and System Knowledge

Comprehensive domain knowledge is accrued from continuous cycles of learning and practical application, which produces both successful and failed outcomes.  Domain knowledge is central to software development, as it ensures alignment of requirements and implementation details. It also enables software developers, the ability to offer insights regarding software implementation related risks.

Failure to recognize implementation risks can lead to rework and customer dissatisfaction.  Early identification and socialization of implementation risks, allows organizations the opportunity to engage in upfront risk mitigation reviews.  This is especially important for organizations that enter into fix bid commercial arrangements.

Design and implementation of robust and scalable solutions requires system knowledge.  Effective developers are aware of the impact their implemented features and solutions have on the following system resources:

• CPU consumption.
• Memory usage.
• Disk activity.
• Network bandwidth consumption.

An effective developer monitors system resources during feature testing, ensuring system resource usage is aligned with recommended baselines.  Doman and system knowledge also facilitates earlier discovery of issues.

Design and Big Picture Thinking

Design thinking facilitates feature and solution development from a customer perspective.  An effective developer does not begin coding without engaging in some form of design thinking.  Design thinking entails the following:

Big picture thinking occurs during the “Identify Potential Solutions” stage.  During this stage, the main focus is brainstorming different ideas regarding potential solutions that solve the problem domain.  However during this stage, the effective developer extends his/her thought process to ensure that proposed solutions are also:

• Scalable
• Robust
• Maintainable
• Extensible

A holistic thought process facilitates well rounded implementations.  Therefore, domain and system knowledge are keys to effective design and big picture thinking.

Business Knowledge

The effective developer has a level of awareness regarding organizational structure, strategy and industry standing.  His commitment to organizational behaviors entails:

• Respecting organizational roles.
• Collaborating in meaningful ways.
• Engaging in knowledge transfer and transparency.
• Budget awareness.

An effective software developer has a business oriented approach to development and understands that the software value chain composition includes primary and supporting activities.  He recognizes that both are required for organizational success.  During collaboration sessions, he communicates effectively and engages in active listening.  He seeks consensus for an approach which bests provides customer value.

Engaging in knowledge transfer and practicing transparency benefits both the organization and the effective developer.  Effective developers understand organizational concerns regarding risks associated with reliance on a single source of knowledge and expertise.  Therefore, to mitigate these concerns the effective developer engages in brainstorming sessions, socializes implementation concerns/breakthroughs and ensures contextual understanding during code reviews.   These actions facilitate:

• A healthy work-life balance.
• Uninhibited software value chain flow during developer absences.
• Opportunity and mobility to serve on various feature implementation teams.

When presented with multiple design and implementation choices, the effective developer selects those which provides customer value and poses the least risks for the organization.

The effective developer is cognizant of budget constraints recognizing that there is not an unlimited source of funding. Effective software developers engage in earnest level of efforts dialogues, regardless of the source of budget allocations, whether from corporate R&D funding or fix bid commercial agreements.

Value Engineering

New and enhanced product features are often borne from visionary thinking, market indicators, customer feedback and overall company strategy.  Furthermore, product augmentations are usually part of a strategic plan, tied to forecasted R&D investments and expected revenue gains.

This approach ensures proposed new and enhanced features when implemented, provide increased product value propositions that appeal to a broad customer base.  When new and enhanced features are planned, an upfront review of associated benefits and risks is required.  This review is necessary to ensure the delicate balance between implementation costs and valued product differentiators.

The effective software developer practices value engineering, respecting probable complexities associated with brownfield development.  Therefore, design and implementation details are based on unambiguous understanding of requirements. Gold plating or self-induced scope increase to showcase one abilities is avoided by the effective developer.  He understands the significance of expending effort, ensuring “built-in” quality for requested features.  Instead, the effective developer socializes his ideas, enabling the appropriate value proposition vetting, budget and forecasted release timeline impact reviews.

Personal Toolbox

The effective software developer is proficient in the use of commercial diagnostic tools (i.e. debugger, memory leak detector, task profiler).  However, he understands that scenarios will occur wherein a smaller and more focused diagnostic footprint is required, to facilitate a timely root cause analysis and subsequent resolution. Therefore, the effective developer has a personal set of diagnostic tools used when investigating and analyzing the behavior of specific types of bugs (i.e. Heisenbugs).

The effective software developer’s toolbox also contains reusable code fragments and libraries which have proven reliability.  These constructs are used to lower implementation risks associated with similar contextual related domain problems.  The effective developer continuously extends and augments his personal toolbox to ensure preparedness for future development opportunities and debugging scenarios.

Continuous Learning

The effective software developer understands the significance of continuous learning as a means, to increase professional value through improved technical and soft skills.  He understands the role of complacency, as a barrier to internal and external growth opportunities.

Furthermore, time to market considerations often limit the amount of ramp-up time available for technology familiarization.  Therefore, engaging in continuous learning enables practical application of new knowledge.  Improving preparedness, increases the probability of being able to make contributions towards varied workplace design and implementation activities.

Software organizations, have a role in facilitating continuous learning. However the effective developer, does not have sole reliance on his employer.   He/she maintains an active role in one or more online software communities.  In addition, the effective software developer periodically engages in self-study and/or contributes to open source projects.

Conclusion

Quality software provides business value and is essential for continuous software delivery and sustainment of an optimized deployment pipeline.  Organizational culture, level of commitment to quality and adopted processes facilitate production and delivery of quality software.   However, the contributions made by effective software developers are a key differentiator for producing quality software.  Effective software developers are not the proverbial “water walkers”, however their collaborative spirt, respect for other roles along the software value chain, creativity and commitment to continuous learning and production of quality software are undeniable.

Effective software developers are more likely to thrive in organizations that have a viable product strategy, are structured to facilitate business agility and openly acknowledges, values and rewards their contributions.  These organizations also provide suitable tools, build, development and test environments, adopts light-weight processes, encourages continuous learning and offers growth opportunities.

Software organizations must actively take measures to recruit and retain effective developers to facilitate continuous production of quality software.  Although, continuous delivery of quality software requires teamwork, effective developers play a central role and should be acknowledged for their contributions.