Category Archives: Java/Java EE

zoom new years eve – looking back on a year

Posted on by
Reply

Last night was the second year in a row that my friends and I did a Zoom New Years Eve party. It felt very different this year. I’m writing this blog post to reflect on why.

I’m not burned out on zoom

Last year, I had very little in person interaction for the over 9 months leading up until New Years. (In a “good” month, I saw two friends.) Having everything happen on Zoom just made me miss real humans even more. It was like a constant reminder of what I was missing. Now, Zoom is more because it is appropriate. Not everything needs to be in person.

I saw some of them more recently

I saw one of the people at the zoom party in person in early December and four others in August or September. (The remaining person I rarely see outside this annual party in the first place)

I don’t mind spending New Years at home

Granted it’s been a long time, but I have spent New Years Eve alone watching TV. And I’m fine with that. So it’s not a day where I feel sad if I can’t see people. (I do enjoy seeing my friends; it just doesn’t have to be then). Which means last year was more about “ugh, another Zoom thing”

I spend way less time in my apartment

There was definitely a cumulative effect of feeling trapped at home. Now that I’ve been working in the office, I get significant breaks from my apartment. Also, my work problems stay at work and aren’t in my home. This separation has helped me a lot.

Using a Local Record for Readability

Posted on by
Reply

Sometimes there is something we really want to put in our cert book that doesn’t fit. You can only have so many case studies/real world scenarios after all. I rescued this from the trash heap and made this blog post./

Suppose we want to count the number of names that have both a first and last name beginning with E. We want to call the method as:

var names = List.of("Sarah Smith", "Eve Edwards");
System.out.println(local.countNamesStartingWithEs(names));

We can read this with streams:

public long countNamesStartingWithEs(List<String> names) {
   return names.stream()
      .map(t -> t.split(" "))
      .filter(a -> a[0].startsWith("E"))
      .filter(a -> a[1].startsWith("E"))
      .count();
}

The code works. However, it has array positions sprinkled throughout. This requires you to keep remembering the format. We can refactor using a local record:

public long countNamesStartingWithEsWithRecords(List<String> names) {
   record Name(String first, String last) {}

   return names.stream()
      .map(t -> t.split(" "))
      .map(t -> new Name(t[0], t[1]))
      .filter(n -> n.first().startsWith("E"))
      .filter(n -> n.last().startsWith("E"))
      .count();
    }

The record lets us give the fields names so we can reference them as n.first() and n.last(). The only place that has to know about the order is the call record constructor. For such a simple example, the approaches are similar. For longer and more complex pipelines, the local record approach can make the code easier to read.

Presenting vs interacting online

Posted on by
Reply

Today I ‘presented” at the NYC Scrum User Group on “Remote Agile Games“. I’ve been avoiding presenting remotely. I did do a panel. Today wasn’t bad. I think the key reasons were

  • It wasn’t a lecture
  • No slides (or code). Just me and the audience.
  • Enough people were on video
  • Part of it was a game (so I wasn’t speaking)
  • The audience participated, shared experiences, etc

All this made it feel like a conversation. Which isn’t draining the way an online presentation is.