Better code, one method one responsibility

Question

Let's say you're writing an algorithm for some collection, for example method 'contains' for some List. The code could look something like this (this is very simple, just for the sake of the example):

def betterContains(list: List[String], element: String): Boolean = {
   if (list.isEmpty) false 
   else if (list.head == element) true
   else betterContains(list.tail, element)
}

Imagine a more complex algorithm, examples would be searching for elements in trees, graphs, etc. And for some reason you add code for logging:

def betterContains(list: List[String], element: String): Boolean = {
   if (list.isEmpty) {
      log.info("The element was not found in the list.")
      false
   } 
   else if (list.head == element) {
      log.info("Yes! found it!")
      true
   }
   else {
      log.info(s"Still searching, ${list.tail.size} elements pending")
      betterContains(list.tail, element)
   }
}

Then, let's say you are adding code for saving some progress data in a text file. At the end, you will have one method that is doing 3 things:

search for a element in a list
logging info to the console
adding data (related to the progress) to a text file

If the developer decides to use a new log library he will have to make changes to the method implementation. Also if he decides to change the way the data is being saved in the text file, again he will have to make changes to the method implementation.

Is there any approach to avoid this? I mean, I only want to make changes to the method if I found a better way (a better algorithm) to find the element in the list. It seems to me that the algorithm does not meet the single responsibility principle, it is doing more than one thing.

Ideally, you would have both logging and saving to the file behind some custom interfaces so you never need to touch to logic function to change how those additional behaviors work. — Luis Miguel Mejía Suárez, Nov 08 '22 at 00:30
People have tried a lot of things and debate tradeoffs. So the answers will be largely opinion based. But https://en.wikipedia.org/wiki/Aspect-oriented_programming may be of interest to you. — btilly, Nov 08 '22 at 03:21
In a strict sense, this would be a violation of SRP if you were to use an instance of some concrete logger class rather than a logger interface, as changes to the concrete implementation of the logger could also demand changes to your algorithm code. Logging with the logger interface does not really break SRP as changing the algorithm code and the log message strings still fall under the same "reason to change". But from what I hear this is opinion-based. — Krafter, Nov 08 '22 at 23:42

Dmytro Mitin · Accepted Answer · 2022-11-08T20:39:19.567

It seems to me that the algorithm does not meet the single responsibility principle, it is doing more than one thing.

Right. This is one of the reasons why for logging, auditing, security checks, performance monitoring, exception handling, caching, transaction management, persistence, validation etc. i.e. for different kinds of additional orthogonal behavior people use instrumentation of their code

What are the possible AOP use cases?

Instrumentation can be runtime (runtime reflection, runtime annotations, aspect-oriented programming, java agents, bytecode manipulation), compile-time (macros, compile-time annotation processors, compiler plugins), pre-compile-time/build-time (source generation, Scalameta/SemanticDB, sbt source generators, boilerplate templating) etc.

For example you can instrument your code at compile time with a macro annotation logging branching ("if-else")

import scala.annotation.{StaticAnnotation, compileTimeOnly}
import scala.language.experimental.macros
import scala.reflect.macros.blackbox

@compileTimeOnly("enable macro annotations")
class logBranching extends StaticAnnotation {
  def macroTransform(annottees: Any*): Any = macro LogBranchingMacro.impl
}

class LogBranchingMacro(val c: blackbox.Context) {
  import c.universe._

  val printlnT = q"_root_.scala.Predef.println"
  def freshName(prefix: String) = TermName(c.freshName(prefix))

  val branchTransformer = new Transformer {
    override def transform(tree: Tree): Tree = tree match {
      case q"if ($cond) $thenExpr else $elseExpr" =>
        val condStr = showCode(cond)
        val cond2   = freshName("cond")
        val left2   = freshName("left")
        val right2  = freshName("right")

        val (optLeft1, optRight1, cond1, explanation) = cond match {
          case q"$left == $right" =>
            (
              Some(this.transform(left)),
              Some(this.transform(right)),
              q"$left2 == $right2",
              q""" ", i.e. " + $left2 + "==" + $right2 """
            )
          case _ =>
            (
              None,
              None,
              this.transform(cond),
              q""" "" """
            )
        }

        val backups = (cond, optLeft1, optRight1) match {
          case (q"$_ == $_", Some(left1), Some(right1)) =>
            Seq(
              q"val $left2  = $left1",
              q"val $right2 = $right1"
            )
          case _ => Seq()
        }

        val thenExpr1 = this.transform(thenExpr)
        val elseExpr1 = this.transform(elseExpr)

        q"""
          ..$backups
          val $cond2 = $cond1
          $printlnT("checking condition: " + $condStr + $explanation + ", result is " + $cond2)
          if ($cond2) $thenExpr1 else $elseExpr1
        """

      case _ => super.transform(tree)
    }
  }

  def impl(annottees: Tree*): Tree = annottees match {
    case q"$mods def $tname[..$tparams](...$paramss): $tpt = $expr" :: Nil =>
      val expr1 = branchTransformer.transform(expr)
      q"$mods def $tname[..$tparams](...$paramss): $tpt = $expr1"

    case _ => c.abort(c.enclosingPosition, "@logBranching can annotate methods only")
  }
}

// in a different subproject

@logBranching
def betterContains(list: List[String], element: String): Boolean = {
  if (list.isEmpty) false
  else if (list.head == element) true
  else betterContains(list.tail, element)
}

  //   scalacOptions += "-Ymacro-debug-lite"
//scalac: def betterContains(list: List[String], element: String): Boolean = {
//  val cond$macro$1 = list.isEmpty;
//  _root_.scala.Predef.println("checking condition: ".$plus("list.isEmpty").$plus("").$plus(", result is ").$plus(cond$macro$1));
//  if (cond$macro$1)
//    false
//  else
//    {
//      val left$macro$5 = list.head;
//      val right$macro$6 = element;
//      val cond$macro$4 = left$macro$5.$eq$eq(right$macro$6);
//      _root_.scala.Predef.println("checking condition: ".$plus("list.head.==(element)").$plus(", i.e. ".$plus(left$macro$5).$plus("==").$plus(right$macro$6)).$plus(", result is ").$plus(cond$macro$4));
//      if (cond$macro$4)
//        true
//      else
//        betterContains(list.tail, element)
//    }
//}

betterContains(List("a", "b", "c"), "c")

//checking condition: list.isEmpty, result is false
//checking condition: list.head.==(element), i.e. a==c, result is false
//checking condition: list.isEmpty, result is false
//checking condition: list.head.==(element), i.e. b==c, result is false
//checking condition: list.isEmpty, result is false
//checking condition: list.head.==(element), i.e. c==c, result is true

For example Scastie instruments user-entered code with Scalameta

https://github.com/scalacenter/scastie/tree/master/instrumentation/src/main/scala/com.olegych.scastie.instrumentation

Another approach to add additional behavior in functional programming is effects, e.g. monads. Read about logging monad, Writer monad, logging with free monads etc.

Better code, one method one responsibility

1 Answers1