DEV Community: Danny Ramos

Introduction to Testing in Ruby with RSpec

Danny Ramos — Thu, 10 Apr 2025 00:00:22 +0000

Testing is a fundamental part of software development, ensuring your code works as expected and behaves consistently. In this blog post, we’ll cover the essentials of testing in Ruby using the RSpec framework, explore common testing patterns, and offer a hands-on extension exercise to help you solidify your learning.

Why Do We Test?

Before diving into RSpec, let’s address why testing is crucial:

Catch bugs early: Tests help identify errors before they reach production.
Ensure consistency: With tests, you can refactor code confidently, knowing you’re not breaking existing functionality.
Improve collaboration: Tests provide clear expectations for how methods should behave, helping your entire team work with consistent standards.
Save time: Although writing tests takes time upfront, it reduces time spent debugging and fixing issues later.

🛠️ Setting Up RSpec

To start using RSpec for testing Ruby code, you’ll need to install the rspec gem. Run the following command in your terminal:

gem install rspec

Next, initialize RSpec in your project by running:

rspec --init

This creates a /spec directory and an .rspec configuration file. You’ll place your test files in the /spec directory, while your implementation code will live in the /lib directory.

File Structure Example

Here’s how your project should be structured:

.
├── lib
|   └── student.rb              # Your Ruby class
└── spec
    └── student_spec.rb         # Your RSpec tests

🔎 Writing Your First RSpec Test

Let’s write a simple Student class and create a test suite for it using RSpec.

Step 1: Define the Class

First, create the student.rb file in the /lib directory and add the following code:

class Student
  attr_reader :name, :cookies

  def initialize(name)
    @name = name
    @cookies = []
  end

  def add_cookie(cookie)
    @cookies << cookie
  end
end

Step 2: Create the Test File

Next, create the student_spec.rb file in the /spec directory and add the following test suite:

require 'rspec'
require './lib/student'

describe Student do
  describe '#initialize' do
    it 'is an instance of Student' do
      student = Student.new('Penelope')
      expect(student).to be_a(Student)
    end

    it 'has a name' do
      student = Student.new('Penelope')
      expect(student.name).to eq('Penelope')
    end

    it 'has an empty cookie array by default' do
      student = Student.new('Penelope')
      expect(student.cookies).to eq([])
    end
  end

  describe '#add_cookie' do
    it 'adds a cookie to the cookies array' do
      student = Student.new('Penelope')
      student.add_cookie('Chocolate Chip')
      student.add_cookie('Snickerdoodle')

      expect(student.cookies).to eq(['Chocolate Chip', 'Snickerdoodle'])
    end
  end
end

🔥 Understanding RSpec Syntax

Let’s break down the key components of the RSpec test suite:

describe blocks:

Groups related tests, either by class or method.
Example:
describe Student do
Groups all tests related to the Student class.

it blocks:

Defines individual test cases.
Example:
it has a name do
Describes the expected behavior being tested.

Assertions with expect:

Verifies the actual result against the expected outcome.
Syntax
expect(actual).to eq(expected)
Example:
expect(student.name).to eq('Penelope')

All examples together:

require 'rspec'
require './lib/student'

describe Student do
  describe '#initialize' do
    it 'has a name' do
      student = Student.new('Penelope')
      expect(student.name).to eq('Penelope')
    end
  end
end

🚦 SEAT: A Testing Framework Mnemonic

When writing tests, follow the SEAT framework to ensure they are clear and effective:

Setup: Prepare the initial conditions for the test.

Example: student = Student.new('Penelope')

Execution: Call the method you are testing.

Example: student.add_cookie('Chocolate Chip')

Assertion: Verify that the result matches the expectation.

Example: expect(student.cookies).to eq(['Chocolate Chip'])

Teardown: RSpec handles teardown automatically, so you don’t need to worry about cleaning up after each test.

Dynamic and Edge Case Testing

Effective tests account for dynamic functionality and unexpected inputs. Here’s how you can extend your Student tests to cover more cases:

Dynamic Test Example

describe '#initialize' do
  it 'can have different names' do
    student1 = Student.new('James')
    student2 = Student.new('Taylor')

    expect(student1.name).to eq('James')
    expect(student2.name).to eq('Taylor')
  end
end

Edge Case Test Example

Let’s handle unexpected input by assigning a default name if the input is invalid:

class Student
  attr_reader :name, :cookies

  def initialize(name)
    @name = name.is_a?(String) ? name : 'Default Name'
    @cookies = []
  end
end

Test for the edge case:

it 'assigns a default name if given invalid input' do
  student = Student.new(42)
  expect(student.name).to eq('Default Name')
end

Extension Exercise: Practice What You’ve Learned

Now it’s your turn to write and run tests for a new class!

Step 1: Create a Car class
In `lib/car.rb`:

class Car
  attr_reader :make, :year

  def initialize(make, year)
    @make = make
    @year = year
  end

  def drive
    "Honk Honk!"
  end
end

Step 2: Write the Test Suite
In spec/car_spec.rb:

require 'rspec'
require './lib/car'

describe Car do
  describe '#initialize' do
    it 'creates an instance of Car' do
      car = Car.new('Toyota', 2020)
      expect(car).to be_a(Car)
    end

    it 'has a make and year' do
      car = Car.new('Honda', 2018)
      expect(car.make).to eq('Honda')
      expect(car.year).to eq(2018)
    end
  end

  describe '#drive' do
    it 'returns a driving sound' do
      car = Car.new('Ford', 2022)
      expect(car.drive).to eq('Honk Honk!')
    end
  end
end

Challenge: Add more tests to handle edge cases, such as passing invalid year formats or unexpected values.

Key Takeaways

RSpec is a powerful framework for testing Ruby code, helping you catch bugs early and maintain reliable applications.
Following the SEAT framework ensures that your tests are clear and effective.
Practice dynamic and edge case testing to make your code more robust.
Consistent testing habits will save you time and effort as your projects grow.

Next Steps and Resources

Refactor your Ruby projects to include test coverage.
Experiment with different RSpec matchers like .include, .be_nil, and .be_true.

Benchmark It: Optimization Decisions Based on Real Data and Not Vibes

Danny Ramos — Mon, 31 Mar 2025 23:16:32 +0000

The performance of our code is something that we should all care about deeply as developers. We should always be striving to make our code run as quickly and as efficiently as we can, within reason. But that begs the question, how can we objectively measure how fast our code is?

Rather than guessing at what implementation we are considering based purely on vibes, benchmarking can give us empirical data so we can make good decisions. Specifically, we want to do this when we are optimizing code paths, comparing different approaches, and evaluating third-party libraries.

We can’t rely on our instincts and vibes to determine how good our code is, we need data. Ruby has a library for that.

Getting Started

We are going to be using the Benchmark library, which is a part of the Ruby standard library. We start by requiring it.

require 'benchmark'

The first thing we are going to do is measure how long it will take to create an array of one million elements.

require 'benchmark'

time = Benchmark.measure do
  array = Array.new(1_000_000) do |i| 
      i 
  end
end

puts time

We will get an output that looks like this:

0.024869   0.000951   0.025820 (  0.025847)

These numbers represent from right to left:

User CPU time
System CPU time
Total CPU time (user CPU time + system CPU time)
Real Elapsed Time - this is in parentheses.

The real elapsed time is what we are interested in because it represents what users experience. User CPU time is the time spent by the computer executing our code in user mode, which is the Ruby code we have written, the Ruby standard library stuff, code in any gems we are using and the Ruby interpreter. System CPU time is lower level stuff like all of the things our operating system is doing as requested by our Ruby, such as file operations, memory allocation and management, etc.

I Want Prettier!

Admittedly, that output is not that easy to read. So we can take things to the next level. We can use Benchmark.bm to generate a much more readable result and let us compare algorithmic approaches against each other.

This code will do the same thing - create an array of one million elements, but it will do so using three different approaches and then give us a report that will allow us to determine which approach is the best. I want to note that the 10 being passed to the #bm method specifies the width of each column. You can set it to whatever, we are just using 10 because that suits our purposes here.

require 'benchmark'

n = 1_000_000

Benchmark.bm(10) do |x|
  x.report("Array.new:") { Array.new(n) { |i| i } }
  x.report("Range:") { (0...n).to_a }
  x.report("upto:") { 
    array = []
    0.upto(n-1) { |i| array << i }
    array
  }
end

Running that we get output similar to this:

                 user     system      total        real
Array.new:   0.024696   0.000604   0.025300 (  0.025357)
Range:       0.011129   0.001368   0.012497 (  0.012498)
upto:        0.027432   0.001566   0.028998 (  0.029064)

Just with a glance at this, we can tell that using the Range Approach is the fastest.

Warm It Up

An important thing that we should be aware of is that when we benchmark in Ruby, occasionally, the first run of a bit of code will perform differently than in subsequent runs. To address this, we have the very creatively named #bmbm method. What this does is that it will run your code twice. The first time is considered a “rehearsal” in order to warm things up and the second time it does it for realsies. It will provide data for both so you can determine if there was some sort of impact.

Let’s look at an example. We are going to create a large array, and do some stuff to it:

require 'benchmark'

array = (1..1_000_000).to_a
sorted = array.dup
reversed = array.reverse

Benchmark.bmbm(7) do |x|
  x.report("sort:") { array.dup.sort }
  x.report("sort!:") { sorted.dup.sort! }
  x.report("reverse:") { reversed.dup.sort }
end

Running this, we get this result:

Rehearsal --------------------------------------------
sort:      0.005534   0.001237   0.006771 (  0.006823)
sort!:     0.005565   0.001304   0.006869 (  0.006881)
reverse:   0.027210   0.001318   0.028528 (  0.028594)
----------------------------------- total: 0.042168sec

               user     system      total        real
sort:      0.005511   0.001054   0.006565 (  0.006577)
sort!:     0.005554   0.001061   0.006615 (  0.006617)
reverse:   0.026982   0.001266   0.028248 (  0.028336)

The code will tell you how long the rehearsal took. We can see that everything ran just slightly faster.

But Does it Scale?

We can use this library to create a report to show us if our code will scale well.

This bit of code will run the code we are testing four times with different sizes to see how it performs based on how much data it has to deal with.

require 'benchmark'

sizes = [50_000, 100_000, 500_000, 1_000_000]

Benchmark.benchmark(Benchmark::CAPTION, 15, Benchmark::FORMAT, ">total:", ">avg:") do |x|
  results = sizes.map do |size|
    x.report("Array(#{size}):") do
      Array.new(size) { |i| i }
    end
  end

  sum = results.inject(:+)

  [sum, sum / results.size]
end

These are the results generated:

                      user     system      total        real
Array(50000):     0.001398   0.000038   0.001436 (  0.001462)
Array(100000):    0.002823   0.000114   0.002937 (  0.002938)
Array(500000):    0.014158   0.000335   0.014493 (  0.014605)
Array(1000000):   0.028183   0.000675   0.028858 (  0.028969)
>total:           0.046562   0.001162   0.047724 (  0.047974)
>avg:             0.011640   0.000291   0.011931 (  0.011994)

Conclusion

You should be benchmarking your code, and though there are other tools for it, Ruby gives you one in its standard library. With this knowledge, we can make sure that we are making optimization decisions based on real data and not vibes and we can understand performance implications of various algorithmic approaches.

However, remember that performance is only one dimension of good code. Readability and maintainability are generally much more important. The fastest code is not always the best choice.

This blog was written by Turing instructor, Mike Dao.

Be sure to follow us on Instagram, X, and LinkedIn - @Turing_School

Sets are the Data Type Your Code Needs

Danny Ramos — Tue, 25 Mar 2025 23:13:17 +0000

At Turing, we have seven months to teach you programming and software engineering. While we cover a lot of ground, there are still plenty of fascinating topics that don’t make it into the core curriculum. This blog series explores intriguing ideas and concepts we’re passionate about—but don’t typically get to teach.

This blog was originally posted here.

What are sets?

Put into the simplest terms, a set is a unique unordered collection. It's the implementation of the set from mathematical theory, which you might have studied in school. In practical terms, the set helps us efficiently determine whether an item is a part of the collection or not. We can contrast this with an array, which is concerned with what position is the item at.

Why are sets?

Most of the things we can use sets for, we already do with arrays. The problem is that doing so can be incredibly inefficient. In terms of computational efficiency, we can think about the #uniq method. Finding unique elements in an array requires Ruby to scan through the entire array. If we were to use the #include? method, we still scan through the entire array, but we also have to scan through any duplicates that exist in the array as well.

Arrays with duplicate elements also add to memory overhead. These duplicate items consume additional memory but don’t have any new information. Think about an array with a million copies of the string, "Athena" - this array uses a million references to the same data. There may be some object sharing taking place to cut down this overhead, and a million strings isn’t THAT much memory, but we can see how this can balloon for sure when we are storing complex objects and not just simple strings.

We can also encounter some incredibly annoying bugs. When we remove an element from an array, using #delete only removes the first instance in which it encounters the element! You have to end up checking the entire collection to make sure you got all of the things using the #count method, which adds complexity.

Photo by Timo Volz / Unsplash

How do sets fix this?

We get improved computational efficiency, because, under the hood, sets are implemented using hashes - each item in a set is the key in a hash. (We don’t use the values). So when we look to see if a set includes an item, it’s just a hash lookup, which is an O(1) constant time operation, regardless of how large our set is. WOWOWOWOW. Gone are the days where you have to scan an entire collection to see if it had the thing you were looking for.

Memory overhead is a thing of the past. Sets store only unique elements, and it will not add additional copies no matter how many times you add the same thing to it. If you have a large array full of the same data and convert it to a set, the size of that set is just one.

Remember the potential for bugs we were just talking about earlier? Removing elements from a set removes it completely. It obviates the need to go back and ensure that you’ve in fact removed everything. When you add elements to a set, you can’t create duplicates.

Summary of Key Benefits

So before we get into the code and implementation, let’s recap the key advantages, and recap just why we want to use sets when it’s the right choice.

Guaranteed Uniqueness - this one’s the main benefit. Uniqueness is enforced, so never again will we have to worry about duplicates ruining our data or logic.
Performance Advantages - we get almost constant time lookup performance regardless of the size of the data we are working with, as compared to the linear time performance that we get with arrays.
Mathematical Set Operations - we’ll get into this later, but we get access to set math, which allows us to perform operations such as union, intersection, and difference without having to do it by hand.
Clear Code Intent - I always say that Ruby code should be written in a way that your code should express your intent. How better to let people know that this collection of data needs to be unique than by using a set?

Photo by Joshua Fuller / Unsplash

Getting Started With Sets in Ruby

The first thing we have to do to get started with using sets in Ruby is to add the library.

require 'set'

Why? Because sets are not part of the core library, but they are part of the Ruby standard library. I like to think of the difference between the two as such: Things that are in the core library are things you will need in nearly every single project you work on. Strings, arrays, hashes, your basic mathematic operations, enumerables. Things that are in the standard library are things that you MIGHT need. Sets, the JSON stuff, CSV, FileIO, Benchmark, Date, and so on and so forth.

There are a number of ways we can create a set. We can just create an empty set.

set = Set.new
puts set.inspect # => #<Set: {}>

We can create a set from an array!

numbers = [1, 2, 3, 2, 1]
set = Set.new(numbers) 
puts set.inspect # => #<Set: {1, 2, 3} >

Note that when we have an array and that we make a set out of it, it removes any duplicates in the array upon creation of the set.

We have ourselves a #to_set method.

numbers = [1, 2, 3, 2, 1]
set = numbers.to_set
puts set.inspect # => #<Set: {1, 2, 3} >
And finally with a block.

set = Set.new do |s|
    s << 1
    s << 2
    s << 3
    s << 2
    s << 1
end

puts set.inspect # => #<Set: {1, 2, 3} >

Again, notice that with all of these examples, when we create a set, any duplicates found are removed. The set will only contain unique values.

Your First Set Steps

So we now know how to create a set. And no we are not going to make you draw the rest of the owl by jumping into set math. Let's just start at the beginning.

Just like with an array, we can use the shovel operator to add things to a set

fruits = Set.new
puts fruits.inspect  # => #<Set: {}>

fruits << "apple"
puts fruits.inspect  # => #<Set: {"apple"}>

Instead of push, we also have an #add method. Conceptually, push doesn’t really work here, because sets aren’t an ordered collection.

fruits.add("banana")
puts fruits.inspect  # => #<Set: {"apple", "banana"}>

As we have said before, adding a duplicate DOES NOTHING.

fruits << "apple"
puts fruits.inspect  # => #<Set: {"apple", "banana"}>
We can add multiple things at a time using the #merge method.

fruits.merge(["orange", "grape", "banana"])
puts fruits.inspect  # => #<Set: {"apple", "banana", "orange", "grape"}>

We’ve added elements and now we should remove them.

colors = Set.new(["red", "green", "blue", "yellow"])
colors.delete("green")
puts colors.inspect  # => #<Set: {"red", "blue", "yellow"}>

We can also delete items with a conditional.

colors = Set.new(["red", "green", "blue", "yellow"])
colors.delete_if { |color| color.length > 3 }
puts colors.inspect  # => #<Set: {"red"}>

Finally, we can check membership. #include? and #member? are the same thing.

animals = Set.new(["dog", "cat", "bird"])
puts animals.include?("cat")    # => true
puts animals.member?("cat")    # => true

puts animals.include?("cat")    # => false
puts animals.member?("cat")    # => false

Set Operations

So this is where the rubber meets the road. We’ve mentioned previously set operations, but this is what it will look like in code.

Union is where you want to get all of the elements that exist in either set.

set_a = Set.new([1, 2, 3, 4])
set_b = Set.new([3, 4, 5, 6])

union = set_a | set_b
puts union.inspect  # => #<Set: {1, 2, 3, 4, 5, 6}>


Intersection is when you want elements in BOTH sets.

set_a = Set.new([1, 2, 3, 4])
set_b = Set.new([3, 4, 5, 6])

intersection = set_a & set_b
puts intersection.inspect  # => #<Set: {3, 4}>

Difference is when you want elements in set_a but NOT set_b.

set_a = Set.new([1, 2, 3, 4])
set_b = Set.new([3, 4, 5, 6])

difference = set_a - set_b
puts difference.inspect  # => #<Set: {1, 2}>

Finally, we have symmetric difference. I’ve actually never heard this term before, and upon looking it up, I found other names for it that you might find familiar - Disjunctive Union or Exclusive OR.


set_a = Set.new([1, 2, 3, 4])
set_b = Set.new([3, 4, 5, 6])

sym_difference = set_a ^ set_b
puts sym_difference.inspect  # => #<Set: {1, 2, 5, 6}>

Iterating Over Sets

Thankfully, we can use our love, enumerables on sets.

We can keep things simple.

planets = Set.new(["Mercury", "Venus", "Earth", "Mars"])

planets.each do |planet|
  puts "Planet: #{planet}"
end

We can use other methods.

planets = Set.new(["Mercury", "Venus", "Earth", "Mars"])

large_planets = planets.select { |planet| planet.length > 5 }
puts large_planets.inspect  # => #<Set: {"Mercury", "Venus", "Earth"}>

I also suppose we can turn our set back into an array if we really needed to.

planets = Set.new(["Mercury", "Venus", "Earth", "Mars"])

planets_array = planets.to_a
puts "Array: #{planets_array}"  # => Array: ["Mercury", "Venus", "Earth", "Mars"]

When do we use sets over arrays?

We want to use a set when uniqueness is a core part of what we are trying to do.
We want to check membership or if an element is included in the collection SUPER FAST.
We want access to set operations. This is a real-world example with roles:

require 'set'

employees = Set.new(["Alice", "Bob", "Charlie"])
managers = Set.new(["Bob", "Diana"])

# Employees who are also managers
employee_managers = employees & managers
puts employee_managers.inspect  # => #<Set: {"Bob"}>

# Everyone (employees and managers)
all_staff = employees | managers
puts all_staff.inspect  # => #<Set: {"Alice", "Bob", "Charlie", "Diana"}>

# Employees who aren't managers
regular_employees = employees - managers
puts regular_employees.inspect  # => #<Set: {"Alice", "Charlie"}>

# People who are either employees or managers, but not both
exclusive_roles = employees ^ managers
puts exclusive_roles.inspect  # => #<Set: {"Alice", "Charlie", "Diana"}>

You want to reduce memory overhead from duplicates.

When do we use arrays over sets?

Let’s think about the reverse. We want to use arrays when:

Order matters.
When repeated elements represent real data - when duplicates are meaningful.
When position of data in your collection matters.
You need Array methods.

Additional Resources

This blog was written by Turing instructor, Mike Dao.

Be sure to follow Turing School of Software and Design on Instagram, X, and LinkedIn - @Turing_School

Outside Insights: Fireside Chat with Greg Baugues and Jeff Casimir

Danny Ramos — Wed, 12 Mar 2025 21:10:44 +0000

AI is reshaping how we work, learn, and create. In our latest Outside Insights fireside chat, Jeff Casimir, Executive Director of Turing School of Software and Design, sat down with Greg Baugues to talk about the reality of AI in software development, the misconceptions even technical people have, and how AI is becoming an essential tool for the future of coding. The following is a brief recap

AI in Software Development: Where Are We Now?
Many people associate Gen AI with problem solving and simple text manipulation—like summarizing documents or writing cover letters—however, the real power of AI goes far beyond that. During the chat, Greg shared some of the most interesting AI use cases he’s explored, including:

LLMs as non-judgmental coding tutors – AI tools like Claude and Cursor help developers onboard faster, understand complex codebases, and debug issues.
AI-assisted productivity boosts – Developers leveraging AI effectively could see 2x or even 10x improvements in their efficiency.
Tool orchestration and automation – AI is enabling workflows that previously required manual intervention, changing how software is built and maintained.

💡 Want to explore AI-powered tools? Here are the technologies discussed:

Superwhisper – An advanced AI-powered voice transcription tool.
Cursor – An AI-powered code editor that enhances developer productivity.
Claude – A cutting-edge AI assistant for coding, research, and more.

The timestamp to watch a demo of Greg using AI-powered tools to build a Game of Life implementation is 17:30 in the Outside Insight video below.

What’s Next for AI in Software?
It’s clear that nearly every software product will incorporate AI in some way. But what does that mean for developers? Greg shares that you can ask ChatGPT to write you a poem and the poem is awesome, but that is because he isn't a poet. When you review a response that you're a expert in you find that the responses can fall short.

“AI demos tend to be very impressive especially if it's in an area you're not an expert in, and then when you try to adopt it you'll typically find that it falls short or that it does the first 80% really well. Then the last 20% you end up spending 3x more time on trying to get the last 20% than if you had just done it the old fashioned way.”

AI isn’t replacing developers—it’s becoming a critical tool for them. Developers who embrace AI today will have a competitive edge in the job market over the next few years.

Mental Health in Tech: Why Openness Matters
Greg was one of the first people in web development to openly discuss mental health challenges, including bipolar disorder and depression. He emphasized how the conversation has evolved and how important it is for tech professionals to support one another.

In our breakout discussion, we explored questions like:

Should developers be more open about mental health at work?
What are the best onboarding experiences you’ve had with dev tools?
Have you used LLMs in your workflow? What are you learning?

Key Takeaways and Career Advice
For those just starting in tech, Greg’s advice is clear:

“People who say ‘AI is going to replace all the developers’ just haven’t used the tools.”

Instead of fearing AI, learn to leverage it. Experiment, build prototypes, and take advantage of the many free tools available for students and aspiring developers.

Whether you're a junior dev, a career switcher, or an experienced engineer, AI is here to stay—and those who adapt will thrive.

Watch the Full Conversation
📺 Catch the full session here:Outside Insights with Greg Baugues

Connect with Greg Baugues
🌐 Website
🎥 YouTube
💼 LinkedIn

Big thanks to Jeff for hosting this insightful chat. Want to join the conversation? If you're interested in speaking at or joining a future session, reach out!

Mines, Climbing, and Archeology: Unearthing a Tech Path

Danny Ramos — Fri, 20 Sep 2024 11:37:34 +0000

From a young age, Alexa was determined to follow in her father’s footsteps, goatee included, and become an engineer. This led her to the Colorado School of Mines, but after two years, she realized it wasn't the right fit. She found joy in the climbing community but missed the problem-solving challenges of STEM. Encouraged by her roommate, Alexa discovered coding while peeking over her shoulder and decided to pursue software development at Turing. Part of the 2303 cohort, her journey highlights the importance of aligning one's career with personal values and interests, ultimately leading her to a fulfilling role at FactorEarth as a Web Application Engineer.

A Rocky Start ⛰️

Born in the tiny town of San Isabel, Colorado and later growing up in Golden, CO, Alexa had tall aspirations to be like her 6 '10 dad and become an engineer. And she was on track to do so by attending Colorado School of Mines, one of the best engineering schools in the US. However, she soon realized that the rigid and competitive environment wasn't where she wanted to be.

“What drew me to engineering is the combination of solving complex problems and making a real impact on somebody's life… but getting into the Mines coursework I wasn’t feeling that connection. A, my degree was very focused on metallurgy, which I wasn't super interested in, and B, it felt like everyone was there to be the best. And, they just wanted to be better than everyone else. And Mines definitely cultivates that. It creates some incredibly intelligent people, but it also just didn't feel like there was any collaboration happening.”

Despite leaving after completing her second year, she was confident in her decision to seek something that resonated more with her values and interests. She decided to invest more time in her other passions - climbing and coaching. Alexa climbing at Joe’s Valley Utah.

The Spark of Curiosity ✨

After varied positions at Movement Golden Alexa found herself coaching kids. She loved, and still enjoys, being able to guide young minds through problems and see their confidence and strength develop. Even though she had found a role that aligned more with her values and interests, STEM was still in the back of her mind. A turning point came when Alexa's friend, who was pursuing software engineering, would talk about the collaborative community at Turing. As Alexa watched her friend’s progress and heard about the problem-solving aspects of coding, her curiosity was piqued. She began researching possibilities, “I did some light research into other ones, but literally everything was like, yeah, Turing's the best”, said Alexa. The combination of solving complex problems and making a meaningful impact drew her in, and she decided to pursue a career in tech.

“Watching the way she collaborated and the way she was connecting with people and still learning that was what initially made me feel like I could do it. It was collaborative and it was also STEM related. So I was like, okay, these are two things I like.”

Day 1 📋

Right from the get-go Alexa was confident in her decision in the community she was now a part of at Turing. She appreciated the difference in communication and collaboration from her time at Mines. From helping with terminal set up to debugging to group projects Alexa would always find someone to be “stuck” with.

“There was always somebody to be like, you're stuck? Let me help you. Let’s hop in a zoom call, let’s debug. And it felt like nobody got left behind.”

Previously she felt like it was a “misery contest” of people going back and forth of who had more homework or who got less sleep, but at Turing she felt that everyone recognized that they were all in it together. And even after her time at Turing she is still utilizing the resources and community whilst at her first tech job. She references the Joan Clarke Society which is a a group at Turing for underrepresented genders in tech being a great resource navigating one of the only women at her company.

Small Parts 🔹

Embarking on the tough job market after graduation Alexa knew she needed to act fast. She felt the jolt of a new education and the looming reality of running out of savings pushed her to be very intentional with the jobs she applied to.

“I applied to companies that I resonated with in some way. I extensively researched their websites. I wrote good cover letters. Every single one, fully custom cover letter. Like, this is why I love your company. These are the things that I found on your website that I connect with. This is how I'm going to bring my experience. This is why you should hire me.”

She capitalized on her strengths and her knowledge of being on the other side of the interview. From her experience interviewing people at the climbing gym she knew what interviewers look for. She was confident that if she could land an interview she could land an offer. To make the process easier to tackle she applied what she learned at Turing, and started to pseudo code.

“I was like, okay, I need an interview to get a job. What do I need to do to get an interview? And I tried to just break it down into small parts and then optimize those pieces as much as I could.”

The Coffee Chat ☕️

Like many others, Alexa’s approach was all about intentional networking and building community while she applied for jobs. If she cold outreached to 5 people and only heard back from one she saw the new connection as a win. This tactic eventually led her to a coffee chat with someone at the company she works at today.

“I messaged two of the engineers. I heard back from one of them. He happened to be local. We met up at a coffee shop, 15 minutes turned into an hour and a half. And then the next day I like to log on to my zoom interview. And what do you know? He's interviewing me.”

Working with History 📜

Alexa started in her first role after Turing in November 2023 at FactorEarth - an archaeology company based in Golden, Colorado. The small developer team makes the admin process for discovering human made artifacts much more streamlined. Archaeologists have “millions of hours” of paperwork, so Alexa’s team builds a web application that organizes and handles all that, i.e. the not so fun part one has to do after you find bones etc.

“When I was looking for a job, of the big things that I really wanted was I did not want to feel like I was just doing something mindless, regardless of how cool the company was. I really wanted to feel like I was making a difference in some way and actually helping.”

By taking on a new challenge, Alexa found a job in STEM that aligns with her personal values and interests while also helping others. Much like climbing, life and coding is all about problem-solving. There will be moments where something seems impossible but ‘sometimes problem solving is doing the hard work of training’, Alexa pointed out, and that training can be something as simple as a new education in software engineering.

“90 % of coding is failure. And then the other 10 % is when you actually do it and it feels amazing. It's like the best feeling ever.”

Calls to Action

Ready to start your journey in software development? Sign up for a Try Coding workshop—or join the Turing cohort that starts in October.

Be sure to follow us on Instagram @turing_school, X, and LinkedIn.

Visit Turing.edu

New Dad, New to Code: Career Changing into Tech 🌟

Danny Ramos — Fri, 23 Aug 2024 16:20:39 +0000

Culinary School, Supply Chain, and Code

Sometimes you take a chance and completely pivot into an engineering program, only to realize that someone you went to high school with is in the community Slack. That’s exactly what happened to Colby Pearce when he recognized Danny Ramos (me 👼🏽) after starting Mod 1 at Turing. Small world, and go Wolverines! Now a software developer at Nextworld, I got to catch up with Colby—from leaving Parker, CO (where we grew up and home of the Chaparral Wolverines) to attend Johnson and Wales, becoming a supply chain buyer, and ultimately finding his way to Turing.

Supplying Food to Supply Chain

Initially, Colby attended Colorado State University and studied history and business. But like many of us in the midst of late nights studying and partying, he began to wonder, “What am I going to do?” After graduating, he wasn’t really sure what was next but found that he enjoyed working in restaurants. He then attended Johnson and Wales University to earn a culinary arts degree while working. However, the challenging work-life balance in the restaurant industry led him to pursue other career options.

“At that point, I was already married for a couple years. Monday and Tuesday nights were essentially our only shared time off, which after a while I was like, alright, this sucks.”

Combining his education and experience, Colby transitioned into a role as a buyer in supply chain management, working for wholesale food manufacturers for about seven to eight years. However, he was still not finding the work-life balance he was looking for, especially with a child on the way. Being on call nonstop while working in sourcing and transportation during COVID-19 (a “complete nightmare”) motivated him to explore a career in tech. His wife, a product manager, recognized that she had managed many Turing alumni throughout her career at Red Robin and Vista Print, so she suggested he try coding and look into Turing. After attending Turing's Try Coding events, Colby decided to hang up the apron and throw away the company phone and enroll.

“She had developers come on that had gone through the program. So I was like, all right, there's multiple people that are going through this program working at real companies. This seems legit."

New Dad, New to Code

Although he hated the amount of time he was stuck on the phone while writing up emails, Colby enjoyed the problem-solving aspect of the supply chain management role. Even in the kitchen, he was constantly thinking on his feet, so he was pleased to see that coding was very similar.

“Once I got everything down, two weeks into mod two, I would feel like, all right, now I can meet up, help people out, walk through how I try and break through these problems and make practice problems for other people”

However, it didn't start off that way. With no previous experience in software development and having a newborn baby, Colby quickly realized there was going to be an adjustment period.

“It wasn't hard for me to implement code when I figured out what I was trying to do, but for me to wrap my head around concepts and what I was supposed to be trying to do, that was the hard part for me. I struggled pretty bad the first time through Mod two.”

As a new dad, Colby faced the huge challenge of balancing being a dad and a husband with the demands of learning to code. The reality of juggling a newborn and a rigorous coding program quickly set in. He gives props to his wife and the schedule he crafted before starting, sticking to it meticulously throughout the program.

“When I woke up, I would take baby to daycare, come back and then do class. My wife would pick baby up and then I would cook dinner while she did that. We would put him to bed and then I would basically head back downstairs to the basement until 10, 11, or midnight each night and then repeat that.”

Sticking With It

The job search can be…interesting, especially when that search coincides with widespread tech layoffs. "It was pretty brutal," he said, reflecting on how the slowdown in the job market made finding opportunities challenging. Initially, he planned to network and secure a position during his final months at Turing, but the reality didn’t go as expected.

For three months, Colby applied to around 100 different places, often trying to leverage any connection he could find. "I would try and reach out to any potential tie," he shared, but despite his efforts, he wasn’t getting much traction. At one point, he went through a lengthy interview process, only to be ghosted after completing a coding project and final interview.

Taking a much-needed pause from job applications for a family wedding, Colby returned to find a new lead through a college friend’s wife who worked at Nextworld. After reaching out to her, receiving a recommendation, and then applying for a position, Colby faced weeks of silence. However, much like his persistence in understanding how to code, he “just stuck with it” and reached out again before finally getting a response that led to interviews and eventually securing his current role.

No More Work Phone

Colby has now come full circle at Nextworld, where he's been for a little over a year. After years of using similar ERP software in three different supply chain roles, he's now contributing directly to a similar codebase that powers these systems. New to the tech world, he recognizes that he’s continuously learning.

“There's days where I feel like I don't know what I'm doing. Or I just started last week, ya know? But continuing to build on what I've learned there is a win.”

Despite the challenges of changing careers, starting a family, learning to code, and navigating a tough job market, Colby was able to secure a role that fit his needs. He now has the work-life balance that is parallel to his wife’s, unlimited PTO, a hybrid work schedule, a short commute, and no more work-related stress outside of office hours. Although his salary is comparable to his previous supply chain role, he now has more room for growth in his new career… and no more calls in the middle of the night.

Calls to Action

Ready to start your journey in software development? Sign up for a Try Coding workshop—or join the Turing cohort that starts in October. Be sure to follow us on Instagram, X, and LinkedIn.

Career Change: Managing Code School and a Thai Restaurant

Danny Ramos — Wed, 14 Aug 2024 18:39:31 +0000

After receiving degrees in psychology and Japanese, Saki and her mom decided to open up Chada Thai. After 10 years of managing, collaborating, and cleaning a spill or two Saki realized she was living her mom’s dream and not hers. She wanted her own path. In this post Saki, now a software engineer at Ling, breaks down her journey into tech all while still managing Chada Thai and making her passions into her career.

Saki shares:
🔹 The importance of organization and time management.
🔹 How to see networking as an opportunity to hear someone's story.
🔹 Narrowing down the job search.

Chada Code 🍛

Saki was struggling to figure out what her passions were. She knew she wanted to do something on her own, so she broke it down to what her passions were. After some research she recognized how critical developers are to a range of companies. From fashion to language Saki knew she could eventually find a company she was passionate about. All she needed now was the developer education. This is where she came across Turing School of Software and Design.

“So the reason why I even heard of it is because I had a couple of friends go there….high school friends who also had a similar story to me. They didn't really know where they were going in life and what they wanted to do for a career.”

After researching various companies she was interested in, learning from friends’ Turing experience, and having a touch of code experience from the MySpace (thank you, Tom!) days she knew Turing was going to be part of her path. Despite being able to jump into Turing with no experience Saki is a self-described “over-planner”. Before starting and making the decision to join she took courses at Udemy to get familiar with JavaScript, HTML, and CSS.

“I'm a person who is an over-planner. I never step into anything without really knowing what I'm getting into. So, I found that doing a little bit of pre-work and learning what JavaScript is and things like that helped a lot in my transition to begin Turing.”

At Chada Thai, they take pride in being Denver's inaugural Thai restaurant, bringing you the rich and authentic flavors of Thailand.

Daily Special: Organization 📆

Managing a restaurant is no easy task, and Saki quickly realized what made her and her mom successful in the restaurant business was going to prove to be pivotal in her tech journey.

“I would say that the number one thing I noticed that I didn't realize would potentially help me in coding is that I'm very organized.”

Having a background in management, a lot of soft skills within software development were second nature. Saki was able to communicate effectively with other people, work collaboratively, document notes/ideas, and hold to a schedule. Keep in mind, all this was done all while still working at the restaurant, so she not only organized her work life to a T but also her Turing life. OH, and she was a new mom! But she didn’t reveal that til later.

“I'm very good at time management. So the key for me was just organizing my time at Turing, organizing my time at the restaurant, and making sure that I did a lot of pre-work, so that I wasn't completely lost when we were in class. I used class time more for me to ask questions about the work that I had just done for it. And just being really organized helped me a lot.”

Community Channel Watch 👀

Saki managed her time in a way that allowed her to work day and night, but she was surprised by how interactive the Turing community was.

“I really, really enjoyed that aspect, like, the community part, the support that I got from random strangers on the internet. I thought that was really cool.”

However, it wasn’t all work all the time. She appreciated how tight-knit her cohort was and all the avenues of fun that took place.

“We had a fun channel where we just post random things. And then we also had a cohort game channel where we get together and play games... I didn't have so much time for that stuff because I was really busy, but I did enjoy watching other people post and interacting.”

Post Turing

Being a recent grad Saki was well aware of the current job market and how competitive it is, so she began her search early. The Turing program is split into 4 Modules and Saki hit the ground running networking and fine-tuning her LinkedIn during Module 2. She wanted to start the conversation early to get an idea of what the job hunt was like so when her first interview came in Mod 3 she was prepared. However, like any good software developer during the first interview, she bombed it.

“Didn't get the job obviously, but it was a really good experience. I enjoyed actually being able to see what it was like to interview...., so that's kind of where my official job hunt started. ”

After graduation, Saki wanted to keep coding, so she enrolled in a women’s hackathon in order to get another project rolling while on the job hunt. The job hunt can feel like being in limbo, with various avenues to explore and many different things vying for your attention. Saki found it helpful to look into organizations like Women Who Code for opportunities and keeping her coding and networking skills sharp

Passion to Career 🎀

Narrowing down her job search to companies that fit her interests and passions Saki was able to land a role at Ling. What makes Ling unique in the language learning space is that they focus on languages that aren’t taught as frequently. So, a lot of Southeast Asian, Eastern European, and African languages are just some examples of what is on their platform. Before narrowing down her search she was applying to everywhere and anywhere and wasn’t finding much success.

“I decided to only focus on what are my passions, what companies do I actually want to work for?”

At Ling she’s been able to make a large impact looking at the product as a user and as someone who loves learning languages. recently , Saki was placed on a large project where she was initially going to pair with a senior engineer, however because of an increase in workload it ended up being just her. So, capitalizing on her previous experience and new education she took on this project with confidence. A career milestone for her was having that code she worked on recently be merged into production and being able to see it user side and think about all the people around the world doing the same.

Oh yeah, Saki had a Newborn Baby Too!

“I had a baby. I was still working. I was doing Turing and the job hunt. You can do it. No matter what's going on in your life, if you want a career change, things might be crazy, but you can do it. I did it.”

Calls to Action

Ready to start your journey in software development? Sign up for a Try Coding workshop!
Be sure to follow us on Instagram @turing_school, X @turingschool, and LinkedIn.

🌟 Corporate Ladder to Software Developer 🌟

Danny Ramos — Thu, 01 Aug 2024 00:42:39 +0000

2 kids 5 dogs and Work-Life Balance

Anna Johnson spent a lot of her time traveling for her demanding career in retail senior leadership. She wanted to pivot into a career with more work-life balance. Anna decided to enroll in Turing to be home more than just a few days a month and spend quality time with her husband, two kids, and five dogs.

A Family Agreement

Anna gave up the company credit card and hung up her frequent flier miles to go back to school in 2021. Despite being in the 2107 Front End cohort, she is currently a backend developer at Heroku. Before Turing, she was involved in senior leadership and operations, handling new store expansion strategy plans for a startup. However, the amount of travel the job required became taxing.

"I was looking for a career that would offer me a great work-life balance so that I could enjoy what I do and fulfill kind of the professional parts of my goals, but also be able to step away and enjoy my life and be a mom, be a partner, and enjoy life instead of being on a plane 24/7."

After climbing the corporate ladder having the biggest role, she decided to drop everything and start over. She gives big kudos to her husband and kids for supporting her decision and going through the difficult journey alongside her.

“We had a family agreement that mom was gonna be unavailable for a lot of six months and we’re all gonna work really hard to help”

Code School Shopping

After expressing interest in software development to some coworkers, Anna knew what school she wanted to attend, no questions asked.

“I am not a savvy shopper or consumer. Like if I see something, I'm like, instant, doing it.”

In her previous work, she was all too familiar with developers and the engineering team that was responsible for building e-commerce websites. A few of them, being Turing alumni themselves, encouraged her to look into Turing now that it’s been fully remote since 2020. After doing a Try Coding event, she was hooked and decided to enroll.

Continuous Learning

Anna hit the ground running landing a full-stack role at a high growth startup once she finished at Turing. Despite “drinking from a firehose,” she felt more than prepared, learning server side development, APIs, databases, Postgres, SQL, and data queries.

“It was a lot, but it was really fun.”

After 7 months of learning at Turing she found herself learning all over again for another six months, during which she developed a strong understanding of full-stack application work and how backend and frontend infrastructure work together. She credits this fast-paced full-stack role for making her role at Heroku all the easier to get.

Is This Field For Me?

Before landing a job at Heroku, one of the first cloud platforms, and navigating a vigorous high-growth startup, Anna’s experience was similar to many women and underrepresented folks in the tech industry. She found herself experiencing imposter syndrome. Is this field for me? Should I be doing this? Am I smart enough?

“I just had to keep reminding myself that I deserve to be there as much as anybody else. ”

At the end of the day she knew that a career in software is for all. With persistence and their own little personal “zoo at home” anyone can learn software development. As someone who identifies as neurodivergent she emphasized the need for diverse perspectives in tech and reassured others that with the right support and grit, anyone can succeed in the field. Anna reached the top of the corporate ladder and realized she hated it. So, despite having little knowledge in engineering and no previous experience in tech, she knew she deserved to be there as much as anyone else.

Job Search Strategy

“Build, build, build” isn’t only the name of the game at Turing but was also a key strategy for Anna during her job search. She emphasized the importance of networking over simply cold-applying. She reached out to people and built genuine connections to expand her tech connections and community. By sharing her journey with her network and employees of companies she admired, she ultimately was offered an interview because of a LinkedIn post (and because her skillset, of course 😏).

There Isn't Anything To It But To Do It

Despite the tough job market and already having a successful career, Anna just “did it” for a lifestyle change and discovered her love for software architecture. At Heroku, she is discovering her love for helping others can translate in ways other than leadership. Her journey illustrates how a career shift not only leads to more time with your family or Rotten Rottie Rescue but also personal growth.

Calls to Action

Ready to start your journey in software development? Sign up for a Try Coding workshop—or join the Turing cohort that starts in August.

Be sure to follow us on Instagram @turing_school, X @turingschool, and LinkedIn.

Career Change: Corporate Ladder to Software Developer 🌟

Danny Ramos — Thu, 01 Aug 2024 00:42:34 +0000

2 kids 5 dogs and Work-Life Balance

A Family Agreement

"I was looking for a career that would offer me a great work-life balance so that I could enjoy what I do and fulfill kind of the professional parts of my goals, but also be able to step away and enjoy my life and be a mom, be a partner, and enjoy life instead of being on a plane 24/7."

“We had a family agreement that mom was gonna be unavailable for a lot of six months and we’re all gonna work really hard to help”

Code School Shopping

After expressing interest in software development to some coworkers, Anna knew what school she wanted to attend, no questions asked.

“I am not a savvy shopper or consumer. Like if I see something, I'm like, instant, doing it.”

Continuous Learning

“It was a lot, but it was really fun.”

Is This Field For Me?

“I just had to keep reminding myself that I deserve to be there as much as anybody else. ”

Job Search Strategy

There Isn't Anything To It But To Do It

Calls to Action

Ready to start your journey in software development? Sign up for a Try Coding workshop—or join the Turing cohort that starts in August.

Be sure to follow us on Instagram @turing_school, X @turingschool, and LinkedIn.

6 Years of Teaching to 6 Figures

Danny Ramos — Wed, 17 Jul 2024 19:24:57 +0000

With six years of experience in education, Alyssa Joyner shares her journey of transitioning from teacher to Software Developer. Alyssa is now a SWE at Grafana Labs. In this interview, she discusses how she discovered coding, her experience at Turing School of Software and Design, and her job hunt strategy.

Classroom to Code 🎒

Despite having a successful career in education, from running the math department to walking the halls as the assistant principal walkie-talkie in hand, Alyssa was looking for a change. While gaining many skills, memories, and friendships at work she felt that she was reaching her limit within the classroom.

“I kind of hit this kind of a fork in the road, which is like, I can really commit myself to education and continue down this path. Or I can try to pivot and do something that's going to allow me to grow and lean into more aspects of myself.”

So a friend, who was also a teacher and Turing alum, suggested she try coding at a Try Coding event that Turing hosts. After recognizing her skills as an educator were transferable to a career in tech she joined the front-end program. From problem-solving, collaboration, and adaptability she was more than prepared for a career pivot.

Why Turing? 🎓

Alyssa’s coding experience was tinkering with HTML for her Myspace page which ultimately was a whole lot of copy-paste (a developer’s best-kept 🤫 ). However, despite her limited initial coding experience, her passion for learning and problem-solving made her a great fit. Turing’s curriculum deep dives into technical skills, but also develops a student’s ability to tackle ambiguous projects and collaborate effectively, not to mention how to Google (another dev secret 🤫🤫).

I know so many people echo the sentiment of … Turing taught me how to learn

As a former educator, Alyssa was all too familiar with the importance of using various learning resources, asking questions, and adapting to new challenges every day.

As a teacher no two days are the same. And you're constantly having to learn things both from the people around you and the curriculum…constantly leveling up on knowledge…having to think on your feet and just collaborate. And that's software!

On top of learning Object-Oriented Programming, Web Application Development, Professional Web Applications, and Cross-Team Processes and Applications the Software Engineering Program strongly emphasizes collaboration. The Turing student experience mirrors a real-world work environment, where you get constructive feedback and build a strong support system with your peers and instructors. Read about Turing's 10-year refresh here!

Not only was Alyssa interested in the teaching style of Turing but she was impressed by the community. She was able to lean on instructors, alumni, and fellow cohort-mates for help whilst in the program. When she found herself stuck on a problem or needed a rubber-duck (iykyk) she knew someone in her Turing network could help. In case you don’t know - check out this cool article!.

The best thing about Turing is all the layers of support… And I've actually gained some lifelong friends through my cohort, which is really, really cool.

The community at large played an important role in Alyssa’s journey providing support and diverse perspectives. She now pays it forward volunteering her time helping whenever she can with interview preparation or resume review in the same community channels she found to be crucial during her experience.

The Job Hunt 🌎

It's not an easy task to completely change careers and jump into the job hunt, so Alyssa focused on leveraging her personal strengths and building connections after graduating. Instead of networking for a job, which, yes is the goal, she focused on forming genuine relationships with people within the industry to gain insights into their jobs and personal stories. By having these conversations, she practiced telling her story effectively (highlighting her unique background and experiences) eventually landing multiple interviews and her first tech job.

Most of us are career changers coming through Turing, and so how can you actually use that as a strength and be able to talk about that? I think ultimately that's what got me hired…

Lean into the Journey 🫵

Alyssa’s journey started at a fork in the road, or shall I say school hallway? She says she started her tech journey after leaving her career as an assistant principal, but she had already started it with an equipped toolbelt of experience. If she could go back and give advice to Alyssa on that first day of Turing she’d say, “Lean in”. Lean into all the struggles and utilize all the tools you have at your disposal. Coding is not about mastering everything but about the continuous learning process. Lean into an “endless possibility for growth”.

Calls to Action 💫

Ready to start your journey in software development? Sign up for a Try Coding workshop — or join the Turing cohort that starts in August.

Be sure to follow us on Instagram, Twitter, LinkedIn.

What To Know Before Your Next Tech Interview w/ Ian Douglas

Danny Ramos — Tue, 22 Mar 2022 21:36:09 +0000

Twitter@iandouglas736 | LinkedIn

Ian Douglas is a Senior Developer Advocate at Postman and is live-streaming his learning in public on Twitch. He loves developer education in all forms and is a strong proponent of accessible content and diversity in tech. He has about 26 years of professional experience in the industry as a developer, manager, director, DevOps engineer, business owner, freelance developer – AND he loves a good "dad joke". He also live streams twice a week to give people free career advice for getting into the tech industry.

Mi Teacher es su Teacher

While being in code school it's hard to imagine getting that FIRST job. Learning to code is hard enough, but now you have to go through the whole interview process which is also new. So, it was cool to be able to interview one of my previous instructors from the Turing School of Software and Design on how he shares resources to make that process easier for folks. Plus it's even more rad that Ian is rad and so full of interview wisdom and wisdom in general. He told me to throw in “software teacher” in his bio too which was hilarious because he’s pretty much done it all – one of those things being to help me get a new career.

Coder to Teacher 👨🏼‍🏫

“I was born at a young age.” - Ian started off strong with a Dad joke. Ian then explained as he progressed in his career he got to a point where he was mentoring his peers on his team. However, he recognized very quickly that teaching a class of 30 is very different from a 1:1 driver-navigator instance. He had to adjust his teaching style to cater to the scale of knowledge within a classroom which later led to an ideal role in Developer Advocacy at Postman after being at Turing. I remember having a 1:1 call with Ian asking him if DevRel was a possibility out of code school. While eating a bag of seeds he looked at me and said, “you could definitely do but it’ll be hard” (lol) which was enough for me to go for it and sometimes you just need someone to push you in the direction you’re interested in.

“I can change the world by changing your world” - Ian

Techinterview.guide 📓

Ian streams (multiple platforms) on Sundays and Thursdays to help, dare I say, guide individuals on the tech interview process. He has guests every week to get their perspective on topics like how to go about creating a resume. His panel discussions allow for a variety of opinions and answers to questions in the chat. Ian welcomes healthy debate, community stories, and shares all his resources on techinterview.guide.

“When they ask you to tell me about yourself or why you want this job they are asking you to explain how your background and your skillset will make them better - what’re you bringing to the team? – And convince us to hire you.” - Ian

“Get up there and be yourself. Be genuine and authentic.” - Ian

Ok that’s enough Ian quotes but I’m also writing these down and hanging them above my desk. Definitely take some time and listen to this episode. It was such a good time to hangout out with my former instructor, Ian Douglas.

Launchies podcast episode:

An Interview with Interview Expert Ian Douglas

Launchies

Your browser does not support the audio element.

1x initializing... ×

Transcript of Interview

Call To Action

Write us on Twitter @newrelic @muydanny @lolocoding

Build your board of people that will give you feedback + mock interview.

Goodie Bag 🛄

El Dipy song I was obsessed with:

How to Support a Junior in DevRel 👼🏽

Danny Ramos — Thu, 17 Mar 2022 22:10:21 +0000

Mentorship, hiring, and support of juniors in DevRel

On February 22, New Relic brought together a collection of minds for a Twitter Space on Mentorship, hiring, and supporting juniors in DevRel. I had the pleasure of hosting it from the comfort of an Airbnb in Mexico with an absolutely roasted back. That didn't stop me from soaking in all the knowledge that I could from Mo McElaney, Jason Legstorf, and Aisha Blake.

Fishing for compliments and knowledge

First and foremost I really appreciated everyone taking the time out of their day to share their experience as managers with not only me, but the community of folks that listened in. I said during the Twitter Space I felt like I had brought together the collection of minds on DevRel, but what I really meant was the Megatron of DevRel, or the giant Thundercat (was there one?), or any type of super-robo-monster thing that defeats evil - that's exactly what it felt like!

Being the host I got the opportunity to ask all the questions that have been top of mind for me being a junior in DevRel myself. Prior to joining the DevRel team at New Relic I was told that DevRel really is for the “experienced” developer, the one who has been an engineer for years, and can answer all the questions. However, that seems to be an idea of the past. Now, more companies are highlighting juniors “learning in public”. So, I wanted to ask the panel their thoughts on the current state of DevRel and what they are doing to help it evolve as more and more juniors join teams. It was especially nice having Aisha on because she’s my manager, so she gave great insight into all the great things I’m doing. 😈

The recording of the Twitter Space is below if chilling with some headphones in is more your thing. Please tell me if I sound nervous, because I was!

Here👈🏽👈🏽🎧

What Does Mentorship Even Look Like?

Right off the bat, it was really interesting to get Mo, Jason, and Aisha’s take on mentorship. Mo stated mentorship on her team is really “creating spaces for them to connect with each other and learn from one each other”. Jason prefers the idea of “co-growth” or a “community exchange”. He looks more for a relationship between people that exchange information that can assist in career growth, perspective change, or whatever, so we all learn from one another. Aisha agreed with how Mo and Jason spoke about mentoring but I specifically want to highlight how she ends every call. We say our goodbyes and she looks at me and says, “and again, if there is anything you need, I’m here for you.” 😤 Making me feel all supported and seen and stuff!

Learning By Doing 💻

Since DevRel is relatively new, many companies are being thoughtful when creating teams, so juniors aren’t the only ones learning in public. Aisha stated that as a team, New Relic has been innovative but also got things wrong, which is not a bad thing. They (we because I’m on the team hehe) have made a commitment to being thoughtful in the structure and treatment within the team to create a space where we can learn and grow from one another. Shout out to big dawg Jonan Scheffler.

Free Pizza 🍕

Much like many things in this current climate, DevRel has changed and evolved to best cater to the tech community. Meetups, to get free pizza, and conferences were the creme de la creme of DevRel. Now, many communities have been built online, so a lot of DevRel is communication via Twitch, Discord, Community Slack channels, and other social platforms in an effort to support the community. DevRel is continuously changing and so is the community. More and more people are getting into tech and the best way we can grow is by learning from one another.

Goodie Bag of Resources 🛄

Follow me on Twitter because I write less on there @muydanny
Follow New Relic for all the Twitter Space goodness
Follow Launchies
A @newrelic #techpodcast hosted by @muydanny & @lolocoding for early-career devs, or soon-to-be devs, offering advice on navigating career progression. Each season we dive into a specific topic and this season is all about the interview 🚀

Join the New Relic Community Slack
Come and hangout at [{Future}Stack]!!(https://bit.ly/futurestack2022)