DEV Community: Jonathan-Bryant19

The Infinite Impact of Technology - My Reasons for Pivoting to Software Engineering

Jonathan-Bryant19 — Thu, 31 Mar 2022 16:40:46 +0000

I was born before the internet and technology took over, and I'm grateful for that.

It's not a nostalgic clinging to the past that I can credit for that gratitude, but rather the fact that I'm caught in an endless loop of amazement. Playing video games on a TV was mind blowing to me as a kid because of the fact that I remember a time before that was normal.

With each new piece of technology that amazement never left. I remember being shocked when my dad showed me how his pager worked. Cell phones came along a little while after and it hit me again. Now, as an adult, I see what's happening with AR/VR, machine learning, and AI and I know the ride is nowhere near over.

When I was around 12 years old my parents bought me a book on programming. I had absolutely no idea what it was talking about but I kept going back to it over and over again. I never got anything substantial out of that book, but my fascination with the inner workings of technology never left.

As much as I was fascinated by technology, the thought of making it my career was never fully explored by the time college rolled around. Whether it be fate, circumstance, or a combination of both, I wound up studying psychology and ultimately entered the field of Applied Behavior Analysis (ABA).

ABA is a set of scientific principles that leverage the fundamentals of learning and motivation in order to change behaviors of social significance. ABA is most well known for its effective use in the treatment of autism and other developmental disorders. I spent nearly 15 years in the field and came to know its inner workings quite well. However, the industry hasn't evolved in ways I expected especially in terms of technology.

Before I go further, I need to admit that I didn't see the value in the iPad when it first came out. When it was released I felt it was just an oversized cell phone without much utility, and even though I was fortunate enough to receive one for Christmas I didn't use it much.

Then I brought it to work with me one day.

You gotta understand that working with children with autism has its own unique challenges, chief among them being fleeting attention and motivation. However, the response I got when I started incorporating an iPad into my sessions was incredible. Suddenly, gaining the attention of my clients and keeping them motivated was much easier and sessions were more productive as a result.

I fully expected to see an onslaught of applications aimed at supporting this niche, but that never happened. Don't get me wrong, there have been tools like Proloquo2Go and CentralReach that have done great things, but there's so much more that can be done.

When I didn't see what I thought should exist, I began working out my ideas and hired freelancers to help start putting things together. That has been a very slow process, due mainly to the fact that it has been self funded.

Around the same time, the company I was working for decided to transition from pen/paper data collection to data collection using tablets. The software exported data in a format that was difficult for employees to manage and the developers recommended we learn to write macros to format the data as needed. I had no idea what a macro was, but I volunteered to give it a shot.

In retrospect, I think that's the moment everything changed. I felt like that 12 year old kid again, only this time I had the mental faculties of an adult and access to Google. Once I realized what was possible I was hooked. I spent as much time as I could spare working on it for three months, but it was worth it. The end result allowed the company to know everything they need to know about a program in order to make clinical decisions quickly. A process that used to take several weeks suddenly took a matter of minutes. It was a game changer.

The more I thought about how technology could impact the quality of care the more I felt it was necessary. According to the CDC, 1 in 44 children in the United States are diagnosed with autism annually. With roughly 3.5 million births per year, that's approximately 80,000 diagnoses annually. Additionally, the average annual cost for ABA services is $60,000. Typically, ABA services begin around 3 years of age and terminate when the child starts school (around 6), which means that approximately 2 billion dollars is spent on ABA treatment annually in the United States.

So who pays for that?

In California, insurance companies were mandated to provide coverage for ABA services back in 2012 and most states have followed suit. Although that has ensured access to care, it has also created a dynamic with pressure to keep the cost of care low.

When all is said and done, there is a clear need to increase the quality and portability of care while decreasing the cost of that care. I believe technology is the means to make that happen and my hope is my shift to software engineering can expedite that goal.

Bust Bugs with the Byebug Bug Debugger

Jonathan-Bryant19 — Thu, 17 Mar 2022 16:48:13 +0000

Byebug is a helpful and easy-to-use debugger made for Ruby. It allows developers to use traditional debugging features to help identify what is happening in a program while it's running. Byebug was created by David Rodriguez in hopes of building a better Ruby debugger.

The core features of Byebug include stepping through a program, setting breakpoints to pause a program, basic REPL functionality, and variable tracking.

Starting Byebug

There are several ways to start a debugging session with Byebug. If you want to start the debugger from the first line of code, you can run your file from the command line and add the "byebug" prefix: $ byebug /path/to/ruby_file.rb. Alternatively, adding the keyword byebug to the source code will trigger a breakpoint and start a byebug session on execution:

def printer(n)

    # breakpoint will trigger here
    byebug

    n.times do |i|
        puts "This is round #{i}"
    end
    puts "hello"
    puts "world"

end

printer(10)

Stopping Byebug

Getting out of a byebug session is just as easy as getting into one. You can terminate a byebug session at any time by using the quit or q command. However, developers should be mindful that code following the current breakpoint will not execute once the byebug session is terminated using quit.

Navigating a Byebug Session

help

It's always great to have quick access to info on what commands you can run while in a byebug session. The help command will return a list of useable commands. help <command-name> will return information specific to that command.

continue

The continue command allows the program to continue running after hitting a breakpoint. The program will continue to run until finishing or hitting another breakpoint. Additionally, when an integer is passed as an argument (e.g., continue 5), the program will execute the number of lines passed as an argument before initiating another breakpoint. Alternatively, the continue! variation will run the program and ignore any future breakpoints.

The next command will execute the next line of code and only the next line of code. However, the next command will step over method calls. It will also accept an integer as an argument and will execute the number of lines passed as the argument.

step

step is similar to next with the key difference being that step will step into (and execute) method calls. Since byebug remembers the last command you entered, simply hitting return/enter will continue running the program one line at a time with each press. Combining this feature with byebug's REPL functionality allows developers to access information about a program's state throughout each step of the program's execution.

In this example, entering next would cause byebug to skip the loop and jump to line 8. Entering step will cause the first line of the loop to run. Subsequent step commands will continue executing the loop. While inside the loop, we can access the value of i at any time using byebug's REPL functionality.

restart

As the name implies, restart will terminate and restart the program in byebug. This could save a few steps as you go through rounds of debugging.

irb

It was a surprise to find that you can enter an IRB or VIM session during a byebug session. Simple type irb to initiate the session. When you exit IRB, you'll be right where you left off in the byebug session.

These commands only begin to scratch the surface of what you can do with byebug. I'd recommend the following resources if you want to take a deeper dive on how to use this fantastic Ruby debugging tool.

Resources

Methods to the Madness - My First 10 Ruby Challenges

Jonathan-Bryant19 — Thu, 10 Mar 2022 04:38:29 +0000

There's no better way to learn a new programming language than just writing code. Having just transitioned from JavaScript to Ruby for the first time, I found myself struggling to find the right method for the job.

Websites like LeetCode and codewars are great for grinding out practice, so I decided to start logging which methods I needed to use and how often. To my surprise, I didn't wind up using the same method more than once across the first 10 Ruby problems I came across on codewars.

Some of these answers I came up with on my own while several others were listed under "Best Practices". Here's my running list of common Ruby methods. I'll update the list as I continue to complete problems in hopes of curating a list of some of the most common and fundamental Ruby methods.

`delete`

Problem for Context
Documentation

The delete method takes an object as an argument and deletes everything from self that is equal to the object. I used the delete method below to remove all vowels from a given string:

def disemvowel(str)
  str.delete "aeiouAEIOU"
end

`slice!`

Problem for Context
Documentation

The slice! method differs from slice in an important way. slice returns the element at a specified index while slice! deletes the element at the specified index and returns the deleted object. I used slice! to remove the first and last characters in a string:

def remove_char(s)
  s.slice!(0)
  s.slice!(-1)
  s
end

`even?` and `odd?`

Problem for Context
Documentation

These are extremely simple methods that can be called directly on integers (since everything in Ruby is an object). I'm used to using % 2 in JavaScript to determine if a number is even or odd, but Ruby simplifies that process immensely. I used .even in a ternary to solve this problem:

def even_or_odd(number)
  number.even? ? "Even" : "Odd"
end

`method`

Problem for Context
Documentation

This is one that I have to keep reading the documentation on. As I understand it, method can be called on an object and, in doing so, creates an object that can be used to invoke a method elsewhere. Here's an example provided by the documentation:

class Thing
  def square(n)
    n*n
  end
end
thing = Thing.new
meth  = thing.method(:square)

meth.call(9)                 #=> 81
[ 1, 2, 3 ].collect(&meth)   #=> [1, 4, 9]

In this example, calling method on thing allows the square method to be called later on. I used method to build a basic calculator:

def basic_op(operator, value1, value2)
  value1.method(operator).(value2)
end

`split`

Problem for Context
Documentation

split is a handy method to keep in your back pocket if you ever need to iterate over a string. split takes a delimiter as an argument and separates a string into substrings based on that delimiter. I used split to break apart a sentence string into individual words in order to determine which word was shortest:

def find_short(s)
  lengths = []
  s.split(" ").each do |w|
    lengths.push(w.length)
  end
  return lengths.min
end

`min` and `max`

Problem for Context
Documentation

min and max are simple range methods that return the maximum or minimum value in a range, respectively. They're exceptionally easy to use and much more straightforward than their JavaScript counterparts. I used max and min to write a few simple range functions:

def min(list)
  list.min
end

def max(list)
  list.max
end

`to_i`

Problem for Context
Documentation

The to_i will convert a string to an integer when called on a string. Again, calling the conversion method directly on the object itself makes running the conversation very simple. I used to_i to parse an integer from a string:

def get_age(age)
  age[0].to_i
end

You down with OOP? Yeah you know me!

Jonathan-Bryant19 — Fri, 25 Feb 2022 04:21:37 +0000

A Beginner's Attempt at Explaining Object Oriented Programming

Wikipedia is great, but when I attempted to look up Object Oriented Programming I was confused after a single sentence:

Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data and code...

Actually, I made it five words in before I had questions if I'm being honest with myself. What's a "programming paradigm"? Once again, Wikipedia to the rescue:

Programming paradigms are a way to classify programming languages based on their features.

Ok, so OOP is a collection of features that leverages the concept of objects. In this post, I'll attempt to explore what an object is along with the main features of OOP.

What's An Object?

The second half of Wikipedia's definition alludes to the idea that objects are made up of data and code. Generally speaking, objects are a collection of data in the form of properties/attributes and code in the form of procedures/methods.

In other words, an object is made up of code that allows the object to do things along with data that gives the object some kind of state.

Think of a motorcycle as an example. If the motorcycle is the object, there might be a method to turn the engine on, speed up, slow down, and turn off. Additionally, there may be data to tell us what color it is, how fast it's going, etc. Ultimately, the object "motorcycle" is a collection of these properties and methods.

Where Do Objects Come From?

An important idea in OOP is the relationship between objects and classes. A class acts like a template for the data and methods associated with the objects the class creates. If our motorcycle is the object, the Harley factory could be the class. The factory stores all the information needed to create a new motorcycle.

What Are the Main Features of OOP?

The dynamic between classes and objects allows for the implementation of features that are advantageous when engineering software.

As part of its programming paradigm, OOP has four main features: Encapsulation, Abstraction, Inheritance, and Polymorphism.

Encapsulation

At this point I just start thinking of things in terms of boxes. The class is a giant box that has a bunch of info regarding how to create objects. Each object the class creates is also its own box. Within each of these classes and object containers is info about that container's state and how it can behave.

Encapsulation is the idea that the information in these containers can be either public or private. The ability to define those privileges gives us the power to define how objects interact with one another.

Abstraction

The bigger a program gets, the more difficult it can be to manage. Let's say it's first thing in the morning and you want/need a cup of coffee. Would you rather build a coffee maker from a pile of parts, or push a button and get on with your day?

Abstraction is the process of stripping away the complex inner workings of a particular feature and exposing only the critical details of an object to its client. The class/object relationship creates a dynamic that allows abstraction to occur.

Inheritance

Often times we have objects that are similar, but not identical. The class/object relationship allows for the creation of objects that vary slightly from one another, but creating those objects would be difficult if done individually. Doing so would require lots of repetitive code. Enter inheritance: the ability for objects to inherit code from other objects.

Let's say we want to build a bunch cars, trucks, and busses. We could build each one from scratch, but that would require a lot of repetition. Instead, we could start with a parent class that has all the info shared by each vehicle (e.g., 4 tires, an engine that turns on and off, brakes, etc.). We can then create more specific classes that inherit all that info from the parent class, but also contain their own specific properties and methods. Using this method, both a sports car and a minivan could inherit the same code from a parent class, eliminating the need to rewrite all that code.

Polymorphism

Polymorphism is the ability to exist in different forms. In the world of OOP, it refers to a dynamic that allows for flexibility with how methods are executed.

It's like filling a glass with water from a pitcher. The water itself doesn't change when you pour it into a glass, but the water is flexible enough to adapt to its new container.

We demonstrate polymorphism by writing code that is flexible in its implementation. For example, a motorcycle might inherit a method for turning on, but that method could be implemented in different ways (e.g., push start, key turn, kick start, etc.).

Sources

Six Steps to Tackle Any Algorithm

Jonathan-Bryant19 — Sun, 30 Jan 2022 21:10:41 +0000

One of the best things about programming is experiencing that moment when everything clicks, the program works, and the problem is solved. I love that feeling and I don't think I'm alone.

You know what sucks though? That moment when the code doesn't work, you have no idea why, and you're being timed. That's not a good feeling and, again, I don't think I'm alone.

I recently started a software engineering bootcamp at Flatiron and have had a steady diet of both feelings over the past few weeks. However, as part of the curriculum I recently received an algorithm for solving algorithms. At first I thought the extra work was, well, just extra work, but having a mental framework to leverage when the way forward isn't clear has proved to be invaluable.

Here is a coding challenging I worked through on Codewars. Honestly, this is a challenge I would have passed on until recently, but armed with a handy problem solving framework I managed to solve it.

Here's how I broke down the problem, step by step.

1. Rewrite the Problem in Your Own Words

Here is the question as written on Codewars:

Your goal in this kata is to implement a difference function, which subtracts one list from another and returns the result.

It should remove all values from list a, which are present in list b keeping their order.

Rewriting helps clarify several things, in particular the input and output data types. I've found it's helpful to look at any test conditions, if provided, to see if there are special circumstances to consider (e.g., blank arrays, invalid inputs, etc). I rewrote the problem as follows:

You are given two arrays of numbers as inputs. Take each number in the second array and remove all instances of that number from the first array. Return an array of the remaining numbers.

2. Write Your Own Test Cases.

This doesn't mean you actually have to write code for unit tests. Simply writing a few instances of the input and expected output of a function can help ensure all expectations of the challenge are considered.

function arrayDiff(a, b) {

}

arrayDiff([1,2,2,2,3,4], [2])
// returns [1,3,4]

arrayDiff([1,2,3,3,4,4], [3,4])
// returns [1,2]

3. Pseudocode the solution.

Personally, this is one of the most valuable steps for me. Writing out how to approach the problem step by step in plain english provides an outline for how to go about solving the problem. This is especially critical as the complexity of the challenge increases.

Another reason to pseudocode is to demonstrate how you would approach a problem even if you can't ultimately solve it. If I were given a problem I'm unable to solve in an interview, I'd rather show the interviewer what I know than sit there in a catatonic stupor.

/*
1. Iterate through the first array and look for the first value of the second array (maybe a for loop?).
  a. If the value exists in the first array, delete it (maybe using splice?). 
2. Repeat the process for each value in the second array (I might need a nested loop here). 
3. Return a single array of values.
*/

4. Code a solution.

Now that we have an outline, it's time to put some code together. Here's what I had for my first attempt at completing step 1:

function arrayDiff(a, b) {
  for ( i = 0; i < a.length; i++) {
    if (a[i] === b[0]) {
      a.splice([i], 1)
    }
  }
  console.log(a)
}

arrayDiff([1,2,2,2,3,4], [2])
// returns [1,2,3,4]

This looked promising at first, but I wasn't getting consistent results using my tests. I found that using splice() this way allowed for repeats to slip through the cracks because of the way the placement of values in the array shift every time splice() is used. To prevent this I iterated through the array backwards:

function arrayDiff(a, b) {
  for ( i = a.length -1; i > -1; i = i - 1) {
    if (a[i] === b[0]) {
      a.splice([i], 1)
    }
  }
  console.log(a)
}

arrayDiff([1,2,2,2,3,4], [2])
// returns [1,3,4]

This solves step 1 for me, but the function does not allow for the b array to be longer than one number. All I need to do at this point is figure out how to loop through the second array. This was my attempt:

function arrayDiff(a, b) {
  for ( j = 0; j < b.length; j++)
    for ( i = a.length -1; i > -1; i = i - 1) {
      if (a[i] === b[j]) {
        a.splice([i], 1)
      }
    }
  console.log(a)
}

arrayDiff([1,2,3,3,4,4], [3,4])
// returns [1,2]

It works! At this point I have code that does it's job, but there are two more steps before I'm ready to submit.

5. Clean Up the Code

A quick review of the function helps to ensure indentations and variable names are clear and clean. I don't have any variables to worry about but my i and j variables really should be switched. Also, I can iterate through the loop backwards by changing j = j - 1 to j--. I'll also change my console.log to return.

function arrayDiff(a, b) {
  for ( i = 0; i < b.length; i++)
    for ( j = a.length -1; j > -1; j--) {
      if (a[j] === b[i]) {
        a.splice([j], 1)
      }
    }
  return a
}

6. Consider Optimization

At this point in my learning I'm just beginning to explore optimization. I wasn't a fan of using a nested loop and I was fairly sure there was a better way to go about solving this.

One of the things I love most about Codewars is the feedback you get after submitting a correct solution. I've had many forehead slap moments after seeing a solution much easier than my own.

Here's what Codewars provided as the top answer under "Best Practices":

function array_diff(a, b) {
  return a.filter(e => !b.includes(e));
}

This was definitely a forehead slap moment. I hadn't considered using filter() in conjunction with includes(). Also, this was also the first time I've seen the bang operator used with an array method.

I'll just go ahead and repeat this process a few thousand times and I think I'll be well on my way to increasing my proficiency as a programmer.

DEV Community: Jonathan-Bryant19

The Infinite Impact of Technology - My Reasons for Pivoting to Software Engineering

Bust Bugs with the Byebug Bug Debugger

Starting Byebug

Stopping Byebug

Navigating a Byebug Session

help

continue

next

step

restart

irb

Resources

Methods to the Madness - My First 10 Ruby Challenges

delete

slice!

even? and odd?

method

split

min and max

to_i

You down with OOP? Yeah you know me!

A Beginner's Attempt at Explaining Object Oriented Programming

What's An Object?

Where Do Objects Come From?

What Are the Main Features of OOP?

Sources

Six Steps to Tackle Any Algorithm

1. Rewrite the Problem in Your Own Words

2. Write Your Own Test Cases.

3. Pseudocode the solution.

4. Code a solution.

5. Clean Up the Code

6. Consider Optimization

`delete`

`slice!`

`even?` and `odd?`

`method`

`split`

`min` and `max`

`to_i`