Question

In software-testing applications, it is useful to be able to count the number of times a given procedure is called during the course of a computation. Write a procedure make-monitored that takes as input a procedure, \(f\), that itself takes one input. The result returned by make-monitored is a third procedure, say mf, that keeps track of the number of times it has been called by maintaining an internal counter. If the input to \(\mathrm{mf}\) is the special symbol how-many-calls?, then \(\mathrm{mf}\) returns the value of the counter. If the input is the special symbol reset-count, then \(m f\) resets the counter to zero. For any other input, \(m f\) returns the result of calling \(f\) on that input and increments the counter. For instance, we could make a monitored version of the sqrt procedure: (define s (make-monitored sqrt)) \((\mathrm{s} 100)\) 10 \(\left(\mathrm{~s}^{\prime}\right.\) hou-many-calls?) 1

Short answer

Implement `make-monitored` to wrap a function with a call counter and special commands.

Step-by-step solution

Understand the Task

We are tasked with creating a procedure, `make-monitored`, that takes another procedure `f` as an input. The aim is to track how many times this procedure is called.

Create a Counter

Inside `make-monitored`, we need to create a counter variable initialized to zero. This counter will track the number of times the procedure is called.

Define the Monitored Function

Within `make-monitored`, define a new procedure, `mf`, which will handle different types of inputs, including the special symbols for checking and resetting the counter.

Handle Special Inputs

In the function `mf`, check if the input is the symbol `how-many-calls?`. If so, return the current value of the counter. If the input is `reset-count`, set the counter back to zero.

Handle Regular Function Calls

For any other input, `mf` should call procedure `f` with this input, increase the counter by one, and return the result of the procedure call.

Return the Monitored Function

Finally, ensure `make-monitored` returns the `mf` function as the output, closing over the counter to maintain its state.

Key concepts

Procedure Monitoring

Procedure monitoring is an essential technique in software testing, where the goal is to observe and track the activity of specific functions during a computation. This involves creating a wrapper or modified version of a procedure that can count and record each time it is executed. By implementing procedure monitoring, developers can better understand how often certain functions are called, which can be useful for debugging, optimizing, and ensuring that the software behaves as expected. One common approach to procedure monitoring is to develop a high-order function, such as `make-monitored` in our example. This function takes another function as its parameter and returns a new procedure that not only calls the original function but also includes functionality to track its usage. With this, procedure monitoring becomes a powerful tool in the developer's toolkit for identifying unexpected behaviors and potential inefficiencies.

Function Calls

In programming, a function call is when a function is executed or invoked. It's an essential mechanism that allows you to run reusable blocks of code throughout your program. In the context of procedure monitoring, each time you call the monitored function, it's crucial that the call is recorded correctly. Function calls typically involve providing arguments to the function. For example, when you call a function designed to calculate a square root, you provide a number as the input. In our exercise, whenever the `mf` procedure is called with an argument that isn't a special instruction (like `how-many-calls?` or `reset-count`), it treats the argument as a typical function input, increments the call counter, and then returns the result of the function call. By systematically tracking function calls using a counter within the monitored function, developers can gain insight into function usage patterns and identify potential areas for performance enhancement.

Counter Variables

Counter variables are simple yet powerful tools in programming, often used to track how many times an event occurs. In the procedure monitoring scenario, a counter variable is employed to keep a tally of how often the monitored procedure is invoked. The counter is usually initialized to zero at the start. Every time the monitored procedure is called, the counter is incremented. If the special input `how-many-calls?` is received, the counter’s value is returned, showing the total number of calls made so far. Similarly, if the input `reset-count` is received, the counter is reset to zero. Using counter variables in the described manner simplifies the process of tracking occurrences without having to write more complex logic. It allows for a clear understanding of function usage frequency, which is especially helpful in testing and debugging phases.

Scheme Programming

Scheme is a minimalist, elegant dialect of Lisp, emphasizing functional programming. It is widely used in academic settings to teach programming concepts due to its simple syntax and powerful abstractions. In the context of the exercise, Scheme is used to create a function that monitors procedures. In Scheme, functions are first-class citizens, meaning they can be passed as arguments to other functions, returned as values, and be part of lists. This characteristic makes it straightforward to create higher-order functions like `make-monitored`. Such functions take advantage of Scheme's capabilities to modify or enhance functions by adding additional behavior—like counting calls. One key feature of Scheme that supports our exercise is lexical scoping, which ensures that a variable (like the counter) retains its state within the scope it's defined. This inherent trait of Scheme makes it ideal for creating stateful functions, such as those required for monitoring procedures. Understanding these Scheme principles is crucial for effectively leveraging the language in functional programming tasks.