pip - The Product Vision

What is pip?

pip is the package manager for Python. A package manager is a tool that allows you to install and manage additional libraries and dependencies that are not distributed as part of the standard library. It can be used to install packages from the Python Package Index and other indexes. These indexes are online repositories that host these libraries and dependencies.

pip has been included with the Python installer since versions 3.4 for Python 3 and 2.7.9 for Python 2. However, since version 21.0 of pip, support for Python 2 has been dropped.

The package manager was first introduced as “pyinstall” in 2008 as an alternative to “easy_install”. The name “pip” was chosen after several suggestions from its users. According to Ian Bicking (the creator of pip)1, the name pip is a recursive acrnonym for “pip installs packages”.

Overall, pip is one of the largest open-source projects written in Python. With almost 7000 stars on GitHub, over 500 contributors, and countless users around the world, you can easily see that the community behind pip is enormous.

Key domain concepts

Package Management

The main domain for pip is to manage the Python libraries and dependencies on a local machine. pip makes it easy for users to install and keep track of packages that are not included in the standard python library.

Python programming language

Since pip is so important to Python, the package installer has been included in the Python installer. At the moment there are no realistic alternatives to pip, and because pip is included in the Python installer, we can assume that pip will stay relevant as long as Python stays relevant.

Documentation Portal

There is a pip documentation portal2 that provides its users all the documentation that is needed. It contains installation manuals, user guides and development news, and how to contribute to the development of pip.

pip’s capabilities and properties


As a package managing software, some features are deemed to be included within the software. These features are mostly related to installing and uninstalling packages. With these key features, pip has helped countless developers managing packages in their Python projects.

Installing packages: One of the core capabilities of pip is installing packages from PyPI through a single command in the terminal, making it easier for developers to develop software. Python already included a nice set of packages and modules to support developers, however, for more specific functionality the packages must be installed externally, making this functionality of pip very useful.

Uninstalling packages: pip can also uninstall packages with a single command in the terminal. The capability to uninstall packages would allow developers to properly manage their packages. This would allow users to uninstall and delete unused packages.

Updating packages: Updating installed packages allows developers to include for example new features, bugfixes or security measures included in the updated version of the package. This is optional for the developer and could be done through a command in the terminal.

Searching packages: Available packages for pip are mostly listed in PyPI. Additionally, all Python packages, including the ones found in PyPI, can be found through pip’s search command. The search command uses a query and retrieves packages based on names and summaries.


pip has some properties that makes life easier for developers. These properties are mostly derived from user comfort and accesibility.

Included in Python installers: pip is quite popular among developers and has helped a lot of developers manage their packages. It has carved its position into the development process and has been so important for Python developers that it has been included in Python 3.4 and onwards.

Supports Unix/Linux, MacOS and Windows: All commands related to pip can be performed on Unix/Linux, MacOS and Windows terminals making it quite accessible for all developers.

Current and future context

As mentioned before, pip is included in the Python installation package starting from Python 3.4 onwards. Since pip heavily depends on Python, it is given that when Python has heavy changes, pip has to adapt to it. However, whenever Python commits changes, the changes in pip should not be very drastic as the core still functions the same. The same can be told about the other dependencies such as PyPI and multiple operating systems. It is not very likely that all these dependencies would make drastic changes as they are all widely used and known within the development community.

Stakeholder analysis

According to Peters3, stakeholders are people that care about your project. pip has three main stakeholders; the developers/maintainers, end-users and funders.

The developers and maintainers are the people who keep pip up-to-date with new features and who make sure that bugs in the software will be solved. When looking at the contributors4 of this repository, it showed that there are 10 main contributors with a lot of lines and commits. These contributors do most of the code reviews for pull requests and will make sure that all code will adhere to the standards of pip. Developers and maintainers are very important for pip, because without them, pip would probably not exist.

The second group of stakeholders are the end users. These are the Python developers who are using pip as their package installer. This is the largest group of stakeholders, because pip is the most popular package installer for Python. This is therefore the most important stakeholder for pip, since pip has to make sure that the software will satisfy the goals and concerns of software developers5.

The final stakeholder of pip are the funders and sponsors. Within pip, there is not a difference between sponsors and funders. According to Mobus (2019)6, there has recently been two funders. These funders are Mozilla and the Chan Zuckerberg Initiative. They supported pip with 407.000 US Dollar in 2020 to support their development in that year. The main goal of these two funders was to make the package installer easier to use and easier to troubleshoot6. Funders are very important for pip, because pip is free-to-use and maintained by open-source contributors. Funders allow maintainers and developers to use more resources to improve the development of pip and pip itself. Other past funders and sponsers can be found on the PyPi website7

pip’s key quality attributes

As mentioned earlier, pip is a package installer which should be used to install, uninstall and update packages from the Python Package Index. Quality attributes are properties of a system to indicate how well the system satisfies the stakeholders8. There are many different quality attributes for systems, such as usability and security. In the context of pip, all quality attributes can be divided into internal and external quality attributes. External quality attributes are about the purpose of the software product, while internal quality attributes are about the engineering process. pip has different stakeholders which all require different key quality attributes. This section will discuss what the key quality attributes of pip are and how they will satisfy the needs of all different stakeholders.

Maintainability (internal quality attributes)

Reading the documentation and analysing the code base of pip, it showed that pip is maintainable, which should make it easy for developers to maintain pip and add new features. The system is easy maintainable, because it is documented very clearly and the CI runs many checks to ensure code quality. pip also added a bot to generate documentation and requires specific files explaining what has been changed for every PR, which will be converted into one single file with all changes. This will help developers to keep track of their changes. Since the goal of the funders is to also improve the maintainability of the code, the needs of the funders will also be satisfied with these quality attributes.

Usability, portability and functionality (external quality attributes)

Other important key quality attributes of pip are that it is easy to use, portable and contains all required functionality for the end-users. These are all very important attributes for the end-users, because they want an easy to use package installer. The functionality of pip is very easy to use as most of them are simple command line commands, which makes pip very usable. pip is also very easily installable on different devices with different operating systems. This makes pip portable. Finally, end-users are mainly using pip to install, uninstall and update packages. pip contains all this functionality in addition with some more advanced functionalities. Therefore, pip also contains all required functionality expected from its end-users.


For reference, the current version of pip as of writing this, released on the 23rd of January 2021, is v21.0. This means that we will discuss the features planned for future releases from this version onwards. As pip is actively maintained, this very paragraph could already be outdated the moment you are reading this.

Future development documentation

pip does not have an actual roadmap, but does have very limited documentation on (possible) future developments. In this section of the documentation, they directly link to PEP 426. PEP is a Python Enhancement Proposal, where 426 describes metadata for Python software packages 2.0. This however, was withdrawn from Python itself in favour of PEP 566, which was claimed to be more modest. The general idea behind both of these proposals is to have a mechanism for publishing and exchanging metadata related to Python distributions. pip describes that one of their future developments is, once this has been implemented by Python, to migrate to using that interface.

Future labelled issues

Unfortunately, this is their only future development documented in the pip documentation for v21.1. To further search for possible planned updates, we looked at the issues that were open on pip’s GitHub. Here, we found an issue label that defined “UX - future work”, and we considered this to also be a feature or enhancement that pip would like to see in the future. The sole issue with this label defined a requirement for auditing ‘pip’ output. This issue was moved to being future work as “this is not something that we’ve been able to achieve within the current funded UX work.”, quoted directly from one of pip’s active contributors who labelled the issue.

Ethical considerations

pip is a command line program and purely used as a package manager for the programming language Python. It allows to install and manage extensions to the Python standard library. Usually, the extensions pip installs are from PyPI (Python Package Index). One could argue that the only ethical issues pip has, is to make sure that package names are morally right, but since pip is not the source of these packages, as this is PyPI, it could be argued that those ethical issues and considerations fall under PyPI, and not pip.

Aside from this, pip does have a Code of Conduct9, in which it requires all interactors of pip to follow the PSF Code of Conduct10 (Python Software Foundation’s CoC). This Code of Conduct describes rules to the community, their standards, what defines inappropriate behaviour and the consequences of not following this conduct (and other topics, some of which don’t direclty apply to pip).


  1. Bicking, I: a blog :: pyinstall is dead, long live pip! (2008, October 28). Ian Bicking. https://www.ianbicking.org/blog/2008/10/28/pyinstall-is-dead-long-live-pip/index.html ↩︎

  2. pip documentation portal, https://pip.pypa.io/en/stable/ ↩︎

  3. Peters, S. (2018). Do you know who your stakeholders are? - O’Reilly Open Source Convention in Portland 2018. Do You Know Who Your Stakeholders Are? https://conferences.oreilly.com/oscon/oscon-or-2018/public/schedule/detail/66945.html#:%7E:text=Stakeholders%20are%20the%20people%20that,a%20project’s%20contributors%20and%20users↩︎

  4. pip contributors, https://github.com/pypa/pip/graphs/contributors ↩︎

  5. Pautasso, C (2020), Software Architecture visual lecture notes ↩︎

  6. Mobus, M (2019), Python Software Foundation: Mozilla and Chan Zuckerberg Initiative are funding pip with $407,000m, retrieved from https://jaxenter.com/python-pip-mozilla-chan-zuckerberg-initiative-165356.html ↩︎

  7. pip sponsors, https://pypi.org/sponsor/ ↩︎

  8. Silva, A. (2017, December 27). How to Write Meaningful Quality Attributes for Software Development. How to Write Meaningful Quality Attributes for Software Development. https://www.codementor.io/@antoniopfesilva/how-to-write-meaningful-quality-attributes-for-software-development-ez8y90wyo ↩︎

  9. pip code of conduct, https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md ↩︎

  10. PSF Code of Conduct, https://www.python.org/psf/conduct/ ↩︎