Dynamic program slicing is a technique that identifies the subset of program statements that actually affect the value of a variable occurrence for a specific input. Unlike static slicing, which considers all possible inputs, dynamic slicing focuses on the actual execution path that leads to the observed error. This makes dynamic slicing more useful for debugging and testing as it isolates the relevant parts of the program. The paper explores several approaches to computing dynamic slices. The first two approaches are based on the Program Dependence Graph (PDG) and involve projecting the graph to the execution history and then applying static slicing techniques. However, these methods can produce overly large slices that include statements not actually affecting the variable in question. The third approach introduces the Dynamic Dependence Graph (DDG), which tracks dependencies during execution. This graph allows for more accurate dynamic slicing by considering the specific execution path. However, the size of the DDG can be unbounded, depending on the execution history. To address this, the fourth approach proposes the Reduced Dynamic Dependence Graph (RDDG), which creates new nodes only when necessary. This reduces the graph size to a level proportional to the number of distinct dynamic slices generated during execution, making it more efficient. The paper also discusses related work, including earlier approaches to static slicing and dynamic slicing by other researchers. It highlights the importance of dynamic slicing in isolating the exact statements responsible for a variable's value, which is crucial for debugging. The proposed methods aim to balance accuracy, efficiency, and scalability in dynamic slicing.Dynamic program slicing is a technique that identifies the subset of program statements that actually affect the value of a variable occurrence for a specific input. Unlike static slicing, which considers all possible inputs, dynamic slicing focuses on the actual execution path that leads to the observed error. This makes dynamic slicing more useful for debugging and testing as it isolates the relevant parts of the program. The paper explores several approaches to computing dynamic slices. The first two approaches are based on the Program Dependence Graph (PDG) and involve projecting the graph to the execution history and then applying static slicing techniques. However, these methods can produce overly large slices that include statements not actually affecting the variable in question. The third approach introduces the Dynamic Dependence Graph (DDG), which tracks dependencies during execution. This graph allows for more accurate dynamic slicing by considering the specific execution path. However, the size of the DDG can be unbounded, depending on the execution history. To address this, the fourth approach proposes the Reduced Dynamic Dependence Graph (RDDG), which creates new nodes only when necessary. This reduces the graph size to a level proportional to the number of distinct dynamic slices generated during execution, making it more efficient. The paper also discusses related work, including earlier approaches to static slicing and dynamic slicing by other researchers. It highlights the importance of dynamic slicing in isolating the exact statements responsible for a variable's value, which is crucial for debugging. The proposed methods aim to balance accuracy, efficiency, and scalability in dynamic slicing.