I believe the answer to above question is Yes! If researchers of computer science try to discover the innate nature and essential characteristics uniquely and universally shared by each and every known physical functional component, I can’t find any valid reason why the researchers could fail. The last several paragraphs are dedicated to support this answer (please let me know, if there is any flaw).
If the answer is Yes, why is it not possible to invent equivalent software components sharing the innate nature and the essential characteristics?
Let me define what is meant by essential characteristics: The essential characteristics are the minimum set of properties uniquely and universally shared by each and every known physical functional component. That is, if ‘X’ is an essential property, no physical functional part can be a functional component without having the property ‘X’, and the physical functional component could no longer be a physical component, as soon as it looses the property ‘X’.
In software applications, we only deal with functional components and larger components are more useful, so as a first step I am only interested in discovering such essential characteristics of the physical functional components. This also eliminates possible conflicts and confusion in case of border or fringe cases and non-functional parts such as bolts, nuts, washers and other individual pieces of metal (e.g. panels for car such as bumper, bonnet or grill), plastic or glass (e.g. windshield glass or mirror). Of course, a functional component such as auto-engine may be created by assembling multiple pieces or parts of metal.
Let me provide background for how and why I started this research effort:
I accidentally stumbled onto a GUI library that is capable of implementing a class definition by encapsulating the application code for any GUI-application (where the class definition is referred to as RCC-Replaceable Component Class). These RCCs can be used to assemble these applications as sub-components to build larger and larger RCCs (for building larger and larger container-components). In this case, it required just 3 lines to assemble each replaceable component by using respective RCC, and the component can be effectively removed by removing the 3 lines. For example, this sample application is created by 6 such RCCs: http://real-software-components.com/CBD/City_GIS.html
After implementing application code for many small GUI-applications as RCCs, it was fascinating to see even junior developers able to build complex GUI-applications having hierarchy of replaceable components by using each of the RCCs to assemble each of the replaceable components. It induced irresistible curiosity more than 10 years ago and decided to focus on this research. Another thing, I felt (after creating hundreds of hierarchies of replaceable components) that the replaceable components are equivalent to the ideal physical functional components and each of the hierarchy of replaceable components is logically equivalent to the CBD-structure (one of the essential aspects of the CBD design of physical products). See CBD-structure: http://real-software-components.com/CBD/CBD-structure.html
This kind of experiments made me consider the possibility that it is possible to invent real components for software that are equivalent to physical functional components for achieving real CBD for software (e.g. by achieving a structure equivalent to the CBD-structure for any software application).
After careful observation of many large physical functional components, I believed, there exists a mysterious property that is uniquely and universally shared by each and every known physical functional component. I could not find any terminology to describe the mysterious property. After further research and making satisfactory progress and beginning to grasp the innate nature, I named the mysterious property ‘self-contained’, since I felt that the term “self-contained” roughly (or vaguely) fits the intended meaning of the mysterious property.
So I created a hypothesis that each and every physical functional component shares an essential property, which I named “self-contained”. I must validate this hypothesis for discovering the nature by employing a scientific process. I used the following method (which I believe is a widely used proven scientific method) to discover the intended meaning of term “self-contained”: http://real-software-components.com/RSCC/accurate_description_for_CP.html
I believe, any software expert can discover the intended meaning of ‘self-contained”, but it is not a simple task to discover the innate nature and the essential characteristics of the physical functional components. If this task is simple, software engineering would not be in this mess. For example, existing software engineering paradigm has been evolving for decades by relying on an erroneous postulation (or axiom or hypothesis), which defined the term ‘software components’ as an alias to ‘software parts’ either having useful properties (e.g. reuse or standardized etc.) or conform to so called component models. I believe, this task to discover is not impossible either. I believe, it requires few weeks of intense experimentation, critical analysis of facts and focused mind exercises or critical thinking (e.g. to overcome conformation bias, perceptions and basic concepts of deeply entrenched existing paradigm) to achieve gestalt’s shift.
Each large software application comprises of multiple ‘self-contained’ parts or modules. Since the essential property of ideal functional components is not yet discovered, today the chief software architects and designers of large software applications are not putting any conscious effort to identifying ‘self-contained’ parts or modules exist in the applications. I am proposing a new kind of CBD (Component Based Design) that requires identifying the multiple ‘self-contained’ parts or modules and implement the application code for each of the ‘self-contained’ parts or modules as an RCC (Replaceable Component Classes).
Each of the RCCs must require no more than 3 to 5 lines of code to assemble the respective replaceable component, and one must be able to effectively remove this replaceable component by removing the said 3 to 5 lines. It is preferable to not implement any more code for communication or configure each of the object instances of RCCs (i.e. replaceable components), so each replaceable components must rely on an intelligent CASE tool to collaborate with other components or parts of the container application. A internal implementation of a sample intelligent CASE tool is illustrated in FIG-3 at: http://real-software-components.com/CBD/Sample_SoA_CASE_tool.html
Therefore, the essential pre-requisite for the proposed CBSD (Component Based Design for Software) is discovering the essential properties of ideal functional components (of the physical world) to positively identify equivalent components in the context of software applications (a virtual world). That is, if the essential property is ‘self-contained’ (as I proposed), the software designer of an application must discover the intended meaning of the term ‘self-contained’ for positively identifying large self-contained parts in his software applications.
The primary differences between existing software design and proposed design for any large software application is: The chief designer must discover the essential properties (e.g. intended meaning of term ‘self-contained’) for positively identifying multiple ‘self-contained’ parts or modules. Implement each of the ‘self-contained’ parts or modules as a RCC, where each of the RCCs must rely on an instance of intelligent CASE-tool (included in the application by using a reusable class) for collaborating with other components and parts of the application.
It is not hard to implement a reusable class for the intelligent CASE-tool that can maintain coupling-interfaces of each of the components and facilitate communication between any two components by couplings the interfaces of components. Once a ‘self-contained’ part or module is identified, it is not hard to implement the application code in a set of exclusive files associated with a class definition referred to as RCC (in any modern Object-oriented programming languages such as C++, Java or C#).
In case of GUI-applications, the task of identifying self-contained parts or modules is less complex. In case of non-GUI-applications, the task of identifying self-contained components is more complex. That is, it requires lot more practice, knowledge and expertise not only on the innate nature of the component but also respective domains of non-GUI-applications.
However there is a catch-22 situation: In case of GUI-application, even though it is less complex to identify self-contained parts or modules, but no other GUI library (e.g. Windows/VC++ or Java/Swing) are designed to encapsulate application code of a self-contained component (e.g. a small GUI-application) such as City_LandMarks in a class definition. I am only saying that capability doesn’t exist in each of those GUI libraries (because the vendors of respective GUI platforms haven’t even heard of replaceable components). I am sure vendors of respective GUI platforms can quickly implement that capability, if they want to (e.g. if they discover the replaceable components and believe such RCCs are useful).
The most complex part for achieving real CBSD (Component Based Design for Software) is discovering the intended meaning of the term “self-contained”. Discovering the nature help the chief-designer to identify various parts and functionality or features of the applications that can be implemented as RCCs (Replaceable Component Classes).
Therefore, the trillion dollar question is: Is it possible to discover the nature and essential characteristics of ideal physical functional parts? I believe, the answer is absolutely YES! I am not saying it is easy to make this discovery. I am only saying that it is not impossible. I can’t give elaborate argument here, but let me give a simple argument (I am hopping smart people can connect the dots and fill any gaps or missing pieces). Also I appreciate finding any flaws or shortcomings to oppose (e.g. cons) or in support (e.g. pros) of the following argument.
Theoretically it is possible to discover nature (i.e. essential properties) of any physical being, including components. If attempted to discover the innate nature and essential characteristics, mankind never failed to discover the essential characteristics of any physical beings which can be seen and touched. A big part of basic sciences (e.g. chemistry, botany, zoology and physics) is to discover the nature (e.g. essential characteristics) of physical beings and (e.g. essential aspects of) phenomenon. Of course, mankind already discovered innate nature and essential characteristics of more complex and diverse species such as mammals, animals, plants, elements, atoms, molecules and bacteria etc.
Unfortunately it is impossible to find any evidence that researchers of computer science ever tried to discover the innate nature and essential characteristics of good old physical functional components (i.e. certainly a physical being) or essential aspects of good old CBD for physical products (i.e. logically a physical phenomenon). Without even trying and not even contemplating, is it wise to assume or argue that it is impossible to discover the innate nature and essential characteristics of good old physical functional components (i.e. certainly a physical being) or essential aspects of good old CBD for physical products (i.e. logically a physical phenomenon).
Let me name one of the exceptions that prove the rule: Scientists not yet successful in discovering the internal structure and nature of electrons, protons and neutrons (that are certainly physical beings), for which the scientists have been using string-theory to make this discovery. An example for a phenomenon the scientists not yet successful in discovering is origin of universe, for which the scientists are using theories such as big-bang-theory. It is very hard to find such rare exceptions. No one disputes the fact that, the right answer must be an objective Truth (if it is ever discovered). Although some experts might argue that it is impossible to discover the internal structure of sub-atomic particles, but all agree that there must exist a unique answer and the answer is an objective Truth. That is, no one disputes the very existence of an objective truth, only express doubt about mankind’s ability to discover the truth any time soon.
Hence there exists an objective Truth for the essential characteristics and nature of any kind of physical being including for ideal physical functional components. I can’t find any valid reason, why mankind can’t discover the objective Truth. We can’t see internal functioning of sub-atomic particles, but we can see internal functioning of ideal physical functional components. When tried, mankind never failed to discover the essential characteristics and nature of any physical being, even if they are 10 times more complex than physical functional components. Hence, there is no valid reason, why it is not possible discover the essential characteristics of physical functional components, if researchers of computer scientists try to discover innate nature of ideal functional components.
If an alien send to the Earth to find an elephant, the pre-requisite to successfully accomplish this task the alien must discover or know accurate description to positively identify the elephants. Likewise, designer of a software application must know or discover the accurate description (i.e. objective facts about the essential properties) of ideal functional components (in the physical world, in the context of the application domain) to positively identify equivalent software components (of virtual world – an alien landscape) in the applications.
Sorry for a long background and summary for the above question. If I am right, correct answer to this question would have profound impact on the progress of software engineering. I believe it is possible discover the essential characteristics of physical functional components. Also I believe it is possible to invent real components for software by having the essential characteristics.
The exiting software engineering paradigm has been evolving for several decades by relying on these untested premises (postulations or hypotheses), which are: Today each kind of software components is nothing but a kind of software part (or module) either having given useful properties (e.g. reusable or standardized etc.) or conform to a so called component model. Using one or more kinds of such so called software components is defined as a kind of CBSE or CBSD (Component Based Design for Software).
If it is possible to discover the essential properties and when the essential properties are discovered, the discovery not only exposes errors in above postulations (or untested premises or hypotheses) that sidetracked progress of software engineering for decades but also puts back the progress of software engineering on right tracks by allowing us to invent real components for software (for achieving real CBD for software, since logically real-CBD for software requires using real components for software).
P.S: This is posted at: https://www.researchgate.net/post/Is_it_possible_to_discover_innate_nature_and_essential_characteristics_uniquely_and_universally_shared_by_all_the_physical_functional_components#share
Best Regards,Raju Chiluvuri