Code Restructuring Principles Control and Data Restructuring

Lecture 12 of SE602 Software Re-Engineering focuses on source code restructuring, the modification of internal source code structure at the same level of abstraction without changing external observable program behavior. Students investigate legacy spaghetti code characterized by unconstrained branching, unstructured goto statements, and convoluted control flow paths. The lecture examines the Böhm-Jacopini structured programming theorem, which proves that any computable algorithm can be expressed using only three basic control structures: sequence, selection (if-then-else), and iteration (while loops). Students study algorithm transformations that remove goto jumps, eliminate dead code, consolidate redundant conditional branches, and restructure fragmented data variables into cohesive records, significantly improving readability and testability. Practical code illustrations demonstrate safe code transformations, automated refactoring preconditions, and behavioral equivalence preservation. Scholars analyze Chidamber-Kemerer object-oriented metrics including WMC, CBO, and RFC to quantify the architectural impact of refactoring. Cloud migration pathways including rehosting, replatforming, and cloud-native refactoring are examined as extensions of legacy modernization. The relationship between technical debt accumulation, architectural degradation, and long-term enterprise software viability is reinforced. In this lecture, students examine formal methodologies, structural transformations, and analytical metrics of software re-engineering systems. Through detailed theoretical breakdowns, the lesson explores software evolution dynamics, legacy system preservation, and maintainability enhancement. Special emphasis is placed on reverse engineering workflows, abstract syntax tree construction, and program dependency representations. Mastering these foundational software re-engineering paradigms empowers software engineers to systematically revitalize enterprise legacy platforms. Analytical exercises and architectural traces help students prepare thoroughly for Virtual University midterm and final term examinations. The curriculum systematically aligns theoretical software evolution principles with practical source code modernization across industrial codebases. Reviewing the accompanying lecture handouts and metric tables reinforces understanding of coupling, cohesion, and architectural decay. Consistent evaluation of control flow graphs, call graph hierarchies, and database schemas ensures robust preparation for academic assessments. Students investigate the trade-offs between system replacement, wrapping legacy components, and iterative code refactoring transformations. The discussion highlights how Lehman laws of evolution, system complexity growth, and declining quality necessitate continuous code restructuring.