DEV Community: Vets Who Code

Ten Things I’ve Learned After Ten Years at Vets Who Code

Jerome Hardaway — Mon, 03 Jun 2024 00:49:39 +0000

Originally posted here.

Introduction

As I reflect on a decade of leading Vets Who Code, the journey from a 27-year-old founder to a seasoned executive director has been nothing short of extraordinary. Over the years, I have accumulated a wealth of knowledge through my own career and by helping countless veterans and military spouses transition into software engineering. Here are ten valuable lessons I've learned during this time.

Document Your Journey

One of the most powerful tools for growth is documenting your journey. Whether you're self-taught, boot camp trained, or college-educated, sharing your learning process publicly can accelerate your career. By doing so, you not only track your progress but also inspire and educate others. This transparency builds a robust community around you.

Pair Programming

Engage in pair programming as much as possible. This collaborative approach accelerates your learning curve and prepares you for real-world job scenarios. The shared experience of problem-solving and code review enhances your skills and fosters a deeper understanding of coding practices.

Network Early and Often

Start networking from day one, regardless of your current expertise. Building relationships within the industry is crucial for long-term success. Attend meetups, join online communities, and stay connected with peers even after landing a job. Networking opens doors to opportunities and keeps you informed about industry trends.

The Value of Mentorship

Mentorship often outweighs formal education in today’s world of democratized learning resources. Finding a mentor who can guide you through the complexities of the tech industry can provide invaluable insights and accelerate your professional development.

Build Solutions, Not Just Projects

Focus on creating solutions that address real-world problems rather than merely completing projects. This mindset shift helps you gain practical, impactful experience and demonstrates your ability to apply knowledge in meaningful ways. Solutions-oriented thinking also makes you more attractive to potential employers.

Depth Over Breadth

When starting out, it's more beneficial to dive deep into a specific area rather than spreading yourself too thin. Mastering a particular skill set or technology can make you a subject matter expert, which is more advantageous than having superficial knowledge across many topics.

Understand Language Ecosystems

Delve into the ecosystems of the programming languages you use. Knowing the tools, libraries, and best practices within these ecosystems allows you to work more efficiently and solve problems more effectively. This comprehensive understanding can distinguish you from other developers.

Cultivate Adaptability

The tech industry is in a constant state of flux. Being adaptable is crucial to staying relevant and resilient amidst these changes. Embrace new technologies, methodologies, and perspectives to continually evolve with the industry.

Commit to Continuous Learning

Never stop learning. The rapid pace of technological advancements means there’s always something new to master. Commit to ongoing education through courses, certifications, and staying updated with the latest industry developments.

Focus on Personal Growth

Prioritize your growth by leveraging the best tools and practices within your field. Understand your strengths and weaknesses, and continually work on improving your skill set. Personal growth fuels professional success and ensures you remain at the top of your game.

Conclusion

My journey with Vets Who Code has been a blend of challenges, triumphs, and continuous learning. These ten lessons encapsulate the essence of what I've discovered over the past decade. Whether you're a budding software engineer or a seasoned veteran, I hope these insights will guide and inspire you on your path to success.

Join Us in Making a Difference
If you believe in the power of coding to transform lives and want to support veterans and military spouses in their journey into tech, consider making a donation to Vets Who Code. Your contribution can help us provide the resources, mentorship, and training necessary to bridge the gap between military service and successful tech careers. Donate Now

Together, we can continue to empower those who have served our country to achieve their full potential in the tech industry.

Your Post-Bootcamp Journey: A Guide to Landing Your First Developer Role

Jerome Hardaway — Mon, 29 May 2023 21:26:13 +0000

Your Post-Bootcamp Journey: A Guide to Landing Your First Developer Role

Congratulations on completing your coding bootcamp! You've already accomplished something remarkable – learning a new set of complex skills in a compressed timeframe. That's no small feat, and it demonstrates your dedication, ability to learn quickly, and passion for technology. Now it's time to build on that foundation and launch your career in tech.

Embracing the Journey Ahead

One of the most exciting things about entering the tech field is that you're joining an industry built on continuous learning and growth. The next 6-12 months will be your opportunity to transform from a bootcamp graduate into a professional developer. Think of this as your personalized apprenticeship period – a time to deepen your knowledge, build your portfolio, and connect with the tech community.

Keep Learning and Practicing

Your bootcamp has given you a strong foundation, but technology evolves rapidly. Create a learning plan that excites you. Look at the incredible array of technologies available and choose the ones that spark your interest.

Whether it's mastering React, diving into cloud services, or exploring mobile development, follow your curiosity.

Set up a schedule that works for you:

Dedicate an hour each day for focused learning
Practice coding challenges regularly
Stay up-to-date with the latest technology trends
Choose specific areas of specialization that interest you

Build Your Portfolio

Your portfolio is where you get to shine. Each project is a chance to demonstrate not just your coding abilities but your unique approach to solving problems.

For each project, include:

A clear problem statement
Your solution approach
Technologies used
Live demos or screenshots
Links to the source code
Your learning process and challenges overcome

For a more detailed checklist to help you build a strong portfolio, check out this guide:

Portfolio Checklist for Software Engineers

Network with Other Developers

One of the best parts about entering tech is joining an incredibly supportive community. Developers love sharing knowledge and helping others grow.

Here's how to get involved:

Attend local meetups and conferences
Join online communities and coding forums
Share what you're learning
Don't be shy about asking questions
Offer help where you can – even as a newcomer, you have valuable perspectives to share

Contribute to Open Source Projects

Contributing to open-source projects is an excellent way to gain real-world experience and improve your coding skills. It demonstrates your commitment to the development community and can help you stand out to potential employers.

Start with:

Finding beginner-friendly projects
Reading documentation
Fixing small bugs or improving documentation
Working on feature enhancements

Prepare for Technical Interviews

Technical interviews are your opportunity to show potential employers not just what you know, but how you think.

Prepare by:

Practicing common coding problems regularly
Understanding data structures and algorithms
Improving problem-solving skills
Preparing to discuss your projects in detail
Approaching challenges with curiosity rather than frustration

Tailor Your Resume and Cover Letter

Your professional narrative matters. When crafting your application materials:

Customize for each role
Highlight relevant skills and experiences
Focus on specific accomplishments
Include metrics where possible
Proofread thoroughly
Showcase your passion for technology

Maintain Balance and Stay Positive

The job search process can be challenging, but maintaining perspective is crucial:

Celebrate small wins and progress
Make time for activities outside coding
Stay connected with your bootcamp cohort
Keep refining your approach based on feedback
Remember that every developer started where you are

Don't Be Afraid to Ask for Help

The tech community values collaboration and mutual support. When you need assistance:

Reach out to bootcamp instructors and classmates
Engage with online communities
Join developer forums
Share your learning journey
Offer help to others when you can

Remember, every successful developer started exactly where you are now. Your bootcamp graduation isn't the end—it's the beginning of an exciting journey in tech. The tech industry needs people like you – individuals who are eager to learn, ready to tackle challenges, and passionate about creating solutions through code.

Stay curious, keep coding, and trust in your ability to grow. With dedication and persistence, you'll build the programming career you've envisioned.

Ready to take the next step in your journey?

Choose one action from this guide and get started today. Your future in tech is waiting!

Why I Created a Portfolio Checklist for JavaScript Engineers

Jerome Hardaway — Wed, 03 May 2023 03:23:46 +0000

Introduction

As someone who has been in the tech industry for a while, I have noticed that many students and new professionals struggle with creating a portfolio that showcases their skills and experience. I have often been approached by students who have questions about how to create a portfolio that stands out and gets noticed by potential employers. This is why I decided to create a portfolio checklist that focuses on the most frequently asked questions that students ask me. My goal was to help newer students ask better questions and get better results.

The Importance of a Portfolio

In the tech industry, a portfolio is crucial for showcasing your skills and experience to potential employers. It's your chance to show what you can do and what you have accomplished. However, many students struggle with creating a portfolio that stands out and accurately represents their skills. With my portfolio checklist, I aim to guide students through the process of creating a portfolio that accurately represents their skills and experience.

The Most Frequently Asked Questions

When creating the portfolio checklist, I focused on the most frequently asked questions that I have received from students. These questions include:

What should I include in my portfolio?
How do I showcase my skills?
How do I choose the right projects to showcase?
How do I make my portfolio stand out?
What do I need on my portfolio that I might not think of?

I hope to help students create portfolios that accurately represent their skills and experience by addressing these questions and providing detailed answers.

Conclusion

Creating a portfolio can be a daunting task, especially for students and new professionals. However, with the right guidance and resources, it can be a great opportunity to showcase your skills and experience to potential employers. By creating a portfolio checklist that focuses on the most frequently asked questions, I hope to guide newer students through the process of creating a portfolio that accurately represents their skills and experience. I encourage all students and new professionals to check out my portfolio checklist and use it as a guide to creating their own successful portfolios.

Check out my portfolio checklist for JavaScript Engineers here.

The Dev Grind is Real

Schuster Braun — Tue, 02 May 2023 19:56:00 +0000

I'm a social media junky and there are all these dev lifestyle accounts. A lot of them put on this fake veneer of happiness and ease about work. But, that's not been my experience.

I wanted to make this post because this peachy perspective is actually detrimental to those joining the industry. I got boot camp students who are afraid to push incomplete git commits because they don't have a shiny veneer. They're afraid to share their authentic selves even though that's the most valuable thing they have.

We should normalize how hard development is. That's why I'm a huge fan of the Developers Swearing Twitter account.

It normalizes that we're out here struggling and it ain't all peaches and rainbows. Sometimes development is banging your head against a wall a whole bunch and then asking for help and it finally clicks. This is normal and in fact healthy.

Here's me troubleshooting build issues

What a great green box on my git chart

You can tell that the day of September 2nd was not fun.

In the end, troubleshooting doesn't mean you're a bad developer. I propose the opposite in fact, because once you get out on the other side usually that knowledge won't go to waste. It's okay to bet on yourself and not always be perfect.

Why Vets Who Code is Becoming an AI-Powered Nonprofit

Jerome Hardaway — Tue, 04 Apr 2023 19:40:29 +0000

Recently, we announced that we are becoming an AI-powered nonprofit. Our organization incorporates AI technologies into its programs and operations to enhance its impact and better serve our community.
So, why is VWC becoming an AI-powered nonprofit? There are several reasons.

Improving Training Programs

First, AI can help the organization improve its training programs. By analyzing data on how veterans learn and progress through the program, VWC can better tailor its curriculum to meet their needs. This can help veterans complete the program more efficiently and tremendously successfully.
For example, by analyzing the performance data of troops while leveraging the GitHub API, we can identify their strengths and weaknesses, which can be used to develop personalized learning plans that meet their individual needs. Additionally, we can use AI to analyze industry trends and identify the most in-demand skills in the tech industry. This information can be used to update the training curriculum to ensure veterans have the skills employers seek.

Tracking Outcomes

Second, AI can help us better track the progress and outcomes of its participants. By analyzing data on job placements, salaries, and other metrics, we can better understand the impact of its programs and make adjustments to improve them. This can help the organization demonstrate the effectiveness of its programs to donors and other stakeholders. In our goal to start serving 2500 veterans and military spouses a year, this will be very important to our scaling.
For example, we can use AI to analyze data on job placements and salaries of its participants. By doing so, we can identify the most successful job placement strategies and adjust its training programs accordingly. Additionally, we can use AI to analyze data on the impact of its training programs on the participants' lives. This information can be used to develop data-driven stories demonstrating our programs' effectiveness to donors and other stakeholders.

Streamlining Operations

Finally, AI can help us streamline our operations efforts. As a lean organization with only one contractor, with both directors being volunteers, this frees up our time and resources to focus on more strategic initiatives by automating specific tasks, such as veteran outreach and grant applications.

In conclusion, our decision to become an AI-powered nonprofit is an intelligent move to help the organization enhance its impact and better serve our community. By leveraging AI technologies, we can improve our training programs, track outcomes more effectively, and streamline operations. We will be using AI to drive positive change and make a difference.

Guide to Accessibility Advocacy

Schuster Braun — Thu, 23 Mar 2023 16:39:25 +0000

You work at a company and some pages of the website aren't addressing accessibility concerns. You don't own those pages, but would like to advocate for accessibility at your company. Here's a guide on how to advocate for accessibility at your company.

Legal exposure

Digital accessibility is a legal requirement as put forth by the Americans with Disabilities Act (ADA).

In February [2023], 181 lawsuits were filed. 86% were filed in New York; MARS KHAIMOV LAW, PLLC filed 47 lawsuits in New York; 7 Plaintiffs filed 44% of lawsuits; and 17% of the litigated websites used overlay tools.
~ https://www.accessibility.com/digital-lawsuits

It's important that companies take accessibility issues seriously because users do. Accessibility is not a nice to have it is a legal requirement like GDPR and privacy compliance.

Build reports

Create a metric that teams can use to move a needle and prove progress. You could use Lighthouse to help you accessibility audit single pages. If you need to do something more at scale and can code you could build an accessibility checker

Path to Success

Once an organization is convinced to make the investment here are some resources to help build on that success and scope work.
IBM Equal Access Toolkit will help you to plan, design, develop, verify, and launch accessible digital products. There is also the A11y Project who also build accessibility tooling and resources.

Documentation is Agile

Schuster Braun — Thu, 23 Mar 2023 15:56:19 +0000

A question came across the Vets Who Code community where they asked about "where does documentation come in the dev process?" They further explained that folks on their team believe that documentation is "anti-agile" and boy I have opinions.

Where does Documentation come into the Dev Process

Different forms of documentation fall into different stages of the dev process for me. Though I probably have a looser definition of what documentation is than some. This is just my ideal workflow

Ticket

I think a general ticket should be started by someone who's not going to take on the work. This is the requirement for building of a system. It's a piece of documentation that will tell you who the owner is.

Design

Depending on complexity of that ticket you may need to get multiple eyes on mapping out a solution. This piece of documentation can be a motivating factor to get everyone's goals aligned and get general expectations of the products.

Epic/User Stories

Again depending on complexity build out general technical user stories that folks should be able to pick up and with the context of the design should be able to execute on (it's okay if there are questions).

Tasks/sub-tasks/User Stories

I'll document all the work that I'm doing (pretty much my standup updates) get turned into sub tasks or comments on my user story. This way, if folks aren't paying attention in standup, which I found often is the case they can check progress via tickets.

Code comments

I think if something doesn't fit the general pattern comment it. If there are side effects that could possibly be unexpected, comment it.

Function/Variable naming

Make them explicit, it's a form of documentation

PR Reviews

Are a type of documentation. When using Git Blame you can find the PR that the piece of code comes from. I've gone back to those PRs to find out the point of the feature.

Confluence/Wikis

Document workflows and full features that folks need to know about to be able to complete certain tasks. These are guides that can be shareable between teams. They're good for onboarding. They also reduce fragility of a team, so folks can feel like they can take time off.

API Docs

If you're building an API that's meant to be consumed by anyone, please set these up for the love of Bob.

Anti-Agile Sentiment

I've heard this anti-agile sentiment before. The challenge here is that they're possibly mis-using the concept.
They could be saying that it's anti-agile because it could feel like waterfall. I've had push back when I do design docs because folks believe that's waterfall. It could be a waterfall practice if it was meant to be a source of truth as opposed to a general plan.
The second reason I've heard folks misuse the "anti-agile" concept is that they believe docs slow teams down. I disagree with the concept that agile means fast. I've always interpreted it as agile means flexible.
In the end though when it comes to documentation I have yet to see a verbal argument win. What I do is document as much as possible. You create the trail of breadcrumbs and people find it and are grateful. Sometimes I'll get told that I'm special and like to document. But honestly if you just have it as a part of your workflow folks eventually join, because you're providing value and people will see it.
Warning it may get frustrating because you're the only one doing it. Or maybe folks will tell you to stop. In any case, documentation is good for you and will help you grow irregardless. A team agreement doesn't have to block you from providing value.

Why basic programming is a pre-req for VetsWhoCode

Schuster Braun — Wed, 01 Feb 2023 22:49:52 +0000

This BYU article shows that there are three basic programming concepts:

Sequence of commands (The right commands in the right order)
Conditional Structures (Do certain things based on a true or false, yes or no decision)
Looping structures (A list of instructions to do more than once)

They further explain the programming strategies of top-down design and pseudo code. These concepts are required to understand to begin a journey of programming.

Basic programming courses can be found all over the internet for free (W3 Schools, Odin Project, Free Code Camp, Net Ninja, etc...). Vets Who Code could create their own basic programming course. By having that knowledge as a part of the pre-work we can assume several characteristics of our candidates. These applicants will have demonstrated the ability to find information on the internet and translate it into runnable code. Furthermore, this is prerequisite knowledge for teaching javascript syntax. We have run into instructors teaching "here's how to loop in Javascript" and students going "okay". Then when they go to enact a loop, they don't understand what the point of it is resulting in their projects not incorporating those concepts. It has led to quite a bit of confusion.

We hope that with this format of the pre-work, we'll be able to have clearer goals when it comes to programming in the boot camp.

Vets Who Code Pre-Work

Schuster Braun — Wed, 01 Feb 2023 22:49:23 +0000

Web Development with Javascript

Welcome to the official Vets Who Code Prework.
This document outlines background work that the troop must complete before starting the course. The prework covers the basics so we can focus on more complex subjects. This means we only teach troops the basics of programming once accepted. Here's an article on our thoughts on why we've set this bar. Completing the prework allows us to focus on introducing troops to programming as a job. Troops will work as if they already have a job by solving the types of problems you would focus on in a team environment instead of working on assignments focused on complete isolation.

Why is basic programming a prereq at Vets Who Code?

Programming is a lot like baking. It's easy to make a cake, but it's also not easy to make a good one. A programmer needs to understand three concepts:

A sequence of commands (The proper commands in the correct order)

Conditional structures (Do certain things based on a true or false, yes or no decision)

Looping structures (A list of instructions to do more than once)

By having that knowledge as a part of the prework, we can assume several characteristics of our candidates. These applicants will have demonstrated the ability to find and translate information on the internet into runnable code.

They have also proven their ability to manage time effectively and meet deadlines. This is important because we will ask our candidates to work in teams and submit work promptly.

Proof of work

The central traits we look for in students are technical problem-solving, consistency, and grit. To demonstrate that we'd like students to demonstrate their understanding of programming basics:

Variable assignment
Basic Math operations
Strings
Conditional logic
Loops
Functions
Arrays
String/Array methods
Objects (properties/methods)

Programming Basic Submission Formats

Use any one of the below formats to get something that you can prove your understanding of the above programming basics.

Running Code
You can upload your code to one of these services and have it run. There will be a shareable URL that you can use to reference this code.

Code Repository

If you know a programming language that isn't easy to run then you can use a code repository. However, please have a detailed README.md document explaining how the code is run and maybe screenshots of what it looks like when it is run.

Work Submission Format

In the Prework text box on the course application form, submit a link to a deployed Github Pages website that has:

A link to the Github Repository holding the website code
A link or image showing the proof of work demonstrating understanding of Programming Basics

Resources

Shaye Howe's Getting to Know HTML explains how to build a web page.
The Odin Project's Javascript Basics course up until Fundamentals Part 4 covers all the programming topics needed for proof of work.

Daily message Slack bot

Schuster Braun — Tue, 31 Jan 2023 17:07:31 +0000

I built a bot that posts for daily code challenges in a VetsWhoCode (VWC) Slack channel.

The first iteration of it was using Slack's workflow builder. I just made a slew of scheduled messages. Each message was a different day. So, when all the messages were posted, I needed to go back in and reschedule with what the new date was. After doing this a few times I felt like it was time for a change.

The next iteration is a super simple Node.js AWS Lambda connected to a daily event bridge trigger. The Lambda sends an authenticated POST request to our Slack app's web hook.

The code reads a markdown file of code challenges delimited by ---. It then divides the number of days in a year by the challenge array length. That way it will post a challenge every day.

Future work that could be done with it is:

Build a Challenge explorer/editor
Update the bot so it could work in multiple channels so you can have different kinds of languages
Setup Continuous Deployment. I currently just log in to the AWS account and manually update the challenges/code.

In the end, it's as simple as I could think to make it. I like to build that way, with room to expand.

Before joining a boot camp program, start here

Schuster Braun — Tue, 10 Jan 2023 17:28:02 +0000

I work at Vets Who Code a programming bootcamp nonprofit and we get a number of folks who reach out and ask whether they would be a good fit for the course and what are some of the prerequisites. I would say that the prerequisite for any code boot camp is going to be a budding passion for coding. Boot camps are fast paced and teach programming syntax and job specific tools. Boot camps are good at teaching how to do loops in a programming language. However, students should know what the point of loops are and how they can be helpful.

There's a spectrum of skill that folks come to a boot camp with. On one side of the spectrum there are folks who want to get into tech, but have never done anything considered tech related before. On the other side of the spectrum are folks who have taken other courses and other boot camps with all the knowledge seeking the network and career services of the boot camp. Along that spectrum there are folks who've played video games, created myspace pages, built their own online stores etc.

The approach of this guide is to list a number of resources and what I find their usefulness is to help determine a learning path to prepare for a boot camp, university, or self learning journey.

Websites

Free Learning platforms

There are a number of free learning platforms to teach development. I think they're great at programming, but I feel they don't get students to a place where they're confident enough to start applying for jobs. I recommend students go through one of these curriculums to learn the basics of at least one programming language.

A few that I like.

Launch School Books (CLI, Git, Ruby, JS)
Free code camp (Javascript)
The Odin Project (Ruby/Javascript)

What is Code

Best for: Intro to coding as a career
Link: What is Code by Paul Ford
Description: A single story devoted to demystifying code and the culture of the people who make it. ~Josh Tyrangiel

Roadmap

Best for: Planning out learning tools/skills
Link: roadmap.sh
Description: List of road maps that outlines the tools/skills to become a developer in a specific field

Video Games

Students who enjoy programming have a distinct advantage to succeeding in a programming learning journey. If you have the ability to play video games. I highly recommend checking these out to help along your programming journey.

Code Combat

Best for: Learning how to code
Link: CodeCombat.com
Description: Teaches programming concepts in the context of Javascript or Python programming languages.

Factorio

Best for: How to think like a programmer
Link: factorio.com
Description: A game in which you build and maintain factories.

Else Heart.Break()

Best for: Basic to intermediate coding
Link: elseheartbreak.com
Description: An actually fun video game that has a story and creates a fake programming language gives the player the ability to change the world around them.

Screeps

Best for: Intermediate to advanced coding
Link: screeps.com
Description: It's an open-source game for programmers, wherein the core mechanic is programming your units' AI. You control your colony by writing JavaScript.

Concurrency in Golang with a Binary Search Problem

Phil Tenteromano — Fri, 24 Jun 2022 18:04:52 +0000

Problem

Solving problems with Go can be a really fun and rewarding experience. In this post, I'll go through a "medium" Leetcode challenge "Find First and Last Position of Element in Sorted Array".

The problem is fairly straight forward - it's a sorted array, so we know we can use Binary Search. However, the array is non-decreasing, meaning that elements are allowed to repeat. We're given the task to return a size-2 array with the start and ending index of where the targeted element exists in the array.

Here is the prompt:

Solution Steps

Try to think of a mental solution for yourself before reading any further.

Ignoring the trivial linear solution, we'll focus on the Binary Search solution. Let's think of the steps:

Binary Search for the target
Split the array into "lower" and "upper"
Binary Search on both, separately
Repeat until both splits no longer find the target

Pretty straight forward, I had a lot of fun solving it with Go - most of the syntax is similar to other languages. One of Go's most important features is how simple it makes Concurrency and multi-threading. It uses a data type called Channels with its native Goroutine to synchronize data across threads. Think of it as async / await in other languages.

Code

We'll make a simple Binary Search method, with runtime of O(log n):

// BinarySearch method
func findTarget(nums []int, target int) int {
    low, high := 0, len(nums) - 1

    for low <= high {
        mid := (high + low) / 2

        if nums[mid] == target {
            return mid
        }

        if nums[mid] < target {
            low = mid + 1
        } else {
            high = mid - 1
        }
    }

    return -1
}

We'll call this method a few times, but on ever-decreasing slices of the array - we'll never call it with the same memory space twice.

Now we can easily find any initial target:

func searchRange(nums []int, target int) []int {
    // Initial Search
    high := findTarget(nums, target)

    // Didn't find it, return early
    if high == -1 {
        return []int{-1, -1}
    }
    // TODO: finish function
}

Here we have the early return, when the target does not exist at all. But now what happens when we find it? Well we need to search up and down the array. We can of course do this linearly, but think about the worst case: what if theres an array of 10 million elements, all target. If we started with the center - now we have to linearly crawl through 5 million elements up and down the array. Not great!

Because of that, we'll stick with Binary Search. Golang allows us to cut up its slice datatype (slices are pretty much arrays, with a lot more flexibility, read more here). Without using concurrency, here's the rest of the method:

func searchRange(nums []int, target int) []int {
// ...

// Found target, lets search left and right
    low := high

    // Search lower half of array
    for {
        temp := findTarget(nums[:low], target)
        if temp == -1 {
            break
        }
        low = temp
    }

    // Search upper half of array
    for {        
        temp := findTarget(nums[high + 1:], target)
        if temp == -1 {
            break
        }
        // temp is reindexed at 0 - account for that
        high += temp + 1
    }

    return []int{low, high}
}

Pretty straight forward, we're just binary searching until we no longer find the element on each slice. Great! This passes on Leetcode, and we can be done. But how can we make this a little better? A primary bottleneck with this code is the fact that the "Upper" search is completely blocked until the "Lower" search completes.

We have an opportunity here - the two for loops are acting on completely separate memory addresses. Let's see what we can do with Goroutines and a Channel, here's the entire completed function, with added concurrency:

func searchRange(nums []int, target int) []int {
    // Initial Search
    high := findTarget(nums, target)

    // Didn't find it, return early
    if high == -1 {
        return []int{-1, -1}
    }

    // Hold our data from the threads
    bounds := make(chan int, 2)

    // Search lower half of array, in its own thread (goroutine)
    go func(low int) {
        for {
            temp := findTarget(nums[:low], target)
            if temp == -1 {
                break
            }
            low = temp
        } 
        // Shovel the lower-bound into the Channel
        bounds<-low
    }(high)

    // Search upper half of array, in its own thread (goroutine)
    go func(high int) {
        for {
            temp := findTarget(nums[high + 1:], target)
            if temp == -1 {
                break
            }
            high += temp + 1
        }
        // Shovel the upper-bound into the Channel
        bounds<-high
    }(high)

    newLow := <-bounds
    newHigh := <-bounds

    // No garauntee which one finishes first, so order them
    if newLow > newHigh {
        newLow, newHigh = newHigh, newLow
    }

    return []int{newLow, newHigh}
}

Now, we create an anonymous function and call it immediately, but we use the go keyword to run a Goroutine. With the scope of the bounds Channel, we can shovel data in and out of it. When pulling data out of the Channel (<-bounds), Go will block until there is actually data there.

This means that both the "lower" and "upper" slices will be processed simultaneously! Congratulations, you just solved a Leetcode challenge using thread-safe concurrency💪🧵!

Follow up

We can also clean this code up a bit by pulling the functions for "lower" and "upper" out into their own methods. This would make the primary searchRange method a bit cleaner. But for the sake of simplicity, I left them in.