Computing Thoughts

Bruce Eckel's Programming Blog

Sep 6, 2018 - 4 minute read

The Evolution of the Developer Retreat

I’ve been experimenting with different forms of events for many years now. Mostly this has been in the form of self-organizing conferences, but in recent years I’ve tried going further, to even less structure. I’ve held a number of “developer retreats” where we had a theme that everyone focused on, and those have been quite interesting and valuable.

To be honest, what I really wanted to try with the developer retreats is zero structure. People just get together and individually work on whatever they want. And then see what happens. However, I could never quite bring myself to suggest such a flaky-sounding experiment.

But the week of August 19-25, it happened anyway. And it was great.

For various different reasons (probably mostly because I seem to be bad at promoting events), neither the Kotlin seminar nor the Software Architecture Forum were working out. However, Luciano Ramalho and one other person had made plans and still wanted to come, so I decided to call it a developer retreat, but one where we made up the theme during the retreat.

As it turned out, we each had things we wanted to work on (for some people, this included their job), so we did, and we never established a central theme. This meant that we ended up exploring many more topics than in previous retreats, because some explorations didn’t take very long, or didn’t pan out or weren’t interesting enough, so we went on to other topics. But I’m saying this as if we studied each topic as a group, which wasn’t the case. Each person worked on their own experiments and we would sometimes have discussions about these. For me, it was the best developer retreat experience I’ve had—the relaxation and freedom to do whatever you want, but with other people around with whom you could discuss and share.

We also ended up spending most of the working time in the new co-working space that I’ve been setting up, called Evolve (The web site is not live yet).

Among the topics we explored and discussed:

  • Kotlin: The working environment ispired me to make quite a bit of progress on Atomic Kotlin, and this produced some discussions about the language.

  • Elixir: Luciano was delving into Elixir (and preparing to take a workshop at the upcoming ElixirConf), so we had discussions about the way Elixir was designed, and its roots in Erlang.

  • Flutter: Another member of the group dove into Flutter and within a short time had a simple app working on his Android phone, with plans to try it on his iOS device. I was skeptical at first because my initial experience with the Dart language left me nonplussed, but Dart has evolved quite significantly since then and I’d say it’s roughly 1/3 of the way between Java and Kotlin; which is to say: much nicer to use than Java. And the Flutter framework itself might just be one of the actual solutions to single-source development across Android and iOS.

  • Ubuntu on Windows: We discovered that Ubuntu is now an app in the Windows 10 app store, and can be installed and used effortlessly (vs. the earlier experimental version, which required some hoop-jumping to get up and running). This makes Windows 10 even more attractive for development.

  • Games: There were some side discussions and demos of some interesting new games, and about the game world in general.

  • Testing: We had some good testing conversations and Q&As, in particular for Django-based web apps.

Although the full-group explorations that we’ve done in the past—studying a chosen topic, in my living room, sharing the TV screen using Chromecast—might well have a place in this new model of the developer retreat, I suspect that it might comprise only a shorter and occasional portion, if it even happens. My own experience during previous developer retreats is that this format became onerous and restrictive after awhile, and exhausting after multiple days. Indeed, developer retreats were formerly limited to four days because it became too intense for a longer period, while this new relaxed format easily worked for a week.

So, until even better insights come along, this is the new format for developer retreats:

  • Most of it happens at the co-working space.
  • People do whatever they want, including work projects when they need to.
  • Occasionally someone starts a discussion about what they’ve found or where they’re stuck.
  • Meals offer further opportunity for discussion.
  • We can go for outdoor adventures as weather permits.
  • If a group exploration seems appropriate, we can do that, but only for as long as it works well.

This format is also more flexible for people’s schedules—if someone can’t make it for the whole event, they can still get a lot of value if they are only there part of the time.