DEV Community: David J. Davis

Random Code Prompts and Traumatic Brain Injury

David J. Davis — Mon, 11 Oct 2021 02:48:30 +0000

TLDR;

I used ruby and pointless programming challenges from all over the internet to work on recovering from a Traumatic Brain Injury.

What Happened?

On the 9/15/2021 I was in a major car accident that my daughter and I will struggle with for the rest of our lives, but I don't want to go into many details about that accident. While this post has tangential information I'm going to try to focus on keeping it in the technical realm. That being said I do need to talk about a few injuries. My injuries are quite severe and I'm currently recovering in a nursing home probably for the next couple months. Over simplifying, I have 2 broken legs, a broken shoulder, and a mild traumatic brain injury.

The good thing is I will get over my brain injury, but I have to rehab it just like I would any other limb or muscle. I am over simplifying a lot here, but brain injuries are no joke they can cause you to have a variety of symptoms that could take weeks, months, or years to fix. For me mental slowness in my cognitive reaction times, dizzy spells, short term memory loss, and frustration at my slowed cognitive reaction times are the symptoms I'm working to rehabilitate.

What Am I doing?

I am not a complacent person, I do not take the easy way out of things and I often like to think ahead. As a software engineer I need to get my problem solving skills back up to snuff. I began doing what I find comfortable and distractive enough from other pains, solving stupid code problems. Writing solutions to stupid code problems makes me happy, puts my brain to use, and gives me an escape from the physical and emotional traumas that I'm not ready to face yet.

Code Problems

These problems are small simplistic things on the internet that most likely have no real world implications. Most of them I will treat that way and not refactor, the solution you see is many times to first solution I'm writing.

Day 1 (Fake Binary String Problem)

This problem was taken from a prompt sent out by codewars. The goal was to take any numerical string and turn it into a fake binary string by converting numbers to 1's and 0's. If the number is a 5 or less it is a 0, otherwise it is a 1.

Let me say that this is no where near any real binary strings and I think we could go further with it to fake it better and make a converter and parser, but I stuck to the original params.

def fake_binary(str) 
  arry = str.split('')
  new_arry = []
  arry.each do |int| 
    if int.to_i <= 5
      new_arry.push 0
    else 
      new_arry.push 1
    end 
  end 
  new_arry.join
end 

bin = fake_binary '113843948' 
puts bin # '000100101' 
puts "Solution Correct" if bin == "000100101"

Post Mortem: This was a good day 1 project for me, at the time my cognition was much lower and I was still able to put together a quick solution that worked. At the end of this I had maybe an hour or half hour into it including the time it took to setup a dev environment on the computer I was using. By the end I was getting dizzy, blurred vision, and my right shoulder (broken) was hurting, but I had a viable solution that worked without any major changes and I had some fun.

Day 2 (Longest Word)

This problem was taken from a prompt on eadabit.

The goal is to write a function that finds the longest word in a sentence. If two or more words are found, return the first longest word. I found this task too easy, and know that if it was a realistic task would be to return all the longest words.

sentences = [
    "When we are children we seldom think of the future; This innocence leaves us free to enjoy ourselves as few adults can.",
    "Finding a needle in a haystack isn't hard when every straw is computerized.",
    "I decline the title of Iron Cook and accept the lesser title of Zinc Saucier, which I just made up."
]

def longest_word_singular(sentence)
    words = sentence.scan(/[\w']+/)
    words.max_by(&:length)
end 

def longest_word_multiple(sentence)
    words = sentence.scan(/[\w']+/).sort_by!(&:length).reverse!
    max = words.map(&:length).max
    words.select { |word| word if word.length == max}.join(', ')
end 

puts longest_word_multiple(sentences[0]) # innocence, ourselves
puts longest_word_multiple(sentences[1]) # computerized
puts longest_word_multiple(sentences[2]) # decline, Saucier

puts longest_word_singular(sentences[0]) # innocence
puts longest_word_singular(sentences[1]) # computerized
puts longest_word_singular(sentences[2]) # decline

Post Mortem: I felt a little stronger mentally when dealing with this problem. I even felt strong enough to look at the at a top level and add to the criteria to push myself a little bit. I don't see any obvious refactors with either function and they seem like viable solutions.

Day 3 (COVID Hand Washing Prompt)

I'm not sure where I pulled this one from, but the prompt is as follows. The goal write a program that calculates time spent washing hands during the global pandemic. It takes 21 seconds to wash your hands and help prevent the spread of COVID-19. In one function calculate the number of times a person washes their hands in a day and number of days they follow this routine. Use this function to calculate duration in minutes and seconds.

WASH_TIME = 21

def hand_washing_time(days, washes_per_day)
  seconds = days * (washes_per_day * WASH_TIME)
  minutes_seconds(seconds)
end 

# humanizes the time to something good looking
# i like this result, but when I thought about it I 
# was not keeping with the scope
def humanize_time(seconds)
  Time.at(seconds).utc.strftime("%H:%M:%S")
end 

# this is not something I would really want to do
# however this is the scope of the challenge.
def minutes_seconds(seconds)
  mins = seconds / 60
  remainder = seconds % 60
  "#{mins} Mins #{remainder} Seconds spent washing your hands."
end 

puts hand_washing_time(4, 8) # 11 Mins 12 Seconds spent washing your hands.

Post Mortem: This problem was pretty easy, but I have to be honest with myself I kept veering off the path to complete the goals as defined. I had trouble keeping my mind focused on the task instead of being off coding in tangential sub-tasks.

Day 4 (Matching case but changing string)

This prompt I do not remember where it came from, but the goal was to take a given string and match the input style while changing the output to a different string. So if the string coming in is lowercase the string coming out would be lower case. The same would be true for upper or alternating case styles.

def change_string(str, new_str = "holler") 
  new_str.upcase! if uppercase?(str)
  new_str.downcase! if lowercase?(str)
  new_str = alternating_case(new_str, 0) if alternating_even?(str)
  new_str = alternating_case(new_str, 1) if alternating_odd?(str)
  new_str
end 

def uppercase?(str)
  str == str.upcase
end 

def lowercase?(str)
  str == str.downcase
end 

def alternating_even?(str)
  str == alternating_case(str, 0)
end 

def alternating_odd?(str)
  str == alternating_case(str, 1)
end 

def alternating_case(str, offset = 1)
  if offset == 1 
    str.gsub(/[A-Za-z]/).with_index{|letter, i| i.odd? ? letter.upcase : letter.downcase}
  else 
    str.gsub(/[A-Za-z]/).with_index{|letter, i| i.even? ? letter.upcase : letter.downcase}
  end 
end 

sample = "somestring"
sample2 = "SoMe ReAlLy CoOl StRiNg ThAt DoEs SoMeThInG"
sample3 = "FUNKY MAGIC MAN"

puts change_string(sample) # holler
puts change_string(sample2) # hOlLeR
puts change_string(sample3) # holler

Post Mortem: A little bit stronger of a problem and more fun of a task, but still pretty easy and pretty pointless. However the goal is to slowly get my brain working and wrapping around programming tasks so that I can rehabilitate myself. I will say each day has been a little more progressive and this day was much faster than the days before. My typing is better, my memory and focus is a little better. So I would say not only is this a viable solution it shows that I'm getting a little more normal.

DAY 5 and 6 (Developer Productivity Tasks)

I didn't give up on these days, but I was having some pain and there was some definite concentration loss. I am using a laptop of mine that was setup for different uses, but now that I'm the main user I figure it is okay to setup a development environment. That being said we had some work todo.

Install Homebrew
Use Brewfile to install dependencies
Check dependencies are working properly
Install and setup rbenv
- This includes installing the version of ruby and some gems such as rubocop, rails, and other ones that I use often.
Get text editor up to snuff
- Installing plugins
- Modifying Settings
- Automatic corrections
- Snippets
- Code Smells Detection
- Rubocop

Day 6: (Palindromic Primes)

This problem came from hacker rank I believe, but I'm not 100% on that because I had it written down on day 5. The problem was to define a function that used .lazy method and returned only numbers that were both prime numbers and palindromes. I took this time to make something that felt more like usable ruby. Even though the problem ended up being super pointless from a code standpoint and would probably never be seen in a "production code base".

class PalindromicPrimes
  def initialize(size)
    @size = size
  end

  def palindrome_primes(size)
    1.upto(Float::INFINITY).lazy
     .map { |num| num if prime?(num) && palindrome?(num) }
     .select { |x| x.is_a? Integer}.first(size)
  end

  def prime?(num)
    (2..(num - 1)).each do |multiple|
      return false if (num % multiple).zero?
    end
    true
  end

  def palindrome?(str)
    str.to_s == str.to_s.reverse
  end
end

p = PalindromicPrimes.new(5)
puts p.palindrome_primes(7).inspect # [1, 2, 3, 5, 7, 11, 101]
puts p.palindrome_primes(18).inspect # [1, 2, 3, 5, 7, 11, 101, 131, 151, 181, 191, 313, 353, 373, 383, 727, 757, 787]

Post Mortem: Primes are a bitch to figure out, possibly because the years I've been away from math. To be honest I googled to figure out how to deal with the primes, but I tried to figure it out only from the Math point of view. That being said one of the resources I looked at was a JavaScript solution for doing the same thing. I was really disappointed in the fact that I couldn't map without getting nils in the array and struggled to find another solution. That is why I had to add the select so that we weren't getting all the nils in the final array. Overall a much tougher project, but I feel more confident that I did day 1 and I felt like my brain activity was much better.

Closing Thoughts

I don't know if I'm the first person to try to battle the effects of a Traumatic Brain Injury with programming skills, but I think there is some validity to doing it for those who had the skills prior to having the accident or injury. I feel like it has given me some confidence in my skills and is working my brain for my eventual return to work.

I'm going to keep working on some problems, maybe even try to do some work on some open source repositories. I may even try to do some more writing to really work my brain and snap myself out of this fog.

I think time will be the best way to heal myself, but at least this makes time go by much faster. Thanks for reading.

Plain Ole Ruby Objects

David J. Davis — Fri, 30 Apr 2021 12:43:32 +0000

TRIGGER WARNING && TL;DR
I think that service objects are sometimes over engineered in Rails, when in fact a plain old ruby object would potentially be better. If you are using a gem to manage services, presenters, library modules, etc, then maybe you should reconsider and weight what benefits it provides.

During the Digital Rails Conf this year I watched a video called the The Missing guide to Service Objects;
To me this was an opinionated guide to service objects, but he did discuss multiple ways of handling those service objects and some ways to accomplish it for newcomers to Rails. While it was a great talk I think that my thought process would be refactoring that talk into a "Lets talk about POROs".

To me the best rails setups do the following:

Rails is best used when all things in the Models folder are strictly for setting up and modeling your data, meaning that it directly deals with database data.
The controllers are simple and reference business logic or models directly.
Business Logic is stored in the appropriate name format and is away from the controller logic.

In order to do this you may think, "I need need: #{insert_one}". Service objects, presenters, components, monkey-patches, flying-monkeys, pokémon, modular objects, and widgets.

You might, but most likely they are going to be plain old ruby objects anyway, so call them whatever the hell you want, just focus on a design pattern that works for you and your team.

Why PORO?

To establish why, examine the following code. A simple class that takes a parameter and runs a perform method. Putting it simply this is a service object, but it is also a plain old ruby object.

class Num::SquaredService
  def initialize(num)
    @num = num
  end 

  def call
    @num * @num  
  end 
  alias_method :peform, :call
end

Looking at this file inspector. This assumes that you have access to multiple classes, it determines a type based on a matcher method inside each class. This file inspector can be a factory, it could be in the lib folder, or references as any other name.

class FileInspector::Type
  TYPES = [
    FileInspector::Image,
    FileInspector::Audio,
    FileInspector::Video,
    FileInspector::Text,
    FileInspector::Pdf, 
    FileInspector::Other
  ].freeze

  # Sets up mime type instance
  def initialize(file)
    @mime = `file --b --mime-type #{file}`.strip
  end

  # Determines the Type to be used in another object.
  def inspect
   TYPES.find { |type| type.matches?(@mime) }.name.demodulize
  end
end

With a few keystrokes this PORO can look a lot like a service object, lets do that.

class FileInspector::TypeService
  TYPES = [
    FileInspector::Image,
    FileInspector::Audio,
    FileInspector::Video,
    FileInspector::Text,
    FileInspector::Pdf, 
    FileInspector::Other
  ].freeze

  # Sets up mime type instance
  def initialize(file)
    @mime = `file --b --mime-type #{file}`.strip
  end

  # Determines the Type to be used in another object.
  def call
   TYPES.find { |type| type.matches?(@mime) }.name.demodulize
  end
  alias_method :peform, :call
end

With that, we now have a service object. With a few more changes and some HTML we could turn this into a presenter. My point is that we should be thinking more about the functionality of the object; not the name, or the location of the object in a directory structure.

The reason I lean towards keeping them as POROs is to keep everything simple and keep all classes focusing on a single responsibility. Breaking down big problems to small problems that are easily testable.

Adventures in Ruby

David J. Davis — Wed, 29 Apr 2020 16:49:36 +0000

TLDR;

If you have used include? on an array while evaluating comparisons then you may want to look at sets instead!

INTERLUDE

Before we set off on our quest for knowledge we have to know why this quest is so important. We are not going to be saving a princess from a burning building, but instead 17 million princesses from a select 500 thousand burning buildings. (Truth be told there is no fire in this, but I wanted to add a bit of excitement to the story)

I was recently tasked with parsing a CSV file that had over 17 million records in the file and was roughly 8GB. When given the params I initially said "no problem, that would be a welcomed 2-hour break from my other project". I would soon regret those words when I downloaded the files to see that I needed to combine fields from file A which contained roughly 17.9 million records and file B which contained the IDs for 500 thousand records along with some other data that had already been manually by someone.

THE BATTLES

My first attempt, was not pretty because of my prior experience with modifying CSVs. I had not had to modify anything larger thank 50k items at most, which is 1/10 of the smallest dataset in this task.

My second attempt was feeling around how to parse the data properly and then trying to parse the biggest files. Again it proved to be a failure, but lead me to the correct way of parsing files, just not the correct way of dealing with that much data.

My third attempt was a step in a positive direction, giving me the appearance that I was doing things in a better way, however, looking back at it I added un-needed complexities that hurt the performance rather than boosted it. The concept was simple, create a list of item ID's then be sure there are no duplicates, and finally iterate through the largest file only performing modifications on data that was needed in the final iteration.

My fourth attempt was another positive step because it de-dupped the number of records in the largest file, only processing the ones that need to be processed, but does that inherently add performance.

Looking at both the third and fourth attempts I did fall into a Ruby trap here, instead of thinking in terms of data I was thinking in terms of ruby weaponry. Knowing what I could accomplish easily with Arrays and not looking at that as a potential downfall.

My fifth attempt, well there were many more than 5 attempts, but let us assume for this article that I was smart enough to only do it in 5 attempts with the help of StackOverflow. Basically I got smarter in handling my hashes, writing CSV, and switching to sets for comparisons as recommended from StackOverflow.

This attempt is the attempt that saved all the princesses and put out the fires without even blinking. Before attempt 5 the maximum amount of time I let the script run was about 5 days because of a long weekend. That is an enormous amount of time, but after attempt 5 reprocessing took 7-10 minutes. It made me feel ill, but also very happy.

WEAPON ANALYSIS

My first mistake was unfamiliarity with large datasets leading me down the road to being decapitated by the big O notation dragon who guarded the princesses. Moreover, it reveals that when programming I need to be more cognizant of more performant processes and not just default to things I've done in the past.

Ruby is like having a locker of ready to go weapons that can accomplish tasks quickly, but instead of saving the princesses with my awesome sword of justice, I cut my arm off. It wasn't me who realized this though, it was a user(Casper) on StackOverflow who pointed out my mistake.

My approach was to use an array of items to check for inclusion which in my given subset of objects was going to be a minimum of 500,000 each time I went over a single record in the 17 million records, but in fact I was doing this twice with processed items, so that was growing the number of checks which at its smallest amount was 500,000 and largest was 1 million. This means that 17 million records made a million checks on objects before it ever did any actual processing. Benchmark testing on these items showed me the error of my ways and showed me that the script as I had it in iteration 4 would have finished in 156 days.

I can't blame Ruby, it was doing exactly what I told it to do. Instead I need to blame myself for not thinking of performance in such a simple little script. I can blame in-experience, but I think the biggest thing to look at is the ruts of everyday programming. As a junior developer, you get things working and just try to get by figuring things out, as a senior level developer you need to look more at performance, maintainability, and reliability. In that same retrospect you need to get out of the ruts you may have developed through your working life.

Testing Numbers Arrays VS Sets

I wanted to see what this comparison of sets vs arrays in comparing simple numbers such as an ID. I wrote a simple benchmark test and ran it similarly to running the other script just to see the output or performance of set vs array. In comparisons sets are 14 times faster than arrays and I find that quite amazing!

My Ruby Conf 2019

David J. Davis — Sun, 24 Nov 2019 15:59:12 +0000

Nashville Ruby Conf 2019

Conferences are a great time to reflect on past, future, and present work. This year’s Ruby conference was a great time that included lots of learning, reflection, and auspicious gratitude for my employment and my employer. I really enjoyed the diversity of people that I met at Ruby Conf this year. From the young ladies that had just finished a coding boot camp, to the people who worked at Shopify, a couple of people who work for Pixar, the young man from Sentry who was really interested in what the Libraries does, the excellent speakers, attendees that I merely talked to as we waiting for the keynotes to start, and even community members who worked in other University Libraries.

The Keynotes

Matz gave the opening keynote and started us off with some good insight into the future of Ruby including the features that will be added/removed from Ruby 2.7 and Ruby 3.0. This discussion was even enhanced further by the third day’s Q/A session with Matz. No matter how much Aaron Patterson wants an emoji-based pipeline operator, it will not go into the next release of Ruby (a joke probably better suited for those who attended the Q/A session). The goal for Ruby in the future is to continue to grow as a community and add features that still make the language fun to work with, but also provide the functionality of the other popular languages (Haskell, Elixir, Python, JavaScript).

The other keynotes tended to be a bit political/socially driven, and less technical which seemed off-putting to me, except for the one delivered by Sandi Metz. While I was expecting a technical talk that hinged on object-oriented programming in Ruby; instead I was left floored by a talk about economic dispersity, government intervention in free market that lead to socio-economic inequality, student loan debt, housing loan debts, and an apology by a boomer who was sorry for not recognizing what needed to change. This talk was very brave, passionate, and not a maligning to any one person’s political opinions.

Metaprogramming

Metaprogramming was a very interesting topic that was included in a few topics. Some suggesting metaprogramming for good some, others referencing the more sinister side of metaprogramming. One of the more interesting thoughts and practices with metaprogramming including creating monkey patches to trace bugs. I found this an interesting thought as you can write something that essentially tells you what the problem is in great detail and allows you to fix it in a much faster way than traditional debugging. Another facet was in the ability to make gems for older and newer versions of Ruby by using it to create a “polyfills” for lack of a better term for newer Ruby functionality. Another talk even referenced creating functionality achieved by functional programming languages in Ruby to do very terrible things (those naughty lemurs see functional programming for more).

Functional Programming

There are some interesting things that can be done with functional programming in Ruby. Ruby is an object-oriented programming language, but that is not to say you can use functional programming inside of Ruby. One speaker demonstrated how well written functional programming and well written object-oriented programming tend to look similar because of the single responsibility principle which states that a function or method should only have one responsibility. If you find that your functions do not look as they would in a functional language then you are probably breaking that rule. There are even functions currently in Ruby (lazy, curry, recursive!) that lend a hand to functional programming. Another speaker was very entertaining about his approach to functional programming issues telling a story of a curious lemur who uses concepts from other functional programming languages to do very bad and dangerous things within Ruby. This was more hypothetical things you probably would not do in a serious project but could have merit in trying to find ways to speed up your program in some ways.

Memory Management

A few talks spoke to memory management and parallel programming in Ruby. It looks like things will only get better and better with Ruby moving forward and I’m really excited about performance boosts in Ruby 3. I was happy to get some good tips about setting an environmental variable to set the maximum number of GCC arenas in ruby that helps to speed up all Ruby/Rails applications. MALLOC_ARENA_MAX=2 Another talk leads me to believe that it would be better to use jemalloc to handle the garbage collection and RAM management, but that would require a little more work to get working properly.

Computer Science Concept

Without getting too technical here there were some common computer science problems that were discussed with Ruby examples. Sorting algorithms, Big O notation, and other things that are known as “computer science common knowledge essential to programming”. At the end of it there was a consensus of many of the speakers to say this is good to know, but not required for programming, however, you still get asked these questions in interviews. Not really lumped in with computer science concepts but something really cool and nerdy in the computer science realm was a talk where a person worked to create Ruby on an Apple 2 computer using byte code or assembly language. It was a really awesome interactive presentation that had a ton of work involved in creating it which really goes to show you how versatile programmers can be but also showcasing the passion Ruby developers have for wanting to use Ruby in a variety of platforms.

Conclusion

This was a great conference and this writeup has gone way over my short succinct thought process of “giving the highlights”, but I still feel I have barely scratched the surface. Hearing others having similar problems and struggles that you face with tools you commonly use is a really empowering thing to have to happen. It helps to validate the inner thoughts most developers have at one point in a project such as “I’m not a total idiot” and “I’m on the right track”.

Side Note (maybe ranting)

Many people think that ruby is “dead”, “dying”, and “Just limping along”. I say that is not that case, there are many new startups kicking off each year. Rails continues to grow and gain traction among startups and people who need to create things quickly. I'm noticing substantial activity around the integration with Webpack, React, Stimulus, and other frontend tooling and JS libraries. To illustrate how not dead ruby continues to be, here is a list of people who were looking to hire Ruby developers at Ruby Conf 2019.

ActBlue
AdHawk
Airbnb
Anvyl
Appriss
BackerKit
Bendyworks
Braintree
Cookpad
CoverMyMeds
def method
Doximity
E&E NEWS
Envoy
ezCater
Finalsite
Fleetio
Flexport
Fullscript
General Dynamics
Global Impact
Gravitational
Guild Education
Hover
Invoca
Justworks
Kenna Security
Mastery Logistics Systems
Movable Ink
Nava PBC
Nexmo
Nikola
OMBULABS
OneMain Financial
One Medical
Optoro
Planet Argon
Privia Health
RAMSEY Solutions
ReviewTrackers
Runtastic
Shopify
Simply Business
Snapdocs
SportsEngine
Springbuk
Street Easy
Stripe
Square
Test Double
thoughtbot
Tidelift
TrueCar
Upstart
Vimeo
VisuWell
Vynyl
Zillow