International Research Journal of Engineering and Technology (IRJET) e-ISSN: 2395-0056 Volume: 07 Issue: 06 | June 2020 www.irjet.net p-ISSN: 2395-0072 © 2020, IRJET | Impact Factor value: 7.529 | ISO 9001:2008 Certified Journal | Page 1349 Decomposition and Modularity in Software Systems Anmol Gaba 1 , Dr. G N Srinivasan 2 1 Department of Information Science and Engineering, RV College of Engineering, Bengaluru, Karnataka, India 2 Professor, Department of Information Science and Engineering, RV College of Engineering, Bengaluru, Karnataka, India ---------------------------------------------------------------------***---------------------------------------------------------------------- Abstract - This paper ventures into the discussion about software decomposition and the related modularity aspects necessary for the development of modern software architectures. There has been an evident rise in the efforts by organizations to develop and master the standard practices, be it agile or the regular waterfall model. In relation to this , modern programming frameworks need to develop consistently so as to abstain from getting less helpful, as it is in the case of many legacy systems riddled with the technological debts. Be that as it may, rehashed changes in the product may block the internal nature of the framework. Seclusion of the program modules is viewed as a significant part of a decent internal quality, and the useful decomposition is a methodology that empowers to accomplish great particularity. Nevertheless, existing methodologies for useful deterioration overlook implementation endeavors, and this may cause a circumstance where the necessary changes are too exorbitant to even think about implementing. In this paper we portray a way to deal with useful deterioration for programming design advancement considering additionally the usage endeavors. Key Words: Software Modularity, Decomposition, Legacy Software, Modern Systems, System Architecture 1. INTRODUCTION Programming frameworks must develop after some time, else they continuously become less helpful. When a framework is discharged, it constantly changes, for example because of developing client prerequisites (perfective changes), bug fixes (restorative changes), stage modifications (versatile changes), or revision of inactive blames before they become operational issues (preventive changes). Thus, the framework floats away from its underlying engineering because of the developmental changes. A significant part of decent programming engineering is its measured quality. A framework may at first comprise exceptionally durable subsystems with low coupling between them. Be that as it may, as greater usefulness is added to the framework, their coupling will in general increment and their union abatements. Consequently the framework turns out to be less reasonable for engineers, bringing about diminished quality and a framework that is progressively hard to keep up. Programming engineering is the significant level plan and structure of the product framework. While planning the framework is speedy, reasonably contrasted and building the framework, it is basic to get the design right. When the framework is constructed, if the engineering is damaged, wrong, or only deficient for your necessities, it is amazingly costly to keep up or broaden the framework. The substance of the engineering of any framework is the breakdown of the idea of the framework all in all into its including parts, be it a vehicle, a house, a PC, or a product framework. A decent engineer likewise recommends how these segments collaborate at run-time. The demonstration of recognizing the constituent parts of a framework is called framework decay. 2. LITERATURE SURVEY In [1] authors find that in the plan advancement of programming improvement measured quality has consistently had a solid effect. It is seen that despite the fact that firmly coupled parts are more enthusiastic to keep up; they have a high probability of endurance and use in resulting adaptations of a planned worldview. Despite the fact that they streamline advancement, they experience more shock changes to their reliance connections that are not related to new usefulness. They become "more enthusiastic to increase," in that the new segments included in every rendition are more secluded than the first heritage structure. In [2] it is seen that long-running programming frameworks experience the ill effects of programming disintegration, because of their consistent advancement to meet new or evolving necessities, seriously constraining their viability. Relocating programming frameworks, for example moving heritage frameworks into present day conditions and advancements without evolving usefulness, is a key strategy of programming development, and serves to continue existing programming frameworks operational. Organized movements take into consideration moving set up programming answers for bleeding edge innovation, without thinking about the fundamentally