A modern programming language that makes developers happier.

kotlinlang

How does everyone feel about the answer from <@U092N7GGG> here? I personally really like using !! when I want to assert that something is not null at that point.
<https://discuss.kotlinlang.org/t/requirenotnull-or/1562/2>

It provides a shitty debugging experience without any reason for the error

Using `requireNotNull` expresses intent more clearly.

Agree in avoiding bang-bang (unless it's a reference to Jessie J, Ariana Grandle and Nicki Minaj). `requireNotNull` and `checkNotNull` express intent more clearly, or when it makes sense just using `if`s with smart-casting. :sunglasses:

The one place i use `!!` is to tell kotlin that a platform type is not null, e.g. `someJavaCall()!!`

<@U2E974ELT> thoughts on this post? <https://fragmentedpodcast.com/episodes/176/>

&gt;Donn walks through why Kotlin’s Not Null Assertion Operator (!!) is a code smell and what you can do to alleviate it.

Have not listened to it. Is there a transcription available?

The podcast basically says never to use `!!`, except maybe in tests.

I think it’s a bit too strong, there are cases even in production code where things should absolutely never be `null` (e.g. a configuration file should be part of the distribution). Your app is going to crash if that thing is `null`, so it’s all a matter of how you want to crash.

Yeah. <@U0B8ZP13Q> personally I prefer to crash if I know it should never be null, but it sounds like the podcast author uses some other techniques, but I haven't found anything as easy to use as !!.

You can use ` ?: error("This should not happen")`. I guess a project might have a policy to provide a better message that includes a context in this case. That would be a material improvement over `!!`. Without additional context in a message I see no benefit in writing longer code, though.

The “better error” part here is also a reason why I prefer `requireNotNull`/`checkNotNull` over `!!`. :+1:

`require` vs `check`? I … don't know, I guess I just remember that `require` is in the context of arguments, where `check` is in the context of state, but I'm not sure why. :stuck_out_tongue:

<@U2A9C33NF> I tried to just do a requireNotNull check, but it didn't do anything because my value was mutable, so I still had to use !! or ? in line when accessing the variable.

`requireNotNull&lt;T?&gt;` returns the `T` (non-nullable, so you could potentially do this:

```
val value = requireNotNull(nullableValue)

// use value henceforth
```

Or, you could also inline the `requireNotNull(value)` calls to wherever you're accessing `value`, but I often find it nicer to just put it in a local `val` and “be done with it”.