Thank you compose team! I didn't laugh that much w...

# compose-desktop

[Paul Woitaschek]

Thank you compose team! I didn't laugh that much while developing for a while now 😂
And yes, I just finished Queens Gambit on Netflix 🙈

[ian.shaun.thomas]

ship it

[Big Chungus]

Is it intentionally so buggy?

[Paul Woitaschek]

Isn't this how chess is supposed to work?

[Ole K. Øverland (Norway)]

Chess 2.0

[marstran]

Is this the off-by-1 opening?

[Paul Woitaschek]

It's the cut-out-pieces-of-the-board-with-a-saw opening

[xetra11]

it should be called Chonk

[xetra11]

@Paul Woitaschek also how dare you to do this in kotlin?

[Paul Woitaschek]

What's wrong with that?

[Michal Harakal]

removed?.let {
}

@xetra11?

[xetra11]

ye do the let stuff with fancy kotlin nullables

[xetra11]

its magic @Paul Woitaschek please join the magical side

[Paul Woitaschek]

Nah the code is fine like it is

[Paul Woitaschek]

Its easy to read and makes use of smart casts

[Big Chungus]

I'm with @Paul Woitaschek on this one. Let can be easily abused

[xetra11]

@Big Chungus Do you have an example at hand?

[Big Chungus]

Not at hand, but too many nested let push the code too far to the right and can make it hard to follow. All I'm saying is that java style null checks are nothing to be affraid of. While they are a bit more verbose, I feel they make the code easier to follow.

[xetra11]

Hm wouldn't the amount of nested if (x != null) be the same as the ones of nested lets ?

[xetra11]

It took me a while to "feel" let like I felt if (x != null) that I have to admit. But after I became warm with ? and the whole things I really feel it's nicer. Just my opinion tho.

[Big Chungus]

Yes, but you can do multiple null checks in java style check

[xetra11]

Well ok that is possible but I don't design code like that - so I think we have different styles 😄 luckily there is something for everybody ;0

[Paul Woitaschek]

I only use ?.let for scoping when the body of the function becomes so complex that the scoping is actually helpful.
But in most cases that applies, I'd refactor the function into smaller functions before doing that.
Regular if checks make use of smart casts and whats nice of these is that multiple smart casts work together.

[Paul Woitaschek]

This:

if (currency != null && rate != null) {
  result[currency] = rate
}

Is easier to understand than this:

currency?.let {
  rate?.let { rate ->
    result[it] = rate
  }
}

[xetra11]

Well I have to admit that this is true. However as I mentioned I rarely come over code sections where I need to check two things for null since I strip them to be not null as early as possible. In my projects nullable data is mostly coming from perstistence or filesystem layers and I strip them to notnull as soon as I read/query the data. Afterwards I never have to care about null states again

[gildor]

if null check is almost always better than using let for null check