On a real quiz Jev scores 20% — below the 25% you get by guessing — and the one question it gets right is the Parnas one

As part of a large application, you are reading an input and need to sanitize it by escaping all single quotes. Which of these two options is better and why? Assume both do the exact same thing.

Option 1: x = sanitize(readInput());
Option 2: x = readInput().replaceAll("'", "\\'");

Multiple benefits of your preferred option may apply. Choose the best answer.

WHY B IS THE ANSWER
The idea of a sanitized string and the idea of a string with escaped quotes are different ideas that happen to share an implementation. Option 2 can only be known to work by relying on a secret of the sanitize module, so it is incorrect as written.

Consider this Rectangle type as you might find in a GUI framework.

class Rectangle {
  constructor(
    private x: number,
    private y: number,
    private width: number,
    private height: number
  ) {}
  getArea(): number {
    return this.width * this.height;
  }
  getPerimeter(): number {
    return 2 * (this.width + this.height);
  }
}

Which of the following is mostly likely to be a design improvement to this class?

WHY A IS THE ANSWER
Asked in plain English what data defines a rectangle, people say a corner and a dimension, not four integers. Taking a Point and a Dimension matches that and turns 23 of the 24 argument orderings into type errors.

Here is a snippet of code you might find in an ecommerce website. Think about what you would do to generally improve this code without changing the behavior.

public setProductDisplayType(displayType: string): void {
    if (displayType === "compact") {
        this.maxDescriptionLength = 140;
        this.numSimilarProductsToShow = 2;
        this.numReviewsToShow = 1;
    } else if (displayType === "detailed") {
        this.maxDescriptionLength = 500;
        this.numSimilarProductsToShow = 5;
        this.numReviewsToShow = 7;
    }
}

Try to think of the best refactoring yourself before looking at the answers. We are deliberately not showing you full detail in the answers below, for fear that showing you the possible solutions would make this question too easy. But if you can think up the best refactoring, then it should be clear which of the answers below is the best match.

WHY B IS THE ANSWER
The three numbers travel together, so they are one configuration object. Passing that object is the only answer that truly removes the conditional instead of renaming it.

Consider the following code that you might find in a blog or news website.

class Post {
  private comments: Comment[];
  constructor(
    private id: number,
    private content: string,
    private author: string,
    comments: Comment[]
  ) {
    this.comments = [...comments]; // Create a shallow copy of the comments array
  }
  getId(): number { return this.id; }
  getContent(): string { return this.content; }
  setContent(content: string): void { this.content = content; }
  getAuthor(): string { return this.author; }
  getComments(): Comment[] {
    return [...this.comments]; // Return a shallow copy of the comments array
  }
  addComment(c: Comment): void {
    this.comments.push(c);
  }
}

Which of the following proposed changes is most likely to improve the maintainability of this code and the rest of the system? Note that this code may contain other flaws not listed among these choices.

WHY B IS THE ANSWER
A useful subset of the program has posts but no comments, so the Post class must not depend on the Comment class. Copying the list is correct, not a flaw.

Following is code you might find in a distributed system. A digest in this context is a hash of information relating to the cluster. This function is used to simultaneously compare an unordered set of objects (files, messages, etc) against a checksum. It first combines the digests of each object by taking their XOR, and then compares the result to the target checksum, also using XOR. Note that, while there are many disadvantages to using XOR as a digest, this example is adapted from a real codebase where those were deemed not important.

function compareDigestsToTarget(digests: number[], target: number): boolean {
  let combinedDigest = 0;
  for (const curDigest of digests) {
    combinedDigest = combinedDigest ^ curDigest;
  }
  const difference = combinedDigest ^ target;
  return difference === 0;
}

Choose the best of the following proposed code improvements. There may be other useful improvements not named.

WHY D IS THE ANSWER
The two XORs have the same implementation but different specifications - combining digests and comparing digests. Identical code with different specs must not be merged.