DEV Community: G Hewitt

Water Intake Program in Ruby: Part 2

G Hewitt — Tue, 26 Nov 2024 23:56:13 +0000

After taking some time to familiarize myself with Ruby, I decided to take a look back at the Water Intake Program I created a few months earlier with the purpose of applying what I learned and (hopefully) simplify my code.

Creating the Program

The first major difference you will see in my code is that it starts with the addition of a class. The best way to describe a class is as a blueprint for creating objects, which makes sense because Ruby is an object-orientated language.

class WaterIntakeCalculator
  attr_accessor :name, :weight, :minutes_exercised, :temperature, :pregnant

After naming the class, I added attributes by using attr_accessor. It is best described as a shortcut that creates methods for each attribute, so we don't have to define these methods individually.

Next, I created instance variables using "@" and put them inside the initialize method to set the starting values for each instance of my WaterIntakeCalculator class. This method should run every time a new object is created from the class.

 def initialize(name, weight, minutes_exercised, temperature, pregnant)
    @name = name
    @weight = weight
    @minutes_exercised = minutes_exercised
    @temperature = temperature
    @pregnant = pregnant
  end

I had trouble understanding the concept of Instance Variables. It started to make more sense once someone explained it to me using this real world example:

Imagine kids sitting at the same table with their lunchboxes from home. Inside their lunchbox, they each have their own food and snacks that make it uniquely theirs. One child might have a turkey sandwich while someone else might have a fruit cup.

In this analogy, the lunchbox is the object I created from the class, the food inside it represents the instance variables, each holding specific values that belong only to their lunchbox.

Just like I did in the first version of this program, I made two methods, one to calculate weight intake and the other to calculate exercise intake. These will come in handy later:

  def calculate_weight_intake
    @weight * 0.5
  end

  def calculate_exercise_intake
    (@minutes_exercised / 30.0) * 12
  end

To wrap it all together, I created a method that calculates the total water intake by combining the weight and exercise intake. This method will also adjust based on the needs of the user. Adding 32 extra ounces if your pregnant, and an additional 16 ounces if the current temperature is higher than 70°F. (In the future, I plan to integrate an API to automatically adjust intake based on real-time temperature.) Finally, I added a method that will convert the total intake into glasses of water (8 ounces each).

def calculate_total_intake
    intake = calculate_weight_intake + calculate_exercise_intake

    intake += 32 if @pregnant.downcase == 'yes'

    intake += 16 if @temperature >= 70

    intake
  end

  def glasses_of_water
    (calculate_total_intake / 8).to_i
  end 
end

To complete the class above, I added the final 'end' to close the WaterIntakeCalculator class definition, while also making sure the code is properly structured and error-free.

def home
  puts "Enter your name:"
  name = gets.chomp

  puts "Hello #{name},
This is a water intake program that will estimate the amount of water you'll have to drink today. 
It will take into consideration:
 - Weight
 - Activity Level
 - Outdoor Temperature
 Let's get started! Are you currently pregnant or breastfeeding? (yes/no)"
 pregnant = gets.chomp

 puts "Next, enter your weight (in pounds):"
 weight = gets.chomp.to_f

 puts "Please enter the amount of minutes exercised today:"
 minutes_exercised = gets.chomp.to_f

 puts "Now let's take into consideration the weather. What is the current temperature?:"
 temperature = gets.chomp.to_i

Everything above may look familiar if you read the first part of my Water Intake post. In the previous version, this script was scattered all across various sections. This time around, I organized it all under the method named 'home' (I couldn't think of a better name). Doing this made my code feel cleaner and easier to follow.

The next few lines following is where things get different:

calculator = WaterIntakeCalculator.new(name, weight, minutes_exercised, temperature, pregnant)

 daily_intake = calculator.calculate_total_intake
 glasses_of_water = calculator.glasses_of_water

Here, I'm creating a new instance for the WaterIntakeCalculator class to hold the user's data for when the program calls for the 'calculate_total_intake' and 'glasses_of_water' methods.

 puts "Thank you #{name}. Your water intake for today is #{daily_intake} ounces. That equates to around #{glasses_of_water} glasses of water. Stay hydrated, my friend!"
end

puts home

Finally, I closed the 'home' method and called it at the end of the file. When I run this program, it will execute everything within that method. Everything runs smoothly!

Conclusion

I’ve transformed my Water Intake Program by structuring it with a class and organizing my code into methods, making it cleaner and easier to understand. It’s exciting to see my growth in Ruby as I apply these concepts to enhance my projects. I look forward to continuing this journey and refining my skills further!

Water Intake Program in Ruby

G Hewitt — Tue, 27 Aug 2024 21:41:07 +0000

To avoid getting stuck in tutorial hell, I decided to create a few small projects to apply the Ruby skills that I'm currently learning and record my progress on my blog.

After spending too many hours wondering what my first official project should be, I decided to work on a water intake program.

The goal of this program is to calculate how many ounces of water a person should drink daily based on their:

Weight
Daily Exercise
Special Circumstances (Pregnant/Breastfeeding, Outdoor temperature, etc.)

After calculating the required ounces of water, I will then tell the program to translate that into glasses of water, where 8 Ounces = 1 Glass.

Water Intake Research

The sources I used to research the calculations for this program are:

University of Missouri System

Kinetico Water Systems

According to both sources, The first thing to calculate when finding out your daily water intake is your weight. The formula for that is:

weight * 0.5 = ounces of water per day

The next step is to find out how many ounces to add to the previous result based on the amount of time you spend exercising that day. It is recommended to add 12 ounces every 30 minutes that you spend exercising. The formula would look like:

previous result + (minutes of exercise / 30 * 12) = ounces of water per day

Lastly, There are special situations where more ounces might be added to the total intake. For example, If someone is pregnant or breastfeeding, they will need to increase their intake by 32 ounces.

The temperature also plays a role in water consumption. In this program, If the current temperature is over 70 degrees, another 16 ounces will be added to the total daily intake.

Creating Program

Since each user will have their own results, I decided to make the program more personal by starting off with asking for their name. To do this, I used the method 'puts' followed by the "Enter your name:" in quotations. doing so will print the string to the console.

Afterwards, the console needs to read input from the the user. That is done by using the 'gets.chomp' the first of these methods, 'gets' allows the user to type their input, in this case, 'name', and turn it into a string. While 'chomp' is used to remove the new line character from the captured string. So far, the editor should look like this:

puts "Enter your name:"

name = gets.chomp

From now on in the program, whatever the user input for 'name' string was, will show up anytime #{name} is present. This is called String Interpolation. After the user provides the program with their name, They will be introduced to text that explains how the program works, and ask if the user is pregnant.

puts "Hello #{name}!
This is a water intake program that will estimate the amount of water you'll have to drink today.
It will take into consideration:
- Weight
- Activity Level
- Outdoor Temperature
Let's get started! Are you currently pregnant or breastfeeding? If so, It is recommended to increase your daily intake by 32 ounces"

pregnant_response = gets.chomp

The 'pregnant_response' string will look for either a 'yes' or 'no' response. This will play a part in the program later on. After the user enters a response, the program will set the 'daily_intake' integer to 0. Doing so allows the variable of 'daily_intake' to start at zero and lets the program track the intake from there.

The program will then ask the user to put in their weight and the amount of minutes that they exercised today. We'll use the same 'gets.chomp' that we used earlier when asked to type your name, but with the addition of '.to_f'. This converts the string into a floating-point number. Which is a number with a decimal point.

daily_intake = 0

puts "Next, enter your weight:"

weight = gets.chomp.to_f

weight_intake = weight.to_f * 0.5

puts "Please enter the amount of minutes exercised today."

minutes_exercised = gets.chomp.to_f

exercise_intake = (minutes_exercised.to_f / 30) * 12

daily_intake = exercise_intake + weight_intake

You might have noticed the two expressions that are typed out under both 'get.chomp' strings. These expressions are what we use to calculate the value of the variable. In the case of the 'weight_intake' variable, we use 'weight' variable multiplied by 0.5. Then we calculate the 'exercise_intake' variable by dividing the 'minutes_exercised' variable by 30 and multiplying that answer by 12.

the final expression shown above takes the answer from both the 'weight_intake' and 'exercise_intake' and adds them together giving you the 'daily_intake' variable.

puts "Now let's take into consideration the weather. What is the current temperature?:"

temperature = gets.chomp.to_i


if pregnant_response == "yes" 
  daily_intake += 32
end

if temperature >= 70
  daily_intake += 16
end

glasses_of_water = daily_intake / 8

puts "Thank you #{name}. You water intake for today is #{daily_intake} ounces. That equates to
around #{glasses_of_water.to_i} glasses of water. Stay hydrated, my friend."

This is where the special circumstances come into play. Earlier in the code, the user was asked if they were pregnant or breastfeeding. If the answered 'yes' to that question. 32 ounces gets added to the final 'daily_intake' number. If the user entered an integer that was greater than 70 when asked what the temperature was, 16 ounces is also added to the final 'daily_intake' number.

Our last expression in the code is used to convert the amount of water in ounces to glasses of water by dividing our final 'daily_intake' by 8.

You might notice that 'glasses_of_water' has a string of '.to_i' instead of '.to_f'. This will round the variable to the nearest whole number. instead of a number with a decimal.

Creating this water intake program was a great way to apply the Ruby skills that I have been learning. I'm excited to continue working on more projects like this and sharing my progress on the blog!

TIL: The Basics of GitHub

G Hewitt — Wed, 26 Jun 2024 15:56:05 +0000

"Every morning we are born again. What we do today is what matters most." — Buddha

When I began writing blog posts earlier this year, I would start off with a quote that reflected my current outlook on life. I think it would be a good idea to continue that tradition here.

Today I learned how to store a static webpage on GitHub. GitHub is used to store code, and keep track of the revisions made to your files. I feel like this will be very useful for collaborating with others.

In addition, I used Codespaces, which is a cloud code editor that is based on VSCode. I was relieved when I saw this because the only code editor I had experience with before this apprenticeship was VSCode. So I felt right at home with Codespaces

After creating a simple "Hello world!" webpage, I deployed the app by using Render. Render is a hosting provider that allows your page to be viewed by anyone.

I had to plug this code into my Codespace in a new file called 'render.yaml'

services:
  - type: web
    name: hello-world
    env: ruby
    plan: free
    buildCommand: "./bin/render-build.sh"
    startCommand: "./bin/render-start.sh"

After doing this and creating a blueprint, I went back to GitHub Pages to deploy my site! I know it's not much, But i feel like this will be a milestone that I will look back on!