Component-based Software Engineering (CBSE), to produce software by connecting of the shelf ready-to-use components, promises costs reduction during the development, the maintenance and the evolution of a software. The recent period has seen the production of a very important set of new results in this field. As the term “component” is very general, it encompasses many researches having different objectives and offering various kind of abstractions and mechanisms. However one main overall accepted idea is to model software with components organized into architectures and to generate code from such abstract descriptions. This is a good idea but the question arises to know which languages are good candidate for the generated code. In the current practice the design phase happens in the component world and the programming phase occurs in the object-oriented world. It appears that languages and technologies used to achieve component-based development are only partially component-based. Our first claim is that to use component-based languages to write the executable code is primarily important just because the original component-based designs (e.g. requirements, architectures) do not vanish at run-time, making programs more understandable and reversible. By doing this, it is then possible to imagine that design (modeling) and programming can be done at the same conceptual level and why not using the same language. Usually, objects are most always chosen to implements component-based designs. It is true that an object is certainly the existing executable thing the closest to a component as they are understood today; close but not exactly the same. Our second claim is then that it is possible to achieve component-programming languages by smoothly modifying object-oriented ones. Following these ideas, we implemented a new pure component-based programming and modeling language, named COMPO incorporating, in a simple and uniform way, core concepts and mechanisms necessary for the description and implementation of components and of component-based architectures: component, port, service, connection and the following mechanisms: instantiation, service invocation, composition and substitution. We also claim that describing components, their architectures (structures) and their services (behavior) would benefit (as objects descriptions do) from an inheritance-based differential description. In consequence we propose a specification and implementation of an inheritance system taking requirements into account on a covariant specialization policy base and with a corresponding dedicated substitution mechanism. We finally claim that making such a language fully reflective will open an interesting new alternative (in the component’s context) for any king of model or program checking or transformation. We revisit some standard solutions to achieve an original component-oriented reification of concepts to build up an executable meta-model designed on the idea of “everything is a component”. A complete prototype implementation of the COMPO language has been achieved and is described in the following thesis: https://www.lirmm.fr/compo/download/Petr-SPACEK-thesis.pdf