• Top
    • Documentation
    • Books
    • Boolean-reasoning
    • Projects
    • Debugging
    • Std
    • Proof-automation
    • Macro-libraries
    • ACL2
      • Theories
      • Rule-classes
      • Proof-builder
      • Recursion-and-induction
      • Hons-and-memoization
      • Events
      • Parallelism
      • History
      • Programming
        • Defun
        • Declare
        • System-utilities
        • Stobj
        • State
        • Mutual-recursion
        • Memoize
        • Mbe
        • Io
        • Defpkg
        • Apply$
        • Loop$
        • Programming-with-state
        • Arrays
        • Characters
        • Time$
        • Defmacro
        • Loop$-primer
        • Fast-alists
        • Defconst
        • Evaluation
        • Guard
        • Equality-variants
        • Compilation
        • Hons
        • ACL2-built-ins
        • Developers-guide
          • Developers-guide-background
          • Developers-guide-maintenance
          • Developers-guide-build
          • Developers-guide-utilities
          • Developers-guide-logic
          • Developers-guide-evaluation
          • Developers-guide-programming
          • Developers-guide-introduction
          • Developers-guide-extending-knowledge
          • Developers-guide-examples
          • Developers-guide-contributing
          • Developers-guide-prioritizing
            • Developers-guide-other
            • Developers-guide-emacs
            • Developers-guide-style
            • Developers-guide-miscellany
            • Developers-guide-releases
            • Developers-guide-ACL2-devel
            • Developers-guide-pitfalls
          • System-attachments
          • Advanced-features
          • Set-check-invariant-risk
          • Numbers
          • Efficiency
          • Irrelevant-formals
          • Introduction-to-programming-in-ACL2-for-those-who-know-lisp
          • Redefining-programs
          • Lists
          • Invariant-risk
          • Errors
          • Defabbrev
          • Conses
          • Alists
          • Set-register-invariant-risk
          • Strings
          • Program-wrapper
          • Get-internal-time
          • Basics
          • Packages
          • Oracle-eval
          • Defmacro-untouchable
          • <<
          • Primitive
          • Revert-world
          • Unmemoize
          • Set-duplicate-keys-action
          • Symbols
          • Def-list-constructor
          • Easy-simplify-term
          • Defiteration
          • Fake-oracle-eval
          • Defopen
          • Sleep
        • Operational-semantics
        • Real
        • Start-here
        • Debugging
        • Miscellaneous
        • Output-controls
        • Macros
        • Interfacing-tools
      • Interfacing-tools
      • Hardware-verification
      • Software-verification
      • Math
      • Testing-utilities
    • Developers-guide

    Developers-guide-prioritizing

    Prioritizing: When to Make Changes

    It may be tempting to enhance ACL2 whenever an intriguing idea comes along for making an improvement. There is something to be said for doing so: the immediate motivation may make the work fun and lead to good results.

    SUMMARY THAT SHOULD SUFFICE: Fix bugs, prioritize what will actually be used, and beware of massive regression failures. Changes can be extremely valuable, and can also be substantially more work than predicted.

    But there can be drawbacks to taking on every opportunity to make an improvement. Heuristic improvements can be very difficult to work out without breaking, or slowing down, the regression suite. A change may inadvertently break something. Changes may be much more time-consuming than expected, and may take time away from other more important changes to be made. Below we explore some aspects of prioritizing development tasks.

    Bugs

    Bug fixes are generally a priority, especially (of course) if they impact soundness. Enough said?

    Accommodating user requests

    It has been observed that many ideas for improvements that may seem helpful are actually not very helpful to anyone actually using ACL2. It is therefore usually a good idea to prioritize changes that either accommodate specific requests from a user, or at the least can be seen as having significant positive impact on users. It is very easy to think a new feature will be useful, but with the result that it's rarely or ever used, yet it complicates the source base. A feature you consider might be close to being useful, but by waiting for a specific request, you can perhaps get substantially more insight about what would truly be useful, thus refining your initial idea for that feature.

    Impacts on the regression suite

    The ACL2 community-books provide a well-established set of libraries, as well as a useful set of regression tests. Changes to ACL2 may cause some failures when certifying these books. Often these are easy to fix, for example by modifying theory hints or by changing subgoal names on hints. Changes may also impact ACL2(p) or ACL2(r), which are probably tested significantly less frequently. More worrisome is the potential impact on private repositories, for example proprietary (not public) sets of books at companies. There can also be slowdowns, which can be debugged by running the tool compare.pl; see the chapter, developers-guide-maintenance. There is a balance, addressed by using judgment, between introducing behavioral changes and maintaining the community books and private repositories. There needs to be a guess about whether the benefit of the change outweighs the effort required to design and implement it and the fallout of requiring changes to books.

    NEXT SECTION: developers-guide-evaluation