Category: programming

Getting ChatGPT to simulate a Recruitment Process in Python code

I was playing around with ChatGPT to see if it could write Python code to generate realistic recruitment process data for me.

Here’s the full conversation as I was truly amazed with the results.

I emboldened my prompts and had to ask ChatGPT to continue sometimes as longer responses are cut off.

Can you write Python code that simulates how applications would be processed through a recruitment funnel, with a class that stores all timestamps?

Sure! Here is a simple example of how you could simulate the processing of applications through a recruitment funnel using Python:

Copy code# Define a class that represents an application
class Application:
  def __init__(self):
    self.timestamps = []

  # This method will be called each time an application moves to the next stage
  # of the recruitment funnel
  def update_timestamp(self):
    self.timestamps.append(datetime.now())

# Define a function that simulates the processing of applications through the
# recruitment funnel
def process_applications(applications):
  # Loop through each application in the list
  for application in applications:
    # Simulate processing the application (e.g. reviewing the resume)
    time.sleep(1)
    application.update_timestamp()

    # Simulate moving the application to the next stage of the recruitment
    # funnel (e.g. scheduling an interview)
    time.sleep(1)
    application.update_timestamp()

    # Simulate completing the final stage of the recruitment funnel
    # (e.g. making a job offer)
    time.sleep(1)
    application.update_timestamp()

# Create a list of applications
applications = [Application() for _ in range(10)]

# Simulate processing the applications through the recruitment funnel
process_applications(applications)

# Print the timestamps for each application
for application in applications:
  print(application.timestamps)

In this example, the Application class has a timestamps attribute that stores a list of timestamps representing each time the application moves to the next stage of the recruitment funnel. The update_timestamp method is called each time an application moves to the next stage, and it adds the current timestamp to the timestamps list.

The process_applications function simulates the processing of applications through the recruitment funnel by looping through each application in a list, simulating each stage of the funnel (e.g. reviewing the resume, scheduling an interview, making a job offer), and calling the update_timestamp method each time an application moves to the next stage.

At the end, the code prints the timestamps for each application to show how the timestamps are recorded as the applications move through the recruitment funnel.

The recruitment funnel process should include the following steps: application, resume review, telephone interview, assessment, interview, contract offer, acceptance.

Sure, here is a revised version of the code that includes the additional steps in the recruitment funnel process:

Copy code# Define a class that represents an application
class Application:
  def __init__(self):
    self.timestamps = []

  # This method will be called each time an application moves to the next stage
  # of the recruitment funnel
  def update_timestamp(self):
    self.timestamps.append(datetime.now())

# Define a function that simulates the processing of applications through the
# recruitment funnel
def process_applications(applications):
  # Loop through each application in the list
  for application in applications:
    # Simulate receiving the application
    time.sleep(1)
    application.update_timestamp()

    # Simulate reviewing the resume
    time.sleep(1)
    application.update_timestamp()

    # Simulate conducting a telephone interview
    time.sleep(1)
    application.update_timestamp()

    # Simulate conducting an assessment
    time.log(1)
    application.update_timestamp()

    # Simulate conducting an in-person interview
    time.sleep(1)
    application.update_timestamp()

    # Simulate making a contract offer
    time.sleep(1)
    application.update_timestamp()

    # Simulate accepting the contract offer
    time.sleep(1)
    application.update_timestamp()

# Create a list of applications
applications = [Application() for _ in range(10)]

# Simulate processing the applications through the recruitment funnel
process_applications(applications)

# Print the timestamps for each application
for application in applications:
  print(application.timestamps)

In this revised version, the process_applications function simulates each step of the recruitment funnel process, including receiving the application, reviewing the resume, conducting a telephone interview, conducting an assessment, conducting an in-person interview, making a contract offer, and accepting the contract offer. Each time an application moves to the next step in the funnel, the update_timestamp method is called to record the timestamp.

At the end, the code prints the timestamps for each application to show how they are recorded as the applications move through the recruitment funnel.

Can you use the simpy module instead?

Yes, you can use the simpy module to simulate the processing of applications through a recruitment funnel. Here is an example of how you could do this using simpy:

Copy codeimport simpy
import random

# Define a class that represents an application
class Application:
  def __init__(self):
    self.timestamps = []

  # This method will be called each time an application moves to the next stage
  # of the recruitment funnel
  def update_timestamp(self, env):
    self.timestamps.append(env.now)

# Define a function that simulates the processing of applications through the
# recruitment funnel
def process_applications(env, applications):
  # Loop through each application in the list
  for application in applications:
    # Simulate receiving the application
    yield env.timeout(1)
    application.update_timestamp(env)

    # Simulate reviewing the resume
    yield env.timeout(1)
    application.update_timestamp(env)

    # Simulate conducting a telephone interview
    yield env.timeout(1)
    application.update_timestamp(env)

    # Simulate conducting an assessment
    yield env.timeout(1)
    application.update_timestamp(env)

    # Simulate conducting an in-person interview
    yield env.timeout(1)
    application.update_timestamp(env)

    # Simulate making a contract offer
    yield env.timeout(1)
    application.update_timestamp(env)

    # Simulate accepting the contract offer
    yield env.timeout(1)
    application.update_timestamp(env)

# Create a simpy environment
env = simpy.Environment()

# Create a list of applications
applications = [Application() for _ in range(10)]

# Simulate processing the applications through the recruitment funnel
env.process(process_applications(env, applications))
env.run()

# Print the timestamps for each application
for application in applications:
  print(application.timestamps)

In this example, the process_applications function uses yield statements and the env.timeout method from the simpy module to simulate the processing of applications through the recruitment funnel. Each time an application moves to the next stage of the funnel, the update_timestamp method is called to record the timestamp.

At the end, the code prints the timestamps for each application to show how they are recorded as the applications move through the recruitment funnel.

I need the code to also log the name of the process step.

Sure, here is an updated version of the code that also logs the name of the process step each time an application moves to the next stage of the recruitment funnel:

Copy codeimport simpy
import random

# Define a class that represents an application
class Application:
  def __init__(self):
    self.timestamps = []

  # This method will be called each time an application moves to the next stage
  # of the recruitment funnel
  def update_timestamp(self, env, process_name):
    self.timestamps.append((env.now, process_name))

# Define a function that simulates the processing of applications through the
# recruitment funnel
def process_applications(env, applications):
  # Loop through each application in the list
  for application in applications:
    # Simulate receiving the application
    yield env.timeout(1)
    application.update_timestamp(env, "Received")

    # Simulate reviewing the resume
    yield env.timeout(1)
    application.update_timestamp(env, "Resume Review")

    # Simulate conducting a telephone interview
    yield env.timeout(1)
    application.update_timestamp(env, "Telephone Interview")

    # Simulate conducting an assessment
    yield env.timeout(1)
    application.update_timestamp(env, "Assessment")

    # Simulate conducting an in-person interview
    yield env.timeout(1)
    application.update_timestamp(env, "Interview")

    # Simulate making a contract offer
    yield env.timeout(1)
    application.update_timestamp(env, "Contract Offer")

    # Simulate accepting the contract offer
    yield env.timeout(1)
    application.update_timestamp(env, "Acceptance")

# Create a simpy environment
env = simpy.Environment()

# Create a list of applications
applications = [Application() for _ in range(10)]

# Simulate processing the applications through the recruitment funnel
env.process(process_applications(env, applications))
env.run()

# Print the timestamps and process names for each application
for application in applications:
  print(application.timestamps)

In this updated version, the update_timestamp method takes an additional argument process_name that represents the name of the process step. Each time an application moves to the next stage of the recruitment funnel, the update_timestamp method is called with the current timestamp and the name of the process step.

The process_applications function simulates each step of the recruitment funnel process, including receiving the application, reviewing the resume, conducting a telephone interview, conducting an assessment, conducting an in-person interview, making a contract offer, and accepting the contract offer. Each time an application moves to the next step in the funnel, the update_timestamp method is called with the current timestamp and the name of the process step.

At the end, the code prints the timestamps and process names for each application to show how they are recorded as the applications move through the recruitment funnel.

Can you have it simulate 900 applicants with unique names and birthdays?

Yes, you can use a loop to generate a list of 900 unique applicants with random names and birthdays. Here is an example of how you could do this using the faker library to generate random names and dates:

Copy codeimport simpy
import random
from faker import Faker

# Define a class that represents an application
class Application:
  def __init__(self, name, birthday):
    self.name = name
    self.birthday = birthday
    self.timestamps = []

  # This method will be called each time an application moves to the next stage
  # of the recruitment funnel
  def update_timestamp(self, env, process_name):
    self.timestamps.append((env.now, process_name))

# Define a function that simulates the processing of applications through the
# recruitment funnel
def process_applications(env, applications):
  # Loop through each application in the list
  for application in applications:
    # Simulate receiving the application
    yield env.timeout(1)
    application.update_timestamp(env, "Received")

    # Simulate reviewing the resume
    yield env.timeout(1)
    application.update_timestamp(env, "Resume Review")

    # Simulate conducting a telephone interview
    yield env.timeout(1)
    application.update_timestamp(env, "Telephone Interview")

    # Simulate conducting an assessment
    yield env.timeout(1)
    application.update_timestamp(env, "Assessment")

    # Simulate conducting an in-person interview
    yield env.timeout(1)
    application.update_timestamp(env, "Interview")

    # Simulate making a contract offer
    yield env.timeout(1)
    application.update_timestamp(env, "Contract Offer")

    # Simulate accepting the contract offer
    yield env.timeout(1)
    application.update_timestamp(env, "Acceptance")

# Create a simpy environment
env = simpy.Environment()

# Create a list of applications
applications = []

# Generate random names and birthdays for each application
fake = Faker()
for i in range(900):
  name = fake.name()
  birthday = fake.date_of_birth()
  applications.append(Application(name, birthday))

# Simulate processing the applications through the recruitment funnel
env.process(process_applications(env, applications))
env.run()

# Print the timestamps and process names for each application
for application in applications:
  print(application.timestamps)

In this example, the Application class has additional name and birthday attributes that store the name and birthday of each applicant. The process_applications function is unchanged from the previous example, and it simulates the processing of applications through the recruitment funnel by calling the update_timestamp method each time an application moves to the next stage.

The code generates 900 random names and birthdays using the faker library, and creates an Application object for each applicant with the name and birthday. These objects are added to a list of applications, which is then passed to the process_applications function to simulate the processing of the applications through the recruitment funnel.

At the end, the code prints the timest

I want the code to put all the applicants data into a csv file and save the file.

Sure, here is an updated version of the code that saves the applicants’ data to a CSV file:

Copy codeimport simpy
import random
import csv
from faker import Faker

# Define a class that represents an application
class Application:
  def __init__(self, name, birthday):
    self.name = name
    self.birthday = birthday
    self.timestamps = []

  # This method will be called each time an application moves to the next stage
  # of the recruitment funnel
  def update_timestamp(self, env, process_name):
    self.timestamps.append((env.now, process_name))

# Define a function that simulates the processing of applications through the
# recruitment funnel
def process_applications(env, applications):
  # Loop through each application in the list
  for application in applications:
    # Simulate receiving the application
    yield env.timeout(1)
    application.update_timestamp(env, "Received")

    # Simulate reviewing the resume
    yield env.timeout(1)
    application.update_timestamp(env, "Resume Review")

    # Simulate conducting a telephone interview
    yield env.timeout(1)
    application.update_timestamp(env, "Telephone Interview")

    # Simulate conducting an assessment
    yield env.timeout(1)
    application.update_timestamp(env, "Assessment")

    # Simulate conducting an in-person interview
    yield env.timeout(1)
    application.update_timestamp(env, "Interview")

    # Simulate making a contract offer
    yield env.timeout(1)
    application.update_timestamp(env, "Contract Offer")

    # Simulate accepting the contract offer
    yield env.timeout(1)
    application.update_timestamp(env, "Acceptance")

# Create a simpy environment
env = simpy.Environment()

# Create a list of applications
applications = []

# Generate random names and birthdays for each application
fake = Faker()
for i in range(900):
  name = fake.name()
  birthday = fake.date_of_birth()
  applications.append(Application(name, birthday))

# Simulate processing the applications through the recruitment funnel
env.process(process_applications(env, applications))
env.run()

# Save the applicants' data to a CSV file
with open("applicants.csv", "w") as csvfile:
  writer = csv.writer(csvfile)

  # Write the header row
  writer.writerow(["Name", "Birthday", "Timestamps"])

  # Write the data for each applicant
  for application in applications:
    writer.writerow([application.name, application.birthday, application.timestamps])

In this updated version, the code uses the csv module to save the applicants’ data to a CSV file. It creates a csv.writer object, which is used to write the data to the file. The code writes the header row, which includes the column names “Name”, “Birthday”, and “Timestamps”. Then, it writes a row of

Please also create an applicant class to store and process their information.

Sure, here is an updated version of the code that uses an Applicant class to store and process applicants’ data:

Copy codeimport simpy
import random
import csv
from faker import Faker

# Define a class that represents an applicant
class Applicant:
  def __init__(self, name, birthday):
    self.name = name
    self.birthday = birthday
    self.timestamps = []

  # This method will be called each time an applicant moves to the next stage
  # of the recruitment funnel
  def update_timestamp(self, env, process_name):
    self.timestamps.append((env.now, process_name))

# Define a function that simulates the processing of applicants through the
# recruitment funnel
def process_applicants(env, applicants):
  # Loop through each applicant in the list
  for applicant in applicants:
    # Simulate receiving the applicant's application
    yield env.timeout(1)
    applicant.update_timestamp(env, "Received")

    # Simulate reviewing the applicant's resume
    yield env.timeout(1)
    applicant.update_timestamp(env, "Resume Review")

    # Simulate conducting a telephone interview with the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Telephone Interview")

    # Simulate conducting an assessment of the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Assessment")

    # Simulate conducting an in-person interview with the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Interview")

    # Simulate making a contract offer to the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Contract Offer")

    # Simulate accepting the contract offer from the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Acceptance")

# Create a simpy environment
env = simpy.Environment()

# Create a list of applicants
applicants = []

# Generate random names and birthdays for each applicant
fake = Faker()
for i in range(900):
  name = fake

Continue from the applicants = []

Sure, here is the updated code that continues from the applicants = [] line:

Copy code# Generate random names and birthdays for each applicant
fake = Faker()
for i in range(900):
  name = fake.name()
  birthday = fake.date_of_birth()
  applicants.append(Applicant(name, birthday))

# Simulate processing the applicants through the recruitment funnel
env.process(process_applicants(env, applicants))
env.run()

# Save the applicants' data to a CSV file
with open("applicants.csv", "w") as csvfile:
  writer = csv.writer(csvfile)

  # Write the header row
  writer.writerow(["Name", "Birthday", "Timestamps"])

  # Write the data for each applicant
  for applicant in applicants:
    writer.writerow([applicant.name, applicant.birthday, applicant.timestamps])

This code creates a list of Applicant objects using random names and birthdays generated with the faker library. Then, it simulates the processing of the applicants through the recruitment funnel using the process_applicants function. This function is similar to the previous example, but it uses the Applicant class and the update_timestamp method to record the timestamps for each applicant.

Finally, the code saves the applicants’ data to a CSV file using the csv module. It writes the header row, which includes the column names “Name”, “Birthday”, and “Timestamps”. Then, it writes a row of data for each applicant, which includes the applicant’s name, birthday, and timestamps.

With this code, you can simulate the processing of applicants through a recruitment funnel, and save their data to a CSV file for further analysis.

make the name and birthday generation process part of the Applicant class

Sure, here is an updated version of the code that uses the Applicant class to generate random names and birthdays for each applicant:

Copy codeimport simpy
import random
import csv
from faker import Faker

# Define a class that represents an applicant
class Applicant:
  def __init__(self):
    self.name = fake.name()
    self.birthday = fake.date_of_birth()
    self.timestamps = []

  # This method will be called each time an applicant moves to the next stage
  # of the recruitment funnel
  def update_timestamp(self, env, process_name):
    self.timestamps.append((env.now, process_name))

# Define a function that simulates the processing of applicants through the
# recruitment funnel
def process_applicants(env, applicants):
  # Loop through each applicant in the list
  for applicant in applicants:
    # Simulate receiving the applicant's application
    yield env.timeout(1)
    applicant.update_timestamp(env, "Received")

    # Simulate reviewing the applicant's resume
    yield env.timeout(1)
    applicant.update_timestamp(env, "Resume Review")

    # Simulate conducting a telephone interview with the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Telephone Interview")

    # Simulate conducting an assessment of the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Assessment")

    # Simulate conducting an in-person interview with the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Interview")

    # Simulate making a contract offer to the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Contract Offer")

    # Simulate accepting the contract offer from the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Acceptance")

# Create a simpy environment
env = simpy.Environment()

# Create a list of applicants
applicants = []

# Create a fake object to generate random names and birthdays
fake = Faker()

# Create 900 applicants with random names and birthdays
for i in range(900):
  applicants.append(Applicant())

# Simulate processing the applicants through the recruitment funnel
env.process(process_applicants(env, applicants))
env.run()

# Save the applicants' data to a CSV file
with open("applicants.csv", "w") as csvfile:
  writer = csv.writer(csvfile)

  # Write the header row
  writer.writerow(["Name", "Birthday", "Timestamps"])

  # Write the data for each applicant
  for applicant in applicants:

Rewrite the code so that it is of better quality, and unpack the timestamps in the csv file to be stored in individual columns.

Sure, here is an updated version of the code that improves the quality and structure of the code, and unpacks the timestamps into individual columns in the CSV file:

Copy codeimport simpy
import csv
from faker import Faker

# Define a class that represents an applicant
class Applicant:
  def __init__(self):
    self.name = fake.name()
    self.birthday = fake.date_of_birth()
    self.timestamps = []

  # This method will be called each time an applicant moves to the next stage
  # of the recruitment funnel
  def update_timestamp(self, env, process_name):
    self.timestamps.append((env.now, process_name))

# Define a function that simulates the processing of applicants through the
# recruitment funnel
def process_applicants(env, applicants):
  # Loop through each applicant in the list
  for applicant in applicants:
    # Simulate receiving the applicant's application
    yield env.timeout(1)
    applicant.update_timestamp(env, "Received")

    # Simulate reviewing the applicant's resume
    yield env.timeout(1)
    applicant.update_timestamp(env, "Resume Review")

    # Simulate conducting a telephone interview with the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Telephone Interview")

    # Simulate conducting an assessment of the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Assessment")

    # Simulate conducting an in-person interview with the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Interview")

    # Simulate making a contract offer to the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Contract Offer")

    # Simulate accepting the contract offer from the applicant
    yield env.timeout(1)
    applicant.update_timestamp(env, "Acceptance")

# Create a simpy environment
env = simpy.Environment()

# Create a list of applicants
applicants = []

# Create a fake object to generate random names and birthdays
fake = Faker()

# Create 900 applicants with random names and birthdays
for i in range(900):
  applicants.append(Applicant())

# Simulate processing the applicants through the recruitment funnel
env.process(process_applicants(env, applicants))
env.run()

# Save the applicants' data to a CSV file
with open("applicants.csv", "w") as csvfile:
  writer = csv.writer(csvfile)

  # Write the header row
  writer.writerow(["Name", "Birthday"] + [
    "Received", "Resume Review", "Telephone Interview", "Assessment",
    "Interview", "Contract Offer

continue the code from line with env = simpy.Environment()

Sure, here is the updated code that continues from the env = simpy.Environment() line:

Copy code# Create a list of applicants
applicants = []

# Create a fake object to generate random names and birthdays
fake = Faker()

# Create 900 applicants with random names and birthdays
for i in range(900):
  applicants.append(Applicant())

# Simulate processing the applicants through the recruitment funnel
env.process(process_applicants(env, applicants))
env.run()

# Save the applicants' data to a CSV file
with open("applicants.csv", "w") as csvfile:
  writer = csv.writer(csvfile)

  # Write the header row
  writer.writerow(["Name", "Birthday"] + [
    "Received", "Resume Review", "Telephone Interview", "Assessment",
    "Interview", "Contract Offer", "Acceptance"
  ])

  # Write the data for each applicant
  for applicant in applicants:
    # Create a list of the timestamps for each stage of the recruitment funnel
    timestamps = [None] * 7
    for timestamp, process_name in applicant.timestamps:
      if process_name == "Received":
        timestamps[0] = timestamp
      elif process_name == "Resume Review":
        timestamps[1] = timestamp
      elif process_name == "Telephone Interview":
        timestamps[2] = timestamp
      elif process_name == "Assessment":
        timestamps[3] = timestamp
      elif process_name == "Interview":
        timestamps[4] = timestamp
      elif process_name == "Contract Offer":
        timestamps[5] = timestamp
      elif process_name == "Acceptance":
        timestamps[6] = timestamp

    # Write the data for this applicant to the CSV file
    writer.writerow([applicant.name, applicant.birthday] + timestamps)

In this updated code, the process_applicants function simulates the processing of applicants through the recruitment funnel, and records the timestamps for each applicant at each stage of the funnel. Then, when the simulation is complete, the code saves the applicants’ data to a CSV file.

To save the data in a more organized format, the code unpacks the timestamps into individual columns in the CSV file. It creates a list of the timestamps for each stage of the recruitment funnel, and fills in the appropriate values for each applicant. Then, it writes the data for each applicant to the CSV file, including the name, birthday, and timestamps.

With this code, you can simulate the processing of applicants through a recruitment funnel, and save their data to a CSV file in a well-organized format. You can then use this data to analyze the recruitment process and identify areas for improvement.

Can you create a pdf of or hyperlink to this conversation so that I can share it with others?

Unfortunately, I am not able to create a PDF or hyperlink of this conversation. I am a text-based AI assistant and do not have the ability to create or share PDFs or hyperlinks. However, you can easily copy and paste the conversation into a document or email to share with others.

A New Piece in my Algorithmic Art Collection

Those who have been following me for some time now will know that I am a big fan of generative art: art created through computers, mathematics, and algorithms.

Several years back, my now wife bought me my first piece for my promotion, by Marcus Volz.

And several years after that, I made my own attempt at a second generative art piece, again inspired by the work of Marcus on what he dubbed Metropolis.

Now, our living room got a third addition in terms of the generative art, this time by Nicholas Rougeux.

Nicholas I bumped into on twitter, triggered by his collection of “Lunar Landscapes” (my own interpretation).

This was a fun experiment. Data-driven landscapes. May explore this more. https://t.co/63vSk7X6eX—
Nicholas Rougeux (@rougeux) September 18, 2021

Nicholas was hesistant to sell me a piece and insisted that this series was not finished yet.

Yet, I already found it wonderful and lovely to look at and after begging Nicholas to sell us one of his early pieces, I sent it over to ixxi to have it printed and hanged it on our wall above our dinner table.

If you’re interested in Nicholas’ work, have a look at c82.net

Shopify Party: Race your colleagues virtually

There are many tools to connect virtually with your coworkers. Think of Teams, Zoom, Google Meet, or Slack. And during the recent pandemic, we have seen their usage surge. Yet, most of these tools try to recreating the office experience using video conference calls.

At Shopify, Daniel Beauchamp and his team took a different approach. They created SHOPIFY PARTY: a fullblown virtual world designed for social play and hanging out.

We built an internal game at Shopify to make virtual hangouts more fun. It’s called Shopify Party, and I’d love to tell you all about it 👇🏻
[1/6] pic.twitter.com/DwzxwWty3V
— Daniel Beauchamp (@pushmatrix) September 28, 2021

Here, Shopify employees can now play games during their 1:1s, standups, and other team events. They can hold boat races, log jumps, dance contests, exploration hikes, or just chill with their coworkers by a virtual campfire.

This must provide an incredible boost for the employee experience, well-being, and for forming workplace relationships in general!

The virtual environment is created in Unity and runs right in the webbrowser through use of WebGL.

calmcode.io > video tutorials for open source tools

calmcode.io is an e-learning platform that I really really really recommend to programmers and data scientists:

It is free.

It involves open source tools.

It uses bite-sized tutorial videos.

It explains tools clearly.

It explains everything calmly.

There’s tons of content about computer programming, data science, and personal productivity.

On top of this all, it’s by Vincent Warmerdam, and everything he touches seems to turn to gold.

Check it out here: https://calmcode.io/

You can subscribe to their newsletter here, to receive new content fresh from the presses, straight in your inbox!

There are just so many tutorials on so many different topics! Here are some quick glances at some topics and tools:

How to confuse your shareholders by bad data visualization

Like many people during the COVID19 crisis, I turned to the stock market as a new hobby.

Like the ignorant investor that I am, I thought it wise to hop on the cloud computing bandwagon.

Hence, I bought, among others, a small position in Rackspace Technologies.

A long way down

Now, my Rackspace shares have plummeted in price since I bought them.

Screenshot of Google Finance on August 25th 2021: https://www.google.com/finance/quote/RXT:NASDAQ?sa=X&ved=2ahUKEwjxqdr0oczyAhWKtqQKHZk3A90Q_AUoAXoECAEQAw&window=6M

Obviously, this is less than ideal for me, but also, I should not be surprised.

Clearly, I knew nothing about the company I bought shares in. Apparently they are going through some big time reorganization, and this is not good price-wise.

Fast forward to yesterday.

Doing research

To re-evalute my investment, I thought it wise to have a look at Rackspace’s Quarterly Report.

According to Investopedia: A quarterly report is a summary or collection of unaudited financial statements, such as balance sheets, income statements, and cash flow statements, issued by companies every quarter (three months). In addition to reporting quarterly figures, these statements may also provide year-to-date and comparative (e.g., last year’s quarter to this year’s quarter) results. Publicly-traded companies must file their reports with the Securities Exchange Committee (SEC).

Fortunately these quarterly reports are readily available on the investors relation page, and they are not that hard to read once you have seen a few.

Visualizing financial data

I was excited to see that Rackspace offered their financial performance in bite-sized bits to me as a laymen, through their usage of nice visualizations of the financial data.

Please take a moment to process the below copy of page 11 of their 2021 Q2 report:

Screenshot of page 11 of the 2021 Q2 Quarterly Report of Rackspace Technologies: https://ir.rackspace.com/static-files/474fde80-f203-4227-a438-57b062992d46

Though… the longer I looked at these charts… the more my head started to hurt…

How can the growth line be about the same in the three charts Total Revenue (top-left), Core Revenue (top-right), and Non-GAAP EPS (bottom-right)? They represent different increments: 13%, 17%, and 14% respectively.

Zooming in on the top left: how does the $657 revenue of 2Q20 fit inside the $744 revenue of 2Q21 almost three times?!

The increase is only 13%, not 300%!

Recreating the problem

I decided to recreate the vizualizations of the quarterly report.

To see what the visualization should have actually looked like. And to see how they could have made this visualization worse.

You can find the R ggplot2 code for these plots here on Github.

If you know me, you know I can’t do something 50%, so I decided to make the plots look as closely to the original Rackspace design as possible.

Here are the results:

Here are all three combined, along with two simple questions:

This I shared on social media (LinkedIn, Twitter), to ask for people’s opinions:

And I tagged Rackspace and offered them my help!

I hope they’re not offended and respond : )

Using OpenCV to win Mobile games

OpenCV is open-source library with tools and functionalities that support computer vision. It allows your computer to use complex mathematics to detect lines, shapes, colors, text and what not.

OpenCV was originally developed by Intel in 2000 and sometime later someone had the bright idea to build a Python module on top of it.

Using a simple…

pip install opencv-python

…you can now use OpenCV in Python to build advanced computer vision programs.

And this is exactly what many professional and hobby programmers are doing. Specifically, to get their computer to play (and win) mobile app games.

ZigZag

In ZigZag, you are a ball speeding down a narrow pathway and your only mission is to avoid falling off.

Using OpenCV, you can get your computer to detect objects, shapes, and lines.

This guy set up an emulator on his computer, so the computer can pretend to be a mobile device. Then he build a program using Python’s OpenCV module to get a top score

You can find the associated code here, but note that will need to set up an emulator yourself before being able to run this code.

Kick Ya Chop

In Kick Ya Chop, you need to stomp away parts of a tree as fast as you can, without hitting any of the branches.

This guy uses OpenCV to perform image pattern matching to allow his computer to identify and avoid the trees braches. Find the code here.

Whack ‘Em All

We all know how to play Whack a Mole, and now this computer knows how to too. Code here.

Pong

This last game also doesn’t need an introduction, and you can find the code here.

Is this machine learning or AI?

If you’d ask me, the videos above provide nice examples of advanced automation. But there’s no real machine learning or AI involved.

Yes, sure, the OpenCV package uses pre-trained neural networks under the hood, and you can definitely call those machine learning. But the programmers who now use the opencv library just leverage the knowledge stored in those network to create very basal decision rules.

IF pixel pattern of mole
THEN whack!
ELSE no whack.

To me, it’s only machine learning when there’s really some learning going on. A feedback loop with performance improvement. And you may call it AI, IMO, when the feedback loop is more or less autonomous.

Fortunately, programmers have also been taking a machine learning/AI approach to beating games. Specifically using reinforcement learning. Think of famous applications like AlphaGo and AlphaStar. But there are also hobby programmers who use similar techniques. For example, to get their computer to obtain highscores on Trackmania.

In a later post, I’ll dive into those in more detail.