Packages – Difference Between Package and Component

componentpackages

I commonly come across the terms "package" and "component" in software engineering. To my understanding, both indicates an independent software that can be used by another (larger) software.

What are the technical definitions of "package" and "component" and what are the difference between them?

Best Answer

Component

The principle of systems made of components and the quest for reusable components have driven lots of work in the OO software engineering since the early 80s. There is therefore a rather clear consensus about what it is.

The SWEBOK provides the following definition in section 7.Software Design Strategies and Methods:

A software component is an independent unit, having well-defined interfaces and dependencies that can be composed and deployed independently.

The UML specifications provide for similar semantic in section 11.6.3:

A Component is a self-contained unit that encapsulates the state and behavior of a number of Classifiers. A Component specifies a formal contract of the services that it provides to its clients and those that it requires from other Components or services in the system in terms of its provided and required Interfaces. A Component is a substitutable unit that can be replaced at design time or run-time by a Component that offers equivalent functionality based on compatibility of its Interfaces.

The core idea of both definition is that the component is something that is self-contained ("independent ... having well-defined ... dependencies"), that provides an interface with a contract (i.e. a promised behavior, the latter being implied by "independently composable"), and is replaceable by another component offering the same interface and contract.

However, despite this consensus, component may still mean slightly different things to different people. For example, some consider that a component must be embodied in a deployable artefact (e.g. executable, dynamic library, ...), while other see the component already in the construction process (e.g. separate compilation unit).

Package

There is unfortunately lot less consensus on what a package is. The reason is that different mainstream technologies use the same term for different purpose. For example:

A java package is a mean to group related classes and interfaces, by organizing a common namespace. In practice, packages often end up (alone or with other packages) in JARs which are deployable artifacts that could match the definition of a component.
A Software deployment package is a group of files and configuration items that make a deployable software unit. Packages are in general versioned. Package managers allow to automate the deployment of such packages.
An UML package is a way to structure complex models into smaller, more manageable sub-models, by regrouping packageable elements.

So depending on the context, it is a group of deployagble artifacts that form a whole (which is in fact very close to the definition of a component), a group of components, or just a subdivision of something larger. The only general consensus here seems to be that a package regroups artifacts.

Related Solutions

Function vs Component – Key Differences Explained

There is no clear notion of the term »component«. You could use it in many different ways. But if you go to the root of the word (in terms of linguistics) you have »componere«, which is itself a »compositum« of »cum« (with) and »ponere« (put). So if you put something together you have a »composition« of individual parts.

There are two main aspects for components:

Composition »put together«
Compartmentalization »independent things«

So a software component is a unit or part of software, which in itself could be used independent from the actual composition - but on the other hand is used to build a larger system. Ideally you have a software in which each component is orthogonal, which means, no component is dependent on another component and they do each their job, where no functionality is duplicated (a form of DRY).

In most cases you could substitute »component« with »part«.

I am trying to figure out what components mean in the context of the composite pattern.

The point of the composite pattern is to put independent parts under a unique interface. You have the base component as a contract for each part to comply with. You have a leaf which is the part and you have the composite, which contains a collection of those parts.

1) What is the difference in purpose between a function and a component?

A component is the subject / carrier of a function ( in OO-terms). On the other hand, if you take functional languages, I think it would be okay, to speak of functions as components in a functional composition. In a broader sense, you could speak of a component in a whole, which represents one function: e.g. »a printing component« which stands for the function to be able to print.

2) What does a component have to do with the composite pattern?

See above: Composite is about putting together components.

3) Can you describe what a component is by using a funny metaphor? For example, explain how creating a component like baking an apple pie.

One way to put it: A component is like an ingredient for a meal.
Another way to put it: A component is a player in a soccer game. Each of them is different and has to play another role in the game, but together, they are a team and play soccer.

Python – Should Scripts Be Included Inside a Python Package?

Yes, this is possible and quite common for packages that serve as both command-line tools and imported libraries.

In setup.py, add a module's function as an entry point:

setuptools.setup(
    ...
    entry_points={'console_scripts': [
        'foo = my_package.some_module:main_func',
    ]},
    ...
)

To create a script named foo that calls the my_func function inside of my_package.some_module. Read more at https://pythonhosted.org/setuptools/setuptools.html#automatic-script-creation.

It is also a convention it to add:

#!/usr/bin/env python

...

if __name__ == '__main__':
    my_func()

to the modules that can be called as "scripts" where my_func is the function you'd like to call externally.

Here is an example of setup.py:

https://github.com/jacebrowning/gdm/blob/fa998167f5f6de64bc8bdfd8b9433870d79ef814/setup.py#L28-L31

and a callable module:

https://github.com/jacebrowning/gdm/blob/fa998167f5f6de64bc8bdfd8b9433870d79ef814/gdm/cli.py#L161-L162