DEV Community: Jeff Sheets

Language Version Managers - the Developer Parachutes

Jeff Sheets — Thu, 29 Sep 2022 14:47:12 +0000

Installing multiple language versions (e.g. Java 11, Java 19, Java 8 | Node 8, Node 16 | Python 2, Python 3 | etc) on your machine is scary, and not for the faint of heart.

Conquer your fears with the benefit of a developer parachute, by using a Language Version Manager!

As software engineering consultants at DevObsessed, we get asked to help with an assortment of various projects – from legacy codebases running in maybe Java 8 or NodeJS 6, to greenfield creations using the newest versions of Java 19 or NodeJS 16. This isn't only an issue between companies though, as most organizations have multiple versions of languages running at any given time too.

Managing local installations of Java, Node, Python, Ruby, Elixir, etc can be daunting. In the past, trying out the latest version to check for bugs could lead to a developer's machine being down for hours at a time. And if a rollback to a previous version was needed that could take even longer! Wouldn't it be great if you could have a parachute with you on your mission, so that if anything goes wrong you can easily save yourself and proceed with confidence?

Language Version Managers are your answer. Many version managers exist, and in this post we'll show you how Sdkman for Java, and NVM for Node can provide you the courage to easily utilize multiple language versions without any worry in the process.

Backstory

To set the scene, you should know that originally this post was going to be about the recent release of Java 19. It would be a story about the newest and latest Java features, maybe how to use them, and probably why they would make it great for you to upgrade.

Without thinking about it, using Sdkman with a quick sdk install java 19-open and my MacbookPro was running the newest Java within seconds. It was so easy to upgrade to the cutting edge version, that it was summed up easily in a single tweet:

https://twitter.com/sheetsj/status/1572298842460286980

Not until this moment did I dive in to see that Java 19 was more of an incremental release. Some bugfixes for sure, but mostly it includes just some Preview and Incubator features (hiding behind feature flags) that won't be fully live until Java 20 or beyond.

So after a few moments of trying out Gradle and IntelliJ support, I quickly reverted back to my previous Java version with sdk default java 18.0.2.1-open. No fuss and no worry. Then it dawned on me how before Sdkman this would have taken me probably many minutes if not hours of work to flip back and forth between Java installation versions locally.

Sdkman for Java

sdkman.io

Sdkman is the best Language Version manager for Java and all JVM languages, to include Groovy, Kotlin, and more. Don't use brew or Oracle or some other installer on your macbook. Instead, install Sdkman and use a few commands to manage the version that you use.

Use the install instructions for Sdkman from https://sdkman.io/
sdk ls java to see the various versions of Java that are available
sdk install java 18.0.2.1-open to install the Java18 OpenJdk version (or pick your favorite distribution from Azul or Microsoft or Amazon, etc)
The use keyword can switch the version for a single shell window, like sdk use java 19-open
The default keyword will setup a default for your whole machine, like sdk default java 18.0.2.1-open
Similarly use the same commands for Groovy sdk ls groovy, or Kotlin, or any of the 20+ various JVM languages!

NVM for NodeJS

https://github.com/nvm-sh/nvm

In the Node world, there are a few options like NVM, N, FNM, Volta, and more. I've been a longtime user of NVM, so we'll detail those instructions for use here:

While unofficially supported, nvm can be installed with homebrew using brew install nvm
- Follow any additional instructions to setup your shell in .zsh or .bash_profile or whatever shell you use
- Or find other installation instructions at https://github.com/nvm-sh/nvm#install--update-script
nvm ls to see the available Node versions
nvm install --lts to get the latest stable LTS (Long Term Support) version
nvm install v8.17.0 or similar to get a specific version
nvm use v8.17.0 or similar to use a specific version in a single shell window
nvm alias default v16.17.0 or similar to set a default version

Wrap-up

There are other various version managers for other languages. Ruby has rbenv or RVM, Python has pyenv, Elixir has kiex, and many more. No matter what language you are on, the key is to find a language installation manager to handle the various versions that you may need to use.

In the Java and Node worlds, Sdkman and Nvm are the parachutes you need for confidence, courage, and to save you from configuration management worry!

And if you're looking for the best software engineer consultants for your project or team, developers who average over 10 years of experience, and come with even more tips and tricks that we've learned to improve developer experience over those years -- reach out to us here at DevObsessed! We're obsessed about developer efficiency, and we'll help you achieve your own digital destination!

Export Meetup.com Events to a Github Pages Jekyll site

Jeff Sheets — Wed, 31 Aug 2022 04:13:49 +0000

I help run the Omaha Java Users Group, and for a long time our communication has been through meetup.com/omahajava/, however we do still have an ojug.org website too. At first, we would nicely copy the event to both Meetup and OJUG.org, however within a few months you can see that we simply stopped duplicating effort and the events on ojug.org quickly got out of date. Not a big deal at the time. But it would be nice to archive our past events to the ojug.org site (especially as we explore Meetup.com alternatives in the near future [1]).

(if you want the TL&DR: see all the details at https://github.com/jeffsheets/ojug-meetup-export.)

Exporting Events from Meetup.com

The first step was to find a way to export our past events. I had hoped for a CSV export through the admin UI, but didn't see anything. I then thought it might take some web scraping, or maybe some network dev tools api call watching. But noticed that there was a grayed out setting in the admin UI for the Meetup API 🤔. A quick google found the Meetup GraphQL API Playground page. And to my surprise, sending a test query just worked! 🎉

After a little trial and error from their API docs, and increasing the result count to 100 to get all of our events without paging, I was able to export all of the past events to JSON with:

  query($meetupId: String!) {
    groupByUrlname(urlname: $meetupId) {
      description
      pastEvents(input: {first: 100}) {
        count
        edges {
          node {
            title
            description
            dateTime
            going
          }
        }
      }
    }
  }

And some inputs of:

  {"meetupId":"omahajava"}

Which gave a nice JSON result, like this:

{
    "data": {
      "groupByUrlname": {
        "description": "Omaha's Java User Group [@omahajug](https://twitter.com/omahajug/). yadda yadda yadda",
        "pastEvents": {
          "count": 65,
          "edges": [
            {
              "node": {
                "title": "Angular JS for Java Developers",
                "description": "This month //etc etc etc",
                "dateTime": "2014-05-20T17:30-05:00",
                "going": 27
              }
            },
.....

ojug.org Tech

Before showing you how the event blog post pages were generated, a quick note on the tech for ojug.org (src at https://github.com/OJUG/ojug.github.io). It is running on a standard Github Pages Jekyll workflow stack. While we have thoughts to move that over to 11ty, for now Jekyll is working fine. Create a new markdown file in the _posts folder, merge to the main branch, and the workflow auto-kicks off and redeploys our ojug.org site like magic.

Generating Meetup event Jekyll posts

With this in mind, the blog needs .md files generated for each event in the events JSON. Using a little Groovy, this was done pretty quickly with a GSP template, some functions to prettify date formats, and a filename creation function. The groovy post.gsp template looks like:

---
layout: post
title: " \"&lt;%= longDate %> &lt;%= title %>\""
---

&lt;%= description %>

(This past event was exported from Meetup.com)
(&lt;%= attended %> people had RSVP'd to this event in Meetup)

Then the code that generates the template for each JSON event is in PostGenerator.groovy:

    void generatePosts() {
        def events = new JsonSlurper().parse(getClass().getResource(SRC_JSON)).data.groupByUrlname.pastEvents.edges
        events.each {
            def event = it.node
            def filename = makeFilename(event.title, event.dateTime)
            def outfile = new File("$DEST_FOLDER/$filename")
            def filecontents = new SimpleTemplateEngine()
                    .createTemplate(getClass().getResource('/post.gsp'))
                    .make([
                            title      : event.title.replaceAll('"', '\"'),
                            description: event.description,
                            longDate   : convertToLongDate(event.dateTime),
                            attended   : event.going
                    ])
                    .toString()
            outfile.write filecontents
        }
    }

When executed, nice markdown files are generated in the output directory, similar to 2014-05-20-angular-js-for-java-developers.md:

---
layout: post
title:  "May 20, 2014 Angular JS for Java Developers"
---

This month //etc etc etc

(This past event was exported from Meetup.com)
(27 people had RSVP'd to this event in Meetup)

The last step was to copy all of the new markdown files into the _posts directory, create a PR, merge it, and see the final results up at ojug.org!

Wrap up

And that's it! Writing this blogpost probably took longer than the process to export Meetup to JSON, and generate new markdown files for the Jekyll blog! You can view all of the full source on my github at https://github.com/jeffsheets/ojug-meetup-export

[1] - A quick footnote, about Meetup.com... Over the years Meetup has been great for advertising our group, attracting new members, having a great user interface, and easily collecting RSVP's for events. We've always been lucky enough to have great sponsors to pay the ever increasing fee, which is now up to $197.98/year. However Meetup's decision to not allow us (or any group) to "freeze" the account, means that our sponsor has been paying that fee for 2.5 years with little benefit. Talking to other local tech meetup organizers, it became apparent that many of us are pondering ways to free ourselves from these fees. Our sponsors could throw some pretty great user group parties with the savings! There's a lot of functionality we'd have to replicate though, so I'll leave that full discussion for another time...

Mock Intl and Date globals in Jest (easily!)

Jeff Sheets — Wed, 12 May 2021 01:01:45 +0000

In Javascript land, mocking the browser global objects can be a bit of a pain for tests. Searching StackOverflow gives plenty of complicated answers. Some suggesting using 3rd party mock libraries. Some that overwrite the global object itself.... But Jest already has this capability built-in and it isn't so bad:

So let's say you have a method that gets the user's timezone or the timezone offset. (the timezone offset is used sometimes since IE11 doesn't support easily reading the timezone, but I digress)

/**
 * Useful when passing the browser timezone to a backend Java API that reads a timezone in using ZoneId.of(tz),
 *  as both 'America/Chicago' and '-0600' are valid values when passed to the Java API.
 *  The Offset is used to handle IE11 and other older browsers.
 */
export const getUserTimeZoneOrOffset = () => {
  let timeZone;
  try {
    timeZone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
  } catch (error) {
    // Ignore if this happens, and just use the fallback
  }

  if (!timeZone) {
    //Could not get a browser timezone, maybe IE11, so instead use timezoneOffset formatted for Java
    // https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/ZoneOffset.html#of(java.lang.String)
    const offset = new Date().getTimezoneOffset();

    //Yeah this offset +/- seems backwards,
    // but JS actually returns a positive when local tz is behind UTC (like for US tzs)
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
    // e.g. offset = 300, timeZone='-0500'
    const plusMinus = offset <= 0 ? '+' : '-';
    //leftpad a 0 when needed for two digits
    const hours = ('0' + Math.floor(Math.abs(offset) / 60)).slice(-2);
    const minutes = ('0' + (offset % 60)).slice(-2);
    timeZone = `${plusMinus}${hours}${minutes}`;
  }

  return timeZone;
};

Now to test this, we'll need to mock out both the Intl and Date Javascript globals. We can do this using Jest's spyOn method to temporarily replace the global method with our own implementation. Notice that we setup the spy in the beforeEach and reset everything in the afterEach. The setup works something like this:

import { getUserTimeZoneOrOffset } from './timeZoneUtils.js';  
describe('getUserTimeZoneOrOffset', () => {
    let mockOffset;
    let mockTimezone;

    beforeEach(() => {
      mockTimezone = undefined;
      jest.spyOn(Intl, 'DateTimeFormat').mockImplementation(() => ({
        resolvedOptions: () => ({
          timeZone: mockTimezone
        })
      }));

      mockOffset = undefined;
      jest
        .spyOn(Date.prototype, 'getTimezoneOffset')
        .mockImplementation(() => mockOffset);
    });

    afterEach(() => {
      jest.restoreAllMocks();
    });

    test('returns timezone name when found', () => {
      mockTimezone = 'America/Chicago';
      const result = getUserTimeZoneOrOffset();
      expect(result).toBe('America/Chicago');
    });

    test.each([
      [300, '-0500'],
      [150, '-0230'],
      [-60, '+0100'],
      [-330, '+0530'],
      [0, '+0000'],
      [-765, '+1245']
    ])('timezoneOffset for %i is %s', (offset, expected) => {
      mockOffset = offset;
      const result = getUserTimeZoneOrOffset();
      expect(result).toBe(expected);
    });
  });

But that's it! No need to import an extra library. This is all supplied directly in Jest itself!