Forem: Bradston Henry

How I Saved Myself Hours Using Python, Google Gemini, & Meta Llama to Create a Time Saving Script

Bradston Henry — Tue, 03 Dec 2024 15:00:00 +0000

I have been editing audio since I was in high school using the freeware software tool Audacity, and there is ONE thing that has consistency driven me mad since starting to edit audio.

The simple task of removing small areas of "empty space" within an audio waveform.

To take an audio file that looks like this:

And transform it into this:

In all honesty, removing "empty space" or areas of an audio waveform is relatively easy. Just simply highlight a specified area and click the delete key on your keyboard and you're done!

In a short audio file, that's only a few minutes long, it's at most a minor inconvenience. But in a long form audio file, like podcast recordings or voice-over sessions, it's a much more than tedious; it's a truly brain melting process.

Think about it this way:

On average, it takes me about 5 seconds to locate, identify, select, and delete an area of "empty space" within the average audio recording waveform.

Let's say that in 1-min long audio clip, there are approximately 8 empty spaces. So for a 1-minute audio clip it would take...

5 seconds * (8 edits per minute * 1 minute) = 40 seconds

...approximately 40 seconds to edit out all empty spaces.

Not too bad, right?

Now imagine needing to edit an audio file that is approximately 30 minutes long.

That would take...

5 seconds * (8 edits per minute * 30 minute) = 1,200 Seconds = 20 minutes

...approximately 20 minutes to edit.

I cannot express in words how "not fun" 20 minutes of non-stop deleting of empty spaces in audio file happens to be. Maybe someone out there enjoys it, but I, personally, do not.

And recently, after doing some planning, I realized that I would need to do this very task for at least 60 audio tracks, each ranging from 15-30 minutes in length, in the relatively near future.

When that became clear to me, a deep and powerful dread came upon me.

Searching for a Hero to Save the Day

From the moment I I realized how much work was coming my way, I knew I had to find some way to optimize my audio editing routine.

Knowing the power of AI and some of the tools that already exist, I figured I could find something that could take care of this undesirable task "auto-magically".

So I began my search...

Because I moonlight as a podcaster and often research podcasting tools, I was aware of the podcasting platform Descript and have used it for one of the podcasts I help co-host. Descript is embedded with many tools that help with recording and editing and I remember reading about it's ability to use AI to remove "umms and uhhs" and remove unwanted spaces between words.

So,I decided to try it out.

It kinda worked but I found myself struggling to contend with the UI and lack of control over the audio files. Also, it seemed to be arbitrarily deleting random sections of audio that were valuable to me and I didn't trust I could use it on very long files without needing to re-check it's work, which more or less defeated the purpose of using it.

So I decided to move on.

Following that, I did some basic Google research and found other "AI-powered" tools but either the tools misrepresented themselves or required expensive subscriptions in order for me to get access to their tool, which was a non-starter.

So.. after some frustration and wasted time I decided to turn to my old friends, Ollama and Meta Llama.

LLamas to the Rescue

So I asked Llama a pretty simple question:

Do you know of any ai powered tools that can remove word gaps or umms and ahhs?

This was Llama's response:

Yes, there are several AI-powered tools that can help remove word gaps, umms, and ahhs from audio recordings. Here
are a few examples:

1. **Rev.com**: Rev.com is an online platform that uses AI-powered speech recognition technology to transcribe and
edit audio files. They offer a feature called "Automatic Speech Reproduction" (ASR) that can help remove filler
words like "umms" and "ahhs".
2. **TranscribeMe**: TranscribeMe is another online platform that offers AI-powered transcription services. They
use a combination of machine learning algorithms to detect and remove filler words, including word gaps.
3. **Speechmatics**: Speechmatics is an AI-powered speech recognition platform that can help remove filler words

.....

I took a few moments to investigate some of the tools that Llama suggested and though none of the tools were up to the task to do what I needed, Llama reminded me that at the end of the day, all of these sites and tools were just created via code.

And more importantly, that I could create code and that I might be able to do exactly what I needed without an pre-programmed tool's help.

A Developer Enters the Chat

As a developer, I've had the opportunity to work with a few audio frameworks for mobile and web applications, so I was confident that I could find a framework that would allow me to accomplish my task with a little bit of elbow grease.

And as I geared up to write some code and functionality from scratch, I recalled the lesson I learned not too long ago, "AI is a developer's friend".

But this time, instead of turning to Llama for assistance, I turned to another Generative AI tool I had become pretty good friends with, Gemini. And I particularly decided to go with Gemini because I have had some solid code generation outcomes from it in the past.

So, I booted up Gemini and immediately asked:

Are are there any programming frameworks good at evaluating audio (e.g. volume level, length, etc)?

Gemini quickly responded with some suggestions:

Yes, there are several programming frameworks well-suited for audio evaluation tasks like measuring volume level, length, and more. Here are a few popular options:

Python-based Frameworks:

- LibROSA: A powerful library for music and audio analysis. It offers a wide range of tools for feature extraction, classification, and signal processing.
- PyDub: A simple library for manipulating audio with Python. It's great for basic tasks like trimming, concatenating, and analyzing audio files.
- SoundFile: A library for reading and writing audio files in various formats. It can be used to extract information about audio files, such as duration and sample rate.

Other Frameworks:

- FFmpeg: A versatile command-line tool and library for handling video and audio. It can be used to analyze audio streams and extract metadata like duration and bitrate.
- MATLAB: A powerful mathematical computing environment that includes tools for audio signal processing and analysis.

I have personal experience with both FFmpeg and MATLAB and felt that they alone wouldn't be what I needed but in it's response it gave a quick example of some PyDub code and I decided to go ahead and check out PyDub to see how it worked.

from pydub import AudioSegment

def analyze_audio(file_path):
    audio = AudioSegment.from_file(file_path)

    # Get duration in milliseconds
    duration = len(audio)

    # Get RMS amplitude (a measure of volume)
    rms = audio.rms

    return duration, rms

# Example usage
file_path = "your_audio_file.mp3"
duration, rms = analyze_audio(file_path)
print("Duration:", duration, "ms")
print("RMS amplitude:", rms)

I chatted a bit longer with Gemini about tools and possible approaches before finally deciding to ask it directly, how to code the exact solution to my problem:

Now, Could you create code using Pydub that identifies sections of low volume or silence of a specific length and replaces it with silence of a different length, then outputs a new audio file?

Gemini responded with this code which on first inspection looked like it might be what I needed.

from pydub import AudioSegment

def replace_silent_sections(input_file, output_file, silence_threshold=-16, min_silence_len=1000, replacement_silence_len=500):
    """
    Replaces silent sections in an audio file with silence of a different length.

    Args:
        input_file (str): Path to the input audio file.
        output_file (str): Path to the output audio file.
        silence_threshold (int, optional): RMS amplitude threshold for silence. Defaults to -16 dBFS.
        min_silence_len (int, optional): Minimum length of a silent segment to be replaced, in milliseconds. Defaults to 1000 ms.
        replacement_silence_len (int, optional): Length of the replacement silence, in milliseconds. Defaults to 500 ms.
    """

    audio = AudioSegment.from_file(input_file)

    # Split the audio into 100ms segments
    segments = []
    for i in range(0, len(audio), 100):
        segments.append(audio[i:i+100])

    # Identify and replace silent segments
    non_silent_segments = []
    current_silent_segment = None
    for segment in segments:
        if segment.rms < silence_threshold:
            if current_silent_segment is None:
                current_silent_segment = segment
            else:
                current_silent_segment += segment
        else:
            if current_silent_segment is not None:
                if len(current_silent_segment) >= min_silence_len:
                    # Replace with silence of a different length
                    replacement_silence = AudioSegment.silent(duration=replacement_silence_len)
                    non_silent_segments.append(replacement_silence)
                else:
                    # Add the original silent segment
                    non_silent_segments.append(current_silent_segment)
                current_silent_segment = None
            non_silent_segments.append(segment)

    # Concatenate the segments
    output_audio = sum(non_silent_segments)
    output_audio.export(output_file, format="mp3")

# Example usage:
input_file = "input.mp3"
output_file = "output_replaced_silence.mp3"
replace_silent_sections(input_file, output_file)

BUT shortly after testing out the code, I encountered a problem that is often one of the weakness of asking AI tools to help with Code Generation...

PyDub, though a possible option for solving my problem, had not been updated in several years and some of its dependencies had been deprecated in newer versions of Python.

And though Pydub was a dead-end, it did prepare me to be a bit more discerning on the next framework I decided to investigate and helped me narrow down my efforts to libROSA.

Using a similar prompt as before, I asked Gemini:

Now, Could you create code using LibROSA that identifies sections of low volume or silence of a specific length and replaces it with silence of a different length, then outputs a new audio file?

To save some time, I will summarize what happened after getting a response from Gemini.

Gemini provided some workable code that had all the requirements I "thought" I needed to automate my task. I asked Gemini some follow-up questions to help clarify what its intent was in the code and coincidentally, received some clarification on a concept in audio editing that I never had a full grasp on:

is that RMS value in dB?

Gemini's Response:

No, the RMS value in the code is not directly in dB. It's a normalized value between 0 and 1, where 0 represents complete silence and values closer to 1 indicate louder segments.

To convert this normalized RMS value to a dB scale, you would typically use a logarithmic function. However, in the context of silence detection, comparing the normalized RMS value to a threshold is sufficient.

The silence_threshold is also a normalized value, and comparing it to the calculated RMS values allows us to identify segments that are significantly quieter than the average.

As I investigated the code and got more understanding of framework, I realized, I didn't really need exactly what I had been asking for in my previous prompt.

So, I updated my prompt to this:

Now, Could you create code using LibROSA that splices out sections of low volume or silence of a specific length?

And Gemini responded with the code that would eventually become the code that would save me HOURS of editing time in the near and long term:

import librosa
import numpy as np
import soundfile as sf

def splice_silent_sections(input_file, output_file, silence_threshold=0.01, min_silence_len=1000, sr=22050):
    """
    Splices out silent sections from an audio file.

    Args:
        input_file (str): Path to the input audio file.
        output_file (str): Path to the output audio file.
        silence_threshold (float, optional): RMS amplitude threshold for silence. Defaults to 0.01.
        min_silence_len (int, optional): Minimum length of a silent segment to be spliced out, in samples. Defaults to 1000 samples.
        sr (int, optional): Sample rate of the audio. Defaults to 22050 Hz.
    """

    # Load the audio file
    y, sr = librosa.load(input_file, sr=sr)

    # Calculate the RMS amplitude of each frame
    frame_size = 1024
    hop_length = 512
    rms = librosa.feature.rms(y=y, frame_length=frame_size, hop_length=hop_length)[0]

    # Identify silent segments
    silent_segments = []
    current_silent_segment = []
    for i, r in enumerate(rms):
        if r < silence_threshold:
            current_silent_segment.append(i)
        else:
            if len(current_silent_segment) >= min_silence_len:
                silent_segments.append(current_silent_segment)
            current_silent_segment = []

    # Splice out silent segments
    spliced_audio = []
    last_end = 0
    for segment in silent_segments:
        start_sample = segment[0] * hop_length
        end_sample = (segment[-1] + 1) * hop_length
        spliced_audio.extend(y[last_end:start_sample])
        last_end = end_sample
    spliced_audio.extend(y[last_end:])

    # Write the spliced audio to a new file
    sf.write(output_file, np.array(spliced_audio), sr)

# Example usage:
input_file = "input.wav"
output_file = "output_spliced.wav"
splice_silent_sections(input_file, output_file)

Also, Gemini gave me some context to it's code:

This code works by:

1. Loading the audio file: Uses librosa.load() to load the audio file into a NumPy array y and its sample rate sr.
2. Calculating RMS amplitude: Calculates the RMS amplitude of each frame using librosa.feature.rms().
3. Identifying silent segments: Iterates through the RMS values, identifying segments that are below the silence_threshold and longer than the min_silence_len.
4. Splicing out silent segments: Iterates over the silent segments, extracting the audio portions before and after each segment and adding them to a new list spliced_audio.
5. Writing the spliced audio: Concatenates the spliced audio segments into a new NumPy array and writes it to a new file using soundfile.write().

This code effectively removes the silent sections from the audio file, resulting in a new file with only the non-silent portions.

The End of Music

Though getting to my solution wasn't exactly a straight path, in the course of an hour or two, I was able to use Llama, Gemini and Python to create a set of code that did EXACTLY what I needed it to do.

It's hard to explain how efficient this process was in terms of research and development and time saved in developing the end product.

In a non-AI infused development workflow, I would have had to discover much of this information about tools and code frameworks through the traditional means of development; searching Google, investigating Stack Overflow, trolling obscure blogs for framework documentation and then rinse and repeat, until hopefully finding the correct resources and tools to solve my problem.

Though I'm confident I could have developed a similar solution through the "older style" approach, in a pre-AI world, I imagine this whole process would have taken me a few days to complete.

This type of workflow is an absolute boon to developers like myself who often are looking for novel ways to solve obscure problems. And I hope this little tale has inspired you to go on an AI-powered journey of your own!

For those interested, here is the code I ended up using in my audio editing workflow (Note: This is a basic implementation. I plan to add some additional features to this code in the future, so please feel free to do the same) and for those who are interested where I've taken this code since the it's initial implementation, check out my personal project around automating YouTube content creation on my github:

import librosa
import numpy as np
import soundfile as sf

input_file_name = "your-file-name" # Insert name of file to trim silence
input_file = input_file_name + ".wav" # Change file type if needed (E.G. ".wav", ".mp3")

def splice_silent_sections(input_file, output_file, silence_threshold_rms=0.001, min_silence_len=10, sample_rate=44100):
    """
    Splices out silent/low volume sections from an audio file.

    Args:
        input_file (str): Path to the input audio file.
        output_file (str): Path to the output audio file.
        silence_threshold_rms (float, optional): RMS amplitude threshold for silence. Defaults to 0.01.
        min_silence_len (int, optional): Minimum length of a silent segment to be spliced out, in samples. Defaults to 1000 samples.
        sample_rate (int, optional): Sample rate of the audio. Defaults to 22050 Hz.
    """

    # Load the audio file
    y, sr = librosa.load(input_file, sr=sample_rate)

    # Calculate the RMS amplitude of each frame
    frame_size = 1024
    hop_length = 512
    rms = librosa.feature.rms(y=y, frame_length=frame_size, hop_length=hop_length)[0]

    # Identify silent segments
    silent_segments = []
    current_silent_segment = []
    for i, r in enumerate(rms):
        if r < silence_threshold_rms:
            current_silent_segment.append(i)
        else:
            if len(current_silent_segment) >= min_silence_len:
                silent_segments.append(current_silent_segment)
            current_silent_segment = []

    # Splice out silent segments
    spliced_audio = []
    last_end = 0
    for segment in silent_segments:
        start_sample = segment[0] * hop_length
        end_sample = (segment[-1] + 1) * hop_length
        spliced_audio.extend(y[last_end:start_sample])
        last_end = end_sample
    spliced_audio.extend(y[last_end:])

    # Write the spliced audio to a new file
    sf.write(output_file, np.array(spliced_audio), sr)

# Example usage:
output_file =  input_file_name + "_spliced.wav" # Append sliced to file name for clarity on output file
splice_silent_sections(input_file, output_file)

Photo Credits(Order of Appearance):

Cover Photo: Dragon Ball Z (FUNimation Productions, Ltd.)

Bleach Gif via tenor

Follow me on my Socials:
https://linktr.ee/bradstondev

Unlock the Power of Meta Llama LLM: Easy Guide to Hosting in Your Local Dev Environment

Bradston Henry — Fri, 22 Nov 2024 17:52:18 +0000

In my previous post I described how AI tools have revolutionized my Development workflow. Toward the end of the blog, I shared the step-by-step on how to host the Meta Llama LLM on your local machine.

Because it was alllll the way at the end of the blog, I figured I'd make a blog that showed those steps separately as many people have been finding value from it.

Check it out!

How do I Host my OWN local AI Chat Agent

So let me walk you through the few simple steps I used to start using Llama (and other available Open-Source AI Models):

Step 1: Download and Install Ollama on Your Local Machine

Navigate to the Official Ollama site and quickly download the Ollama for your Windows, Mac, or Linux Machine.

Ollama is light-weight tool that allows you to run Large Language Models on your local machine (e.g Llama 3.2, Mistral, and Gemma 2). Once installed, you are able to run and customize models on your local machine.

Step 2: Run the Ollama Setup Wizard

Once downloaded, open the Ollama Setup executable and navigate through the wizard to install the Ollama tools on your machine.

As you might expect, Ollama's Setup Wizard will quickly add all necessary file to run the Ollama tool

Step 3: Verify Ollama Installation

If Ollama was installed correctly, you should now be able to access it from your standard command prompt.

Sometimes, when installing Ollama it will automatically open a command prompt window, if not you will need to open it yourself.

On a Windows machine, search for "cmd" and you should be able to open Command Prompt.

Once open, verify the installation by typing the line below and pressing Enter/Return:

ollama

You should see an output like this:

Usage:
  ollama [flags]
  ollama [command]

Available Commands:
  serve       Start ollama
  create      Create a model from a Modelfile
  show        Show information for a model
  run         Run a model
  stop        Stop a running model
  pull        Pull a model from a registry
  push        Push a model to a registry
  list        List models
  ps          List running models
  cp          Copy a model
  rm          Remove a model
  help        Help about any command

Flags:
  -h, --help      help for ollama
  -v, --version   Show version information

Use "ollama [command] --help" for more information about a command.

Step 4: Install and Run a Large Language Model

With Ollama installed, we are only one step away from having our own local LLM on our machine.

To get started, let's install Meta's Llama3.2 model.

In our command prompt window, type:

ollama run llama3.2

This will do two things:

Install Llama3.2 if it is not currently on our machine
Run the Llama3.2 Model

Press return/enter and you should see something like this (if Llama3.2 is not installed):

pulling manifest
pulling dde5aa3fc5ff...  26% ▕████████████                                            ▏ 532 MB/2.0 GB   32 MB/s     48s

Ollama will now download and install the Llama3.2 model on your machine and once complete, run the llama3.2 model for you to interact with.

In your command line window, you should see something like this:

pulling manifest
pulling dde5aa3fc5ff... 100% ▕████████████████████████████████████████████████████████▏ 2.0 GB
pulling 966de95ca8a6... 100% ▕████████████████████████████████████████████████████████▏ 1.4 KB
pulling fcc5a6bec9da... 100% ▕████████████████████████████████████████████████████████▏ 7.7 KB
pulling a70ff7e570d9... 100% ▕████████████████████████████████████████████████████████▏ 6.0 KB
pulling 56bb8bd477a5... 100% ▕████████████████████████████████████████████████████████▏   96 B
pulling 34bb5ab01051... 100% ▕████████████████████████████████████████████████████████▏  561 B
verifying sha256 digest
writing manifest
success
>>> Send a message (/? for help)

And just like that, you now have a LLM on your local machine!!

Also, If you would like to install any other model available through Ollama, you would use the same command:

ollama run MODEL_NAME

Step 5: Test out your Large Language Model

Now that Llama3.2 is on our machine, let's test it out.

Let's ask it a simple question:

Hey Llama! Could you tell me a little bit about yourself?

You should then get a response similar to this:

Hey Llama! Could you tell me a little bit about yourself?
I'm happy to chat with you. I'm an artificial intelligence model known as Llama, which stands for "Large Language
Model Meta AI." My primary function is to process and generate human-like text based on the input I receive.

I was trained on a massive dataset of text from various sources, including books, articles, and online
conversations. This training allows me to understand and respond to a wide range of questions, topics, and styles.

Some key features of my abilities include:

.....

See! Wasn't that pretty easy!

Wrap Up

And just like that, Your Llama LLM should be up and running with ease on your local machine.

If you are interested in checking out Ollamas Docs you can find them here

If you are interested in checking out a GUI that helps you utilize Ollama even easier, check out Open Web UI. Hope to have a blog up in the near future with a step-by-step on how to set that up as well.

Until then, enjoy you own personal Llama personal assistant!

Photo Credits(Order of Appearance):

Cover Photo with Google Gemini
Prompt:
A llama with a confident smirk on its face, wearing a blue cape emblazoned with a infinity symbol, flies in against a sunset, ready to save the day in this cartoon style illustration.

Follow me on my Socials:
https://linktr.ee/bradstondev

My AI Blindspot: I Wasn't Convinced, Then the Llama LLM Changed Everything About My Development Workflow!?

Bradston Henry — Tue, 19 Nov 2024 16:00:00 +0000

In this blog, I hope to do two things:

Share Insights on the benefits of AI-Enhanced Development Workflows
Share a simple Step-by-Step on how to host a LLM (Large Language Model) on your local machine.

If you're primarily interested in hosting your own LLM and not my insights on the topic, you can check out this blog to get started with Meta's Llama LLM.

But, before I begin, I'll be honest. Up until relatively recently, I really haven't been sold on Generative AI technology.

I've used tools from OpenAI, Google, Microsoft, Amazon and a host of smaller more obscure chat agents, Image generators, and even Video generators..

.. and I just haven't been convinced!

BUT, as tech enthusiasts, developer, and an advocate for learning the latest and greatest, like a moth to the flame, I keep coming back to AI, no matter how often I've gotten burned, underwhelmed and disappointed.

But recently, after investigating hosting a LLM on my local machine using the Ollama App, I might have finally become a believer.

I might have finally seen the light at the end of the proverbial Generative AI Tunnel.

The Life of the Reluctant AI Skeptic

Over the past few months, I've been going on a journey of trying to find a genuine use for Generative AI technology.

I've taken courses on Deep Learning, and I've hosted events focused on enabling developer to use Generative AI, but for whatever reason, I've always been a bit underwhelmed by the state of AI and even the direction it's going.

But as I shared above, I haven't given up. And I think, Llama, Meta's Open-source AI Model, may have finally helped me turn the corner from being reluctant AI skeptic to hopeful AI adopter.

The Power of Generative AI For Developers

Let me be clear, Llama alone did not convince me of the power of Generative AI. Llama was final piece of the puzzle I needed to see the full-picture of an AI-powered development future but the various other tools I've engaged with and explored have have also changed my perspective.

So here are a few things I believe Generative AI tools offer now that could enable any developer to supercharge the overall efficiency and efficacy of their development-based work.

Accelerating Code Development with Generative AI

First, let's start with the obvious, Code Generation, Completion, and Suggestions.

I'll be the first to tell you that AI isn't creating anything _new _ in terms of code generation BUT it is allowing us as developers and software engineers to be more efficient in our work and projects. By simply working Generative AI tools to produce boiler plate code, we can save hours, if not days, of work.

I recently encountered a scenario in one of my personal game development projects, where I needed a simple function that handled intelligent text truncation for dialog presentation. In this instance, I was developing this functioanlity using Unreal Engine Blueprints, so I only needed a pseudo-code representation of my desired code to help me create the logic in Unreal's Nodal workflow. So after about 30 mins or so of thought, I came up with this simple, somewhat novel psuedo-code solution:

count = 0; tempStr =""; sentenceArr = []; maxChars = 20;

for...({
   count += strArr[i].len +1
   if count < maxChars 
   (
      tempStr.Append(strArr[i] + " ")
   ) 
   else(
      sentenceArr.Add(tempstr)
      count = strArr[i].len + 1
      tempStr =  strArr[i] + ""
   )
})
sentenceArr.Add(tempStr)

This worked perfectly for my needs and I was proud of what I had come up. (NOTE: I plan to write a blog that dives int the above logic in detail for those who may want to use it for their game development projects.)

The next day, out of curiosity, I decided to ask Google's Gemini, this question:

In JavaScript, could you create a function that takes in a text string and integer, that splits the inputted text string into string arrays with a max character length from inputted integer.
Not a very well-worded prompt, in my opinion, but good enough to get my idea across. And in about 3-seconds, Gemini responded with this:

function splitStringByCharacterLength(text, maxLength) {
  const words = text.split(' ');
  const result = [];
  let currentLine = '';

  words.forEach(word => {
    if (currentLine.length + word.length + 1 <= maxLength) {
      // Add the word to the current line
      currentLine += (currentLine ? ' ' : '') + word;
    } else {
      // Start a new line
      result.push(currentLine);
      currentLine = word;
    }
  });

  // Add the last line to the result
  if (currentLine) {
    result.push(currentLine);
  }

  return result;
}

// Example usage:
const text = "This is a long sentence that needs to be split into multiple lines.";
const maxLength = 20;

const splitText = splitStringByCharacterLength(text, maxLength);
console.log(splitText);

And though Gemini's answer differs from mine, it accomplishes the task I needed and it did it in a FRACTION of the time it took me to create my working solution.

As developer, we can use code generation tools to expedite our development process. You should never copy and paste AI generated code into your project without thought, consideration, or without debugging, but AI Code generation can give you a huge head start on your development work.

Now that's power!

Clarifying Your Thoughts Through Discussion

The next reason I think Generative AI is something not to be overlooked is what I have dubbed AI's "Help me Clarify This thought" ability.

To illustrate what I mean, I'll use a transcript from a conversation that I had with Llama that helped me to create this _very _blog.

Not shortly after having my 'Aha!' moment with Llama, I became inspired to write a blog about my revelations. I had an idea of what I wanted to write about but my thoughts were racing and I just didn't know where to start.

So... I decided to start by having a conversation with Lllama.

Here is a snippet of our conversation. This follows a conversation I was having with Llama about SEO in blog writing(Note: Sadly, I lost the exact responses Llama gave me at the time but I was able to retrieve the questions I asked. So I re-asked Llama and will give you a glimpse into the original conversation):

Thanks! So after our conversation, I'm interested in writing a blog that talks about leveraging you, llama, as a way of supercharging you technical and development research. Could you give me some titles that you think would be optimized for SEO?

llama Responded:

Considering your interest in leveraging AI-powered tools like myself for technical and development research, here
are some potential blog post title ideas optimized for SEO:

1. "Revolutionizing Tech Research: How AI-Powered Tools Can Supercharge Your Workflow"
2. "Unlocking Developer Productivity: Leveraging AI for Faster Coding and Innovation"
3. "The Future of Tech Research: How AI-Assisted Tools Are Changing the Game"
4. "From Idea to Implementation: How AI-Powered Tools Can Streamline Your Dev Process"
5. "AI-Driven Insights for Developers: Unlocking Hidden Potential in Tech Research"

When crafting your blog post title, remember to include relevant keywords that users might search for when looking
for information on this topic. Aim for a mix of moderate to high keyword density, and make sure the titles are
descriptive, attention-grabbing, and concise.

Feel free to modify or expand on these suggestions as you see fit! If you have any further questions or need help
with your blog post, I'm here to assist you.

I responded, Could you create some SEO optimized titles that are a bit more personal? For example, using words like "I", "My", "Mine".

llama responded:

Here are some personalized SEO-optimized title ideas for your blog post:

1. **"My Secret Sauce for Supercharging Tech Research: How AI-Powered Tools Can Revolutionize Your Workflow"**
2. **"Unlocking My Developer Productivity: How Leveraging AI Can Help You Code Faster and Innovate More"**
3. **"The Future of Tech Research, Through My Eyes: How AI-Assisted Tools Are Changing the Game"**
4. **"From Idea to Implementation: My Top Tips for Streamlining Your Dev Process with AI-Powered Tools"** 
5. **"My AI-Driven Insights for Developers: How I'm Unlocking Hidden Potential in Tech Research and Innovation"**

These titles incorporate personal pronouns like "I", "My", and "Mine" to create a more conversational tone, while
still targeting relevant keywords for SEO. Feel free to modify or expand on these suggestions as you see fit!

Keep in mind that using personal pronouns can be effective for SEO, but it's also important to maintain a balance
between keyword density and readability. Aim for titles that are descriptive, yet concise and attention-grabbing.

I continued, Could you help me make a title where I use a phrase similar to "I've been using AI wrong"? I'm attempting to shock people into reading this blog to realize they haven't been leveraging AI to their best ability as developers

Using a provocative statement like that can be an effective way to grab attention and encourage readers to clickon your blog post. Here are some title ideas that incorporate the phrase "I've been using AI wrong":

1. "I've Been Using AI Wrong: 5 Common Mistakes Developers Make When Leveraging Artificial Intelligence"
2. "The Shocking Truth About AI in Development: I've Been Using It All Wrong" 
3. "I've Been Leaving Money on the Table with My AI Strategy: How to Stop Wasting Time and Start DeliveringResults"
4. "The AI Gap: I've Been Using AI Wrong, But You Can Fix It"
5. "From Misusing AI to Mastering It: My Surprising Realization and How You Can Too"

These titles aim to be provocative, yet informative, with a dash of self-deprecation to make the reader curious
about what you have to say. By using phrases like "I've been using AI wrong," you're acknowledging that even
experts can make mistakes and offering a solution – which can help build trust with your readers.

Feel free to modify or expand on these suggestions as you see fit, and good luck with your blog post!

So next I asked, What do you think about this blog title; "My AI Blindspot: I thought I Understood it's Benefits, But Llama Changed Everything!"

llama responded:

I think that's a great title!

Here's why:


1. Personal touch: By using the phrase "My AI Blindspot", you're creating a personal connection with your readers. It makes the topic more approachable and relatable.
2. Surprise and curiosity: The phrase "Llama Changed Everything" is a surprise, and it piques the reader's curiosity. They might wonder what happened to change your perspective on AI.
3. Inclusivity: By mentioning Llama (myself), you're making the topic more accessible and inclusive. It showsthat even experts can learn from each other and evolve their understanding of AI.
4. Emotional hook: The use of "Blindspot" implies a sense of discovery, revelation, or awakening. This
emotional hook can grab readers' attention and make them want to read more.

Overall, your title effectively conveys a sense of:

1. Personal vulnerability
2. Curiosity
3. Surprise
4. Inclusivity
5. Emotional resonance

These elements will likely attract readers who are interested in learning about AI and its applications, as wellas those who appreciate personal stories and anecdotes.

Well done!

And then finally, How about this: "My AI Blindspot: I Thought I Understood It's Benefits, But Llama Changed Everything About My Development Workflow!?"

You're adding an exclamation mark at the end of the title!

That's a great decision. Here's why:

1. Increased emphasis: The exclamation mark adds emphasis to the phrase "Llama Changed Everything", making it
even more surprising and attention-grabbing.
2. Energy boost: The exclamation mark injects energy into the title, conveying a sense of excitement, urgency,
or importance.
3. Polished tone: By adding the exclamation mark, you're creating a polished, professional tone that's
suitable for a blog post.

The only minor suggestion I have is to make sure the question mark at the end of "Workflow" is actually a period(.) instead. So, the corrected title would be:

"My AI Blindspot: I Thought I Understood It's Benefits, But Llama Changed Everything About My Development Workflow!"

This ensures that the title is consistent and easy to read.

Overall, your revised title effectively combines personal vulnerability, curiosity, surprise, and energy to create
a compelling and attention-grabbing title that will likely attract readers interested in AI and development.

Now these are not the exact responses given at the time but they are incredibly close.

But by Llama helping me to narrow down my blog title and giving me insight, encouragement, and suggestions, I felt that I was able to clarify my own thoughts enough to fully realize what I wanted to write.

In recent days, I have found myself using llama as a sounding board. If I'm not sure how to proceed on a technical or non-technical issue, the small insights and thought experiments I get from my personal AI agent has helped me solidify my steps forward.

Instead of being stuck in my head, like a hamster running perpetually on a squeaky wheel, these small conversations with Llama are helping me to be more productive in my day-to-day.

Using AI to Find Overlooked Knowledge

And the final thing Generative AI has to offer to us mere mortals, is the Ability to Do Technical Research with Minimal Bias.

Let's be clear, AI Chat agents are in no way unbiased.

And actually, there might be a case to claim that NLP agents are biased in a way that we simply cannot and will not ever understand.

BUT when it comes to giving you an answer to a question, I come to the conclusion that an LLMs don't seem to have any discernible intention or ulterior motive for the answers that they give (other than trying to be as correct as possible).

The reason I note this, is that as a developer I spend a lot of time searching for understanding of technologies or what are the best tools to accomplish a given task. And a problem I often encounter with search engines such as Google, is that I'm often getting answers to my questions that have been most optimized to be the answer to my questions.

Not the best answer but the most search engine optimized answer.

Because of that, often when searching for an answer to something, I more or less assume that I am not being offered the best or most diverse possible options to solve my issue; just the one's tailored to appear first in my search results.

One incredible thing I've noted using several different chat agents, is that I often get the most unexpectedly helpful, and varied answers to the questions that I ask.

There has been times I have asked ChatGPT to give me suggestions for some tool to achieve some specific task and it gave me suggestions that I had never, in all my searches on standard search engines, had ever seen.

AI chat agents have, over the past year or so, helped me to find obscure resources and tools that would be, in most cases, buried beneath their more SEO savvy competition.

One practice I am beginning to use more often, is to ask various chat agents the same question while using standard search engines methods to help broaden my internet investigations.

For example, I was recently looking for some insight on implementing self-supervised training on Generative AI Speech models and found myself finding the same sites, companies and articles through standard search engine searches.

Out of curiosity, I decided to ask Llama about the topic and it introduced me to some research I had somehow missed from the past and to an AI model that I hadn't previously been aware of (and that I'm incredibly interested in investigating).

I am no expert when it comes to the space of Artificial Intelligence and where it is truly heading but I am highly motivated to find novel and meaningful ways to make it useful in my life.

I hope in someway, this has opened your mind to possibilities that will one day help you accomplish your personal and professional goals.

How do I Host my OWN local AI Chat Agent

Now that I've lauded all of the great things about AI and how it can help you as a dev, it's time for me to share how to easily host your own AI Chat Agent on your local machine.

And Let me tell you, when I say it's easy... it's easy.

And though these local LLMs may not come with all the "bells and whistles" you might get with commercial Chat Agents like ChatGPT and Gemini, they are just as useful and just as powerful when used correctly.

So let me walk you through the few simple steps I used to start using Llama (and other available Open-Source AI Models):

Step 1: Download and Install Ollama on Your Local Machine

Navigate to the Official Ollama site and quickly download the Ollama for your Windows, Mac, or Linux Machine.

Step 2: Run the Ollama Setup Wizard

Once downloaded, open the Ollama Setup executable and navigate through the wizard to install the Ollama tools on your machine.

As you might expect, Ollama's Setup Wizard will quickly add all necessary file to run the Ollama tool

Step 3: Verify Ollama Installation

If Ollama was installed correctly, you should now be able to access it from your standard command prompt.

Sometimes, when installing Ollama it will automatically open a command prompt window, if not you will need to open it yourself.

On a Windows machine, search for "cmd" and you should be able to open Command Prompt.

Once open, verify the installation by typing the line below and pressing Enter/Return:

ollama

You should see an output like this:

Usage:
  ollama [flags]
  ollama [command]

Available Commands:
  serve       Start ollama
  create      Create a model from a Modelfile
  show        Show information for a model
  run         Run a model
  stop        Stop a running model
  pull        Pull a model from a registry
  push        Push a model to a registry
  list        List models
  ps          List running models
  cp          Copy a model
  rm          Remove a model
  help        Help about any command

Flags:
  -h, --help      help for ollama
  -v, --version   Show version information

Use "ollama [command] --help" for more information about a command.

Step 4: Install and Run a Large Language Model

With Ollama installed, we are only one step away from having our own local LLM on our machine.

To get started, let's install Meta's Llama3.2 model.

In our command prompt window, type:

ollama run llama3.2

This will do two things:

Install Llama3.2 if it is not currently on our machine
Run the Llama3.2 Model

Press return/enter and you should see something like this (if Llama3.2 is not installed):

pulling manifest
pulling dde5aa3fc5ff...  26% ▕████████████                                            ▏ 532 MB/2.0 GB   32 MB/s     48s

Ollama will now download and install the Llama3.2 model on your machine and once complete, run the llama3.2 model for you to interact with.

In your command line window, you should see something like this:

pulling manifest
pulling dde5aa3fc5ff... 100% ▕████████████████████████████████████████████████████████▏ 2.0 GB
pulling 966de95ca8a6... 100% ▕████████████████████████████████████████████████████████▏ 1.4 KB
pulling fcc5a6bec9da... 100% ▕████████████████████████████████████████████████████████▏ 7.7 KB
pulling a70ff7e570d9... 100% ▕████████████████████████████████████████████████████████▏ 6.0 KB
pulling 56bb8bd477a5... 100% ▕████████████████████████████████████████████████████████▏   96 B
pulling 34bb5ab01051... 100% ▕████████████████████████████████████████████████████████▏  561 B
verifying sha256 digest
writing manifest
success
>>> Send a message (/? for help)

And just like that, you now have a LLM on your local machine!!

Also, If you would like to install any other model available through Ollama, you would use the same command:

ollama run MODEL_NAME

Step 5: Test out your Large Language Model

Now that Llama3.2 is on our machine, let's test it out.

Let's ask it a simple question:

Hey Llama! Could you tell me a little bit about yourself?

You should then get a response similar to this:

Hey Llama! Could you tell me a little bit about yourself?
I'm happy to chat with you. I'm an artificial intelligence model known as Llama, which stands for "Large Language
Model Meta AI." My primary function is to process and generate human-like text based on the input I receive.

I was trained on a massive dataset of text from various sources, including books, articles, and online
conversations. This training allows me to understand and respond to a wide range of questions, topics, and styles.

Some key features of my abilities include:

.....

See! Wasn't that pretty easy!

Wrap Up

If you have been a dev for any period of time, you're likely desensitized to the idea of "The Next Big thing" in tech. Though I have a natural curious nature, overtime, I have become more and more desensitized to "The Cutting Edge"; if its been Virtual Reality, Web3, Crypto, AI or anything else, I have found myself initially hopeful and then later disappointed by the possibilities.

But in a uplifting turn of events, my spark for Artificial Intelligence has been reignited through continued exposure and arelentless desire to find it's value.

I have truly come to the conclusion, that the future of the development will be heavily intertwined with AI and Generative AI tools.

If you are a developer, engineer, software engineer or someone who works heavily in tech spaces, it's time to embrace the benefits that AI technology affords us.

I can't tell you what the future holds for our profession as developers or whats next for AI as a whole, but I do have a strong sense that we are at an inflection point.

I encourage you to take the time to discover your own "AI Blindspots" and utilize the tools and technology we have available to enhance and accelerate your own development workflows.

Photo Credits(Order of Appearance):

Cover Photo with Google Gemini
Prompt:
A happy fluffy white llama, standing tall in the center of the frame, bathed in the warm glow of a bright light shining from behind its head, giving the illusion of enlightenment, its eyes closed in meditation, face looking toward the top right corner as if gazing into the future.

Follow me on my Socials:
https://linktr.ee/bradstondev

Don't Dead End Your Dev Career: Using Communication to Amplify Your Possibilities

Bradston Henry — Thu, 22 Aug 2024 14:06:37 +0000

NOTE TO READER FROM AUTHOR:
This blog is primarily intended for Developers and Software Engineers looking for new ways to improve their career growth potential and attraction to possible future employers.

This is a practical approach to differentiating yourself from amongst your peers and is a brief summary of learnings I have gained from my experience as an Engineer, Software Developer, Team Lead, Interviewer, and Manager. I hope this information is as helpful to you, as it has been for me.

Thanks for reading and enjoy!

As a self-taught software developer, a developer relations manager and an aspiring and ever-growing writer, I've always clung to the belief that it's "All about what you do, not what you say".

That your 'work' should speak for itself, and that 'words' are "nice", but offer very little real value in a tangible sense.

But as I near my 10th year in the tech industry, I've discovered that the adage, “Talk is cheap” may not be as true as I once thought it was.

But that the real adage, especially for my fellow developers and software engineers, should be, “Talk isn't cheap, Talk is ESSENTIAL”.

Do What You Say and Say What You Do

As I look back on my software development career and my overall journey that has brought to where I am now, I have started to recognize a specific skill that has helped me to stand out amongst my peers. That skill is...

The ability to communicate clearly and effectively to those who I work with and those who I engage with, on any level.

I've truly come to realize, that the key to continued success is simply the ability to “talk” or, more aptly said, communicate.

My capacity to express my ideas clearly, if not always succinctly, has allowed me to convey my technical skills and abilities while adeptly navigating the minutia of the complex dynamics that come with intra-organizational functional growth.

“Wait?!? What did you just say?!?”

Essentially, having the ability to communicate has allowed me to showcase my technical skills more readily, while allowing me to navigate the difficulties that come with pursing “that promotion” or that position that I desire.

Having the acumen to speak on my technical ability to diverse audiences has made it a “no brainier” to hire me (or promote me) over candidates with similar skill sets and experience.

I haven't just “walked the walk”, I've “talked the talk”.

Over time, I've discovered that one of the most important skills needed to have an impactful career in software engineering, is the ability to communicate well.

"But I'm a Talented Software Engineer, Shouldn't my Skills Speak for Themselves?"

In a perfect world, humans would be able to easily identify exactly who is the best person for any given role by just simply looking at them.

“Yup! They’ll be the perfect accountant. I can see it in their eyes”

But in reality, determining competency and the ability to perform is a complex task. Finding the best person for any given role or opportunity can be incredibly difficult.

Great things (and even great people) are not easy to recognize, without something “speaking on its behalf”.

Let's take the cautionary tale of the movie Elemental.

Elemental, a Disney Pixar movie that was released in the summer of 2023, has the unfortunate honor of having the 2nd worst box office opening for the animation studio Pixar, since the release of Toy story in 1995.

But oddly enough, Elemental currently has a 93% audience score on Rotten Tomatoes, which shows that the movie was not just enjoyed by those who saw it, but loved.

So what happened to Elemental?

Rua Fay at Cinemasters does a great job of summarizing the events that lead to the fiasco in her blog, but in short, Disney didn't do a great job at marketing the movie. The movie's marketing focused on the wrong elements (pun not intended) of the Elemental while targeting a niche audience.

Luckily, Elemental ended up finding its audience and performing better at the box office (keeping it from being a financial loss for Disney), but it's success was massively hindered by what was communicated about it.

It wasn't successful at the box office because of its quality as a movie.

It was less successful because of what Disney communicated about it.

So take a moment and ponder...

What do you communicate about yourself to others you work with?

How well do you communicate the value you bring to the table?

And lastly..

Are the only people who know your capabilities, competencies and strengths, those who have worked with you directly and/or those who have managed you directly?

Breaking the Curse of the 'Silent Engineer'

Even if you're currently not doing well in the realm of communicating your skills and what you have to offer, I want to ensure you that it's never too late to make a change.

You may not believe this (if you were to follow my career, watch my behaviors and have awareness of the activities I engage in) but I'm an introvert who suffers from social anxiety.

When I was younger, I found managing social scenarios immensely difficult. Though I've grown substantially through out the years, I sometimes still feel incredibly anxious doing simple social things; like raising my hand to answer a question in a classroom setting.

But my personal weaknesses and my general social preferences, have very little to do with my ability to communicate and express myself in a professional setting.

So how does a software developer grow in their communication skills and set themselves apart for more opportunities to flourish in their career?

Well, here are a few things I recommend doing to help yourself grow and build your communications skills:

1. Create a "Personal Elevator Pitch"

If you only had 30-60 seconds to communicate what value you bring to the table as an engineer, what would you say?

If you can't answer the above question easily, spend some time crafting a succinct way to express your value. Think through how you would explain what you have to offer to a person who could have a direct impact on your career growth.

Once you do that, practice sharing your elevator pitch with those you trust. Get feedback on you're communicating and refine your messaging.

Having an elevator pitch in mind better prepares you to express the value you have to offer at anytime, in any place, at any length.

Also, as an added benefit, it helps to build confidence and better define your personal strengths.

2. Find a mentor to help with communication skills

Finding a person who is willing to guide you on your journey of growth in communication is crucial. Your mentor doesn't have to be a software engineer and your mentor doesn't have to work with you.

Your mentor should be someone you trust, you admire and who has the experience to help you navigate your path to success. Someone you can ask honest questions, get genuine feedback, and who will encourage you throughout the process.

In all honesty, a mentor can truly be a "cheat code" when it comes to building skills you lack. Having a mentor(s) is an absolute game-changer to achieving success and growth in communication.

If you don't have a mentor, reach out to someone you think of highly today, and start the conversation.

3. Practice, Practice, Rehearse

Sadly, there is no shortcut to building stronger communication skills, BUT there is a method that works almost every time in helping you be a better communicator; practice.

In the Asurion Developer Advocacy Program, this is one of the topics I hone in on in my lesson on Public Speaking.

A key component of successful communication is confidence. In order to build confidence, you must first build competence. And to build competence, you must practice.

Practice can come in many forms: Speaking in the mirror to yourself, preparing a presentation with a colleague, joining Toastmasters, or creating a podcast. (Note: This is not an exhaustive list)

But what's most important is intentionally taking time to work on communicating ideas more effectively in a "safe space", where you can make mistakes and grow.

As they say, "Practice makes perfect", and building communication skills is no exception.

4. Speak up! Advocate For Yourself!

This is hands down one of the most important lessons I was taught in the latter half of my career (from one of my mentors).

Advocating for yourself is understanding that it is absolutely your responsibility to own you career and speak up for yourself.

No matter how great your support system, noone, and I mean noone, will ever be able to advocate for you as well as yourself.

When you believe you are able to do something, say it.

When you get a new certification or achieve a new accomplishment, share it.

If you feel you are not getting opportunities for growth and advancement that you believe you deserve, speak up about it.

This specific principle has been one of the keys to my personal career success. I would not have achieved what I have to this point in my career, without truly adopting this principle.

5. Watch the Masters

If you really want to become great at communication, watch and emulate those who are already great at it.

Sometimes, the best way to learn and grow is to imitate. By watching an individual who is recognized by their peers and community as a strong communicator, you have the opportunity to pick up on obvious and subtle skills that makes them great.

Also, make sure to watch a diverse set of communicators and see if you can learn the common tactics and approaches they all use. Sometimes, it's hard to recognize what makes any particular individual great without having a greater perspective on different communication styles.

And if possible, consider asking one of those "masters" if they'd be willing to be your mentor. You never know, you might just get lucky!

6. Volunteer to be Uncomfortable

The former CEO of IBM, Ginni Rometty, once said...

One sign an idea is a good one is if it makes people a little bit uncomfortable. That’s because growth and comfort never coexist.

In order to grow, you have to be willing to be uncomfortable.

And this principle is true in almost all aspects of life and even more so when it comes to communicating.

In order to really grow and build your communication skills as a developer or a software engineer, you need to put yourself in situations that challenge you and take you out of your comfort zone.

Sometimes, it will work out that you will be given a task or assignment that will force you to use your communication skills in new and challenging ways. But, you should never wait for that opportunity to come to you.

Instead, you should be seeking out opportunities of growth and putting yourself in situations that will force you to grow.

Is your manager looking for someone to volunteer to communicate some technical details to stakeholders? Volunteer to speak on behalf of the team.

Is there a need, at the end of a Sprint, for a person to share a summary of work completed by the dev team to the greater team? Speak with your team lead and volunteer to give that summary.

Are there seemingly no opportunities for communication roles on your team? Speak with your team lead or manager and ask if they can create those opportunities for you.

Be active in seeking out opportunities to grow in your communication skills.

Volunteer and take the chance to be uncomfortable and discover the growth that follows.

In Conclusion

I feel I have been very blessed in my career and have been able to experience both substantial skill growth and positional growth. I would attribute that, not only to my technically proficiency, but also to my goal of focusing on communicating more effectively.

And I can confidently say, that when competing for roles or opportunities, where I am equally qualified or even less qualified than my peers, that my ability to communicate has helped me to outpace the competition.

If you are looking to advance your career, expand your influence within your company or community at large, or if you aim stand out amongst candidates all vying for the same open role at an organization, consider building your communication skills.

I know without a shadow of a doubt, I owe much of my career success to the ability to not just “walk the walk” but also “talk to talk”.

All the best,

Bradston Henry

Do you have any other suggestions on how developers and engineers can grow their communication skills? If you do, please share them the comments below. I would love to hear them!

Note:
I am very passionate about this topic and believe that for many software engineers, that this area of expertise that can be difficult to master. If you'd like me to expand on this topic and go into more depth into the specifics of how to grow proficiency in communication, please let me know. I'd love to continue diving into this topic if others would find value in it. Thanks!

Photo Credits(Order of Appearance):

Cover Photo by Dustin Tray from Pexels

Photo by Startup Stock Photos

Photo by Pixabay from Pexels

Follow me on my Socials:
https://linktr.ee/bradstondev

Using React to Store Azure OpenAI DALL-E images using Base64

Bradston Henry — Tue, 03 Oct 2023 21:29:09 +0000

Author's Note: If you are interested in jumping right into the code, please skip down to Getting our DALL-E images. The paragraphs prior to that section are intended to give context on how and why I chose this particular conversion/storage method.

In Mid-September 2023, I helped to host and participated in a 48-hour Generative AI hackathon at my company, Asurion. The Hackathon was called the Code Jam: AI Hackathon and while hacking with my team, I stumbled into a slightly novel way to store DALL-E images, using React, for later use.

The Magic of Base64

If you have worked in software development for some amount of time you may have encountered the use base64 to convert JPEG and/or PNG images. Base64 is a data format that allows you to store certain types information in, essentially, a plain text format.

For our Hackathon project, we were in need of using DALL-E generated images but we realized that continuously generating new DALL-E images for our application was not sustainable (or cost effective) for the long term. And because image reuse wasn't an issue within our project (and we stored quite a bit of our application data in JSON-based database), base64 was the logical approach for image storage.

Though Base64 text strings for images can be pretty long, storing our images as text was preferable to using an image storage service to preserve images in their original format.

Now instead of needing to store an image like this in its original PNG format:

We could now store images as text like this:

data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAgAAAAIA....

With that decision made, I began, what seemed to me, the trivial task of converting DALL-E images to Base64.

IMPORTANT NOTE:

This blog is best suited for those with some knowledge of React and Javascript and with a basic understanding of APIs and network calls. I've tried my best to explain my process as much as possible but I do not explain everything about the code that I've shared.

The Azure OpenAI Caveat

So one thing that made me excited about pursing the base64 conversion approach, was that I was aware that OpenAI's DALL-E API offered an option to request DALL-E images in base64 format instead of image format. That essentially meant that OpenAI would have done most of my work for me, and all I had to do was configure our application to save those base64 text strings into our database.

Well, sadly I was not so lucky..

As some of you may be aware, Microsoft recently created an enterprise ready version of many of OpenAI's service offerings after some corporations ran into trouble when their proprietary information inadvertently was exposed using its tools. This version of OpenAI, Azure OpenAI, has been touted as a "closed system" that aims to protect corporations from the accidental leaking of crucial intellectual property feed into their systems.

Asurion, my employer, has been very interested in leveraging Generative AI technology and has had the opportunity to be one of the first companies working with the Azure OpenAI environment.

The only caveat is that Azure OpenAI's API varies in slight ways from the public version on OpenAI.

One of those ways it varies is the DALL-E API's lack of a base64 option.

Note: If you are interested in learning about the ImageGenerationOptions offered by Azure OpenAI's DALL-E API, you can check it out here

So that left me with no choice but to do the conversion manually within our React application.

Keeping the Conversion Native

When I started this task, one key thing that I wanted was to keep the conversion process "simple" within our code base.

If at all possible, I wanted to avoid using any React or Javascript frameworks that were not default libraries within a standard React project.

There are many reasons for why that was important to me, but the main reason was that I wanted to keep the code lightweight and easily transferable to other projects.

With that in mind, I went on the hunt for native Javascript and React library/framework options.

Getting our DALL-E images

Once I knew my desired approach to the problem, I first wanted to make sure I knew what type of data I'd be getting from the OpenAI DALL-E API so I could be aware of how I would need to approach this conversion process.

Because this blog is not about how to use the Azure OpenAI DALL-E, I am going to skip some steps here and share an example of an output you'd receive when requesting an image via the Azure OpenAI API:

https://dalleproduse.blob.core.windows.net/private/images/8d5392fb-34a9-43aa-93f8-d05da65b5b29/generated_00.png?se=2023-09-30T03%3A49%3A45Z&sig=lPn2mhiURJxgxM04wFj46U0AB%2B%2BM5X%2FV0mEVSyhb0zU%3D&ske=2023-10-05T05%3A34%3A21Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-09-28T05%3A34%3A21Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d

Looking at the above URL you might notice a few things.

Though it does have a somewhat standard URL structure, you will notice that after the ...b29/generated_00.png portion of the URL, that there is an interesting URL parameter.

Note: From my understanding, this parameter denotes the lifespan of the URL. DALL-E images are only available for a limited time after generation.

The reason I point out this URL parameter is that if you were to think to yourself that you would be able to access a generated image from the URL without the URL parameter (aka removing everything after ...b29/generated_00.png in the URL) you would be wrong.

It is crucial when accessing the images generated by DALL-E to use the entire URL as a shortened URL will not work.

For whatever reason, OpenAI has created a URL structure that only allows access to their generated images if you use the entire provided by the API.

Locally saving your image for conversion

Once I knew how images were presented and had retrieved the corresponding URL from the Azure OpenAI DALL-E endpoint, I needed to store any images I retrieved locally so I could encode them into Base64.

The easiest way to do this in React was to use the Fetch API which is one of the most basic protocols for fetching resources from network resources.

Within a async function, it has a pretty straightforward syntax:

export async function getDatafromURL(url:string) {
    //Fetch data from url 
    const data = await fetch(url);
}

As the code reads within the async function, you pass the desired url with the resource you'd like to retrieve into the fetch function, using await to return the data from the url.

Because of the nature of base64 conversion in React, the easiest way to convert image data from a URL into base64 is to save that image as a blob.

This is actually very simple process when using the standard javascript library within React.

Here what that would look like:

export async function getDatafromURL(url:string) {
    //Fetch data from url 
    const data = await fetch(url);
   //Create blob of data
    const dataBlob = await data.blob();
}

Once I had my data from the retrieved URL, all I needed do was use the .blob() method of the data object to quickly convert it into a blob that could be used later.

So let me get more specific to the actual DALL-E resource and what that would all look like .

Here is the same functionality described above while using an example DALL-E URL:

const dalleImageURL= 'https://dalleproduse.blob.core.windows.net/private/images/8d5392fb-34a9-43aa-93f8-d05da65b5b29/generated_00.png?se=2023-09-30T03%3A49%3A45Z&sig=lPn2mhiURJxgxM04wFj46U0AB%2B%2BM5X%2FV0mEVSyhb0zU%3D&ske=2023-10-05T05%3A34%3A21Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-09-28T05%3A34%3A21Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d';

 async function getImageBlobFromURL(url:string) {
    //Fetch image data from url 
    const imageData = await fetch(url);
    //Create blob of image data
    const imageBlob = await imageData.blob();
    return imageBlob
};

const dalleImageBlob = await getImageBlobFromURL(dalleImageURL);

Now that I had locally saved the DALL-E image URL data as a blob, it was time to make the base64 string of from the DALL-E image data.

Converting our image blob data into base64

Now came the most important step; converting the image blob that I had created from the DALL-E image URL into Base64.

To do this, I used the FileReader library within a async function using the FileReader's readAsDataURL method to transform the blob into a base64 string.

Here is the async function I used:

//Use File Reader to decode Blob as a Base64 string
async function blobToBase64(blob: Blob) {
    return new Promise((resolve, _) => {
      const reader = new FileReader();
      reader.onloadend = () => resolve(reader.result);
      reader.readAsDataURL(blob);
    });
}

Using FileReader within a Promise closure, I created a reader object that used the .onloadend listener (which fires when a file read event has completed) to return the base64 string after the reader.readAsDataURL(blob) completed converting the blob object.

Note: If you are not familiar with Promise syntax or FileReader object functionality, I encourage you to look into the documentation to see how they work (links in this note)

If I were to use this method using this syntax with a set image blob, imageBlob,

const dalleBase64String = await blobToBase64(imageBlob);

and were to console.log(dalleBase64String) I would get something that would look like this:

data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAA....

The above is the exact base64 text data I had been working to get.

Note that the base64 output has a three parts:

The data: tag at the beginning.
The designator marking what type of data it is: image/png;base64,
and the actual base64 data of the image which is represented by the extremely long string of characters at the end.

Here is the full code that could be used to convert a DALL-E URL to base64 data:

const dalleImageURL= 'https://dalleproduse.blob.core.windows.net/private/images/8d5392fb-34a9-43aa-93f8-d05da65b5b29/generated_00.png?se=2023-09-30T03%3A49%3A45Z&sig=lPn2mhiURJxgxM04wFj46U0AB%2B%2BM5X%2FV0mEVSyhb0zU%3D&ske=2023-10-05T05%3A34%3A21Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-09-28T05%3A34%3A21Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d';

async function getImageBlobFromURL(url:string) {
    //Fetch image data from url 
    const imageData = await fetch(url);
    //Create blob of image data
    const imageBlob = await imageData.blob();
    return imageBlob
};

const dalleImageBlob = await getImageBlobFromURL(dalleImageURL);

//Use File Reader to decode Blob as a Base64 string
async function blobToBase64(blob: Blob) {
    return new Promise((resolve, _) => {
      const reader = new FileReader();
      reader.onloadend = () => resolve(reader.result);
      reader.readAsDataURL(blob);
    });
}

const dalleBase64String = await blobToBase64(dalleImageBlob);

Be wary of 'no-cors' mode with fetch

Something I wanted to note, because it took me down a non-productive rabbit hole, is to be careful when using the 'no-cors' mode with Fetch API calls.

When I first began this process of building the functionality of converting DALL-E to base64 my original getImageBlobFromURL function looked like this:

async function getImageBlobFromURL(url:string) {
    //Fetch image data from url 
    const imageData = await fetch(url, {mode: 'no-cors'});
    //Create blob of image data
    const imageBlob = await imageData.blob();
    return imageBlob
};

I originally took this approach of adding the optional parameter of {mode: 'no-cors'} because I was concerned about Cross-Origin issues that arise when downloading image data using fetch using the browser.

I tested the above method on other image resources hosted at other URLs before trying with DALL-E and, at the time, the function seemed to work fine. But when I attempted to implement it with the DALL-E generated URLs I ran into issues.

The no-cors parameter was problematic when trying to trying to download the image data from the DALL-E image URL.

Because of how the DALL-E images are generated at their designated URL (wrapped in HTML by OpenAI), when using the no-cors parameter my base64 data that I received through the blob conversion process could not be converted into an image.

When I used the no-cors parameter, I would get something like this:

data: text/html; base64,V2VsY29tZSB0byA8...

This data type, text/html, can not be directly converted back into an image but holds html page data, which is a bit more complicated to deal with.

If you are interested in the nature of base64 conversion and the nuances of how conversion works, then the no-cors issue might not bother you. But if you are looking for the conversion to remain relatively simple, I would be wary of that no-cors parameter.

Conclusion

So just like that, I easily took a Azure OpenAI DALL-E generated image, hosted at a OpenAI URL, and converted it into base64 string for storage.

In this blog, I did not cover how you could store these base64 strings for retrieval at a later date in some external filing system, but now you have the tools you need to take on that challenge yourself.

In all honesty, this task should have been a relatively straightforward process but the minor nuances of how OpenAI manages image generation made this task a bit more complex.

I hope this helps any developer who is using Azure OpenAI DALL-E services with the goal of storing DALL-E images in base64 format.

Thank you for reading this blog and I wish you all the best!

Bradston Henry

Cover Photo generated by DALL-E

Cover Photo
Image Prompt: A person taking a headshot with face visible, with the right half of their face being photorealistic and the left half of their face being drawn in matrix style

Doggo Photo
Image Prompt: A happy doggo in ukiyo-e style

Follow me on my Socials:

https://linktr.ee/bradstondev

The Good, the Bad, and the Biased: Is Bias in Generative AI a Flaw or a Feature?

Bradston Henry — Wed, 03 May 2023 14:53:14 +0000

Question: Would you consider cultural, racial, geographical, or gender based-biases in generative AI a feature or a flaw?

As of late, this question has been swirling around my mind.

Recently, I asked ChatGPT a fairly innocuous question:

Can you generate 10 random names?

As expected, this was an easy task for ChatGPT and I was pleased to see that the names generated had a decent amount of variety and, to the human eye, read as real human names.

I then asked ChatGPT:

Can you generate a table with the above 10 names with each name having a random location, age, and favorite food?

And in short order, ChatGPT created a table with the exact information I had requested.

But as I inspected the table more deeply, something struck me as...

...odd.

And as I reflected on what I observed, it became clear to me that how generative AI interprets prompts will have a powerful impact on how developers (and everyone else) will utilize this technology in the future.

Taking a Closer Look

Upon closer inspection, the random names generated, the random locations generated AND the random generated favorite foods weren’t as "random" as I first thought.

Each name, location, and favorite food corresponded (to some degree) to a “cultural expectation” one might have for a person who would have that given name, who might live in that location or would designate that item as their favorite food.

For example, Aaron Kim from Seoul, South Korea’s favorite food was bibimbap.

My first thought was, “Wow! That’s pretty cool that ChatGPT tried to match random names along geographical and cultural lines.”

And then my second thought was “Wait!? Did ChatGPT just randomize names along geographical and cultural lines, without me asking?”

And then it dawned on me; In its default state, ChatGPT operates with some level of inherent bias when considering my questions, thoughts, statements, or prompts.

An AI with Bias is an AI Indeed

For many, this isn’t a revolutionary thought or something that even slightly surprises them.

If anything, this has become a very well known issue that developers and engineers have had to combat when creating new technology for a global audience.

Why this particular instance of bias stood out to me was that ChatGPT, of its own "volition", determined the best way to answer my query was to embed cultural and geographical bias into its answer.

In some ways, I applaud ChatGPT for its cleverness to embed those types of biases, as that is a very human thing to do, but it’s something we as users need to continue to be cognizant of when using ChatGPT or any other generative AI technology.

It can be easy to view Generative AI as just a computer giving the most logical answer using human speech patterns. But generative AI is just as prone to biases as we are, because in many ways it was trained on our own biases.

The data used to train a generative AI to make it so informative, helpful and “human-like” fundamentally encapsulate our human tendencies and biases.

But the question becomes, what do we do with Generative AI systems now that we know they may have some biases built-in.

What Do We Do with Generative AI Now?

This is a somewhat complex question but one answer to this can be to ensure our questions, or our prompts, are specific enough to help guide our AI companions toward our desired output, despite the bias.

So let’s take, for example, the prompt I shared earlier and let’s ask ChatGPT to consider the biases that it unintentionally (or intentionally) baked into its answer.

Let’s try this:

Could you randomize the favorite foods in the table again without biasing the randomness to culture, nationality, race or gender?

At first glance, this question seems hyper specific and somewhat “leading” but that’s exactly the point.

As the user of ChatGPT, it is our job to be explicit in our prompts and requests.

Consider my previous question:

Can you generate a table with the above 10 names with each name having a random location. age, and favorite food?

My expectation from ChatGPT when asking for something “random” was for ChatGPT to select random locations, ages, and foods for the previous randomized names with no consideration for the names it had previously generated.

What ChatGPT interpreted from my prompt was that I wanted those random items to be contextualized to the names and cultural leanings those names represent.

It may have come to that conclusion because when asked similar questions in the past, it received positive feedback when aligning with those biases.

And understand, ChatGPT didn’t do anything wrong, it just did what it was designed to do. It used its past experiences to predict the desired outcome that would most likely fit my needs.

So what was the outcome from the clarification of my previous prompt:

Could you randomize the favorite foods in the table again without biasing the randomness to culture, nationality, race or gender?

The above outcome more reflects my original expectation of “randomness” for my requested attributes.

When ChatGPT was given more focused direction, it was able to give me results that more readily satisfied what I desired.

For Example, Aaron Kim from Seoul, South Korea’s favorite food is now roasted vegetables.

Managing Bias Using Your Wording

So take another moment to consider why the word “random” may have not been sufficient to get the results I expected or wanted.

One way to consider this is to think about how ChatGPT interprets the words/phrases below:

Best
Worst
Most Efficient
Fastest
Good
Bad
Strongest
Most Influential

Though it's hard to exactly predict how ChatGPT would interpret these words, it's fair to assume it would likely interpret the above words similar to how we as humans would. It would make some assumptions on what we meant by those particular words or phrases and would try its absolute best to give results that reflect those assumptions.

Take a moment to consider what makes any one thing the “best”.

If I asked you right now, “What is the best Seafood in your area?”, how would you determine the answer to that question?

When it comes to “best” you might consider the price of the seafood, the location of where the seafood could be purchased, the freshness of the seafood, and you might even consider your personal experience with the different types of seafood you have had in your area. Then, after considering that information, you would likely give a few seafood options that rank amongst the "best" or just one place that stands out to you as the “best”.

So let’s see how ChatGPT answers a similar question:

What is the best Seafood in Baton Rouge, Louisiana?

NOTE: I chose Baton Rouge, Louisiana because I lived there for a time and Louisiana, in general, is known for its overall quality seafood offerings in the US.

If you have used ChatGPT before, you shouldn't be surprised by this type of response.

But my question to you is “How Did ChatGPT determine what is the ‘best’ seafood”?

Well, let's ask ChatGPT:

How did you determine what was the best seafood in Baton Rouge, Louisiana?

In its own words, ChatGPT expresses that it doesn’t have its own preferences, but it uses its trained data to determine what “best” means. It explains a bit more about how it came about making those recommendations and how "best" may differ from person to person.

This bias that ChatGPT has toward what is “best” is not inherently bad, as I mentioned earlier, but if while using ChatGPT you are not aware of how it uses its bias to respond to or answers questions, you may not realize the response you were given is not the "objective truth".

But What Does This Have to do with Me as a Developer?

So how does this apply to you as a developer or engineer?

In plain and simple terms, understanding the biases of the generative AI system you are using and avoiding terms that force the AI system to overly interpret your intent, will help you immensely when using generative AI tools.

It's easy to assume that asking ChatGPT for assistance on how to build code won't be heavily impacted by bias but consider that code is written by humans and humans code in ways that directly impact their technical approach.

Coding/programming is less of a science and more of an art, and understanding that bias has an impact on how we as developers write and consider our code is important to understand.

So here are a few quick tips to help with your prompting:

1) Do not use words and phrases like “best”, “worst”, or “most XYZ” without understanding how the generative AI is interpreting those words

It may seem obvious to you how the AI system may be understanding those words or phrases but if the meaning of a word is too vague or overly biased, you may get results you didn’t expect.

2) Ask the Generative AI system to explain why it gave you that response.

Even with seemingly very well-crafted questions or prompts, the AI system is likely still using some form of bias or inference to provide a quality response. After getting a response that seems reasonable, try and get some context on how and why the system came to that particular conclusion.

NOTE: There is no way to be 100% sure that the response a Generative AI system gives you about why it answered a prompt in a certain way is completely accurate. The AI system may, for example, answer your question, not with the truth, but with what it assumes you would like to know. Please be aware of this.

3) Do NOT assume prompting for technical or coding responses makes you immune to bias

Just because you are asking ChatGPT to generate code in a specific language with specific requirements for a specific purpose does NOT mean you are getting a completely objective unbiased response. Fundamentally, generative AI is based on data accumulated from the past and its responses reflect that. Be aware that the code it generates now, is based on code generated in the past and may reflect technical and coding biases that may not positively impact your current work. Past paradigms of approaching a technical problem may not be the direction needed for future progress.

Bringing it all Together

In short, the biases that Generative AI may have when answering particular prompts or questions is not inherently bad, or even a flaw. If anything, because these systems are created by humans with their own biases, this is to be expected.

It is our responsibility, as good stewards of these technologies, to use them with the understanding that they are in no way fully objective and fundamentally must work off of some form of bias to be optimally effective.

When using these technologies, continue to remember to ask yourself how and why a system came to its conclusion. Also, we should always aim to be as specific and direct in our prompts to help guide our AI associates to the best possible response and to minimize confusion.

In a world that is fundamentally shaped by our individual perspectives and biases, it is only natural to assume the things we design and create carry those biases along with them.

If we continue to confront those biases head on and are honest about how they impact what we do, specifically in these emerging spaces of generative AI, we will continue to have a bright future where we accomplish things, we never thought possible.

What are your thoughts about the bias in Generative AI? Please share them in the comments!

All the best,

Bradston Henry

Cover Photo generated by DeepAI.org

Image Prompt: An AI pondering the answer to a difficult question

Follow me on my Socials:

https://linktr.ee/bradstondev

Why You Probably Don't Deserve That Promotion

Bradston Henry — Thu, 15 Dec 2022 16:57:38 +0000

I've seen it happen so many times...

As the "Season of Promotions" at a company comes to an end, some developers begin complaining that they deserved a promotion (or a raise).

They feel as if they’d earned the right to a promotion and that they were being unduly skipped over for some reason.

As a seasoned developer who’s worked in teams, led teams, and has managed other developers, I've found that, in most cases, that those developers haven’t done what’s needed to deserve a promotion.

I always fight for the success of my team members and those I manage, BUT there’s a reality that I sometimes find hard to communicate because it seems to go against general working culture:

Just doing your job and existing as a non-problematic employee RARELY correlates to a justification for getting a promotion or raise.

At the time of this writing, it's the end of the year and as is the culture of most companies, end-of-the-year reviews are beginning, and employees are making their case for why they deserve a good end-of-the-year rating AND why they should soon be in consideration for promotion opportunities.

So, it got me thinking, "What keeps developers and engineers from being considered for promotions?

In this blog, I’d like to share some of the key reasons why YOU may not be ready for that promotion that you’ve really been wanting. This blog is for the early professional and for the seasoned developer. Experience levels may differ, but I have found these reasons tend to be universal.

1. You don't take initiative

I've been there.

Imagine this: Your dev team lead gathers the team and shares that there’s some task or activity the team needs to complete, but no one wants to do it. In this case, it's a seemingly pointless task that's either low-hanging fruit or a complete deviation from the team’s normal work.

Your team lead then asks who’d be willing to own this task, and no one responds. After a brief but incredibly awkward silence, one team member reluctantly accepts.

You might be thinking you've dodged a bullet, but in reality, you've missed out on an opportunity.

As my manager, Neil Giarrantana, often says:

"The world is run by those who show up."

Often, the difference between a good developer and a great developer is that the great developer takes initiative when no one else is willing to.

If you want to stand out amongst your peers OR if you want your team lead or manager to notice you and your growth potential, take the initiative to solve problems and tackle tasks whenever possible.

If you’re not sure how to take the initiative, here’s a simple way to start...

Approach your team lead or manager and ask them this question:

"Is there anything I can help you with to make your life easier?"

Let's be honest, that's a terrifying question.

It opens you up to almost anything, BUT it shows that you’re taking an active role in seeking growth in your team or in your organization and you're willing to do what others aren’t.

Taking the initiative to work on tasks no one wants to tackle, solving problems before they happen, or assisting your leadership where they need, can have a HUGE impact on your overall career development and can increase your chances of getting a promotion.

2. You don't own your mistakes

Never have I heard a person say:

"Thank you for blaming someone else and preserving your image of innocence. I’m so thankful to know that [insert some problem] was someone else's fault and not yours."

It’s human nature, however, to blame others when we perceive an issue or problem not to be our fault. This is mostly because we’ve learned that the consequences for making a mistake rarely tend to be good.

What I’ve found time and time again, is that those who are willing to own their personal mistakes, and even their team's mistakes, tend to be the ones who end up getting better opportunities.

This is because a person who’s willing to own their mistakes is also a person who takes personal responsibility for any work that they may be involved in. They see a mistake not purely as a failure, but an opportunity to grow.

Mistakes are inevitable and no matter how careful we are as developers or engineers, sometimes, even seemingly good decisions lead to problems we couldn’t have anticipated. There are many times when we initially might not believe an issue to be our fault, only to find out later that we had a hand in the matter.

And sometimes it really isn’t our fault.

But even if it isn’t, how does blaming others benefit you or your team?

Let me ask you a question:

Would you enjoy working under a manager or leader who always blames you or your teammates for things going wrong (even though it may not be your fault)? Is that someone you would trust or want to work under or alongside?

Your answer is likely no.

Knowing that your manager is likely to use you as a "scapegoat" at any given time does not make you feel safe or secure working with them.

Similarly, if you’re a developer who always finds a way to blame others when a problem arises, there’s a good chance others may not want to work with you.

If you’re not sure whether or not you own your mistakes, I encourage you to look back on how many times you’ve said something like:

I'm sorry. I think that might’ve been my fault. Let me look into that.

Oh! My bad! I'm not sure if I caused that issue but let me look into it to see what I can do.

If these types of phrases seem foreign to you, I encourage you to start practicing owning your mistakes instead of finding ways to blame others.

3. You don't prioritize your personal growth

Take a moment and answer this question:

What skills are you currently focusing on to grow in your career?

If you weren’t able to answer this question within a short period of time, there's a good chance you’re not currently prioritizing your personal growth.

As Zig Ziglar once said...

If you aim at nothing, you'll hit it every time.

Without a doubt, it’s extremely common for developers to solely focus on their tasks in their role.

If your role is to build new features, you build new features.

If your role is to fix bugs in production, you fix bugs in production.

When you’re just doing what’s expected of you in your role, you’re bound to forget what skills you’re gaining in the process.

If you’re not even sure what skills you’re trying to gain, how can you communicate what skills you have gained to someone else?

If you’re not sure what skills you’re gaining, how can you be sure you’re meeting the requirements you need to be promoted?

Of course, you can always get lucky, but rarely have I seen luck be the contributing factor of why a particular individual got a promotion to the role they desired.

If it's your goal to be promoted, take some time to consider what skills you’re attempting to expand in your career. Once you identify those skills, spend some time to make sure you're aligning your day-to-day tasks, weekly goals, and extracurricular training to build those skills in a demonstrable and trackable way.

4. You don't share your accomplishments

I'm going to try to keep this point as short and as to the point as possible.

Share what you've accomplished with your manager or leader as often as possible.

The most heartbreaking thing I’ve seen happen on the job was to see a stellar, impactful, hard-working, and accomplished developer passed over for a promotion because their leader was unaware of the INCREDIBLE things they had accomplished.

I 110% support individuals having a heart of humility but I also 110% support individuals who are fans of their own work.

You cannot depend on other people to praise your accomplishments, so whenever possible, share your achievements with your manager or leader.

If you receive a glowing positive email from someone on or outside of your team, politely ask them if they can forward that email to your manager.

Whenever you receive accolades or earn a certification, share that success with your leader as soon as possible.

It can be extremely hard to share your accomplishments with your manager without feeling a bit "haughty" or "prideful", but remember, it's no one else's responsibility to share those things for you.

As a mentor once told me...

Advocate for yourself!

It's always great when someone shares your victories on your behalf, but you can't always depend on that. Always ensure that you share what you've accomplished with your manager or leader, no matter how big or how small it is! It goes a long way!

5. You aren't bringing value to the table

I'm going to ask you three questions:

How have you increased the revenue of your company while in your role?
How have you decreased overhead (overall spending) of your company while in your role?
How have you brought quantifiable value to your company while in your role?

If you’re anything like me, you probably don't like thinking about these questions, but if we're being honest with ourselves, these are some of the MOST important questions we should be asking ourselves when considering if we deserve a promotion.

In most cases, a job promotion also comes with some form of financial incentive or increase. This means that your promotion should be preceded by you adding some form of value to the company.

Your direct value can be a difficult thing to quantify, but overall, you should be able to find ways to explain your value to those who are considering you for a promotion.

Consider these questions:

Did you reduce the overall cloud spend on your cloud provider by refactoring some code on a server?

Did you implement a feature that would help your company reach more customers?

Are you mentoring and upskilling other developers on your team so they are being more productive?

Each of the above things are valuable, and if you've done anything similar, document it so you can share how you've added overall value to your company.

This can be a more difficult task for those still early in their career, but for those leaning toward more senior roles, having an idea of how you add value is incredibly important.

If you don't know where to start to quantify your value to your company, have a frank conversation with your manager or leader and ask them how you can add more value to your team or company. Their answer will likely reflect what they see as value and if you focus on improving in those areas, you'll have a greater chance of getting that promotion.

In no way is this list exhaustive, but from my experience, these have been top reasons why I’ve seen developers miss out on opportunities they otherwise might qualify for.

If there’s anything on this list that you're doing that might be hindering you from your career goals or slowing your opportunities at promotion, realize that all of these things are within your power to change.

Remember, this is an ongoing growth process. One day, you'll have all of the above list fixed and then the next you might forget to share your accomplishments and need to restart that habit again.

By reading this blog and being willing to hear a different perspective, I believe you’re one step closer to that promotion you're hoping for.

Don't give up and keep on pushing forward!

So, what do you think?

What do you think is stopping developers from deserving a promotion?

Do you agree or disagree with my list?

All the best,

Bradston Henry

Special Thanks to Beatriz Marie Dedicatoria for editing this blog.

Photo Credits(Order of Appearance):

Cover Photo by Min An

Photo by RODNAE Productions

Photo by Designecologist

Photo by Karolina Grabowska

Photo by Edmond Dantès

Photo by Towfiqu barbhuiya

Follow me on my Socials:

https://linktr.ee/bradstondev

What Could a Group of Devs Create in Three Months as Developer Advocates?

Bradston Henry — Thu, 29 Sep 2022 18:12:34 +0000

What if you gave eight developers 12-weeks to learn about the art of Developer Advocacy and challenged them with the task of creating content for their fellow dev?

What could they create? What could they accomplish?

Well, You need not wonder anymore.

Through the creation of the Asurion Developer Advocacy Program, we managed to answer that very question.

Take a look at what eight developers (all with full-time development jobs) managed to accomplish when they combined their skill and work ethic with their passion for developer advocacy.

Luis Santiago

Learn how to create a React Native application using the Expo platform through the expo-cli. Also, learn how to debug your newly created application.

Learn how to build a simple layout using CSS grid properties. Luis shows how CSS grid is a great layout system for content arrangement and application responsiveness.

How to Start Working with CSS Grid

Luis Santiago for Developers @ Asurion ・ Jul 27 '22

#css #javascript #cssgrid #webdev

Seth Gunnells

Discover how to create a video using React code while watching this video created using React code 🤯

Seth breaks down why it may not be the best idea to quit your job for another enticing opportunity and why sticking around may just be worth your while.

Don't Quit Your Job

Seth Gunnells for Developers @ Asurion ・ Aug 31 '22

#career

Grace Harders

There is no one perfect hobby or personality type that best suits software engineering - all it takes is a curious mind and a willingness to learn. In this video, Grace shares the journeys that led different individuals into software development.

Learn how important it is to create a dedicated space for team feedback and how team health can be impacted if a team retrospective space is not allocated.

The Why and How of Team Retrospectives

Grace Harders for Developers @ Asurion ・ Jul 25 '22

#productivity #agile #programming

Robert Tate

Explore the concept of 'this' so that you can move 'this' from your passive Javascript vocabulary to your active Javascript vocabulary.

Essential "this" concepts in JavaScript

Robert Tate for Developers @ Asurion ・ Jul 25 '22

#javascript #beginners #programming #codenewbie

Robert guides you through basics of the Lit framework and why you should consider using it, even if you are fan of React.

React is great...but you should try Lit.

Robert Tate for Developers @ Asurion ・ Aug 29 '22

#design #react #lit #javascript

Raymond Luu

At first glance, 'git reset' can seem daunting, if not scary. Raymond shares the how 'git reset' is not that scary the deeper you dive in.

How 'git reset' isn't as scary as it looks.

Raymond Luu for Developers @ Asurion ・ Jul 26 '22

#git

Ready to go full-stack with React. Check out the basics of one of the newest frameworks, Remix.

Ready for a "Remix" on React?

Raymond Luu for Developers @ Asurion ・ Sep 20 '22

#javascript #remix #react

Jenaba Sow

Are you interested in coding but unsure where to start? Check out the creative coding framework p5.JS with Jenaba.

Creative Coding with p5.JS: An inclusive javascript library

Jenaba Sow for Developers @ Asurion ・ Jul 28 '22

#javascript #webdev #beginners #programming

Nathan Sepulveda

Explore how music has helped inspired developers throughout their journey in Tech and how creative endeavors can make a difference on your career path.

I Thought You Moved Here for Music?

Nathan Sepulveda for Developers @ Asurion ・ Jul 22 '22

Design and Engineering go hand-in-hand when creating great products. Nathan dives into the key principles of making the dynamic between Designers and Developers great.

A Quick Guide On How To Make Your Designer Happy

Nathan Sepulveda for Developers @ Asurion ・ Sep 2 '22

Manju Bellamkonda

Learn how to build an application using a Micro frontend architecture and MERN with Manju in this video.

Git Rebase, Merge or Squash; That is the question. Explore the differences between these Git strategies and when and why you should consider using them

Git Rebase VS Merge VS Squash: How to choose the right one?

mrbellamkonda for Developers @ Asurion ・ Jul 28 '22

#github #programming #versioning

Group Advocacy

When starting a software project it can be easy to jump in headfirst without a plan. Grace Harders, Manju Bellamkonda, Luis Santiago and Robert Tate give some advice on how to avoid some of the pitfalls developers can fall into in their project structure. Also can be listened to on Youtube and SoundCloud

34:24

Don't Become A Code Monkey!

Grace Harders for Developers @ Asurion ・ Sep 20 '22

#career #programming #teamhealth

Seth Gunnells, Jenaba Sow, Raymond Luu, and Nathan Sepulveda discuss some of misconceptions around what it takes to enter the software development field and what it takes to be good at it.

Conclusion

If you are reading this and you have never dabbled in Developer Advocacy and it interests you, I encourage you to start learning the craft today.

Let the work of your fellow developer inspire you to find new and exciting ways to share your knowledge and hopefully impact those around you.

It was an honor to work alongside each of these developers throughout the 12-weeks of the Asurion Developer Advocacy Program and I look forward to working alongside them in the future.

You never know what you can accomplish until you put your mind to it!

All the Best,

Bradston Henry

Special Thanks to Kyle Smith for helping to visually design this post!

Cover Photo by Tim Mossholder from Pexels

Follow me on my Socials:

https://linktr.ee/bradstondev

Death of the Coding Test: Interview Methods that Better Evaluate Candidate Competency

Bradston Henry — Wed, 21 Sep 2022 17:02:18 +0000

A little over 7 months ago, I wrote a blog that made a much larger impact in the developer community than I thought ever possible...

Why I Stopped Interviewing with Companies That Require a Coding Test

Bradston Henry ・ Feb 2 '22

#programming #career #discuss #interview

The feedback to my blog was way bigger than I could have ever imagined and the coolest thing about it all was that it elicited a varying degree of responses:

Strong Agreement
Strong Disagreement
Hilarious Memes
Vigorous Debate in the comments
Insults directed at my writing ability 😅

And amongst all of the different responses and comments, one particular thought and question really stuck with me...

If we don't do Coding Tests, What interview approach should replace them in the developer interview process?

In this blog, I hope to answer that question. I'll share some interview approaches that I believe are better (or at least as good) at evaluating the competency of developers, engineers, and programmers for roles at your company or on your teams.

Note: I would love to hear other's thoughts on this as well, so please share your thoughts in the comments below!

Let's Set the Record Straight

Before I share my list of best interviewing approaches, I would like to make sure I convey my opinion on coding tests as succinctly as possible.

I believe that coding tests, as they are currently implemented in the tech industry, are not the best method for evaluating candidate competency or future "on-the-job" performance.

Coding tests take on several forms but essentially challenge the test taker to answer a question or a set of questions that are used to evaluate the takers understanding, knowledge, or competency on core Computer Science or programming fundamentals. Tests can consist of algorithm based challenges, tricky coding problems, and sometimes even questions to assess a test takers knowledge on Computer Science principles and/or programming design patterns.

Coding tests are somewhat standardized across the tech industry but I do not believe that they are a great gauge for evaluating the diverse sets of skills that candidates posses and do not consider the wide range of backgrounds that candidates bring to the interview process.

There are some uses for coding tests in the industry and I don't believe they should be completely thrown away but I do believe they are only truly useful for a smaller portion of the development population and should not be considered the industry standard.

What Do We Do Without Coding Tests?

Something Better!

One nice thing about me being in the tech industry for as long as I have been, is that I've been in A LOT of interviews. Interviews to find new jobs, interviews to join new projects and interviews needed for promotions.

That has given me a broad amount of experience as interviewee, as well as interviewer. And in my current role as Developer Relations Manager @ Asurion, I have the opportunity to talk with developers and engineers on a very regular basis and have learned a lot about how to best understand and evaluate the varied and broad skills of any particular programmer.

So here is my list of better alternatives to coding tests:

1. Take Home Task or Project Assignment

This approach gives the candidate a programming or coding task that could be considered a "take-home assignment". The interviewee would be tasked with solving a programming problem or project challenge that resembles something similar to what they would do in their day-to day in their respective role. In most cases, the candidate is given a timeframe in which to finish the assignment and is expected to return their solution to the interviewee once completed.

I have personally been evaluated in the interview process using this method and feel that it was a great way to measure my skills. In one case, I passed the project assignment with flying colors resulting in a job offer and in another case, I performed decently but not as well as other candidates in the process and was not extended an offer.

In both cases, I felt great about the results. Because the interviewer/company did a great job setting up the parameters and task to reflect what would be needed for the job, I felt it was a great reflection of my actual skill at accomplishing the given task.

I think this a great method for roles that might need to evaluate a candidate on a host of different skillsets; Coding skill, problem solving, critical thinking and time management.

This may not be the best approach to use if you are on a restrictive timeline for finding a candidate for a role. The reason being is that since you are asking people to complete a take-home assignment, you will need to give them the ability to find time in their schedule to do the assignment. For some, they may be able to complete the assignment quickly but for others, who may have busy schedules or a lot of home responsibilities, it may take a bit more time to fit completing the assignment into their schedule.

So here are a few more pros and cons for using this approach:

Pros

Reduces Candidate Performance Anxiety: Candidates are given the ability to select the best timing and environment to accomplish the task. For those similar to myself, this can help them to perform closer to their actual competency level while reducing anxiety that would heavily affect their interview performance.
Customizable Evaluation Approach: Interviewers can create a more bespoke experience for the assignment depending on the candidates skill level, position requirements or time constraints. Interviewers can add or remove objectives as needed to accommodate interviewee.
Two-Stage Evaluation: This works great for evaluating a candidate on coding and programming competency and evaluating their communication and actual understanding of their code. If after receiving a candidate's returned assignment, if you believe they performed well enough to continue in the interview process, you can now use the take-home assignment in a future step of the interviewing process. You can now ask them questions directly about their code and how and why they made their decisions to better understand their critical thinking and communication style and skills.

Cons

At Home Tech Requirement: One thing to be aware of is that not every candidate has the same tools to work with at home. Some may have the skills to perform on the job but not the hardware to perform the take-home assignment reasonably. This needs to be a consideration and should not remove a candidate from the interview process if they lack the personal tools or hardware to accomplish the task at home.
Candidate Time Constraints: As I mentioned a bit earlier, not all candidates have equal time capacity in the interview process. Be aware that this method may not be great for candidates who only have a limited amount of time to participate in the interview process. Consider using a different approach if a candidate expresses that they may struggle finishing or setting aside the time for the take-home assignment.

2. Pair Programming Session

Another great way to evaluate a candidates ability and to see how they may perform in the working environment is to conduct a pair programming session in the interview process.

The pair programming session approach tasks the interviewee at solving a problem or tackling some task with the guidance and assistance of an interviewee. This approach can be done in-person or virtually and can easily be adapted to best match the candidates needs.

I have experienced pair programming-esque techniques being used all throughout different interview processes but I want to make sure I clarify something about how this should be implemented.

This is actual pair-programming NOT a proctored coding test.

I have participated in interviews where it was explained to me that there would be a pair programming session only to find that I was given a task and then was simply watched and questioned about my coding decisions as I accomplished the task.

That is not how pair programming works and not how pair programming should be implemented into the interview process. Pair programming at it's heart is a collaborative effort where two developers try to work together to complete some task.

In the interview process, this is exactly the same. The interviewer and interviewee work together to solve a task while learning from each other. In the interview process, this gives the interviewer a chance to really see how a candidate would work in pair programming environment.

A candidate should not feel as if they are trying to get the problem given to them "right" or "wrong" but should be encouraged to operate as realistically as possible. This can be difficult in the interview process but can be extremely effective on evaluating a candidate.

A huge key to making this approach effective is to make sure to pair program on a problem or task that reflects the actual job. It can be a wasted opportunity if not working on a task that reflects real on the job responsibilities.

So here are a few more pros and cons for using this pair programming approach:

Pros

Code in Realtime: This gives the candidate an opportunity to code directly in front of the interviewer to get their skills evaluated. It can be sometimes hard to get an actual gauge of a candidates' coding proficiency without actually seeing them code.
Low Pressure but Some Pressure: This a good opportunity to see how a candidate performs under some form of pressure in the interviewing process. As natural as you attempt to make the pair programming process, it will still feel like some what of a test to the interviewee. This can give you an understanding of how a candidate performs under pressure. Though I am an individual who can suffer from performance anxiety, I do think it is appropriate to push candidates especially when they are likely to encounter pressure situations on the job.

Cons

Finding the Right Interviewer: The most difficult aspect of this approach is finding the right person to conduct the pair programming. The interviewer should be familiar with the pair programming process but, more importantly, should have the temperament to conduct this portion of the interview. They should have the ability to not only evaluate the candidate's skill but also the ability to work with and support the candidate. To get the best results, the candidate should feel as they are allies with the interviewer and tackling the task alongside them.

3. The "How Would You Solve..." Prompt

In this approach, the interviewer asks the candidate to try and solve a real or hypothetical problem that they would likely encounter on the team they would be joining. The interviewer gives the interviewee a prompt with the basic details of a problem that the team is trying to solve and asks the interviewee to walk them through how they would solve it.

It's extremely important to express at the very beginning of this process that the candidate can ask any questions to get more details on the problem. This makes a big difference because it lets the candidate know it's okay to communicate with the interviewer to get clarity.

One great thing you get by using this process is the ability to evaluate how the interviewee thinks though problems and how they come to conclusions. If the interviewee asks very few clarifying questions or if they ask a lot of clarifying questions, you can get perspective of their experience with dealing with technical, development, and general problems on the job.

Depending on the role that the individual is interviewing for, you can get an idea of if they have the critical thinking and experience needed for the role (and even if they may have more experience and knowledge than the role requires).

Similar to other interviewing approaches, I do not believe interviewers should be looking for the correct solution to the problem to be presented but how the interviewee got to the solution. We can sometimes detract from noticing the benefits of how a person came to their conclusion if we are too focused on them getting the "correct" solution. And as in most things in life, there is rarely a right solution to any problem but solutions with different advantages and disadvantages.

Personally, this is one of my favorite approaches in evaluating a candidate. Sometimes there are individuals who can perform really well in live coding and coding test scenarios but lack insight on how to get to a solution organically. They are very technical and studied individuals who perform well under pressure but can lack critical thinking skills that really matter on the job or in their role.

So let's look at a few more pros and cons for the prompt approach:

Pros

See Their Thinking: As I mentioned before, this method is a great way to get into the mind of the interviewee. Instead of looking at the results of a test or even some static code where you might need to interpret intention or how they might have came to some conclusion, you get to see how a particular candidate thinks. In the long run, you want a great critical thinker on your team, not just a good coder.
Gauge Future Team Impact: One benefit of getting a chance to hear how someone solves a problem is that you can sometimes identify how someone will impact your team. Something they may say or share may indicate that they are able to bring something new or needed to your team that would have never been identifiable through code.

Cons

Be Wary of "Good" Talkers: There are particular individuals who excel at verbal communication and can even at times deceive the most adept of interviewers with clever words. It's important to follow-up and ask deeper questions to determine if someone knows what they are actually talking about or just knows how to speak in a way that seems to indicate understanding.
Best When Used with Other Approaches: This could likely be said for any interview approach, but this rings even more true for this method. In an interview process it is always a good idea to get multiple performance indicators to help you better understand a candidate's possible future performance. This approach can help identify strong critical thinking skills but is not always the best way to evaluate more technicals skills like coding ability and understanding.

4. Personal Project Code Review

Using this approach, an interviewer asks to review a candidate's personal projects, open-source code or any other technical work that they have done outside of being employed in a traditional sense.

This allows candidates to self-select the technical measure on which they will be evaluated and gives an interviewer an idea of what the candidate believes is representative of their skillset. The assumption is that whatever work or code a candidate shares with the interviewer is likely work or code they are particularly proud of and something they would stand by.

When used, this approach should be implemented as a supplemental tool or an optional approach in the interview process. The truth is that not every great developer or programmer codes in their free time or has interest in working on personal projects outside of their normal daily work on the job.

Just because a candidate does not have a personal project or code to share does not mean they are any less of a programmer than an individual who does.

Another thing to note is that it is crucial to not only evaluate their code without them present and then make a determination about their skills. It is important to review their code and then discuss with them the how and why behind their code.

There may be instances where an individual makes, what seems to you, a terrible coding decision but there may be a very specific reason that actually is very clever and not intuitive at first glance. Ask questions about the code, the thinking around the code, and find ways to evaluate their skills in their entirety.

Here are a few more pros and cons for the personal code review approach:

Pros

Can be used as Substitute to Other Technical Evaluations: If a candidate has a substantial amount of personal project code that is available, there are some circumstances where you could use this approach in lieu of another (E.G. Personal Project Evaluation as substitute for Take-Home Assignment). I would recommend making this approach optional in early stages of the interview process as it may allow you to "skip" other parts of the interview process, thus shortening the overall interview experience.
See a Different Coding Style: From my experience, people tend to code differently in their personal projects than they do on their job. This gives an interviewer some insight into the candidate's personal coding style and competency when the only person who will truly evaluate their code is the candidate themselves. It also gives you a glimpse into their general documentation style as they will likely only document what they deem to be important to document.

Cons

Might not be their Code: One thing to be aware of is that when viewing a candidate's personal project is that not all the code may be their code. In our development culture with the existence of StackOverflows and Dev.to-like sites, there is a chance that someone copy-pasted their project to "look good". It is extremely important to ask the interviewee what made them make their decisions and to hear their perspective and thinking around the highest quality and lowest quality sections of their code.
Project Code can be Dated: If code in a project was created long enough in the past, it can present two problems; the code reflects their skill when they were at a lower level OR the code reflects their skill at a level they are not currently at anymore. It is important to have context on when the code was written to understand if the code represents their current skill level or a skill level benchmark of the past.

5. The "Take a Ticket" Approach

In a similar fashion of the "Take-Home Assignment" approach, this method involves giving the candidate a problem to solve or a feature to implement. How this differs is that this would happen during the actual interview, may it be virtual or in-person, and the candidate is given a set amount of time to work on the problem.

To make this approach the most effective, it is a good idea to have the interviewee to solve a problem or implement a feature that is "real" or directly reflects what would be on the job. It's also important to give the candidate access to the same or similar resources they would have on the job and not to "test" them on knowledge that wouldn't matter in a real on-the-job scenario.

To make the "ticket" they would have to solve as real as possible, I would encourage either giving them access to real code (that is not proprietary, running live or would not effect your business advantage in any way) or to make a "dummy" repository with older or slightly modified real code that they could work with. Give them a specific "ticket" that would likely need to be resolved in the real-world and let them code away.

If the interview was happening in person, you could even place them at a desk in your office to help simulate their future work environment as closely as possible.

In this approach, I would recommend going for a more proctored approach where you let the candidate code but do not directly interact with them unless they ask a question relevant to the ticket. You could also, let them work on their own without an interviewer present but you might miss the opportunity to answer any crucial questions they may have or view how the candidate codes and works.

All and all, the goal is to mimic what they would actually be doing on-the-job as closely as possible and to give the opportunity to operate in the method that best suits them.

Let's now look at the pros and cons for the "Take a Ticket" approach:

Pros

Mimics Real Work Experience: This is a great way to gauge how a candidate might operate in a real-world work environment. If set up correctly and if the parameters are communicated effectively, you might see a side of the interviewee that you may have never seen in a "traditional" interview process.
Helps Candidate Evaluate if Work Environment is a Good Fit: One thing I have not mentioned much in this blog is that it's also important for the candidate to evaluate if the job or role they are interviewing for is a good fit for them. This can be a great opportunity to help the candidate feel out what the job might be like and if it's a good match for them.

Cons

More Effort to Implement: Though this method can pay dividends in the long-term, it does take some work to implement correctly. You have to set up the work environment, the code base/tickets, need a solid interviewer to proctor and need to set aside the time in the interview process to make it happen. Given the upfront effort it may not be the best fit for everyone.
Be Wary of Performance Anxiety: Just be aware that some candidates may perform poorly in the proctored format of this approach. It may be useful to think through an alternative implementation if the interviewer notices the candidate is suffering from an episode of performance anxiety. Try your best to take that into consideration.

Conclusion

If there is one thing I'd like you to walk away with in this blog is that there are lots of solid alternatives to the traditional Coding Test that has become standard in our industry.

Just like with any interview method, no method on its own is perfect for every scenario and for every position/role that you may be interviewing candidates for. In my personal opinion, to get a more full understanding of the competency of a candidate, it's best to implement two or more of these methods in the interview process.

I'm not a fan of very long multi-stage interview processes BUT I do believe it is very difficult to evaluate a candidates technical ability or potential through one individual technical screening. And in some cases, using just one approach can create false positive and negative indicators that may not allow you to select the best candidate for the job.

As I mentioned in my previous blog, I think using a blanket approach for evaluating candidates, no matter the approach, may be more efficient but shows a lack of care for candidates and increases the likelihood of hiring the wrong person for roles you are attempting to fill.

I truly believe the effort you put into creating an interview process and the consideration you put into approaches you use to evaluate candidates, will determine not only the quality of candidates you hire but will have direct impact on their sentiment of your company and teams as they go through the interview experience.

Coding tests may be the standard but there are better alternatives that we can consider for interviewing and I encourage anyone who is in the position to impact the process to take some time to consider some of the alternatives I have shared above.

Are there any other alternative interviewing methods to coding tests that you have found to be effective?

Do you think any of the approaches I've shared are not as effective as they seem?

I Would love to hear your thoughts!

Thanks for Reading!

Bradston Henry

Photo Credits (as they appear):
Cover Photo by Pixabay
Photo by Tim Gouw
Photo by Any Lane
Photo by Christina Morillo
Photo by ThisIsEngineering
Photo by Pavel Danilyuk
Photo by ThisIsEngineering
Photo by Tima Miroshnichenko

Follow me on my Socials:

https://linktr.ee/bradstondev

The Time 8 Developers Reminded Me of the Importance of Community

Bradston Henry — Mon, 01 Aug 2022 15:41:32 +0000

If you've ever met or interacted with me, there is a chance you'd believe I was a "Man of the People" who thrives in community.

And I wouldn't blame you for thinking so. Being a former leader of a breakdance crew, me being pretty involved in my local church and my role in Developer Relations would normally signify that I'm someone who likely gravitates towards people.

But if anything, the exact opposite is true.

The Introvert in Me

For most of my life, I've tried to avoid human interaction, where possible.

In a work/office setting, I always preferred to eat lunch alone and in gaming, I've often avoided online multiplayer games as not to have to "talk" to anyone.

In real life, I keep my phone on silent and avoid group gatherings at all costs, in favor of one-on-one conversations.

But like most other humans, I know intrinsically that living life like I've described above is not good for my overall mental state. Even though I prefer to live as a loner, I've found that over extended period of times, it hasn't put me in a positive place.

Yea... some aspects of managing your social and communal interactions can be good for introverts like myself, but just like everything in life, there is a need for balance.

And one thing that I've gleaned over time is that I rarely am able to remove myself from my hermit-like stupor without some type of reminder of why human connections matter and why community is not just a bonus, but a NEED.

Well, not too long ago, I was once again found myself entering into hermit crab mode. Keeping to myself, minimizing social interactions and overall avoiding community where possible.

Then enters the Asurion Developer Advocacy Program into my life; along with the eight inspiring developers that I've had the privilege to work alongside.

And guess what...

My faith in community (and humanity) has been restored!

So let me explain a bit about how this all happened.

How it all Began

In late February of 2022, I started a new role as Developer Relations Sr. Manager at Asurion. I was beyond excited to be in this new role and was ready to hit the ground running. This was a brand new position at our company and it would be my job to help nurture the already existing developer culture within Asurion and to share that culture with others outside of Asurion.

I immediately began ideating on new initiatives, programs and activities and one of the ideas I came up with was the Asurion Developer Advocacy Program or ADAP. The concept would be to create a program that would teach developers within Asurion all about the basic principles of Developer Advocacy while also focusing on 1-on-1 mentoring to help them build the skills that they desired to grow.

The hope was to find talented developers within Asurion who had a desire to create developer-focused content and to help that desire become a reality. We would cover topics like blogging, video content creation and so much more.

But because this program would be a "First-of-its-Kind" effort, I was careful to temper my expectations as I wasn't sure how well my vision would translate into reality. And being aware that this would be the first ever session of the program, I expected that there would be massive learning curve on the part of all the participants...

Well, the 8 participants who entered the program showed me that the sky's the limit when you put your heart into what you do and that my original expectations were way off.

Enter the Eight

Raymond, Jenaba , Nathan, Luis, Manju, Grace, Robert, and Seth have all shown me what it looks like when talent meets opportunity. And what it looks like to own your progress and push yourself to be greater than you were the day before.

In every possible capacity, these eight developers have blown past any expectations I could have possibly had for them. From enthusiasm, to passion, to teachability, to humility, to flexibility, to expertise; these 8 individuals have given me genuine hope in the future.

Along with each individual giving their best efforts, one of the greatest things that this groups has shown me is that community beats being solo any day! At the time of this writing, we have only completed the first half of the program and I am already seeing the fruit of community.

As we go through lessons on different developer advocacy topics and as the cohort meets together in their "final project" or Capstone Project groups, it becomes so much more apparent how much having a support system to encourage you really matters.

Even though each individual in the program has only interacted virtually, there is a sense of camaraderie that has begun to encompass the group. That camaraderie has shown itself in the form of simple support of someone's effort or just the willingness to review and critique someone else's work. Even this blog is the direct result of the energy that I have received from the group during the times that we meet together.

As of the writing this blog, the ADAP crew has begun releasing new developer-focused content here on Dev.to and even on YouTube.

And I can't answer this question for each person in the program but I wonder how much more difficult it may have been to create each of their pieces of content without the support of the ADAP community?

I can personally say, that without the community that has begun to form through this program, that this blog would have never been written. I have been struggling with the motivation to write for some time, and this group has helped light a fire under my feet and this extends even beyond just blogging.

Since starting the program, I have found myself more motivated to create new ideas in my role as Developer Relations Manager and to explore new creative opportunities in my free-time. Seeing the content that the group has created has inspired me to just go for it (even in the form of me releasing my first ever Tik Tok ...more to come soon!).

For those struggling to find the motivation or desire to push forward in endeavors, creative or otherwise, I encourage you to seek out community. If it's a small group of your co-workers grabbing lunch or participating in one of your hobbies with others in your neighborhood; seek out community!

Incredible things happen when you work alongside like-minded, talented, and motivated people.

So thank you ADAP squad for becoming my community and inspiring me to be the best me that I can possibly be. Thank you for helping this hermit crab come out of his shell!

Do you have any examples of how community has impacted you positively? Or any thoughts about why community matters? Please share your thoughts in the comments! I'd love to hear them!

Check Out Their Work

If you are interested in checking out what the ADAP Peeps have been up to, check out what they've all created in the course of 4-5 short weeks:

I Thought You Moved Here for Music?

Nathan Sepulveda for Developers @ Asurion ・ Jul 22 '22

Essential "this" concepts in JavaScript

Robert Tate for Developers @ Asurion ・ Jul 25 '22

#javascript #beginners #programming #codenewbie

The Why and How of Team Retrospectives

Grace Harders for Developers @ Asurion ・ Jul 25 '22

#productivity #agile #programming

How 'git reset' isn't as scary as it looks.

Raymond Luu for Developers @ Asurion ・ Jul 26 '22

#git

How to Start Working with CSS Grid

Luis Santiago for Developers @ Asurion ・ Jul 27 '22

#css #javascript #cssgrid #webdev

Creative Coding with p5.JS: An inclusive javascript library

Jenaba Sow for Developers @ Asurion ・ Jul 28 '22

#javascript #webdev #beginners #programming

Git Rebase VS Merge VS Squash: How to choose the right one?

mrbellamkonda for Developers @ Asurion ・ Jul 28 '22

#github #programming #versioning

Cover Photo by Ingo Joseph

Photo by RF._.studio from Pexels

==== FOLLOW ME ON SOCIAL MEDIA ====

Dev.to: BradstonDev
Twitter: Bradston Dev
Youtube: BradstonDev
LinkedIn: Bradston Henry

Dear Dev: You Deserve The Best

Bradston Henry — Fri, 11 Mar 2022 20:46:38 +0000

In this blog I speak directly to my Developer, Software Engineer (SWE), Game Developer and aspiring Tech Career family (aka you!).

You deserve better!!

Dare I say, You deserve the best!!

I have been a part of the tech industry and have worked as a "Professional" Developer since mid-2015. And even years before that, I was developing games, publishing apps, and looking for my first real chance at being in the industry. And as I have matriculated through the industry and have grown from a "No Nothing" Dev to a Tech Lead, I have always believed one thing to be true…

"Those who work as developers and build the tech that we use in our daily lives, deserve to work in a positive and respectful work environment"

What breaks my heart the most is to see my fellow devs and tech industry family being torn down on the job. I've known devs across many industries, across many companies and have heard and seen many things. Some good, some bad, some incredible and some abhorrent. And I'd like to share some things I feel that we as devs all deserve in the workplace.

To be clear, I can ONLY speak for myself (and I only speak on my own behalf) but here is what I believe every dev deserves; no matter how junior, how senior or how long they have been in the industry.

Fair and Competitive Compensation

Recently, I saw a post on Twitter where a hiring professional told a story about a recent hire. They said when it was time to offer this recent hire, a candidate at the time, their compensation package, they purposely low-balled the offer and this candidate wasn’t aware they were being low-balled. Maybe it was lack of experience, maybe it was lack of research or maybe it was the lack of confidence to speak up for themselves, but recent hire accepted the offer. The hiring manager proudly proclaimed how they had gotten the hire for a "steal" and that the candidate was to blame and should do better at advocating for themselves.

I don't know why, but this hurt me deeply in my soul. I vividly recall my first job offer for a tech job and I was desperate for experience and for a better income. To be very honest, I would have accepted ANYTHING at the time. I had medical issues I was dealing with, student loans in forbearance and a car that was ticking time bomb. When I got the offer and the recruiter asked me if the compensation package that was offered fit my expectations, I said to her genuinely that I had no idea what I should be asking for and that it would be great to be paid more but that I genuinely would take anything. Looking back, that was a bit foolish to say, but I didn’t know any better. Luckily for me, the recruiter heard me and went to bat for me and got me a 5% increase in pay. I was so grateful!

I was extremely lucky! That 5% may seem miniscule to some but that 5% was LIFE CHANGING!

All Devs deserve to be paid their worth. Yes! It should represent competitive salaries and what makes sense for that role, but at no time should a candidate, new hire, or long time employee wonder if they are receiving what they deserve. I encourage my developer and SWE family to be educated on what is a competitive salary for your skills but I would call on more companies to make sure base pay reflects what's right for those candidates at that time.

A Healthy Work-Life Balance

Let's be honest. This pandemic has been extremely hard on everyone worldwide. We lost friends, family, opportunities and the chance to live life to the full. I can't imagine what each one of you have experienced during this time and I wish I could change it all. But in the mire and muck that has been the last few years, one thing has seemed to have shone through the darkness. That we as people are more than our jobs and more than what we do to pay our bills. We are complex and varied people who need balance in our daily lives to survive.

With the pandemic forcing many of us in our industry to Work-From-Home or to work in some form of modified working environment, I think the issue of work-life balance has begun to come to the forefront.

With many workers having to take on more child care, family, and home responsibilities, companies have begun to realize how real life can be for employees. I’ve seen grace that would have NEVER been given in the past being freely extended to employees and employers providing extra services that benefit their employees outside of work.

I believe this needs to be the standard for all working environments. That all employees are people and that they should be treated more holistically as such.

In the past I’ve had prospective employers explain to me that overtime is not only expected but the standard. That doesn't seem like overtime to me! That seems like too much time 😅

I say all this to say that devs should have the reasonable expectation to work their jobs, putting their full effort into it, but should also have the expectation that when they "clock out" they are free to live out other aspects of their lives to the full. It should never be an expectation for an employee to sacrifice their well-being, health or family for ANY job.

An Employer that Invests in Their Growth

I can still vividly remember the Friday when I got my first job offer in the tech industry. It had been a long arduous road where I had been rejected from jobs so frequently, it was essentially the norm. I was beyond excited but there was one problem; This wasn't the only job that was seriously considering me and I had to make a decision between the two.

Job #1 paid significantly less but promised on-the-job training and Job #2 paid significantly more (2x more) but I was explicitly told that I would not be trained and that it would be "up to me" to learn what I needed to perform the job.

Looking back on that moment, the choice should have been obvious but it was a pretty tough decision for me to make. I was absolutely financially destitute and I knew how much a good paycheck would change my life. But after thinking about it, getting advice, praying and meditating, I decided to take Job #1.

One of the best Decisions I've ever made!

To have an employee that directly invested in my professional growth was truly life-changing. I was not only encouraged to learn new skills and expose myself to new concepts that could help me mature in my career, but there were dedicated resources available to that end. There were online courses, in-office classes, and a culture of continuous learning that truly inspired me.

I didn't know how much I took that for granted until I briefly worked for an employer who did not invest in my growth. Not only did it stifle my personal growth, it limited innovation and improvement in me and my teams day-to-day application development on the job. Without the direct investment from our employer into the employees, it felt as if we were on our own to figure out how to improve.

I want to note that not all employers have the same resources to invest in their employees or developers BUT I do believe any form of investment into your employees growth shows that they care. It shows that they care about the long-term of employees/developers and that they want to see their employees flourish, not just "Get the Job Done".

=====

I feel extremely lucky to be working for an employer that lives out all three of these principles above and I hope to see more employers doing the same! It's my hope that in the future, the above will be the standard in all companies because I truly mean it when I say “Devs deserve the best!

So what do you think developers deserve from their employers? What have you experienced on the job or in your job search that you liked or disliked? And Am I missing anything on this list?

Thank you so much for reading this blog and I wish you all the best!

Onwards and Upwards,

Bradston Henry
Developer Relations Manager at Asurion

==== FOLLOW ME ON SOCIAL MEDIA ====

Twitter: Bradston Dev
Dev.to: @bradstondev
Youtube: Bradston YT
LinkedIn: Bradston Henry

How I Knew DevRel was a Perfect Career Fit

Bradston Henry — Thu, 24 Feb 2022 20:40:10 +0000

Interesting Fact: If you asked me in mid-2020 what Developer Relations (or DevRel) was and what a Developer Relations professional did, I literally would have had no idea what to say.

But a year and half later from having general ignorance on the DevRel profession, I feel that I have found my "career home" in the DevRel space.

For those not super familiar with the concept of DevRel or Developer Relations, DevRel is a somewhat broad concept that essentially encompasses individuals and professionals whose job it is to equip developers with knowledge and create developer focused communities that enable developers to adopt new technologies, learn new skills or excel in their development role as a whole. It's contains a broad spectrum of roles that include Developer Advocates, Tech Evangelists, Developer Marketers, Developer Relations Managers and much more. Fundamentally, it’s individuals who aim to introduce developers to new technologies or aim to create environments that allow developers to thrive.

This was all new to me(as I’ve shared in a talk I did recently at DevRelCon 2021) but I didn’t realize that my technical experience, my life passions, and my personal career/life goals made me a perfect fit for DevRel. And now I can say with confidence and certainty, that I'll be working in this space for many years to come.

So in this blog I want to share a few things that helped to show me that DevRel was a perfect fit for me. These indicators helped me to see how great of a match DevRel was for me and hopefully this helps those who are considering DevRel and are not sure if it may be for them.

1. I Love to See Others Succeed

When I was a kid, I had a big sharing problem. At the beginning of each school year, my parents would send me to school with all my needed school supplies but a few days in, I would be asking for more school supplies. My parents would be abit confused on what happened to everything they had given me but would "re-supply" me. But to my parents dismay, I'd "run out" of supplies very soon thereafter. They were completely confused on what was happening until they went to school for a teacher-parent conference. They learned that their son was well loved by all of his fellow classmates because he was an incredible sharer. Mini-Bradston would just give away all of his school supplies to all his classmates in need, leaving himself with none; much to my parent’s financial detriment.

I share this story because for some reason, this has been an innate part of my personality my whole life. I’ve found that it wasn’t that I enjoy sharing but that I really enjoy seeing other people happy and seeing other people succeed. Even if it means my success is somewhat diminished, I LOVE seeing people grow and get closer to their own goals. And this trait has wonderfully translated into my DevRel life.

From the very beginning, what drew me to DevRel was the idea of helping enable developers to accomplish their goals, either through technology or community. Coming from a development background, I know how meaningful it has been for me to have people teach me new technologies, assist me in my career goals, and encourage me along the way. And to know that I could be in a role that was ALL about other's success was incredibly exciting to me and seemed immensely rewarding.

For me, the idea of being able to help others succeed made me feel that DevRel was for me. And as I have continued to work in this space, I fall more in love with that aspect of it every day. In many ways, DevRel is an extension of what I already desire to do and I look forward to doing it more and more.

2. Creating Content Makes Me Feel Alive

To really illustrate this point, I will directly quote one of my good friends, Kyle Smith, as I believe he perfectly encapsulates how I feel about content creation:

“Being creative is when I feel the most alive. And so, whether it be playing music, or drawing, or game development; something that is that creative outlet. I just enjoy making stuff.”

(Skip to 00:46 to hear the quote)

youtube.com

I cannot express to you how deeply those words resonate in me. It’s hard to describe in words but I absolutely love creating new creative content and trying to make things that express who I am as a person. Throughout my life, creative expression is what has helped me to stay positive in the darkest times and has given me hope when things have truly felt hopeless. It is such an integral part of my character, it’s hard to imagine a day where I’m not actively creating something or thinking about the next thing I'm going to create.

And in that way, DevRel has been a natural fit. From the very first day of my DevRel journey as a Developer Advocate, I went straight into content creation mode. I’ve implemented ideas that engage developers in genuine ways, created videos to illuminate technical content, developed and delivered talks at conferences to reach a broader audience in the DevRel community, and as you can probably guess, write blogs whenever possible.

There are several different expressions of DevRel roles and some are less about content creation than others but from my short time in DevRel, I have seen the most success in come to those who create content genuinely, emphatically and consistently. If the content creation element resonates with you as well, DevRel might resonate with you just as much.

3. Building Community is Second Nature

If you have had a chance engage with my content across the different platforms I publish on, you may have noticed one of my largest tendencies; calling everybody who views or listens to my content family or “fam”. I’m not absolutely sure how that comes across to those who are viewing my content but know that I use the word “family” or “fam” genuinely.

This may not be extremely obvious but I truly desire to connect with people in a meaningful and real way. With everything I do, I hope to create an atmosphere of openness and kindness that could somehow permeate the digital divide. My whole motivation is to create community; to create a world where we ALL feel like we are family and that we ALL think of each other in a positive light that is truly mutually beneficial. An environment where we can all grow and thrive together.

Me and my B-boying (Breakdancing) crew/family after performing for a Jerry Springer Retrospective show at my college back in the day

To me this is how I handle everything in my life. If it’s in my physical family, if it's at my church, if it's on the job or if it’s in the various hobbies I’ve participated in throughout my life with others; my goal is to build community. For me, community is a space that allows those in it to express themselves honestly and to be as authentic as possible. I'm not very interested in making a “cool and exclusive” clubs. But I do love to create truly open environments for those who want to engage and connect with others who would like to do the same.

DevRel naturally tends to draw in those who are community builders. I’ve seen DevRel expressed in its many different forms and it's always all about the people; the developer. In order to be successful in DevRel, you have to humanize the technical experience and find a way to speak to your audience in a real way. It’s definitely possible to be in DevRel and not aim to be a community builder but it feels as if you are fighting against the heart of Developer Relations which focuses on the connection between the people (the developer) and DevRel professionals.

—

For me being in DevRel has been an incredible experience and something that I've been very blessed to have found. Just like any profession or any career field, DevRel isn’t for everyone but for those who find a home in it, it can be a truly rewarding experience.

To be clear, even if none of the things that I wrote above are resonating with you personally, that does not mean DevRel is not for you. This is all from my personal perspective and my hope is that this blog can help someone else who might be considering DevRel and looking for indicators if it might be for them.

Now, To all my DevRel fam out there, What let you know that DevRel was a good fit for you? And for my aspiring DevRel Fam and those considering DevRel, what has drawn you to the space and what makes you think it may be a good fit?

I would LOVE to hear from you all!

As always, Thank you so much for reading this blog!

Take it easy,

Bradston Henry

==== FOLLOW ME ON SOCIAL MEDIA ====

Twitter: Bradston Dev
Dev.to: @bradstondev
Youtube: Bradston YT
LinkedIn: Bradston Henry
Podcast: Super Agile Bros