Debugging is a hard and time-consuming programming task that appears in the most stages of software development and maintenance. Therefore, any improvement in the debugging practice can significantly reduce the time and costs of software production. In this dissertation, our focus is on locating defects, a major debugging task. We first analyze the widely-used and new approaches to locating-defects. From this analysis we identify several main problems in these approaches that cause accidental difficulty. In order to better understand the locating-defects process, we systematically analyze this process based on modeling the developer’s mental model. From this analysis, we develop a model that explains how a developer progresses in this stage : a developer’s general strategy is to reduce the suspicious interval on the buggy execution until locating a fault. There are three basic types of movement : controlled forward navigation, search, and causality backward navigation. We propose Querypoint Debugging as a new approach to debugging that attempts to abstract away a developer’s inspection from one particular execution. We show how querypoints are defined for various types of movement, how they are processed, and how they solve most issues existing in the available debugging approaches. We have built two prototypes of the querypoint idea. The first prototype is a general querypoint debugger for Java which is supposed to support various types of querypoints. We demonstrate how a buggy painting application can be debugged using this debugger. The second prototype is one querypoint, lastChange, that is integrated to a famous JavaScript debugger, Firebug. With this prototype, we show that querypoints can be smoothly integrated with traditional debuggers. Moreover, the idea can be implemented even for weakly-typed languages such as JavaScript. We end this dissertation with providing a solution to a special but an important problem which particularly appears in JavaScript debuggers. Anonymous JavaScript functions are a major challenge for tool developers. After analyzing and classifying anonymous JavaScript functions in 10 large projects, we proposed an efficient algorithm that can successfully name 99 percent of anonymous functions.