{"id":{"repo_id":"sdstate","oai_identifier":"oai:openprairie.sdstate.edu:etd-4415"},"canonical_url":"https://search.ndltd.org/etd/sdstate/oai:openprairie.sdstate.edu:etd-4415","repository":{"repo_id":"sdstate","name":"South Dakota State University","base_url":"https://openprairie.sdstate.edu/do/oai/"},"display":{"title":"Reducing the Large Class Code Smell by Applying Design Patterns","abstract":"Software systems need continuous developing to cope and keep up with everchanging requirements. Source code quality affects the software development costs. In software refactoring object-oriented systems, Large Class, in particular, hinder the maintenance of a system by letting it difficult for software developers to understand and perform modifications. Also, it is making the development process labor-intensive and time-wasting. Reducing the Large Class code smell by applying design patterns can make the refactoring process more manageable, ease developing the system and decrease the effort required for the maintaining of software. To guarantee object-oriented software stays clear to read, understand and modify over time, Fowler and Beck claimed that these classes should, therefore, be divided into several classes, or extract the subclasses from the Large Class. The study presents a methodology designed to reduce the Large Class code smell by understanding the feature of the Large Class then analyzing the causes of the Large Class code smell and depends on two features, complexity and cohesion, then classifying the causes to identical types and proposing a best fit design pattern to address each type and refactor the code to improve the quality of software by reducing the complexity and enhancing cohesion. Our methodology focuses on the Large Class code smell while analyzing the complexity and cohesion; however, the methodology itself can be used wherever the code fits in a category.","abstract_html":"Software systems need continuous developing to cope and keep up with everchanging requirements. Source code quality affects the software development costs. In software refactoring object-oriented systems, Large Class, in particular, hinder the maintenance of a system by letting it difficult for software developers to understand and perform modifications. Also, it is making the development process labor-intensive and time-wasting. Reducing the Large Class code smell by applying design patterns can make the refactoring process more manageable, ease developing the system and decrease the effort required for the maintaining of software. To guarantee object-oriented software stays clear to read, understand and modify over time, Fowler and Beck claimed that these classes should, therefore, be divided into several classes, or extract the subclasses from the Large Class. The study presents a methodology designed to reduce the Large Class code smell by understanding the feature of the Large Class then analyzing the causes of the Large Class code smell and depends on two features, complexity and cohesion, then classifying the causes to identical types and proposing a best fit design pattern to address each type and refactor the code to improve the quality of software by reducing the complexity and enhancing cohesion. Our methodology focuses on the Large Class code smell while analyzing the complexity and cohesion; however, the methodology itself can be used wherever the code fits in a category.","abstract_has_math":false,"creators":["Turkistani, Bayan"],"institution":null,"degree_name":"Master of Science (MS)","degree_level":"Thesis - Open Access","degree_discipline":"Electrical Engineering and Computer Science","degree_department":null,"school":null,"contributors":["Yi Liu"],"advisors":[],"committee_chairs":[],"committee_members":[],"year":null,"date_issued":"","date_published":null,"updated_at":"2026-11-19T09:00:03Z","subjects":["Computer Sciences","Software Engineering"],"languages":["en"],"rights":[],"rights_urls":["http://rightsstatements.org/vocab/InC/1.0/"],"identifier_entries":[],"person_identifier_entries":[]},"links":{"outbound_url":"https://openprairie.sdstate.edu/etd/3412","outbound_label":"Repository record","outbound_source":"dc:identifier","record_url":"https://openprairie.sdstate.edu/etd/3412","record_label":"Repository record","record_kind":"record","record_source":"dc:identifier","download_url":null,"download_label":null,"download_source":null,"access_status":null,"embargo_until":null,"access_note":null},"source_record":{"url":"https://openprairie.sdstate.edu/do/oai/?verb=GetRecord&metadataPrefix=oai_etdms&identifier=oai%3Aopenprairie.sdstate.edu%3Aetd-4415","prefix":"oai_etdms"},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:contributor","label":"Contributor","values":["Yi Liu"]},{"key":"dc:creator","label":"Author","values":["Turkistani, Bayan"]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date.available","label":"Dc Date Available","values":["2019-08-08T07:00:00Z"]},{"key":"dc:date.created","label":"Dc Date Created","values":["2019-01-01T08:00:00Z"]},{"key":"thesis:degree_discipline","label":"Discipline","values":["Electrical Engineering and Computer Science"]},{"key":"thesis:degree_level","label":"Degree Level","values":["Thesis - Open Access"]},{"key":"thesis:degree_name","label":"Degree Name","values":["Master of Science (MS)"]}]},{"id":"subjects_keywords","label":"Subjects and Keywords","entries":[{"key":"dc:subject","label":"Dc Subject","values":["Computer Sciences","Software Engineering"]}]},{"id":"language_rights","label":"Language and Rights","entries":[{"key":"dc:language","label":"Dc Language","values":["en"]},{"key":"dc:rights","label":"Dc Rights","values":["http://rightsstatements.org/vocab/InC/1.0/"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier","label":"Identifier","values":["https://openprairie.sdstate.edu/etd/3412"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"dc:description.abstract","label":"Abstract","values":["Software systems need continuous developing to cope and keep up with everchanging requirements. Source code quality affects the software development costs. In software refactoring object-oriented systems, Large Class, in particular, hinder the maintenance of a system by letting it difficult for software developers to understand and perform modifications. Also, it is making the development process labor-intensive and time-wasting. Reducing the Large Class code smell by applying design patterns can make the refactoring process more manageable, ease developing the system and decrease the effort required for the maintaining of software. To guarantee object-oriented software stays clear to read, understand and modify over time, Fowler and Beck claimed that these classes should, therefore, be divided into several classes, or extract the subclasses from the Large Class. The study presents a methodology designed to reduce the Large Class code smell by understanding the feature of the Large Class then analyzing the causes of the Large Class code smell and depends on two features, complexity and cohesion, then classifying the causes to identical types and proposing a best fit design pattern to address each type and refactor the code to improve the quality of software by reducing the complexity and enhancing cohesion. Our methodology focuses on the Large Class code smell while analyzing the complexity and cohesion; however, the methodology itself can be used wherever the code fits in a category."]},{"key":"dc:title","label":"Title","values":["Reducing the Large Class Code Smell by Applying Design Patterns"]}]}],"canonical_facts":{"dc:contributor":["Yi Liu"],"dc:creator":["Turkistani, Bayan"],"dc:date.available":["2019-08-08T07:00:00Z"],"dc:date.created":["2019-01-01T08:00:00Z"],"dc:description.abstract":["Software systems need continuous developing to cope and keep up with everchanging requirements. Source code quality affects the software development costs. In software refactoring object-oriented systems, Large Class, in particular, hinder the maintenance of a system by letting it difficult for software developers to understand and perform modifications. Also, it is making the development process labor-intensive and time-wasting. Reducing the Large Class code smell by applying design patterns can make the refactoring process more manageable, ease developing the system and decrease the effort required for the maintaining of software. To guarantee object-oriented software stays clear to read, understand and modify over time, Fowler and Beck claimed that these classes should, therefore, be divided into several classes, or extract the subclasses from the Large Class. The study presents a methodology designed to reduce the Large Class code smell by understanding the feature of the Large Class then analyzing the causes of the Large Class code smell and depends on two features, complexity and cohesion, then classifying the causes to identical types and proposing a best fit design pattern to address each type and refactor the code to improve the quality of software by reducing the complexity and enhancing cohesion. Our methodology focuses on the Large Class code smell while analyzing the complexity and cohesion; however, the methodology itself can be used wherever the code fits in a category."],"dc:identifier":["https://openprairie.sdstate.edu/etd/3412"],"dc:language":["en"],"dc:rights":["http://rightsstatements.org/vocab/InC/1.0/"],"dc:subject":["Computer Sciences","Software Engineering"],"dc:title":["Reducing the Large Class Code Smell by Applying Design Patterns"],"thesis:degree_discipline":["Electrical Engineering and Computer Science"],"thesis:degree_level":["Thesis - Open Access"],"thesis:degree_name":["Master of Science (MS)"]},"updated_at":"2026-11-19T09:00:03Z"}