Career Current Events Tampa Bay

St. Pete College offers free tech training for laid off/furloughed residents in Pinellas County

If you’re:

  • In the Tampa Bay area (Pinellas County in particular),
  • in technology or looking to get into it, and
  • your job was affected by the pandemic…

…you might be eligible for some very useful free training from St. Pete College’s Rapid Credentialing Scholarship program. It provides full-tuition scholarships to eligible students, and it does so in weeks as opposed to years.

The program offers training in a number of fields. Under technology, here’s the training offered:

You are eligible for the program if you meet all of the following requirements:

  • You’re unemployed, underemployed, furloughed, or expecting to be furloughed
  • You’re a resident of Pinellas County
  • You are a U.S. citizen or permanent resident
  • You are 18 or older
  • You have an Employ Florida account (which you can sign up for here)

To find out more…

Career Tampa Bay What I’m Up To

I’m at The Undercroft’s “Get a Job” career fair!

The class portion of UC Baseline — the cybersecurity training program offered by The Undercroft, Tampa Bay’s security guild — ended yesterday with the final day of Python 101, which marks the end of classes. Every weekday for the past five weeks, 8:00 a.m. to 4:00 p.m., I’ve been in a classroom (masked and socially distanced, of course), studying and furiously taking notes in the following classes:

Course Instructor
Hardware 101
(5 days)
Networking 101
(5 days)
Linux 101
(3 days)
Windows 101
(2 days)
Infosec 101
(5 days)
Python 101
(3 days)

There are still two more days in the program. Today is the “Get a Job” career fair. The Undercroft have gathered a series of recruiters, security companies, and agencies to talk to us, including:

The presentations are quite good — I’m pretty impressed by the representatives I’ve seen so far.

I’m also dressed and masked for the occasion:

Career Players Tampa Bay

You have hours to sign up for a chance at a free scholarship to The Undercroft’s “Baseline” cybersecurity program!

Photo: The Undercroft sign, featuring the Undercroft’s “mascot” — a stag standing upright in a suit, leaning jauntily against an umbrella, walking stick-style.

The Undercroft, Tampa Bay’s cybersecurity guild/collaboration space, is offering scholarships to members and non-members for the July 20th cohort of their UC Baseline cybersecurity skills program. Simply put, it’s a chance to learn essential cybersecurity skills from the area’s experts for free!

Logo: UC Baseline

The UC Baseline program comprises the following courses:

  • Hardware 101: Gain a thorough understanding about the devices on which all our software runs and through which all our information flows.
  • Networking 101: Learn how our systems are connected and the ways in which they communicate through these connections.
  • Linux 101: Covers the foundations of security in Linux environments, the OS on which the internet runs.
  • Windows 101: Here’s a big challenge — learn the foundations of security for Windows environments.
  • Information Security 101: Covers everything from core IT concepts, to cybersecurity principles, methods, and practices.
  • Python 101: If you’re doing security, you should have some coding skills to automate your work and build tooling, and Python’s an excellent language for that task.

Here’s The Undercroft’s offer:

Are you looking to take control of your personal privacy and security? Are you frustrated by disappearing jobs and want to make an impact in the cybersecurity industry? Do you have what it takes to ensure your economic future and that of others?


The Undercroft’s Baseline program was built for those with the fortitude to fight against daily attacks that threaten our way of life.


In response to the global pandemic and increasing uncertainty in our economy, we are offering a select number of scholarships to guild and non-guild members for our July 20th, 2020 cohort.

Interested? Sign up on their scholarship page. You’ve got only until sometime on Friday, July 17th to apply!

(I’ll admit it: Although I’m not likely to qualify, I applied.)

Career What I’m Up To

The Great LinkedIn Premium experiment

Image: Dee Dee from “Dexter’s Laboratory” pressing a button with the LinkIn logo on it
Ooh! What does this button do?

I decided to see if LinkedIn Premium will help with the job search and activated the one month free trial. I’ll keep you posted by writing about the features I find and my experiences with it.


That time I did a children’s technology show for Microsoft

I had a lot of fun, surreal moments during my time as a developer evangelist at Microsoft, and among the most surreal and fun was the short-lived time when I had a technology show for kids called Developer Jr.

Hosted on, a technology education video site launched by Tucows (a prior employer) in 2008, Developer Jr. was an online video show for children ages 7 through 12. Our goal was to teach kids programming and other creative things they can do with computers and technology (particularly Microsoft technology). It starred me as the host and tutor, and “Junior”, an impish puppet played by Brian Hogg. It was sponsored by Microsoft Canada and produced at’s studios in Toronto’s Liberty Village neighborhood in early 2010.

The premiere episode showed how you could use the code-free game development system Kodu (which ran on Windows and the Xbox 360) to make your own videogames:

The follow-up episode covered making your own movies with Windows Live Movie Maker:

There was also this interview with’s Matt Harris in which we discussed the making of Developer Jr.:

Unfortunately, Developer Jr. was cancelled after two episodes for financial reasons. There wasn’t a department within Microsoft Canada who had a budget aimed at the 7 – 12 year-old set.

I’m still pretty pleased with the work that we did during that too-short season, and I’d like to thank Brian Hogg, video wizards Sean Carruthers and Matt Harris for making the magic happen, and Andy Walker for getting the whole thing started!

Career Programming

Programmer interview challenge 2, part 5: An elegant “watcher”-based FizzBuzz implementation in JavaScript

Silhouette of a little black dress on a dress form
Ask someone who follows fashion what they think of when the word “elegant” comes up, and they’ll often come up with the Little Black Dress.

In the previous article in this series, I put out a call for alternate implementations of the “watcher”-based FizzBuzz solution. Frank Quednau answered the call with this elegant bit of JavaScript:

Let’s take a closer look at the code for the watcher, which is assigned a word and keeps track of when to say it:

  • wordWatcher has two parameters:
    • interval: The x in “Every xth number”
    • word: The word to be output
  • It uses those parameters to customize the function that it returns: a function that when called, does two things:
    • It increments its internal counter count, and
    • returns either word (if it’s time to say the word) or an empty string.

If you find yourself writing a lot of similar code with only minor differences — or worse, cutting and pasting code, followed by typing in those minor differences — you may be looking at an opportunity to use a function like this.

If you prefer to have your functions marked with the keyword function, you can change out the arrow notation and the code will still work:

With wordWatcher defined, creating watchers for Fizz and Buzz is easy:

And here’s the loop that provides the output:

  • If it’s time to say FizzBuzz, or FizzBuzz, potentialFizzBuzz will contain that string. The calls to fizzWatcher() and buzzWatcher() will also increment their internal counters.
  • If potentialFizzBuzz contains anything, its contents will be printed to the console; otherwise, the current number — which has 1 added to it because array indexes start at 0 and the FizzBuzz game starts at 1 — is printed instead.

You should check out the rest of Frank’s Gist, Fizzbuzzes in many colours, which looks at FizzBuzz solutions written in several languages.

What does it mean for code to be “elegant”, anyway?

In ordinary everyday use, elegant means “pleasingly graceful and stylish in appearance or manner.” The term has been adapted by people in problem-solving fields — science, mathematics, and yes, programming — to mean “pleasingly ingenious and simple”.

And that’s what elegant code is: pleasingly ingenious and simple. This FizzBuzz implementation is elegant because it solves the problem in just over a dozen lines, is simple and concise, and even provides some new insight into programming (the use of custom-generated functions to avoid repetition).

Here’s a good list of qualities of elegant code, courtesy of Christopher Diggins article, What is the Definition of Elegant Code?:

  • It is succinct
  • It is easy to understand
  • Each function does one well-defined task
  • It conveys the programmer’s intent
  • It reflects the problem domain
  • It is easy to modify and reuse
  • If it fails, it is easy to identify that it is has failed, where it has failed, and why it has failed.
  • Its behavior (in good and bad conditions) is easy to predict

Check out the following articles — sooner or later, you’ll be interviewed by a programmer who’ll want to know if you’ve given some thought to some of programming’s more philosophical questions, and “What does it mean for code to be elegant?” is one of them:

What’s next

FizzBuzzBazz! (or: Making FizzBuzz harder).

Previously, in the “Programmer interview challenge” series


Career Programming

Programmer interview challenge 2, part 4: Using “watchers” to play FizzBuzz “properly”

The Marvel Comics character known as “The Watcher” - “I am known as The WATCHER. My sworn task is to observe and chronicle great events within this sector of the universe. My curse is to always witness and never participate. I must be true to this duty, even to the brink of Armageddon!”
Marvel Comics’ Watcher. His people are sworn to observe, but not interfere in, everything that happens in the universe.

After reading the previous article on FizzBuzz solutions, Reginald “raganwald” Braithwaite, whom I know from my days as part of the Toronto tech scene, tweeted this:

JenniferPlusPlus agrees:

They both make a good point. If you’re playing the FizzBuzz game as the original children’s game and not as an exercise to prove that you can actually write a program, you’d do it like this:

  • Players sit in a circle, not unlike “the circle” in That ’70s Show.(Players don’t have to be high, unless it helps.)
  • The player designated to go first says the number 1, and each player afterwards counts one number in turn. The next player in the circle says 2, and so on.
  • However, for every third number, instead of calling out the number, the player whose turn it is should say “Fizz”.
  • …and for every fifth number, instead of calling out the number, the player whose turn it is should say “Buzz”.
  • The “Fizz” and “Buzz” rules, as the kids would say, stack. In other words, for every number that is both the third and fifth, the player needs to say “Fizz” followed by “Buzz”, or “FizzBuzz”.

So in the spirit of the original game, I’ve put together a FizzBuzz solution that uses “watchers” to keep track of  “every xth number”, with one watcher to keep track of when it’s time to say “Fizz”, and another for when it’s time to say “Buzz”. When it’s time to say “FizzBuzz”, they’ll work in tandem.

I created a class called WordWatcher, which can be summarized as shown below:

Here’s its code:

Some notes about this code:

    • For those of you who aren’t familiar with Python’s approach to class methods, the first parameter for every method in a class is self. It’s the one parameter you don’t fill when calling a method, because Python calls it implicitly (seemingly in violation of Python’s general guideline that explicit is better than implicit). There’s a reason behind this, and it’s explained in this article: Understanding self in Python.
    • Also note that instance variables are declared and defined in the initializer method, __init__(), and any reference to them is always preceded by self.
    • The observe_next_turn() method is meant to be called as the fizzBuzz method proceeds to each new number. It updates the watcher’s internal counter and sets the time_for_word flag accordingly.
    • The speak() method outputs the watcher’s word if it’s time to say the word, or an empty string otherwise.

For FizzBuzz, we’ll need to create two watchers:

  1. One to keep watch for every third turn, at which point it should say “Fizz”, and
  2. one to keep watch for every third turn, at which point it should say “Buzz”.

With the WordWatcher class defined, we can create these two watchers like so:

It will become handy to have these two watchers in the same place. Since the “ha ha only serious” joke about Python is that everything is a list, let’s put them into a list:

Let’s define a fizzBuzz() function that makes use of this list of word watchers:

If you’ve been following the FizzBuzz series of articles, most of this code will be familiar. The part that might need explaining is the part with the comment “This part might need some explaining”.

Explaining the part that needs explaining

Let’s look at the first of the three lines of code in that part:

  • The _ on the left side of the = sign is a throwaway variable. It says “I don’t care about what you do on the other side of the = sign; only that you do something on the other side of the = sign”.
  • On the right side of the= sign is a list comprehension, which is Python’s “show, don’t tell” way of building lists. This list comprehension simply says “call the observe_next_turn() method of every object in the list”.

Let’s look at the next line:

  • This line creates a map that converts the watchers in the list into the words they should say for this turn. If the current turn means that it’s time for any one of them to speak, the watcher will be mapped to the word it’s supposed to say. Otherwise, it will be mapped to an empty string.

And now, the final line:

  • For some reason, map() comes built into Python, but you have to import the functools library in order to use map()’s partner in crime, reduce(). Remember reduce() is a functional programming thingy that takes a collection of items, performs some kind of calculation on that collection, and returns a single value (which you might call a reduction of the collection).
  • The first argument that I’ve provided to reduce() is a lambda — a small function that isn’t given a name — that simply takes the current item in the list and adds it to the previous collected items. Applied over the entire list, it builds a “total”, which in this case is all the words output by the watchers’ speak() methods concatenated together.
  • The second argument is the words map converted into a list. This is the list that the reduce() method will operate on.

At the end of those three lines, current_result will contain one of the following:

  • The empty string
  • Fizz
  • Buzz
  • FizzBuzz

If current_result is still empty at this point, it means that it’s not time for any of the watchers’ words. If this is the case, the string version of the current number is concatenated to current_result:

Here’s the code in its entirety:

And for completeness’ sake, here’s the test file:

You can download and here (2KB, zipped folder with 2 Python files).

That’s a lot of fuss for Fizzbuzz. Why did you do all that?

  1. Reginald asked me to, and I’ve known and respected him for ages, and JenniferPlusPlus seconded the request.
  2. Wait until you see what customers ask you to do.

Did any of this stuff fly over your head?

  1. Don’t feel bad. I had the same trouble when I first learned functional programming, and that was back in 1991, when the computers that ran functional language interpreters were in labs. I spent a lot of time in Queen’s University’s DEClab, which was full of machines that were cutting edge at the time made by a vendor that no longer exists. Computer time, as well as info on any kind of programming, never mind functional programming, was a lot harder to come by. (In case you were wondering, the language we learned was Miranda.)
  2. If you’ve never worked in Python, some of it can be quite weird. It does eventually make sense.
  3. Let me know, either via email or in the comments, if there’s anything you’d like me to cover in greater detail.

Do you have an alternate solution?

I’ve love to hear about it and present it here! Again, let me know via email or in the comments.

What’s next

An elegant JavaScript implementation.

Previously, in the “Programmer interview challenge” series