Jacek finished CS studies at Warsaw University of Technology on Faculty of Electronics and Information Technology with broad range of skills. Started his journey as 3D graphician, majored in low-level digital electronics and then mathed-away to quantitative data research; worked in many technologies from programming FPGAs, through C and Ruby to beloved Scala. Co-founded Iterators — a software consultancy firm.
Strong typing is popular throughout software ecosystem. As functional programmers we love it even more. We want to know all about the monads, higher order functions, lambda types. We often say "it works, type-checker passed". But does it? Do we actually use types in our systems?
My talk is aimed at beginner and mid-level programmers. It's an insight based on my experience leading a team of Scala developers. The talk is divided into three parts. First part presents what strongly typed systems are and it ends with stating the hypothesis "Do we actually leverage the strengths of strongly typed systems when we program?" The second part consists of examples supporting the thesis that we program typed systems poorly. I present and comment Scala code examples. These include: excessive usage of primitive types and side-effecting functions, poorly validated objects, implicit typing and using type inference in wrong places, using tuples and long parameter lists, using brittle math concepts explicitly inside the business domain model and (probably) more. The third part of the talk is about finding the way around those problems. I present: some solutions to the previously presented problems, bottom-up and top-down approaches of creating and refactoring systems with types. I sum it up with talk about trade-offs and problems while using strong typing. The talk's summary is an optimistic message that problems we face when using types can be solved in an elegant way, without adding lot of brittle, unreadable, boilerplate code.