DEV Community: Amanda Mendez

More Ruby newbie time: The importance of 'making the invisible visible' as a beginner (featuring the Date class)

Amanda Mendez — Tue, 14 Nov 2023 04:08:47 +0000

Today, a lesson that I've learned throughout my journey as an educator, has cropped up again. That's the importance of breaking things down into smaller, easier-to-grasp parts. One way to do this in programming was introduced in the online class I'm taking. They introduced the concept of 'making the invisible visible' when programming.

How do you do this? By printing as much as you can when you can.

This probably seems obvious after you've had years of experience, or maybe you're already a programming wizard who doesn't even need to use this as a crutch anymore. But for the beginner it's so essential to building a good foundation in programming.

So let's take this example from a little beginner coding challenge:

THE DATE CLASS

Write a program to identify different parts of today's date and print a String result. For any given date, the output should be:

"The year is: XXXX, the calendar day is: X, and the month is: X."

Use the exact same copy ("The year is..."), but replace "X" with your calculated date. Don't forget to require "date"

So where do we start?

Well thanks to some context clues, we know we're going to be working with the Date class.

I think here is the first small part we have to make sure we understand. What is a class and why do we have to use require "date"?

So Date is a class. As I understand it, this means it is a pre-built piece of code that's already been written to make it easier for us so we don't have to create a program that works with dates ourselves.

Phew! Thanks to whoever made the Date class!

Now another important thing to note is that if we want to use this super handy class someone made for us already, it's not already pre-loaded in a default Ruby program, so you have to always start with require "date" to tell Ruby to get access to that pre-made class.

Great so we can write the first part of our program:

require "date"

So what's next?

Well we have access to the Date class now, so let's use it! Erm...How do we use it? Well the simple answer is by combining it with methods. Methods are also prebuilt pieces of code that make our lives easier. So how can we use them?

Well in this example, the method we'll need to use is .today. To use this method, you have to "plug it into" something. In this case, we'll "plug it into" the Date class. I kind of think of the period before the method name as a little plug that connects it to whatever it comes behind. By using this method, we will have access to all the info the program needs to know the current date.

So we can guess that we'll need to plug our .today method into the Date class. Let's say something like this

Date.today

Nice! But we can't really do anything with that. It's kind of just information right now sitting there chilling.

How can we use it? Enter the variable

So I think of variables as boxes. They are boxes we can hold information in. But what if we have tons of boxes? How are we going to remember which box holds what? That's the beauty of variables in our programs. We can label these boxes anything we want to make them easier to keep track of. I think of it like writing in a big permanent marker, a label on a cardboard box.

So how do we box and label. Here's how I would do it:

require "date"
date = Date.today

So I just put all the information that is included in our Date.today method into my box which I've labeled with my big permanent marker 'date'. It's important to note that I could have called it anything really though. I went with 'date' to remember what's in that box more easily.

Ok now enter the whole concept of making the invisible visible. Let's take a peek inside the 'date' box and see what's inside!

The best way to do this is by adding some kind of print function in front of our variable so we can see what's inside. For example:

require "date"
pp date = Date.today

This will allow us to run our program so far, and see exactly what we're working with. After you run your program, the result would be something like this

#<Date: 2023-11-14 ((2460263j,0s,0n),+0s,2299161j)>

Cool! That's all the information that's stored in our 'date' box or variable. We have plenty to work with to complete the date class challenge above! Let's revisit the challenge briefly:

Write a program to identify different parts of today's date and print a String result. For any given date, the output should be:

"The year is: XXXX, the calendar day is: X, and the month is: X."

So we need the four-digit year, day, and month! All of that's already in our 'date' box!

Now we just gotta get it outta there somehow 🤔.

Let's make more boxes!

We need a year, month, and day box. Let's do that first:

require "date"
date = Date.today

#define variables
year =
month = 
day =

Ok we have boxes, but now how do we pull that information out of the bigger date box and put it in the smaller boxes?

The answer is methods! It's going to kind of be like a method-ception idea here, but that's why the box imagery works so well I think. Remember we can plug methods into things with a '.'

How do we do this for the first box or variable called 'year'?

First we have to refer to the box we want to take the information out of. That would be the date box. Then we have to tell it exactly what information to pull out of that box using a method. In this case if we use .year we can pull the year out of the 'date' box!

require "date"
date = Date.today

#define variables
year = date.year
month = 
day =

Now is a great time to apply the 'making the invisible visible' concept we've been talking about. Let's see what's in that new box we made by printing it!

require "date"
date = Date.today

#define variables
pp year = date.year
month = 
day =

The output should be something like this (assuming you're reading this in the year it was written. If not it will be your current year.):

Nice! Now we can just apply the same idea to the remaining two boxes or variables. Here's what we're left with:

require "date"
date = Date.today

#define variables
year = date.year
month = date.month
day = date.year

You can similarly print all the variables to see what they're holding.

Then you just have to cook up your string to print! If you use string interpolation, it's pretty straightforward:

require "date"
date = Date.today

# define variables
year = date.year
month = date.month
day = date.year

# print the string
pp "The year is: #{year}, the calendar day is: #{day}, and the month is: #{month}"

This should complete the challenge! I hope this could help illustrate the concept of 'making the invisible visible' when building your foundations as a programmer. At least it's been helpful to me so far!

Thanks for reading and happy coding! 😀

Ruby newbie time: Grasping "array-ception" in Ruby

Amanda Mendez — Thu, 09 Nov 2023 01:02:10 +0000

Being fairly new to programming, I start struggling following the logic of the code once I hit topics like loops, arrays, or hash. Not to mention when they all start to combine. Then my head kind of just starts exploding. 🤯

Today I'm learning Ruby and worked on this (courtesy Codeacademy's Learn Ruby course):

s = [["ham", "swiss"], ["turkey", "cheddar"], ["roast beef", "gruyere"]]

s.each do | sub_array |
  sub_array.each do | y |
    puts y
  end
end

To try to understand it better I'll try to break it down starting with the first part:

s = [["ham", "swiss"], ["turkey", "cheddar"], ["roast beef", "gruyere"]]

So the above is what I've dubbed "array-ception". There are three inner-arrays within a larger outer array. Those inner arrays are some run-of-the-mill sandwich combinations: ["meat, "cheese"].

Ok. Makes sense so far right? But what about when we want to start doing things with these "array-ceptions"? For example in our initial code snippet, we're trying to write a simple program where we can just print every element of each array.

I can't be the only beginner who has ever thought, "Where do I even start?", "What's going on?", or "All this thinking about sandwiches is making me hungry."

I suppose since there are kind of two parts, the larger outer array and the smaller inner arrays, we should start tackling the outer array first. I think that's what comes next in the code anyway:

s.each do |sub_array|

If you're like me, this is where it starts to get confusing. If there's anything I've learned, it's that when things are confusing, they're begging to be broken down even further.

Part 1

So let's start with the variable 's'. It seems like 's' is kind of a good way to keep track of that larger outer array we talked about earlier. So that means that 's.each' probably means something like "For each element in the larger outer array called s, do something..."

Ok great! Making more sense now!

Now we just have to contend with the pesky 'do |sub_array|' part. So what does it mean? What are we doing?

Part 2

Well, codeacademy did a great job by naming the variable 'sub_array' because we can assume that to mean we're going to start tackling the inner arrays I mentioned earlier. So that means |sub_array| is pointing us to each smaller array like '["ham", "swiss"]'.

Alright so that's making more sense. Seems like that part we can assume to mean something like 'do something to the inner arrays...'

So putting parts 1 and 2 together means "For each element in the larger outer array called s, do something to the inner arrays called sub_array..."

Woohoo! I think we got the first part down.

Part 3

Now that that's cleared up, we can tackle the next part:

sub_array.each do |y|

Hmmm... this should be looking familiar. 🤔 Actually now that I look at it it's basically exactly the same except for the variables named. So instead of doing something to the larger array, we're now starting with the inner arrays or sub arrays.

What's confusing to me here is '|y|'. What is it?? Where did it come from? To make it easier to follow in my head, I'd probably change the variable name to something like 'smallest_element' because here I think 'y' is just tracking each inner element of the sub arrays. That's the smallest part the arrays can be broken down into.

So I'd think of it more like this: sub_array.each do |smallest_element|. And to translate that to plain English, it'd be something like, "For each sub array do something to the smallest element in the array."

Cool! I think we can put it all together now.

So parts 1-3 would translate to something like. "For each element in the larger outer array called s, do something to the inner arrays called sub_array. What are we doing to the inner arrays? Well, for each inner array, do something to the smallest element in that array called y."

Ok. I can follow the logic so far, but I haven't actually done the big 'something' that we've been alluding too. The anticipation is killing me. What are we going to do to those smaller elements?

    puts y

That's where the last part of the code comes in. It's the final flourish of our little program. We're going to simply 'puts y' meaning we want to display each of the smallest elements of the array on a new line.

And that's it! The output should look like this:

ham
swiss
turkey
cheddar
roast beef
gruyere

Hopefully that helped you out if you were having trouble following the logic. It certainly helped me to try to type it out to explain it anyway.

And keep in mind I'm a beginner and learning along with you. Or maybe you're more advanced, in which case, don't hesitate to correct me if I've made an error.

See you in the next post!

Starting the Full Stack journey

Amanda Mendez — Wed, 08 Nov 2023 00:43:41 +0000

About a year ago, I decided to try a career transition from teaching and music into tech. I started with the ambition of becoming and SDET. It's been tough, but I'm still here.

I recently got the opportunity to possible be considered for a full stack apprenticeship. Nothing is certain, but I'll give it my best shot.

Today I made my very first full stack project. It's quite a bit different than what I'm used to coming from a Java background in software testing, but it was kind of fun!

Let's see where this journey takes me!