Stages of Software Development

Pythons Trove Classifiers have 7 stages of software development:

Development Status :: 1 - Planning
Development Status :: 2 - Pre-Alpha
Development Status :: 3 - Alpha
Development Status :: 4 - Beta
Development Status :: 5 - Production/Stable
Development Status :: 6 - Mature
Development Status :: 7 - Inactive

In this mini-article I try to describe what those stages are.

Semantic Versioning

There are a couple of different ways to set a version string:

  • git hash: 409b48b0d49c6b5d82ec8711b9341fc99b31ff98
  • Counting upwards: 1, 2, 3, ...
  • Yearly versions:
    • Ubuntu: 16.04, 16.10, 17.04, 17.10, ...
    • pytz: 2016.10, 2017.2, 2017.3, 2018.3, 2018.4, ...
  • Semantic versioning: 0.19.1, 1.0.0, 1.0.1, 1.1.0,... as used by scipy

git hashes are only there to have an identifier for a commit which can be (ab)used as a version string. The other versioning ways are better because you can directly see which version is more recent.

Yearly versions and semantic versioning are better than simply counting upwards, because the version string carries additional information. Instead of only knowing that something is the next version, you either know how much time has passed or which type of change was done.

I suggest taking 5 minutes to read semver.org, but the bare minimum you need to know about it is:

Given a version number MAJOR.MINOR.PATCH, increment the:

MAJOR version when you make incompatible API changes,
MINOR version when you add functionality in a backwards-compatible manner, and
PATCH version when you make backwards-compatible bug fixes.

Development Stages

1 - Planning

Having this trove classifier online basically means you only reserved the name on PyPI.

  • Required properties: There is no software package, no content whatsoever.
  • Typical steps: Creating wireframes (e.g. with Balsamiq), drafting architectures and expected workflows (e.g. UML diagrams), writing user stories, defining features, defining which features NOT to have
  • Semantic version: -
  • PyPI: 2172 projects - noting I know of

2 - Pre-Alpha

  • Required properties: There is already some software that gives an idea what it is supposed to do.
  • Typical steps: Drafting ideas, adding new features, refactoring a lot. Here, the complete architecture of the software might still change.
  • Semantic version: 0.X.X
  • PyPI: 5067 projects - noting I know of

3 - Alpha

  • Required properties: The software has the minimal required set of features to be useful. The architecture of the software is clear.
  • Typical steps: Internal testing. People close to the developers can use the software.
  • Semantic version: 0.X.X
  • PyPI: 10,000+ projects, including Lasagne

4 - Beta

  • Required properties: Software is feature complete
  • Typical steps: External testing, fixing bugs and performance problems. Usability testing.
  • Semantic version: 0.X.X
  • PyPI: 10,000+ projects, including pint

5 - Production/Stable

  • Required properties: No major bugs known, tests cover the most important cases.
  • Typical steps: Fixing bugs, adding updates and new features.
  • Semantic version: ≥ 1.0.0

PyPI: 10,000+ projects, including SQLAlchemy, numpy, pandas

6 - Mature

  • Required properties: Software was in production for more than a year. No new features were required, no major/critical bugs are open.
  • Typical steps: Fixing minor bugs.
  • Semantic version: ≥ 1.0.0
  • PyPI: 415 projects, including Zope, pytz and Pillow

7 - Inactive

At some point the developers will not add updates to software. Maybe it was a free-time project and they are not interested in it anymore. Maybe the company doesn't get enough money from that project. It can still be valuable to keep the software in the repository. Marking it as "inactive" tells developers that it's unlikely known issues will be fixed.

PyPI: 283 projects, including

Important to note here: It is, of course, always possible that it switches back to any of the other development stages

See also

Published


by

Category

Code

Tags

Contact