Friday, June 22, 2018

2018-06-22 Friday - Advice to a Development Team Struggling with Delivery & Defects

Recently I had a discussion with the CEO of a  .NET focused software development company - who was concerned with recurring delays in his development organization's ability to consistently meet agile sprint delivery schedules - and an attendant problem of unexpected defect rates in the code that was delivered.  

After our brief discussion, I suggested that - based on the symptoms he  described - my initial suggestion would be to ensure that the following three areas were not contributors  - and were well understood by the development teams . 

Possible Root Causes To Investigate (in the near-term):

1) Developers may not be adequately trained in agile practices and the language/tools they are using
  • Defects will tend to cluster around either specific persons and/or  specific code modules.  Root-cause analysis is essential to properly determine the appropriate mitigation actions, such as...
  • Use the 5-Whys of Six Sigma to determine the root cause for defects - often it may come down to a lack of knowledge/training - being tasked to do something outside their area of expertise - lack of awareness of good code design principles, etc.
  • For example (from my 2015 Seattle Code Camp talk, Diagnosing The Patient):
    • 1st: Why is the system slow?
      • The DB is slow
    • 2nd: Why is the database slow?
      • The app executes a lot of queries to load a page
    • 3rd: Why is the app designed to be so chatty?
      • DB was designed in an inefficient manner by [X]
    • 4th: Why didn’t [X] use an efficient DB design?
      • [X] was never trained on database design
    • 5th: Why didn’t [X] get any DB design training?
      • There is no budget for training
2) Developers may not be following Test Driven Design/Development (TDD) practices
  • This can be due to a number of possible causative factors:
    • Developers may be overwhelmed with unrealistic workloads squeezed into sprints
    • Developers may not be adequately trained/experienced to properly estimate Epics/Stories/Tasks - and therefore are simply racing as fast as they can to crank out the code for a given sprint
    • Developers may be writing trivial tests - and not focusing on the 20% that represents the `critical section` - first. 
3) Continuous Integration may not be in place (or taking advantage of all of its capabilities)


Uncle Bob Martin's book, Clean Code - is the foundation knowledge that is necessary for every developer to be successful:
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882



He also teaches a 3-day workshop


2018-06-22 Friday - Scaled Agile Framework (SAFe) for Lean Enterprises


I'm researching the pros/cons of SAFe - and this posting will be a placeholder for articles that I find that may be of interest to others.

Background Reading:

  • Chrysler Comprehensive Compensation (C3) project  
    • https://www.martinfowler.com/bliki/C3.html
      • "The software went live in 1997 paying around ten thousand people. The project continued, intending to take on a larger proportion of the payroll but new development was stopped in 1999. Later on the existing live system was reverted back to the COBOL"
      • "C3's cancellation, however, also proves that XP is no guarantee of success."
  • https://en.wikipedia.org/wiki/Agile_software_development
  • http://agilemanifesto.org/
    • Four Values:
      1. Individuals and interactions over processes and tools
      2. Working software over comprehensive documentation
      3. Customer collaboration over contract negotiation
      4. Responding to change over following a plan
  • http://agilemanifesto.org/principles.html
    • 12 Principles:
        1. Our highest priority is to satisfy the customer through early and continuous delivery of valuable software. 
        2. Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage. 
        3. Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.  
        4. Business people and developers must work together daily throughout the project.
        5. Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.  
        6. The most efficient and effective method of conveying information to and within a development team is face-to-face conversation. 
        7. Working software is the primary measure of progress.  
        8. Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.  
        9. Continuous attention to technical excellence and good design enhances agility.  
        10. Simplicity--the art of maximizing the amount of work not done--is essential.  
        11. The best architectures, requirements, and designs emerge from self-organizing teams.  
        12. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly. 
    • https://www.agilealliance.org/agile101/subway-map-to-agile-practices/ 


    SAFe References:

    Case Studies:

    Counterpoints: Some SAFe counterpoints articles to consider...



    There are some people who have misread or misinterpreted the SAFe documentation - and concluded that all technology and architecture decisions are made by the individual delivery teams.  That is not only factually incorrect - it is a gross distortion - and has the probability of severe consequences, over time.

      • O course, not all decisions should be decentralized. Some decisions are strategic, have far-reaching impact, and are outside the scope, knowledge, or responsibilities of the teams. In addition, leaders are still accountable for outcomes. They also have the market knowledge, longer-range perspectives, and understanding of the business and financial landscape necessary to steer the enterprise.

        © Scaled Agile, Inc.
        Include this copyright notice with the copied content.

        Read the FAQs on how to use SAFe content and trademarks here:
        https://www.scaledagile.com/about/about-us/permissions-faq/
        Explore Training at:
        https://www.scaledagile.com/training/calendar/
        Of course, not all decisions should be decentralized. Some decisions are strategic, have far-reaching impact, and are outside the scope, knowledge, or responsibilities of the teams. In addition, leaders are still accountable for outcomes. They also have the market knowledge, longer-range perspectives, and understanding of the business and financial landscape necessary to steer the enterprise.

        © Scaled Agile, Inc.
        Include this copyright notice with the copied content.

        Read the FAQs on how to use SAFe content and trademarks here:
        https://www.scaledagile.com/about/about-us/permissions-faq/
        Explore Training at:
        https://www.scaledagile.com/training/calendar/
        Of course, not all decisions should be decentralized. Some decisions are strategic, have far-reaching impact, and are outside the scope, knowledge, or responsibilities of the teams. In addition, leaders are still accountable for outcomes. They also have the market knowledge, longer-range perspectives, and understanding of the business and financial landscape necessary to steer the enterprise.

        © Scaled Agile, Inc.
        Include this copyright notice with the copied content.

        Read the FAQs on how to use SAFe content and trademarks here:
        https://www.scaledagile.com/about/about-us/permissions-faq/
        Explore Training at:
        https://www.scaledagile.com/training/calendar/
        Of course, not all decisions should be decentralized. Some decisions are strategic, have far-reaching impact, and are outside the scope, knowledge, or responsibilities of the teams. In addition, leaders are still accountable for outcomes. They also have the market knowledge, longer-range perspectives, and understanding of the business and financial landscape necessary to steer the enterprise.

        © Scaled Agile, Inc.
        Include this copyright notice with the copied content.

        Read the FAQs on how to use SAFe content and trademarks here:
        https://www.scaledagile.com/about/about-us/permissions-faq/
        Explore Training at:
        https://www.scaledagile.com/training/calendar/
        Of course, not all decisions should be decentralized. Some decisions are strategic, have far-reaching impact, and are outside the scope, knowledge, or responsibilities of the teams. In addition, leaders are still accountable for outcomes. They also have the market knowledge, longer-range perspectives, and understanding of the business and financial landscape necessary to steer the enterprise.

        © Scaled Agile, Inc.
        Include this copyright notice with the copied content.

        Read the FAQs on how to use SAFe content and trademarks here:
        https://www.scaledagile.com/about/about-us/permissions-faq/
        Explore Training at:
        https://www.scaledagile.com/training/calendar/
        "Of course, not all decisions should be decentralized. Some decisions are strategic, have far-reaching impact, and are outside the scope, knowledge, or responsibilities of the teams. In addition, leaders are still accountable for outcomes. They also have the market knowledge, longer-range perspectives, and understanding of the business and financial landscape necessary to steer the enterprise."


    Wednesday, June 20, 2018

    2018-06-20 Wednesday - Some Reading on Lightweight Architecture Decision Records (ADRs)

    An interesting article to read first:
    Sustainable Architectural Design Decisions
    https://www.infoq.com/articles/sustainable-architectural-design-decisions


    https://www.thoughtworks.com/radar
    Volume 18, May 2018  - Item #1 in the Techniques section of the current ThoughtWorks Radar report recommends adopting "Lightweight Architecture Decision Records"
    [note: This is the only Adopt recommendation in the Techniques section, so that is noteworthy in itself]


    A historical perspective on the evolution of this ThoughtWorks recommendation:
    https://www.thoughtworks.com/radar/techniques/lightweight-architecture-decision-records

    ...and the associated concept of Evolutionary Architecture
    https://www.thoughtworks.com/radar/techniques/evolutionary-architecture

    Michael Nygard's thoughts on Lightweight Architecture Decision Records (2011):
    http://thinkrelevance.com/blog/2011/11/15/documenting-architecture-decisions
    "An architecture decision record is a short text file in a format similar to an Alexandrian pattern that describes a set of forces and a single decision in response to those forces.”


    Increasing Software Transparency with Lightweight Architectural Decision Records (2017)
    https://dev9.com/blog-posts/2017/5/increasing-software-transparency-with-lightweight-architectural-decision-records
    (KM: I prefer the naming convention suggested in this article: "YYYYMMDD-NN-Short-Description.md" vs. Nygards simple sequential numbering scheme)


    Architecture Decision Records in Action (experience of part of the IBM Watson team adopting ADRs, starting on slide #26, see interesting graphs of ADR growth over time)
    https://resources.sei.cmu.edu/asset_files/Presentation/2017_017_001_497746.pdf
    *** see their observations, slide #33
    *** see likes/dislikes, slide #36


    Homepage of the ADR GitHub organization
    https://adr.github.io/

    Command-line tools for working with Architecture Decision Records
    https://github.com/npryce/adr-tools

    See this article too:
    https://kevinjalbert.com/start-now-architecture-decision-records/
    Interesting: the command line tool also supports being able to generate graphviz output for diagram generation (to visualize linked ADRs)
    example:
    adr generate graph | dot -Tjpg > graph.jpg


    Architecture decision record (ADR) examples
    https://github.com/joelparkerhenderson/architecture_decision_record


    Links to some info on the Alexandrian form (that Michael Nygard references in his article):
    http://wiki.c2.com/?AlexandrianForm
    https://www.martinfowler.com/articles/writingPatterns.html

    A deeper look at Alexandrian form....
    https://www.slideshare.net/JoshuaKerievsky/a-timeless-way-of-communicating-alexandrian-pattern-languages
    "the masterpiece, "A Pattern Language", by Christopher Alexander"
    Note: Christopher Alexander's A Pattern Language (APL) as an important influence in the patterns world.



    Also Interesting: 
    A Decision Modelling Language plugin for Sparx Enterprise Architect
    https://github.com/IFS-HSR/ADMentor
    https://github.com/IFS-HSR/ADMentor/releases

     

    2020 Addendums


    2021 Addendums

    2024 Addendums

     

    Sunday, June 17, 2018

    2018-06-17 Sunday - Quantum Computing Instruction Set


    Youtube: Quantum Instruction Set - Computerphile, Robert Smith of Rigetti Computing


    Rigetti Computing Software Demo: Forest
    https://www.youtube.com/watch?time_continue=2112&v=IpoASc18P5Q



    Domain Experts, Welcome to Quantum: Introducing QISKit ACQUA
    https://www.ibm.com/blogs/research/2018/06/domain-experts-qiskit-acqua/
    QISKit ACQUA – Algorithms and Circuits for QUantum Applications.

    Program Quantum Computers More Easily with QISKit 0.5
    https://medium.com/qiskitters/program-quantum-computers-more-easily-with-qiskit-0-5-802d1e4a338d


    ProjectQ: an open source software framework for quantum computing

    Friday, June 01, 2018

    2018-06-01 Friday - Groovy Warning: Java (9, 10) Illegal Reflective Access

    After upgrading to Java 10, I ran into this annoying Groovy warning:

    WARNING: An illegal reflective access operation has occurredWARNING: Illegal reflective access by org.codehaus.groovy.reflection.CachedClass (file:/D:/apps/groovy/groovy-2.4.10/lib/groovy-2.4.10.jar) to method java.lang.Object.finalize()WARNING: Please consider reporting this to the maintainers of org.codehaus.groovy.reflection.CachedClassWARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operationsWARNING: All illegal access operations will be denied in a future releaseCaught: java.io.FileNotFoundException: C:\Users\Kelvin\-V (C:\Users\Kelvin\-V)java.io.FileNotFoundException: C:\Users\Kelvin\-V (C:\Users\Kelvin\-V)        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)        at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

    "An illegal reflective access operation has occurred"
    • https://issues.apache.org/jira/browse/GROOVY-8339
    • Per Paul King:
      • "That warning is to be expected on all currently released versions of Groovy under JDK9. The operation we are doing is perfectly legal under JDK8 and earlier and represents correctly working code. It just doesn't conform to the new rules imposed by the Java 9 module system. It won't affect program use under JDK9."
      • "In unreleased versions of Groovy, we have a temporary workaround to avoid the warnings involving setting an environment property flag but this doesn't apply to using Groovy in an embedded mode like from Gradle. You could adopt the same approach it uses (involves --add-opens and --add-modules) but it would involve some hackery on your part."
      • "There are other nasty hacks to get around the warning but I" don't recommend them"
      • "Groovy continues to work fine with JDK10 despite the annoying warnings."



    Background Reading:

    Copyright

    © 2001-2021 International Technology Ventures, Inc., All Rights Reserved.