name: image layout: true class: center, middle, image --- name: image-white layout: true class: center, middle, image, image-white --- name: image-last layout: true class: center, middle, image, image-last --- name: ambiata layout: true class: ambiata --- name: ambiata-full layout: true class: center, middle, ambiata-full --- name: code-small layout: true class: code-small --- name: question layout: true class: center, middle, question --- name: rule layout: true class: center, middle, rule --- name: boom layout: true class: boom --- name: inverse layout: true class: center, middle, inverse --- class: center, middle template: image-white <img src="images/chopsticks.jpg" /> <h1>Life Without Stack Traces <br/>                     <span style="color: #4795c6">@charlesofarrell</span></h1> --- layout: false template: image <img src="images/in-beginning.jpg"> --- layout: false ## Exception ```java java.lang.NullPointerException at com.example.MyService.list(MyService.java:23) at com.example.MyController.list(MyController.java:11) ``` ??? - Exceptions are part of every day life - Especially NPE --- <img height="600px" src="images/gtfo.jpeg" /> --- template: question ## What it really looks like... --- <pre style="font-size: 12px;"> java.lang.NullPointerException at com.example.MyService.list(MyService.java:23) at net.sf.cglib.proxy.MethodProxy.invoke() at org.springframework.aop.framework.Cglib2AopProxy$CglibMethodInvocation.invokeJoinpoint() at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed() at org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint.proceed() at com.blogspot.nurkiewicz.LoggingAspect.logging() at sun.reflect.NativeMethodAccessorImpl.invoke0() at sun.reflect.NativeMethodAccessorImpl.invoke() at sun.reflect.DelegatingMethodAccessorImpl.invoke() at java.lang.reflect.Method.invoke() at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs() at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod() at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke() at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed() at org.springframework.aop.interceptor.AbstractTraceInterceptor.invoke() at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed() at org.springframework.transaction.interceptor.TransactionInterceptor.invoke() at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed() at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke() at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed() at org.springframework.aop.framework.Cglib2AopProxy$DynamicAdvisedInterceptor.intercept() at com.example.MyController.list(MyController.java:11) at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1157) at com.example.myproject.ExceptionHandlerFilter.doFilter(ExceptionHandlerFilter.java:28) at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1157) at com.example.myproject.OutputBufferFilter.doFilter(OutputBufferFilter.java:33) at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1157) at org.mortbay.jetty.servlet.ServletHandler.handle(ServletHandler.java:388) at org.mortbay.jetty.security.SecurityHandler.handle(SecurityHandler.java:216) at org.mortbay.jetty.servlet.SessionHandler.handle(SessionHandler.java:182) at org.mortbay.jetty.handler.ContextHandler.handle(ContextHandler.java:765) at org.mortbay.jetty.webapp.WebAppContext.handle(WebAppContext.java:418) at org.mortbay.jetty.handler.HandlerWrapper.handle(HandlerWrapper.java:152) at org.mortbay.jetty.Server.handle(Server.java:326) at org.mortbay.jetty.HttpConnection.handleRequest(HttpConnection.java:542) at org.mortbay.jetty.HttpConnection$RequestHandler.content(HttpConnection.java:943) at org.mortbay.jetty.HttpParser.parseNext(HttpParser.java:756) at org.mortbay.jetty.HttpParser.parseAvailable(HttpParser.java:218) at org.mortbay.jetty.HttpConnection.handle(HttpConnection.java:404) at org.mortbay.jetty.bio.SocketConnector$Connection.run(SocketConnector.java:228) at org.mortbay.thread.QueuedThreadPool$PoolThread.run(QueuedThreadPool.java:582) </pre> --- <div class="trace-example"> <pre>java.lang.NullPointerException</pre> <pre class="trace-useful"> at com.example.MyService.list(MyService.java:23)</pre> <pre> at net.sf.cglib.proxy.MethodProxy.invoke()</pre> <pre> at org.springframework.aop.framework.Cglib2AopProxy$CglibMethodInvocation.invokeJoinpoint()</pre> <pre> at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed()</pre> <pre> at org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint.proceed()</pre> <pre> at com.blogspot.nurkiewicz.LoggingAspect.logging()</pre> <pre> at sun.reflect.NativeMethodAccessorImpl.invoke0()</pre> <pre> at sun.reflect.NativeMethodAccessorImpl.invoke()</pre> <pre> at sun.reflect.DelegatingMethodAccessorImpl.invoke()</pre> <pre> at java.lang.reflect.Method.invoke()</pre> <pre> at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs()</pre> <pre> at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod()</pre> <pre> at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke()</pre> <pre> at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed()</pre> <pre> at org.springframework.aop.interceptor.AbstractTraceInterceptor.invoke()</pre> <pre> at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed()</pre> <pre> at org.springframework.transaction.interceptor.TransactionInterceptor.invoke()</pre> <pre> at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed()</pre> <pre> at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke()</pre> <pre> at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed()</pre> <pre> at org.springframework.aop.framework.Cglib2AopProxy$DynamicAdvisedInterceptor.intercept()</pre> <pre class="trace-useful"> at com.example.MyController.list(MyController.java:11)</pre> <pre> at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1157)</pre> <pre> at com.example.myproject.ExceptionHandlerFilter.doFilter(ExceptionHandlerFilter.java:28)</pre> <pre> at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1157)</pre> <pre> at com.example.myproject.OutputBufferFilter.doFilter(OutputBufferFilter.java:33)</pre> <pre> at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1157)</pre> <pre> at org.mortbay.jetty.servlet.ServletHandler.handle(ServletHandler.java:388)</pre> <pre> at org.mortbay.jetty.security.SecurityHandler.handle(SecurityHandler.java:216)</pre> <pre> at org.mortbay.jetty.servlet.SessionHandler.handle(SessionHandler.java:182)</pre> <pre> at org.mortbay.jetty.handler.ContextHandler.handle(ContextHandler.java:765)</pre> <pre> at org.mortbay.jetty.webapp.WebAppContext.handle(WebAppContext.java:418)</pre> <pre> at org.mortbay.jetty.handler.HandlerWrapper.handle(HandlerWrapper.java:152)</pre> <pre> at org.mortbay.jetty.Server.handle(Server.java:326)</pre> <pre> at org.mortbay.jetty.HttpConnection.handleRequest(HttpConnection.java:542)</pre> <pre> at org.mortbay.jetty.HttpConnection$RequestHandler.content(HttpConnection.java:943)</pre> <pre> at org.mortbay.jetty.HttpParser.parseNext(HttpParser.java:756)</pre> <pre> at org.mortbay.jetty.HttpParser.parseAvailable(HttpParser.java:218)</pre> <pre> at org.mortbay.jetty.HttpConnection.handle(HttpConnection.java:404)</pre> <pre> at org.mortbay.jetty.bio.SocketConnector$Connection.run(SocketConnector.java:228)</pre> <pre> at org.mortbay.thread.QueuedThreadPool$PoolThread.run(QueuedThreadPool.java:582) </pre> </div> ??? - Side note: we might like to know what the values at those functions calls were --- ## Real world ```scala def run(a: Auth, u: UserId): Future[User] = for { s <- login(c) b <- load(s, u) } yield b ``` --- ## Boom ```scala def run(a: Auth, u: UserId): Future[User] = for { s <- login(c) b <- load(s, u) } yield b ``` <br/> <pre style="font-size: 13px;"> Exception in thread "main" java.lang.NullPointerException at Example.load(Example.scala:17) at Example$$anonfun$bar$1.apply$mcI$sp(Example.scala:17) at Example$$anonfun$bar$1.apply(Example.scala:17) at Example$$anonfun$bar$1.apply(Example.scala:17) at scala.concurrent.impl.Future$PromiseCompletingRunnable.liftedTree1$1(Future.scala:24) at scala.concurrent.impl.Future$PromiseCompletingRunnable.run(Future.scala:24) at scala.concurrent.impl.ExecutionContextImpl$AdaptedForkJoinTask.exec(ExecutionContextImpl.scala:121) at scala.concurrent.forkjoin.ForkJoinTask.doExec(ForkJoinTask.java:260) at scala.concurrent.forkjoin.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1339) at scala.concurrent.forkjoin.ForkJoinPool.runWorker(ForkJoinPool.java:1979) at scala.concurrent.forkjoin.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:107) </pre> --- template: question ## Partial Functions --- template: question ## Partial Functions ### "A partial function is a function that is not defined for all possible arguments of the specified type" --- template: question ## Partial Functions ### "Functions that throw exceptions" --- template: question ## Partial Functions ### "Functions that throw exceptions (or return null)" --- template: question ## Partial Functions ### "Functions that aren't functions" --- template: image <img src="images/play-game.jpg" /> --- ## Is this partial? ```scala trait Foo[A] { def bar: A } ``` --- ## Looks more familiar ```scala trait Option[A] { def get: A } ``` --- ## Game over ```scala trait Option[A] { /** Returns the option's value. * @note The option must be nonEmpty. * @throws java.util.NoSuchElementException */ def get: A } ``` --- ## Is this partial? ```scala def foo (s: String, i: Int): String ``` --- ## What about now? ```scala def substring(s: String, i: Int): String ``` --- ## What about now? ```scala /** * @throws IndexOutOfBoundsException * - if beginIndex is < or > than the length */ def substring(s: String, i: Int): String ``` --- ## Is this partial? ```scala def hello: List[String] = foo("hello world") ``` --- ## Is this partial? ```scala def hello: List[String] = foo("hello world") ``` - Depends on `foo` --- ## Is this partial? ```scala def hello: List[String] = foo("hello world") ``` - Depends on `foo` - Which depends on `bar` --- ## Is this partial? ```scala def hello: List[String] = foo("hello world") ``` - Depends on `foo` - Which depends on `bar` - Which depends on... --- ## Is this partial? ```scala def hello: List[String] = foo("hello world") ``` - Depends on `foo` - Which depends on `bar` - Which depends on... - We use names (and familiarity) to detect errors - Doesn't scale as we compose --- template: question ## Future Proof --- ## Today ```scala /** * @throws BadException * */ def foo: Unit ``` --- ## Today ```scala /** * @throws BadException * */ def foo: Unit def bar = try { foo } catch { e: BadException => ... } ``` --- ## Tomorrow ```scala /** * @throws BadException * @throws UglyException */ def foo: Unit def bar = try { foo } catch { e: BadException => ... } ``` --- ## Partial Functions - Type signatures not enough - Harder to reason about - Harder to review - Not future proof - Functions that introduce new errors won't require code change - Stacktraces are not always useful - eg. Future --- template: image <img src="images/beach-relax.jpg" /> --- template: image <img src="images/image-world.jpg" /> ## Imagine a world without errors --- ## Either ```scala sealed trait Either[L, R] case class Left[L](l: L) extends Either[L, Nothing] case class Right[R](r: R) extends Either[Nothing, R] ``` --- ## Either ```scala /** * @throws InvalidCredentials */ def login(a: Auth): Either[Exception, Session] /** * @throws UserNotFound */ def load(u: Session, u: UserId): Either[Exception, User] ``` --- ## Either in action ```scala /** * @throws InvalidCredentials */ def login(a: Auth): Either[Exception, Session] /** * @throws UserNotFound */ def load(u: Session, u: UserId): Either[Exception, User] def run(a: Auth, u: UserId): Either[Exception, User] = for { s <- login(c) b <- load(s, u) } yield b ``` ??? - If `login()` returns an exception, stop - If `load()` return an exception, stop - etc --- ## What now? ```scala def run(a: Auth, u: UserId): Either[Exception, User] run(c, u) match { case Left(e) => // Not this again... e.printStackTrace } ``` --- template: question ## Data types are cheap --- ## Data ```scala case class InvalidCredentials(a: Auth) extends Exception /** * @throws InvalidCredentials */ def login(a: Auth): Either[Exception, User] ``` --- ## Data ```scala sealed trait LoginError case class InvalidCredentials(a: Auth) extends LoginError def login(a: Auth): Either[LoginError, User] ``` --- ## Data ```scala case class UserNotFound(u: UserId) extends Exception /** * @throws UserNotFound */ def load(u: Session, u: UserId): Either[Exception, User] ``` --- ## Data ```scala sealed trait UserError case class UserNotFound(u: UserId) extends UserError def load(u: Session, u: UserId): Either[UserError, User] ``` --- ## Data ```scala sealed trait LoginError case class InvalidCredentials(a: Auth) extends LoginError sealed trait UserError case class UserNotFound(u: UserId) extends UserError def login(a: Auth): Either[LoginError, User] def load(u: Session, u: UserId): Either[UserError, User] ``` --- ## Hmmm ```scala def run(a: Auth, u: UserId): Either[???, User] = for { s <- login(c) b <- load(s, u) } yield b def login(a: Auth): Either[LoginError, User] def load(u: Session, u: UserId): Either[UserError, User] ``` --- ## Back where we started ```scala def run(a: Auth, u: UserId): Either[Exception, User] = for { s <- login(c) b <- load(s, u) } yield b sealed abstract class LoginError extends Exception sealed abstract class UserError extends Exception def login(a: Auth): Either[LoginError, User] def load(u: Session, u: UserId): Either[UserError, User] ``` --- template: question ## Data types are cheap --- ## Data types are cheap ```scala sealed trait AppError case class AppLoginError(e: LoginError) extends AppError case class AppUserError(e: UserError) extends AppError ``` ??? - Explain sealed trait --- ## Types FTW ```scala def run(a: Auth, u: UserId): Either[AppError, User] sealed trait AppError case class AppLoginError(e: LoginError) extends AppError case class AppUserError(e: UserError) extends AppError ``` --- ## Fill in the blanks ```scala def run(a: Auth, u: UserId): Either[AppError, User] = for { s <- login(c).???(AppLoginError(_)) b <- load(s, u).???(AppUserError(_)) } yield b ``` --- ## Update error ```scala def run(a: Auth, u: UserId): Either[AppError, User] = for { s <- login(c).updateError(AppLoginError(_)) b <- load(s, u).updateError(AppUserError(_)) } yield b trait Either[L, R] { def updateError[L2](f: L => L2): Either[L2, R] = ... ``` --- ## Update error ```scala def run(a: Auth, u: UserId): Either[AppError, User] = for { s <- login(c).updateError(AppLoginError(_)) b <- load(s, u).updateError(AppUserError(_)) } yield b trait Either[L, R] { def updateError[L2](f: L => L2): Either[L2, R] = this match { Left(l) => Left(f(l)) Right(r) => Right(r) } ``` --- ## Now when we call... ```scala run(c, u) ``` --- ## ...we have to do _something_ ```scala run(c, u) match { case Left(e) => e match { case AppLoginError(InvalidCredentials(_)) => ... case AppUserError(UserNotFound(_)) => ... } } ``` --- ## Print details ```scala def render(e: AppError): String = e match { case AppLoginError(InvalidCredentials(c)) => s"Error on login: ${c.username}" case AppUserError(UserNotFound(u)) => s"Could not find user: ${u.id}" } ``` --- ## Exit status ```scala def loadErrorStatusCode(e: AppError): HttpStatus = e match { case AppLoginError(InvalidCredentials(_)) => notFound403 case AppUserError(UserNotFound(_)) => notFound404 } ``` --- ## Errors as data - Error messages - Logging - HTTP status codes - Executable exit codes - JSON serialisation - ... --- template: question # Future proof --- ## So far so good ```scala sealed trait AppError ... run(c, u) match { case Left(e) => e match { case AppLoginError(InvalidCredentials(_)) => ... case AppUserError(UserNotFound(_)) => ... } } ``` --- ## Please sir ```scala sealed trait AppError case class AppFooError() extends AppError run(c, u) match { case Left(e) => e match { case AppLoginError(InvalidCredentials(_)) => ... case AppUserError(UserNotFound(_)) => ... } } ``` --- ## Compile warnings ```scala sealed trait AppError case class AppFooError() extends AppError run(c, u) match { case Left(e) => e match { case AppLoginError(InvalidCredentials(_)) => ... case AppUserError(UserNotFound(_)) => ... } } ``` <pre><code class="remark-code"><div><span style="color: #DDDD00">[warn]</span> match may not be exhaustive.</div><div><span style="color: #DDDD00">[warn]</span> It would fail on the following input: AppFooError(_)</div><div><span style="color: #DDDD00">[warn]</span> run(c, u) match {</div><div><span style="color: #DDDD00">[warn]</span> ^</div> </code></pre> ??? - Mention `sealed trait` again --- ## Warnings as errors ```scala sealed trait AppError case class AppFooError() extends AppError run(c, u) match { case Left(e) => e match { case AppLoginError(InvalidCredentials(_)) => ... case AppUserError(UserNotFound(_)) => ... } } ``` ```scala scalacOptions in Compile ++= Seq("-Xfatal-warnings") ``` --- ## Compile errors ```scala sealed trait AppError case class AppFooError() extends AppError run(c, u) match { case Left(e) => e match { case AppLoginError(InvalidCredentials(_)) => ... case AppUserError(UserNotFound(_)) => ... } } ``` <pre><code class="remark-code"><div><span style="color: red">[error]</span> match may not be exhaustive.</div><div><span style="color: red">[error]</span> It would fail on the following input: AppFooError(_)</div><div><span style="color: red">[error]</span> run(c, u) match {</div><div><span style="color: red">[error]</span> ^</div> </code></pre> --- template: question # Add more context --- ## Previously ```scala case class AppUserError(e: UserError) extends AppError def run(a: Auth, u: UserId): Either[AppError, User] = for { s <- login(c).updateError(AppLoginError(_)) b <- load(s, u) .updateError(AppUserError(_)) } yield b ``` --- ## Add context ```scala case class AppUserError(e: UserError, u: Username) extends AppError def run(a: Auth, u: UserId): Either[AppError, User] = for { s <- login(c).updateError(AppLoginError(_)) b <- load(s, u) .updateError(AppUserError(_, a.username)) } yield b ``` --- ## Logical stacktrace ```scala AppError was returned -> with AppUserError { username: "bob" } -> with UserNotFound { userid: 123 } -> ... ``` --- ## Errors as data - Types as documentation - Force consumers to deal with them - Can have different failure cases depending on the consumer - Contain all the information you need to debug - "Logical stacktrace" - Future proof - Will fail when error cases change --- template: image <img height="100%" src="images/buckle-up.jpg" /> ## Buckle up ??? - The mechanisms for errors as data is not important --- ## So far ```scala def login(a: Auth): Either[LoginError, Session] def load(u: Session, u: UserId): Either[UserError, User] ``` --- ## What now? ```scala def login(a: Auth): Future[Either[LoginError, Session]] def load(u: Session, u: UserId): Future[Either[UserError, User]] ``` --- ## What now? ```scala def login(a: Auth): Future[Either[LoginError, Session]] def load(u: Session, u: UserId): Future[Either[UserError, User]] def run(a: Auth, u: UserId): Future[Either[AppError, User]] = for { s <- login(c) b <- s match { case Left(e) => Future.ok(e.left) case Right(s2) => load(s2, u) } } yield b ``` --- ## Future + Either ```scala case class FutureE[L, R](run: Future[Either[L, R]]) { } ``` --- ## Future + Either ```scala case class FutureE[L, R](run: Future[Either[L, R]]) { def map(..) = ... def flatMap(..) = ... def updateError(..) = ... } ``` --- ## Future + Either (take 2) ```scala case class FutureE[L, R](run: Future[Either[L, R]]) def login(a: Auth): FutureE[LoginError, User] def load(Session s, u: UserId): FutureE[UserError, Session] def run(a: Auth, u: UserId): FutureE[AppError, User] = for { s <- login(c).updateError(AppLoginError(_)) b <- load(s, u).updateError(AppUserError(_)) } yield b ``` ??? BUUUUUUTTT Need to write each combination --- ## EitherT ```scala case class EitherT[F[_], L, R](run: F[Either[L, R]]) ``` --- ## EitherT + Future ```scala case class EitherT[F[_], L, R](run: F[Either[L, R]]) def login(a: Auth): EitherT[Future, LoginError, Session] def load(Session s, u: UserId): EitherT[Future, UserError, User] def run(a: Auth, u: UserId): EitherT[Future, AppError, User] = for { s <- login(c).updateError(AppLoginError(_)) b <- load(s, u).updateError(AppUserError(_)) } yield b ``` --- template: inverse # Takeaway --- template: question ## Partial functions are not functions --- template: question ## Errors as data --- ## Resources - _Functional Programming in Scala_ by Paul Chiusano and Rúnar Bjarnason - Chapter 4: “Handling errors without exceptions” - _Designing Fail Fast Error Handling_ by Noel Welsh - http://underscore.io/blog/posts/2015/02/23/designing-fail-fast-error-handling.html - https://github.com/charleso/life-without-stack-traces --- template: inverse # Appendix - Checked Exceptions --- ## Checked exceptions don't compose ```java list.map(i => foo(i)) public void foo() throws CheckedException ``` - Language level feature - Not an abstraction --- ### Option 1 - keep throwing ```java public void run() throws LoginError, UserError, ....... { login(); load(); } ``` --- ### Option 2 - single exception ```java public User run(Auth auth) throws AppError { Session session; try { session = login(); } catch (LoginError e) { throw AppError(e) } try { return login(session); } catch (UserError e) { throw AppError(e, session.id) } } ``` --- ### Option 2 - no ADT ```java public class AppError { public LoginError loginError = null; public UserError userError = null; public SessionId sessionId = null; public AppError(LoginError loginError) { this.loginError = loginError; } public AppError(UserError userError, SessionId sessionId) { this.userUser = userError; this.sessionId = sessionId; } } ``` .