DEV Community: coding4grandmas

Flow for Grandmas

coding4grandmas — Wed, 30 Jun 2021 20:26:58 +0000

Normally Ruby and most other programming languages process instructions in a linear way, top to bottom. But what if we needed something more? What if our logic requires us to evaluate certain conditions and then operate upon that choice?

Today we will be covering conditionals, comparison and logical operators, and we will even throw in some ternary operators.

Conditionals

Quoting Russ Olsen from Eloquent Ruby:

"If indention, comments, and the form of your variables are the things that give you program its look, it's the control structures - the ifs and elses and whiles - that bring it to life".

Conditionals play a very important role in our code as it tells the program how to proceed based on defined parameters. The statements that we use are

If / else
if / elsif
unless
case
while / until

IF/ELSE: this is the most important flow control. If a condition is met (true), then it will do something; otherwise, it will do something else - a classic one.

age = 14

if age >= 18
  puts "You can vote"
else
  puts "You can't vote"
end

# => "You can't vote

In plain English, we are telling Ruby - "If the age is equal to or above 18, then print 'You can vote', otherwise print 'You can't vote'".

In programming, we assign 14 to our age variable. When Ruby runs the expression, it checks whether the age variable is greater than or equal to 18. Since the age (14) is less than 18, it does not implement the logic (i.e. "You can vote"). Because the first part of the if expression was not met, Ruby executes the else expression, which means the expression(s) above were false.

ELSEIF: is used when you have more than one condition to evaluate. For example:

digit = 1

if digit == 0
  puts "Zero"
elsif digit == 1
  puts "One"
else
  puts "I don't know this digit,sorry!"
end

# => "One"

In plain English, we are telling Ruby - "If the digit is equal to 0 print "Zero", else if digit equals to 1 print "One", otherwise if none of these are true print "I don't know this digit, sorry!"

Ruby ran the statement, and it evaluated the first expression as false since the value of our digit is 1. Then it checked the second expression, and it was true since 1 equals 1. In this statement, we never reached the else expression. This is perfectly fine.

Unless: is the exact opposite of 'if'. 'If' will execute when the statement is true. 'unless' on the other hand will execute when the statement is false:

age = 14

unless age >= 18
  puts "You can't vote"
else
  puts "You can vote"
end

# => "You can vote

In plain English, we are telling Ruby - "If the age is not equal to or above 18, then print 'You can vote', otherwise print 'You can't vote'". In this instance, we will execute the unless statement since 14 is less than 18, meaning we have a false value. It takes some time wrapping your head around this particular expression.

CASE/WHEN: is very similar to if / else expression. The premise is very similar:

digit = 1

case 
when digit == 0
  puts "Zero"
when digit == 1
  puts "One"
else
  puts "I don't know this digit,sorry!"
end

# => 1

As we said, it is very similar to if-else. In this instance, we are telling ruby to execute the statement when the digit variables match 1.

Comparison Operators

They are used to check values between strings and numbers.

== Equal

!= Not equal

> Greater than

< Less than

>= Greater than or equal to 

<= Less than or equal to

Don't worry; we are not going back to solving math problems. Comparison operators allow the programmer to build a much more complex conditional statement.

For example, the equal (==) comparison will return true if the value on the left is equal to the value on the right

1 == 1
# => true

1 == 2
# => false

Logical Operators

Think of logical operators as Boolean operators.

and and &&

or and ||

not and !

&& returns true when both conditions are satisfied for example

a = 1
b = 2

if a == 1 && b == 2
    puts "True"
end

# => "True"

For the && (and) operator to evaluate true, both conditions need to be true. For example:

a = 1
b = 2

if a == 1 && b == 1
    puts "True"
else 
    puts "False"
end

# => "False"

a == 1 was evaluated as true; however, b was evaluated as false. Hence the output we got was false.

The || (or) works a little bit different. Only when one of the conditions is true, it will return true.

a = 1
b = 2

if a == 1 || b == 1
    puts "True"
else 
    puts "False"
end

# => "True"

Lastly the ! (not) is an interesting one as it returns true when the condition is not satisfied.

1 == 1
!(1 == 1)

# => true
# => false

In this instance, Ruby evaluates the numbers in the parenthesis which is true. However, when the ! (not) operator is used, the value returned is false.

Ternary Operator

The ternary operators is used when you want to make a quick if / else statement.

a = 1

a == 1 ? true : false 

# => true Let's break this down. First, Ruby evaluates whether the statement a == 1 is true or false. If it is true, the code to the left of : gets executed. If the statement is false, the code to the right of : gets executed. You can see it is very similar to an if / else statement, and it is much easier to implement and read.

Lets break this down. First, Ruby evaluates whether the statement a == 1 is true or false. If it is true the code to the left of : gets executed. If the statement is false the code to the right of : gets executed. You can see it is very similar to an if / else statement, also it is much easier to implement/read and quite common in other languages such as Java script.

Summary

We are finally at the end. Today we've covered a few important concepts, conditionals, comparison, logical and ternary operators. All of them play an important role in the program. It does take some time to wrap your head around the conditionals. But once you have a good understanding of it, your code can become much more sophisticated and complex.

Methods for Grandmas

coding4grandmas — Thu, 24 Jun 2021 13:43:07 +0000

Today we will be covering a very interesting topic - methods.

Methods primarily achieve two things:

Allows the code to be reusable
Keeps your code organised

Implementing methods achieves a very important objective - it keeps your code DRY (No grandma, we are not suggesting that you drink less water). DRY stands for Don't Repeat Yourself. In programming, you should always seek to keep your code simple, elegant and easy to understand, hence the need to apply the DRY principle. When possible the programmer should always aim to avoid re-writing code.

Methods allows you to be much more efficient with your programming. Instead of writing the same lines of code a number of times, you can implement a method that will execute a pre-defined code.

For example:

def my_name_is(name)
    puts "Hello my #{name} is!"
end

By implementing this simple method, we can call it when we need it anywhere in our code. Thus we are following the DRY principle and minimising unnecessary lines of code in our program.

Now, let's break it down how a method actually works.
A method is written like this.

def method_name(argument(s))
 executable code 
end

Three points to consider:

Method Names

Similarly, to variables method can be named. We do advise naming the methods in easily understood names that clarify what that method is supposed to do.

Argument

Next is the argument(s). When you want to use a method, most of the time, you pass an argument. In the previous example, we passed a name. What is being passed can be various data types (strings, integers, arrays). You can even pass more than one argument - the possibilities are endless (until your program crashes).

Executable Code

Lastly, this is where the magic happens. As a programmer, you can implement anything you like. Do you want the method to calculate the square area of the house or convert a string to an integer or maybe calculate the age of you grandma. It can be done.

Let's implement an example to understand how a method works fully. For the example below, we are looking to calculate the age of our grandma.

grandma_birth_year = 1930

def calculate_age(year)
    current_age = 2021 - year 
    puts "Grandma is #{current_age} years old"
end

calculate_age(grandma_birth_year)
# => 91

It might seem like there is a lot, but it is not - let's break it down by line.

We assign a birth year which is 1930.

grandma_birth_year = 1930

We create a method which accepts a year. Year in the parenthesis is a parameter which receives an argument, when the method is called.

 def calculate_age(year)

We implement our logic. We take the current year minus the year we passed as an argument (1930).

current_age = 2021 - year

We write some logic which will print out the age of our grandma

puts "Grandma is #{current_age} years old."

The last part we have not covered, which is calling the method.

calculate_age(grandma_birth_year)

When the method is called, it tells the computer not to run any other lines and go to the called method and execute the code inside that method. Once the code has been executed, Ruby resumes from where the method was called.

The outcome, we get is a print statement
"Grandma is 91 years old."

Before we wrap up this blog, it is important to touch on parameters and arguments.
In the example above, the parameter was (year). The parameter is what the method accepts. A point to note the parameter could be named anything we want (however, we also advise following a good naming convention).
The argument in the above is (grandma_birth_year). The code calls the method, and the argument is sent to the parameter in the method.

Summary

What's been covered is very simple in nature (hopefully our grandmas think the same). One thing to consider is that, once the program becomes complex as more logic is implemented, employing methods will achieve two things:

The code will be reusable
The code will be organised

This ties up very well with the DRY principle. The concept is to minimise how many lines are written and not to repeat your self - hence, using method statement achieves both. In the professional environment, methods are used often and we believe every programmer should have a good mastery over them.

Programming Basics for Grandmas (Ruby)

coding4grandmas — Tue, 22 Jun 2021 14:27:50 +0000

Today is the big day; we finally get to explore the intricate world of programming (kind of). Hopefully, by the end of this blog, our Grandmas will be able to write the first lines of code for their Airbnb app clone.

A few points of clarification before we dwell on the blog. As you know, the world of programming is very diverse which covers many different fields. With diversity comes various programming languages. As a matter of fact, our trustworthy Wikipedia source indicates there are approximately 700 programming languages.

Yes, we couldn't believe it as well. But you might ask, what is a programming language? A programming language aims to provide detailed instructions to the computer in a binary format (computers can only understand 0 and 1). In short, any instruction written in a programming language gets translated to binary format, allowing the computer to execute a specific set of instructions (computer language).

With the difficult part out of the way; let's cover what language we will be using. We feel most comfortable in Ruby, and we also believe Ruby is relatively easy to read and understand (very similar to English). One thing to mention more or less, every language is the same in terms of basics. The main difference is how it is written. For the programming savvy, the term is 'syntax'. The reason why we have so many languages is they are used for different purposes - each programming language is designed to make certain things easy. Another point is that once one language is learned, other languages can be picked up relatively quickly.

Now, let's get back to the real stuff - coding!

Today we are going to cover two concepts:

Variables
Data types

Variables

One of the first things we learned when we started coding was variables. Variables are an essential part of programming as it allows you to stores values. The best way to explain how a variable works is through the box example. Value(s) can be stored in the box which are then labelled. In this instance the variable name is Grandma, and the stored value is Barbara.

You might ask, what is so great about variables? The answer is very simple, they allow the programmer to store values that can be accessed at a later use.

The creation of a variable works by associating a Ruby object with a variable name this is called a variable assignment.

Grandma = "Barbara"
puts Grandma 

# => "Barbara"

The best way to understand variable assignments is to read from right to left (we assigned "Barbara" to Grandma variable). Then we can use the Grandma variable when we require.

Data types

The different Ruby data types:

Strings
Numbers (integer & float)
Boolean (True, False & nil)
Arrays
Hashes
Symbols

Strings

A string is a text.

greeting = "Hello world!"
puts greeting.class

# => String

The simplest and most common way to create a string is to enclose the object in quotes.

You can do some nifty stuff with strings. For example, you can use concatenation. Which means you can combine various strings into a single string.

"Grand" + "ma"
# ⇒ "Grandma"

The other way of doing (better) is using interpolation

name = "Grandma"
puts "Hello, #{name}!"
# => "Hello Grandma!"

Other interesting stuff that can be done is using Ruby's build in methods.

"Grandma".length
# => 7

"Grandma".upcase
# => "GRANDMA"

"Grandma".reverse
# => "amdnarG"

Numbers

In Ruby there are two different types of numbers integers and floats. Integers are represented without a decimal places and floats have a decimal places.

Integer

2 + 8
# => 10

Float

2.0 + 8
# => 10.0

Once we introduce division, the difference become apparent - integers and floats will produce different results.

10 / 8 
# => 1

10.0 / 8
# => 1.25

You might ask, why is this happening? The answer is simple integer data type cuts off after the decimal places. In contrast, the float provides the numbers after the decimal places.

Booleans

The Boolean data type is very straightforward; it has three properties true, false and nil. The main purpose of using true or false is to evaluate a logical statement, to check whether it is true or false.

"Grandma" == "Grandma"
#= > true 

"Grandma" == "Barbara"
#= false

Lastly, the nil data type is somewhat unique - it represents nothing (yes, you've heard us right). Sometimes you might need to assign a nil value to an object (this will be discussed in the future).

Arrays

Arrays give the programmer a very useful tool at his or her disposal. It allows to store multiple values in a single variable. The stored values can be any data type from strings to numbers.

grandma_array = [ "grandma" ]

Square brackets represent arrays. As mentioned previously, they can store more than one value.

number_array = [ 1, 2, 3, 4 ]

To access the array is done by referring to the index.

For example:

grandma_items = [ "glasses", "walking stick", "medication" ]

In the array above, the first element would be glasses. Counter-intuitively the index starts at 0.

puts grandma_items[0]
# => "glasses"

puts grandma_items[2]
# => "medication"

This is how indices work within an array. The counting always starts at 0.

grandma_items = [ "glasses", "walking stick", "medication" ] 
                       0             1              2

Hashes and Symbols

We have decided to dedicate a separate blog to hashes and symbols as they are more complicated data types than what's been covered above.

Summary

We've only covered the basics here; in subsequent blogs, we will break down each concept in much greater detail. The reasoning behind this is to keep the posts short and sweet. It can be overwhelming with all the new information, especially with someone like our Grandmas who have no prior experience in coding. The idea is to make each post relatively easy to digest.

In summary, variables allow the programmer to store values (box example). The variables then can be accessed at a later use. Understanding various data types is important as well - if something is unclear, we would advise having another read. If it is still unclear, do not hesitate to get in touch with us. We are happy to help (can't be worse than explaining to our Grandmas).

Git and GitHub for Grandmas

coding4grandmas — Fri, 18 Jun 2021 21:43:00 +0000

Suggested playlist while reading this post.

In today's post, we will cover two very important concepts: Git and Github. While they do sound similar, they serve two very different purposes. Git is an open-source version control system (in layman's terms, it allows you to monitor and track your code). On the other hand, Github is a website (and a cloud-based service) that help programmers manage, store, track, and control changes to their code.

What is Git?

We all know how difficult it can be working within a team - especially in programming with so many moving pieces. However, Git is a tool that overcomes the issues mentioned above. It allows multiple programmers to monitor and track different versions of the codebase (you will still have to deal with your passive-aggressive colleagues, though...).

Without Git (manual version control), this is how version control would look like:

Git does something special, it tracks all the data that has been amended. A better way to explain it: imagine Git saveing/storing information through a series of snapshots. No, Grandma, Git doesn't take literal photos of the code, but it does act in a similar concept. Every time we save the project, Git (being a smart apple) takes a picture of all your files at that moment in time and saves a reference point to that snapshot.

To break it down further, it keeps track of all the data that have been amended. Additionally, it tracks who did it, what they changed and when they changed it. And this is what you call version control. Let's not forget that with Git, you can also share your code with collaborators using GitHub.

GitHub?

While Git is a command-line tool operating locally, Github is a Git repository hosting service for developers to host code and their versions (under Git management). It makes code sharing and collaborating easier. Also, you can find a lot of open source projects on it where you could contribute.

Imagine a massive website like Facebook. Suppose a software developer wants to implement a specific change to the codebase of Facebook. In that case, we can assume it would be very dangerous to alter the code directly within the codebase.

Instead of editing the source code directly, GitHub provides some nifty tools for us.

branching (forking)
merging

Branching allows the programmer to copy the code from the original codebase and implement changes to the copied code without affecting the original code.

Once the developer carries out the desired revisions to the copied code, they can merge the altered code to the official source code. Below is an example of how branching (forking) would work.

Both Git and GitHub provide useful utility for the developer. Git provides a snapshot of the code as it goes through iterations. On the other hand, GitHub allows a programmer to implement changes to a duplicate version of the source code through branching, which can then be merged into the official codebase.

That's all for now, folks; the next blog will cover Ruby programming basics.

Terminal for Grandmas

coding4grandmas — Tue, 15 Jun 2021 12:56:50 +0000

Grandma are you ready (we are not)?

Today's blog will cover the Terminal / Command Prompt / Command Line (all are effectively the same thing)

Once we go through the various terminal concepts, we feel our Grandmas might be able to challenge us in a Hackathon!

Terminal

Linux Shell or Terminal

For clarity we will be using Linux commands.

For the uninitiated, the blank screen might look intimidating; for others, a hacking device. Rest assured, the command line is an essential part of any programmer's toolset.

In Layman's term (or grandmas?), the terminal acts as an interface between the computer and the human.

To break it down further, the command line allows us to input information and read the output from the computer.

You might ask what kind of input?

The answer can range from creating files to running apps.

For example, our grandma wanted to create a folder titled airbnb_clone.

She would input the following command in the terminal.

mkdir airbnb_clone

If she wanted to create a file

touch airbnb.rb

What is this black magic?

mkdir stands for make directory. This creates a folder.
touch creates a file. As we are learning ruby programming language, we have indicated it to be a ruby file by naming it rb.

Are there any other commands?

Glad you asked grandma.

Commands which get used quite often are:

pwd => print working directory

ls => list

cd => change directory (cd )

cd .. => goes back to parent directory

rm => remove a file

rm -r => remove a directory

rm -rf => force remove a directory

mv => move file_1 to file_2_location

mv => rename a file

stt / code . => open sublime text/vs code in the current folder

cat => show the content inside the file

That's how we felt the first time when we saw the various commands. Rest assured, they are not as bad as they seem.

We have learned mkdir and touch.

mkdir creates a folder
touch creates a file.

The beauty of the command line is that the mouse cursor doesn't work. Everything is done via commands (typing).

pwd => print working directory

If you want to know in which directory you are in

ls => list

If you want to check all the file names in the current directory

cd => change directory (cd <folder_name>)

If you wan to navigate to a different directory

cd .. => goes back to parent directory

If you want to go back to the previous directory

rm <filename> => remove a file

If you want to delete a file

rm -r <foldername> => remove a directory

If you want to remove a folder

mv <file_1_location> <file_2_location> => move file_1 to file_2_location

If you want to move a file from one directory to a different directory

mv <file_with_old_name> <file_with_new_name>  => rename a file

If you want to rename the file

stt / code . => open sublime text/vs code in the current folder

If you want to open your text editor like a bad-ass

cat <filename> => show the content inside the file

If you want to look at the contents of the file you are currently in

Hopefully, this wasn't too much (Grandma, are you still awake?). In summary, the terminal is an essential part of the programmer's toolset. It allows implementing various actions from creating files to running programs.

The next blog will cover git and GitHub.

Hello grandma!

coding4grandmas — Wed, 09 Jun 2021 20:31:38 +0000

Who are we as devs?

We are R. and E., and both of us are working in non-programming fields. Our goal is to ditch our current jobs and become software developers.

What are we doing?

We are doing a full stack web development boot camp based in London. As full-stack devs, we are learning back-end (Ruby on Rails, SQL) and front-end (HTML, CSS and Javascript) web development concepts.

Goals?

To allow our grandmas to deploy the next Airbnb killer app;
To keep it simple and accessible (especially for our dear grandmas);
We, as aspiring developers, want to learn through teaching.

Timetable?

The plan is to share what we have learned in the Bootcamp (grandma, thanks for the big loan). We will do it by publishing various programming topics in a digestible format. Next week we will start from scratch discussing Terminal and Git.

puts "Stay tuned!"