Kotlin on BradCypert.com

Adapting Traits for Kotlin

Wed, 10 Apr 2019 00:00:00 +0000

Traits are a pattern introduced in Scala (at least, this was my first introduction to them) that help avoid deep class hierarchies in favor of composition. If you don’t have Scala experience, but do have Java experience, you can treat this similarly to Java 8 Interfaces . However, I still prefer to call them Traits.

Although Traits have first-class support in Scala, Kotlin does not directly have Traits. However, Kotlin does support default interface implementations , just like Java 8. It’s fair to assume then, that Kotlin can have a similar concept of Traits only constructed from Interfaces with default implementations.

Comparing Kotlin to Scala

Tue, 05 Mar 2019 00:00:00 +0000

Kotlin to Scala. Scala to Kotlin. Two contenders for my heart. In the left corner, we have the new comer! Weighing in at just over 1.2MB — The Ambassador of Android: Kotlin! And in the right corner, we have the long-time favorite, weighing in at just over 5.3MB — The Archduke of Akka, The Sultan of Spark: Scala!

If you’ve made it this far through my silliness, you’re likely comparing Kotlin to Scala for your next project. There’s definitely some key takeaways from the above paragraph that may influence your decision. However there’s more to each language than I could dare try to squeeze into an introductory paragraph. The rest of this post will cover each of these languages in comparison to:

Formatter Objects: Testable Fragments

Thu, 24 Jan 2019 00:00:00 +0000

Let’s face it — Fragments are a pain to test and it’s predominantly due to how the Android operating system works. Sometimes, you’ll find yourself writing business rules regarding how a view is displayed. Likely, some data will come back from a web server and you’ll have to format some text differently or color something differently. Nothing crazy, but all this code adds up and needs to be tested.

Ideally, you’ll have some form of automation coverage to help tackle this problem, but Espresso tests can be slow and environment dependent. But what If I told you that you could write unit tests for this logic and simplify your fragments all in one swoop? Hopefully you’re as excited about that as I am.

The Facade Pattern for Simple Dependency Injection

Wed, 16 Jan 2019 00:00:00 +0000

I’ve been working on a Ktor api for a while now and found myself needing to make sure my routes had access to my repositories. Naturally, I sought out the advice of anyone who’s implemented Dagger with Ktor. After digging for a bit, I realized that it was completely unnecessary and likely overkill. Dagger works great on Android because you are tied to the constraints of the platform and lifecycles, but with Ktor I have control of the entire scope of my application.

Controllers in Ktor

Thu, 10 Jan 2019 00:00:00 +0000

Ktor is a microframework written in Kotlin. It’s focus is on building asynchronous servers and clients in connected systems. I’ve been using it predominantly for the “server” slice of that statement. I call Ktor a “microframework” simply because, while it’s opinionated, you have a lot of freedom in the way that you accomplish tasks within the framework.

If you’d like to follow along, you can scaffold out a basic Ktor project via Intellij Idea or the online tool for generating a seed project .

Lambda-Map Performance in Kotlin

Mon, 19 Nov 2018 00:00:00 +0000

Working on an enterprise application written in Kotlin, I’ve recently noticed something that felt “off” to me. Perhaps you’ve seen it, perhaps you’ve written it — maybe even recently! It looks something like this (I call this a Lambda-Map):

object Demo {
  fun main() {
       listOf(1,2,3,4).map {
            plusOne(it)
        }
    }

    private fun plusOne(i: Int): Int = i + 1
}

Sure, this plusOne function isn’t really necessary. We can just inline it in the Lambda, but imagine for just a moment that this function does much, much more than just add one to a number. It then feels just to have that code pulled out into a private function — but that’s not the offender here.

Introducing KotlinToday.com

Tue, 13 Nov 2018 00:00:00 +0000

KotlinToday shut down after several years. Thank you for visiting the site for your Kotlin News.

When I was learning Clojure for the first time, I had two references that I found myself reading every single day. The first resource is a fantastic guide by Daniel Higginbotham called Clojure for the Brave and True . The second resource that I found myself using allowed me to immerse myself into the Clojure community and figure out where people were focusing their efforts – Planet Clojure . Planet Clojure is a metablog that pulls in blog posts from a vetted list of Clojure developers. In fact, you may have even seen some of my posts on there, too! Unfortunately, when I picked up Kotlin, I couldn’t seem to find a Planet Clojure for Kotlin, so I made KotlinToday.com .

Sequence: A Kotlin Type

Sat, 03 Nov 2018 00:00:00 +0000

Kotlin, despite being an object oriented language, offers a ton of support for Functional paradigms. One of the most common functional paradigms involves using a combination of map, filter, and reduce on Iterable types. However, Kotlin uses extension functions on Java Collections to create these functions in their standard library. That means that when you call map on a list, you’ll return a new list. This is usually intended, however, it can become problematic when chaining multiple operations on the same list — You’ll create a ton of intermediate lists!

BDD Assertions with Expekt for Kotlin

Fri, 26 Oct 2018 00:00:00 +0000

Behavior-Driven Development (BDD) has became quite a popular strategy for writing tests in the past ten or so years. BDD is a style of test-writing that focuses on test cases that flow like natural English sentences. Expekt is one such library for writing JUnit assertions in Kotlin. Combining JUnit and Expekt you can achieve results like this:

class FormatterTest {
  @Test
  fun shouldFormatFloatsWithADollarSignAndTwoDecimalPlaces() {
    Formatter.format(1.2345).to.equal("$1.23")
  }
}

Adding Expekt to Your Project

As of writing, the current version of Expekt is 0.5.0 so that’s the one we’ll include in our project. If you’re using Gradle, you can add the following to your dependency list in your build.gradle.

Kotlin Sealed Classes

Fri, 19 Oct 2018 00:00:00 +0000

Kotlin has a concept known as sealed hierarchies (several other languages implement this feature as well). In Kotlin, we can generate a sealed hierarchy through the use of sealed classes.

What are Sealed Classes?

Sealed classes are basically an extension to an enum class. They offer similar functionality with a few key differences. Similarly:

The class can not be instantiated directly
The type can be represented as a type from a limited set, but not from any type outside of the set.

Differences however, are the important part:

Static Methods, Companion Objects, and Testing

Wed, 18 Jul 2018 00:00:00 +0000

I’ve been working with Kotlin a ton recently, both at work and for fun. It’s a fantastic language on the JVM that combines almost all of my favorite Scala features and adds in several new features as well. If you haven’t given it a shot yet and you’re a Java reader, give it a try! You’ll love how expressive it can be and how simple and concise some of the code can be. If you’re a Scala reader, you’ll feel familiar with a lot of the syntax and ideas (Objects, replacing statics for example). One thing Kotlin does that still feels a bit weird is it promotes the use of companion objects. A companion object sits inside a class definition and houses all the static methods which that class will own. Let’s convert a piece of Java code to Kotlin so you can see what I mean.

Using ButterKnife with Kotlin

Wed, 16 May 2018 00:00:00 +0000

Butterknife is a simple but fantastic tool for Android development. When this was introduced, it really simplified my thought process regarding view bindings in my activities, fragments, or view holders. As Kotlin adoption grew, Jake Wharton (creator of ButterKnife) also created KotterKnife , for kotlin-esque view bindings. KotterKnife isn’t bad, but I prefer the annotation syntax of ButterKnife instead! Implementing ButterKnife with Kotlin has a few gotcha’s however, that may be a bit difficult to get setup with. Let’s talk through those.