Programmers use slices when debugging. This study shows that programmers often break programs into non-contiguous pieces called slices, which are sets of statements related by data flow. These slices are not necessarily textually contiguous but may be scattered throughout the program. The research explores how programmers mentally construct these slices when debugging, contrasting this with the contiguous chunk hypothesis. The study involved three programs with simple errors, designed to appear difficult to debug. Participants were asked to debug these programs and then identify code fragments, including relevant slices, contiguous code, and irrelevant slices. The results showed that participants recognized relevant slices more accurately than other types of code fragments. This suggests that programmers use slices when debugging, as they are more memorable than contiguous code. The hypothesis that programmers construct slices when debugging was tested by comparing the recognition of different code fragments. The results indicated that relevant slices were recognized more often than irrelevant slices or jumbles. This supports the idea that programmers use slices when debugging, as they are more useful for understanding the program's structure and behavior. The study also found that participants' memory for relevant slices was not significantly different from their memory for relevant contiguous code. This suggests that slices are not necessarily more memorable than contiguous code, but they are more useful for debugging. The results indicate that programmers use slices when debugging, as they help in understanding the program's structure and behavior. The study's implications suggest that slicing could be used in practical applications, such as interactive debugging tools and program complexity measures. The findings also highlight the importance of understanding slicing in debugging and maintenance. The study concludes that programmers view programs in ways that do not conform to their textual or modular structures, and that understanding slicing can be useful in producing debugging and maintenance aids.Programmers use slices when debugging. This study shows that programmers often break programs into non-contiguous pieces called slices, which are sets of statements related by data flow. These slices are not necessarily textually contiguous but may be scattered throughout the program. The research explores how programmers mentally construct these slices when debugging, contrasting this with the contiguous chunk hypothesis. The study involved three programs with simple errors, designed to appear difficult to debug. Participants were asked to debug these programs and then identify code fragments, including relevant slices, contiguous code, and irrelevant slices. The results showed that participants recognized relevant slices more accurately than other types of code fragments. This suggests that programmers use slices when debugging, as they are more memorable than contiguous code. The hypothesis that programmers construct slices when debugging was tested by comparing the recognition of different code fragments. The results indicated that relevant slices were recognized more often than irrelevant slices or jumbles. This supports the idea that programmers use slices when debugging, as they are more useful for understanding the program's structure and behavior. The study also found that participants' memory for relevant slices was not significantly different from their memory for relevant contiguous code. This suggests that slices are not necessarily more memorable than contiguous code, but they are more useful for debugging. The results indicate that programmers use slices when debugging, as they help in understanding the program's structure and behavior. The study's implications suggest that slicing could be used in practical applications, such as interactive debugging tools and program complexity measures. The findings also highlight the importance of understanding slicing in debugging and maintenance. The study concludes that programmers view programs in ways that do not conform to their textual or modular structures, and that understanding slicing can be useful in producing debugging and maintenance aids.