frc296 / frc-workshop-1

First workshop on Java and Git basics! The goal of this workshop is to reintroduce familiar programming concepts and introduce Git version control.

Basic Java Review

In this workshop, we'll quickly go over Java basics, write some code, and then push it to the FRC 296 repository. Outline:

1. Java review - variables, functions, all that good stuff
2. Java coding challenge
3. 10 minute break
4. Git introduction
5. Pushing with git

• Visit this Java playground to code along if you wish!

What is a programming language?

• A programming language is what allows us to talk to computers
• When we write and run a program, a computer will "read" our program and do what we ask it to
  • We write programs to perform tasks like controlling a robot, calculating things, , etc.

What makes Java different from other languages?

• There are many languages you might've heard of, like Python, C, etc.
• Many differences, but the biggest ones are in syntax and purpose
  • Syntax
    • Syntax for a programming language is like spelling in english
    • When writing a program, we have to "spell" our words correctly so the computer can properly understand
  • Purpose
    • Different languages are written for different reasons
      • HTML is written to render web-pages, MATLAB for engineering analysis, etc.
      • Java is an object-oriented language, like Python or C++
        • Java is used for a wide variety of purposes
        • E.g. Robots, Android Apps, and even MINECRAFT

The Building Blocks of Java

The most important building blocks of a program are variables, operators, classes, and functions.

Variables

• A variable (like in math) is used to represent a piece of data

  • Just as an equation uses a variable x to symbolize a number, a program uses a variable to symbolize a block of the computer's memory

  • We declare a variable by writing its type, its name, and assigning its value. E.g.

    		int myInteger = 5;

    • Here, a variable of type integer (int) named myInteger is declared and set equal to 5

    		String myString = "Hello World!";

    • Here, a variable of type String named myString is declared and set equal to "Hello World"

  • So what does the computer do with this?

    • The computer takes the values we assign, and stores them in the memory
    • Once in the memory, we can use these values to calculate things and much more

  • Most Common Variable Types:

     int
     float
     double
     String

---

Operators

• An operator (again, like in math) is used to modify a stored value
  • E.g. consider two integers stored in memory, that we want to add. We would first declare the integers, and then use the + operator to perform addition

    		int x = 5;
    		int y = 10;
    		int sum = 0;
    		sum = x + y;

    • The addition of x and y is stored in the variable sum
  • Java has many operators. The most important ones we will explore are:
    • Addition                        +
    • Subtraction                   -
    • Multiplication               *
    • Division                         /
    • Assignment                   =
    • Function Call                 .

---

Classes

• A Java class is a sort of container for your code
  • When a class is declared in java, memory is allocated for this class and whatever may be inside it
• Everything in Java is a class! Literally everything
  • This isn't really the norm though; Most languages offer classes but don't require them
• E.g. consider your classic "Hello World" program

   	class HelloWorld 
   	{
   	    public static void main(String[] args) 
   	    {
   	        System.out.println("Hello World!");
   	    }
   	}

  • Here you can see that the main function of the program is contained within a class, called HelloWorld
    • This file would be saved as HelloWorld.java
• Access Modifiers -- Public & Private
  • Variables and functions either declared as:
    • Public: All functions from any file can access the data/function
    • Private: Only functions within the surrounding class can access them

---

Functions

• Functions are called to perform some sort of routine

  • This routine could be adding two numbers, printing a statement, whatever you'd like!

• We create functions so that we don't have to rewrite code

• Functions consist of three main parts:

  • A return type, arguments, and a body
    • The return type tells us what type of variable the function will give us (maybe an integer or a string)
    • The arguments are what we can pass to a function (maybe we pass it one integer, maybe two)
    • The body defines what we do with the arguments, and what we return

• E.g. take a look at the following two functions

   	public static int add(int x, int y)
   	{
   		int sum = x + y;
   		return sum;
   	}

  • Here the return type is integer, the arguments are the two integers x and y, and the body of the function adds the two arguments.

• A function could also not return anything. In that case, we say the return type is void

   	private static void print()
   	{
   		System.out.println("Hello World!");
   	}

  • Note that this function has no return type, nor does it take any arguments! It just prints Hello World! to the terminal.

• Finally, to invoke or call these functions, we would do the following

   	int sum = add(5,10);	// here we assign the return value to the variable sum
   	print();		// here we invoke a void function with no arguments

Conditional Statement and Iterators

• Conditional statment and iterators are tools we use in Java and other languages to control the flow of a program

Conditional Statement

• A conditional statement checks is a conditions is met, and acts based on if it is met or not

  • The condition could be comparing two values, checking if two values are equal, etc.

• The if statement

  • An if statement allows a program to enter a body of code if the condition presented is met
  • E.g. suppose we have the following situation

   	int x = 5;
   	int y = 10; 
   	
   	if(x > y)
   	{
   		// do stuff
   	}
   	if(x < y)
   	{
   		// do more stuff
   	}
   	if(x == y)
   	{
   		// do even MORE stuff
   	}

  • Which of these would execute?

• Conditions we could use include

  • Greater Than                                    >
  • Less Than                                          <
  • Greater Than or Equal to                >=
  • Less Than or Equal to                      <=
  • Equal                                                 ==
  • Not Equal                                          !=

  ---

Iterators

• An iterator makes a body of code loop until a condition is met. There are two types:
• The for loop
  • A for loop makes a body of code execute as many times as we want it to
    • We could make a body of code loop as little as 1 time or as many as 10000000 times
  • E.g., if we wanted to make a loop that runs 100 times and adds 1 to a variable, we could do

   	int x = 0;
   	for(int i = 0; i<100; i++)
   	{
   		x = x+1;
   	}

  • What does the stuff in the parenthesis mean?
    • int i = 0; declares a new variable i
    • i<100 means "Keep looping while i is less than 100"
    • i++ means add 1 to i after every loop
• The while loop
  • A while loop loops forever until a condition is met
    • It's kind of like a for loop, except instead of stopping when a number is reached, the while loop stops when a condition is reached.
  • E.g. if we wanted a while loop to run 100 times and add 1 to a variable, we could say

   	int x = 0;
   	while(x < 100)
   	{
   		x = x+1;
   	}

Putting all of This Together

• Now I will present a little coding challenge

• Using this Java Playground, write a Java code that will have:

  1. A function that takes voltage and current and returns the total amount of power.

     • Takes two integers: Voltage and Current
     • Returns one integer: Power

  2. A function that takes a first name and last name and returns the full name in capital letters as a single string.

     • Takes two string: First and Last name
     • Returns one String: Full name in capitals

  3. BONUS A function that prints your name diagonally using a for loop

     • E.g.

   	A
   		D
   			R
   				I
   					A
   						N	

  • HINTS AND TOOLS
    • Power Equation
      • P = IV (Power = Current * Voltage)
    • String Concatenation
      • Like numbers, strings can also be added together
        • We call this concatenation
    • toUpperCase() function
      • Call my_string.toUpperCase() to make a string all capitals
    • charAt(int index) and length() function
      • Call my_string.charAt(int index) to get the character at a position
      • Call my_string.length() to get the length of a string
    • System.out.print("Your text here"); is used to print a statement to the terminal in Java
    • You can use special characters \n and \t to format printed statements
      • \n prints a line (called the newline character)
      • \t prints a tab (called the tab character)
      • E.g.

   	System.out.print("Statement without any special characters");
   	System.out.print("\n\nStatement with two newlines before and after\n\n");
   	System.out.println("\n\tStatement with a newline and tab before it");

    Output:
  

   	Statement without any special characters
   	
   	Statement with two newlines before and after
  
   		
   		Statement with a newline and tab before it

• Finally, you have to save this file to your desktop by doing the following: * Open Notepad * Copy and paste code into notepad * File > Save As > Code.java

Pushing to GitHub

• Now we will use terminal and git commands to push your work to the FRC 296 WorkShop 1 Repository

What is GitHub?

• GitHub is a form of version control. Version control is used we have multiple people working on the same programming project, and we want to make sure the work done is synchronized.
  • Think of GitHub as the Google Docs for coding

Why Learn GitHub?

• GitHub is an amazing tool for any sort of programmer, for the following reasons:

  1. We can collaborate on programming projects efficiently
  2. Knowing how to navigate GitHub is useful for finding resources to help with projects. For example, check out the following open-source FRC repos
     • FRC Team 254
     • FRC Team 2470
     • WPI Library These could prove to be really useful for a future robot!
  3. Finally, GitHub is simply the name of the game these days. GitHub is used far and wide by from open source projects to companies

Dependencies

• There are a few things your computer needs first
  1. You must have GitBash downloaded.
     • GitBash Download
  2. The username and password for the GitHub account
     • Username: 296RoboticsStudent
     • Password: Robostudent296

Terminal Commands

In this section, we'll go over the most basic and essential terminal commands needed for Git. Knowing these commands are very useful in general

What is a terminal?

• A terminal (AKA console or command line) is a way of communicating with the computer. Communication through the terminal is done using commands, which are usually short abbreviations for actions you want to do
  • A terminal is a computer without its Graphical User Interface (GUI)
  • Some computers don't even have GUIs, and only have a terminal!
    • E.g. RaspberryPis

Who would want to use a computer without a GUI?

• It sounds a bit silly right? Using a dull-looking terminal over a pretty graphical interface
  • We use terminals because they allow us to directly manipulate and talk to the Operating System (like Windows or Mac).
  • Commands in the terminal can be very powerful for controlling a computer
    • Think of commands as the tools we use to navigate the terminal

The Commands

1. Change directory

   cd

   • This command allows us to change our working directory, or the directory our terminal is set to
   • Takes in a path as an argument.
     • I.e. the path we want to set our working directory to
   • Examples:
     • cd Documents
     • cd Desktop/FRC/RobotsAreLit
   • cd ~ will take you back to your home directory

---

2. List

   ls

   • This command simply lists the files in our working directory
   • Example:
     • Input:
       • ls
     • Output:
       • 'Folder 1' 'Folder 2' 'Documents' 'Desktop'

---

3. Make Directory

   mkdir <directory>

   • This command will make a new directory of the name passed
   • Example: mkdir frcWorkshop ls 'frcWorkshop'

Git Commands

This section will cover the needed Git commands we need to push your work to the FRC296 repository.

What is a GitHub Repository?

• A repository is just a name for a place where we store our code for a project, product, etc.
  • E.g. our repository for Workshop 1 is where all of the workshop material is hosted

What is a Git Command?

• Git commands are similar to terminal commands, but they are used for controlling GitHub from the terminal

The Commands

1. Cloning a repository

   git clone <url>

   • This command copies a repository into your working directory
   • E.g. if you changed directory into Documents and then cloned a repository, you'd see the remote reository copied into your local directory

---

2. Add changes to the working directory

   git add .

   • This command adds all the files in our working directory to the staging area
     • In other words, we're just telling git what files we want to add to our remote project
   • If you only want to add one file at a time, you'd say git add file.txt

---

3. Commit your changes

   git commit

   • This command saves or commits our added files to our local working directory
   • To add a message with your commit, you can say git commit -m "This is my commit message!"
     • and you will see it added on GitHub

---

4. Pulling from the remote repository

   git pull origin master

   • Here we are pulling from the origin, or adding the changes we don't have locally
   • We need to do this to make sure our local repository is in the same state as the remote repository

---

5. Pushing our changes

   git push origin master

   • Here we are pushing or "sending" the work in our local directory to its remote origin, the master branch
   • That's it!

Recap -- The Final Push

1. First log in using git bash with the following command:

   git config --global user.email "[email protected]"

2. We clone the existing repository using its url

   git clone https://github.com/FRC296/FRC-Workshop-1.git

3. We add the files we wish to push to the remote repository

   git add .

   • In this case we're adding all
4. We save our work using a commit

   git commit

5. We pull from the remote repository

   git pull origin master

6. And finally, we send our work to the remote repository

   git push origin master