DEV Community: Edwin Torres

Using a Switch for Days of the Week

Edwin Torres — Sun, 04 Sep 2022 15:07:13 +0000

The switch statement is a useful selection statement when there are many values that require different logic.

Here is a program that asks the user to enter a day number (1-7) and outputs the full name of that day of the week.

First, import the Scanner class (for user input), declare the class name, and declare the main method:

import java.util.Scanner;
public class Days {
  public static void main(String[] args) {

Next, declare a Scanner variable and create the object. This object will retrieve user input later:

    Scanner in = new Scanner(System.in);

Declare a variable to store the user input:

    int dayNum;

Ask the user to enter a number:

    System.out.print("Enter a day number (1-7): ");

Use the Scanner object to retrieve the user input. Note that the program will wait here until the user types a value and presses Enter:

    dayNum = in.nextInt();

Create a switch statement that switches on the dayNum variable:

    switch(dayNum) {

Inside the switch statement, add cases for each day. For example, the value 1 will output Monday:

      case 1:
        System.out.println("Monday");
        break;

Here are the other cases. Note that case 5 also outputs TGIF:

      case 2:
        System.out.println("Tuesday");
        break;
      case 3:
        System.out.println("Wednesday");
        break;
      case 4:
        System.out.println("Thursday");
        break;
      case 5:
        System.out.println("Friday");
        System.out.println("TGIF!");
        break;
      case 6:
        System.out.println("Saturday");
        break;
      case 7:
        System.out.println("Sunday");
        break;

The last case is a default case. This case occurs when the dayNum value has a number outside the range 1-7:

      default:
        System.out.println("Invalid day number.");
        break;

Finally, add the closing curly brackets for the switch statement, main method, and class:

    } 
  }
}

Here is the complete program:

import java.util.Scanner;
public class Days {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int dayNum;
    System.out.print("Enter a day number (1-7): ");
    dayNum = in.nextInt();
    switch(dayNum) {
      case 1:
        System.out.println("Monday");
        break;
      case 2:
        System.out.println("Tuesday");
        break;
      case 3:
        System.out.println("Wednesday");
        break;
      case 4:
        System.out.println("Thursday");
        break;
      case 5:
        System.out.println("Friday");
        System.out.println("TGIF!");
        break;
      case 6:
        System.out.println("Saturday");
        break;
      case 7:
        System.out.println("Sunday");
        break;       
      default:
        System.out.println("Invalid day number.");
        break;                      
    } 
  }
}

Thanks for reading. 😃

Follow me on Twitter @realEdwinTorres for more programming tips and help.

Calculate the Volume of a Cube in Java

Edwin Torres — Sun, 04 Sep 2022 14:44:17 +0000

The volume of a cube with side s is: s x s x s or s to the 3rd power.

In Java, the Math.pow(x,y) function raises x to the power y. Both variables are double values, and the function returns a double result.

Let’s write a Java program to calculate the volume of a cube. The first three lines import the Scanner class (needed for user input), declare the Java program class, and declare the main method:

import java.util.Scanner;
public class Volume {
  public static void main(String[] args) {

Declare two variables in the main method to store the side of the cube and the volume:

double s;  // side
double v;  // volume

Create a Scanner object that scans standard input. Store the object in the variable in:

Scanner in = new Scanner(System.in);

Ask the user to input a value for the side:

System.out.println("Please enter the side of the cube: ");

Use the nextDouble() method of the Scanner object to accept the side from the user and store it in the variable s. Note that the program will wait on this line until the user presses the Enter key to input a value:

s = in.nextDouble();

Use the Math.pow() function to raise s to the power 3. Store the result in the variable v:

v = Math.pow(s,3);

Output the result:

System.out.println("The volume of cube with side " + s + " is " + v + ".");

Finally, close the main method and Java program:

}
}

Here is the complete program:

import java.util.Scanner;
public class Volume {
  public static void main(String[] args) {
    double s;  // side
    double v;  // volume
    Scanner in = new Scanner(System.in);
    System.out.println("Please enter the side of the cube: ");
    s = in.nextDouble();
    v = Math.pow(s,3);
    System.out.println("The volume of cube with side " + s + " is " + v + ".");
  }
}

Thanks for reading. 😃

Follow me on Twitter @realEdwinTorres for more programming tips and help.

Java Input and Arithmetic

Edwin Torres — Sun, 04 Sep 2022 13:21:22 +0000

This tutorial is a simple Java program that asks the user for two numbers, adds them together, and outputs the result.

Create a new Java project in VS Code.
Create a new Java file named AddExample.java, where you will type the code below.
Import the Scanner class. This built-in Java class lets you accept input from the user.
```
import java.util.Scanner;
```
Start the class definition. It must match the filename. The curly bracket indicates the start of the program.
```
public class AddExample {
```
Inside the class definition, declare a main method. This method is the first method that the Java interpreter calls.
```
  public static void main(String[] args) {
```
Inside the main method definition, create a Scanner object named s. This object will accept input from the user.
```
    Scanner s = new Scanner(System.in);
```

Output a line that asks the user to enter two numbers.

    System.out.print("Please enter two numbers: ");

Use the Scanner object to read in two integers and store them in two integer variables x and y.
```
    int x = s.nextInt();
    int y = s.nextInt();
```
Use arithmetic to add x and y and store the result in an integer variable z.
```
    int z = x + y;
```

Output the result.

    System.out.println("The sum is " + z);

Close the main method definition with the ending curly brace.
```
  }
```
Close the class definition with the ending curly brace.
```
}
```
Now run your program to see the result.

Congratulations!

You have written a Java program to accept two numbers from the user, add them, and output the result.

Thanks for reading. 😃

Follow me on Twitter @realEdwinTorres for more programming tips and help.

Removing Sensitive Data in Git

Edwin Torres — Tue, 19 Apr 2022 16:27:42 +0000

This guide explain how to remove sensitive text from your Git repo. It requires BFG Repo-Cleaner, which is endorsed by GitHub, and Java.

Close/merge all pull requests.
Make sure all developers' local branches are clean.
Clone your repo to create an emergency backup.
Download the bfg JAR file from BFG Repo-Cleaner, for example bfg-1.14.0.jar.
Go to a temporary working folder.
Clone a bare mirror of your repo, for example: git clone --mirror git@gitlab.com:SomeUser/myrepo.git
Create a text file named sensitive.txt with regular expressions to replace. For example, this text file will replace all occurrences of password123 with ***REMOVED*** and all occurrences of abc123 with samplePassword:

  password123
  abc123==>samplePassword

Copy in the bfg-1.14.0.jar file.
Execute this command to replace the sensitive text: java -jar bfg-1.14.0.jar --no-blob-protection --replace-text sensitive.txt myrepo.git
Go into the mirror repo: cd myrepo.git
Execute git reflog expire --expire=now --all && git gc --prune=now --aggressive
Push to your remote branch: git push . Note: If this fails, you may need to unprotect the branch in the remote Git server.
Ask all developers to re-clone the repo to get the rewritten Git histories.
Verify that the repo looks correct, then delete the local backup repo and temporary working folder.

Now all sensitive data is gone.

Thanks for reading!

Follow me on Twitter @realEdwinTorres for programming tips, software engineering content, and career advice. 😊

The content in this blog post is publicly available at Git, GitHub, GitLab, and BFG Repo-Cleaner.

Using Merge Requests and Feature Branches in your Git Workflow

Edwin Torres — Wed, 02 Feb 2022 02:28:53 +0000

Introduction

Multiple developers contributing to the same master branch of the same repo is asking for trouble. The dreaded merge CONFLICT will surely occur. Merge conflicts happen because multiple developers modify the same file at the same time. Git is not able to choose the correct version.

One way to minimize merge conflicts and improve the Git workflow is to use feature branches and merge requests. This tutorial demonstrates one way to do that.

Prerequisites

Here are the prerequisites for this tutorial:

All collaborators have GitLab accounts with appropriate SSH access.
This tutorial uses a GitLab repo called acme-corp.
The default branch of the repo is called main, but yours might be master.
One collaborator has the Maintainer role. This person sets up the repo.
All other collaborators have the Developer role.
All developers and maintainers have a terminal application on the local computer with Git installed.
All developers and maintainers have a basic knowledge of git and bash commands.

Step 1 - Protect the `main` branch

The Maintainer prevents developers from directly committing to the main branch:

From a web browser, the Maintainer logs into the GitLab account and goes to the acme-corp repo.
Click Settings > Repository.
Expand Protected branches.
Scroll down and ensure that the main branch is protected. Only maintainers should be allowed to push and merge to this branch.

Step 2 - Developers create feature branches

Developers cannot commit directly to the main branch. Instead, they create and work in feature branches:

Open a terminal on your local computer.
Clone the acme-corp repo.

Complete the following steps:

$  # go into the repo folder
$  cd acme-corp
$
$  # make sure the repo is clean
$  git status
$
$  # get the latest changes from the remote GitLab repo
$  git pull origin main
$
$  # create a feature branch off of main and switch to it
$  git checkout -B my-new-feature
$
$  # work in the new feature branch
$  echo "my new file" > newfile.txt  # an example
$
$  # see the status of your new feature branch
$  git status
$
$  # add and commit local changes to the feature branch
$  git add .
$  git commit -m "changes to my feature branch" . 
$
$  # push the new branch to the remote GitLab repo
$  git push origin my-new-feature
$

From the browser, refresh your acme-corp repo in GitLab.
Find the new my-new-feature branch in GitLab.

Step 3 - Developers create merge requests

Developers create merge requests to merge feature branches back into the main branch:

From a web browser, the developer logs into GitLab and goes to the acme-corp repo.
In the left sidebar, click Merge requests.
Click the Create merge request or New merge request button.
Add a Title and Description for the merge request.
Click the Create merge request button.
The developer monitors the merge request while it is in Open status.
The developer checks the merge request for any warnings about existing merge conflicts.

Step 4 - Maintainers review merge requests

It is the responsibility of maintainers to review, accept, and reject merge requests. Do this from the web browser, in the GitLab Merge request area.
Use the Merge request area in GitLab to start discussions, view code differences, comment on code, etc.
Maintainers should reject merge requests that:
- Contain errors
- Contain merge conflicts
- Do not follow coding style guidelines
Maintainers should approve and merge feature branches that contain correct code that follows coding style guidelines.

Step 5 - Developers update or delete feature branches

If the maintainers reject the merge request, update the local feature branch:
- Review the merge requests comments in GitLab.
- Make the appropriate changes to the local my-new-feature branch on your computer.
- Add and commit the changes locally.
- Push your local feature branch to the remote repo in GitLab.
If the maintainers approve and merge, then delete the local feature branch from your computer: git branch -D my-new-feature

Congratulations! You have used a feature branch and merge request to update your main branch. Use this technique to minimize merge conflicts, facilitate simultaneous work among team members, and protect the main branch.

Thanks for reading!

Follow me on Twitter @realEdwinTorres for programming tips, software engineering content, and career advice. 😊

Simple Java Scanner Tutorial

Edwin Torres — Sat, 22 Jan 2022 16:33:57 +0000

Introduction

This is a simple tutorial on using the Scanner class in Java. The Scanner class lets you accept input from the console. The user types on the keyboard and passes that data to the program.

Prerequisites

Install Java and Visual Studio (VS) Code. Here is a tutorial: Tutorial: Visual Studio Code and Java.
Start VS Code.
Create a new Java project as specified in the tutorial.
In the left sidebar, right-click the src folder and select New File. Create a file named Example.java.
Continue to the tutorial below.

Code

In the left sidebar in VS Code, click the Example.java file to show it in the main editor window. Enter this initial code:

public class Example {
  public static void main(String[] args) {


  }
}

To use the Scanner class, import it at the top of the program:

import java.util.Scanner; // NEW

public class Example {
  public static void main(String[] args) {


  }
}

Next, create a Scanner object to read from standard input (i.e., the console):

import java.util.Scanner;

public class Example {
  public static void main(String[] args) {

    Scanner s = new Scanner(System.in); // NEW

  }
}

Now prompt the user to enter some data from the keyboard:

import java.util.Scanner;

public class Example {
  public static void main(String[] args) {

    Scanner s = new Scanner(System.in);

    System.out.print("What is your favorite number? "); // NEW

  }
}

Use the Scanner object to accept an integer value from standard input and assign it to a variable:

import java.util.Scanner;

public class Example {
  public static void main(String[] args) {

    Scanner s = new Scanner(System.in);

    System.out.print("What is your favorite number? ");

    int num = s.nextInt(); // NEW

  }
}

The num variable holds the input data. Output the num variable to verify:

import java.util.Scanner;

public class Example {
  public static void main(String[] args) {

    Scanner s = new Scanner(System.in);

    System.out.print("What is your favorite number? ");

    int num = s.nextInt();

    System.out.println("Your favorite number is: " + num); // NEW

  }
}

Here is a sample run of the program from the terminal:

What is your favorite number? 44
Your favorite number is: 44

Additional Exercise

Modify the program to ask the user for an age and day of the month.
Output the age and day of the month.

Thanks for reading.

Follow me on Twitter @realEdwinTorres for more programming tips. 😀

Simple Test-Driven Development (TDD) With Mocha and Node.js

Edwin Torres — Sun, 16 Jan 2022 21:31:39 +0000

Here is a quick tutorial on Test-Driven Development (TDD) with the Mocha test tool and Node.js.

Overview

Test-Driven Development, or TDD, is a programming style that includes three tightly integrated activities: coding, unit testing, and refactoring.

The TDD approach is a cycle:

RED/FAIL - Write one unit test for a single feature of the program, execute the test, and ensure that it fails. It should fail because the program feature has not been developed yet.
GREEN/PASS - Write "just enough" code to make the test pass. The code may simply hard-code the correct output for a given input value.
REFACTOR - Refactor the code with real logic until it passes the unit test. Implement the feature and remove the hard-coded result. Refactoring does not change the behavior of the program; the given input must still produce the expected output. Refactoring may also enhance a program or improve efficiency.
Repeat.

TDD With Mocha and Node.js

Prerequisites

Download and install Node.js locally on your computer.
A terminal application: Terminal (macOS) or Git Bash (Windows).

Tutorial

Here is a new program feature to implement. The Restaurant Tip Calculator calculates tips for a restaurant bill.

Feature: Restaurant Tip Calculator
Scenario: Calculate a 20% restaurant tip.
When the restaurant bill is `$100`
Then the tip amount is `$20`

Here are steps that illustrate the TDD process:

Open a terminal and go into a working folder:
```
$  cd myfolder
$
```

Initialize the folder to use the Mocha test tool:

$  git init .  # for Git versioning later
$
$  npm install -g mocha  # install mocha locally
$
$  mocha  # try mocha. It will fail; no tests yet...
$  Error: No test files found: "test"         
$

From inside the myfolder folder, create a directory named test: mkdir test .
Create an empty unit test program inside the test folder named TipTest.js: touch test/TipTest.js .
In the myfolder folder create an empty program for the program we are testing: touch Tip.js .
Run the Mocha test. We now have the minimal amount of code to have a failed test:
```
$  mocha

  0 passing (2ms)

$ 
```

Add the first unit test to the TipTest.js program. This unit test checks the tip amount for a $100 amount. The correct/expected tip amount is $20:

assert = require("assert");

Tip = require("../Tip.js").Tip  // program to test

// new unit test
describe("Check tip amount", function() {
  describe("sending in 100", function() {
    it("should return 20", function() {
      var result = new Tip().CalculateTip(100);
      assert.equal(20,result);
    }); 
  }); 
});

RED: Add minimal code to the Tip.js program that initially fails the test:

function Tip() {
}

Tip.prototype.CalculateTip = function(p1) {

  return 0; // hard-code a result that will FAIL

}

module.exports.Tip = Tip;

Run the Mocha test. It will execute the test and fail, because the actual result of the program is 0, but the expected result is 20:

$  mocha

  Check tip amount
    sending in 100
      1) should return 20

  0 passing (6ms)
  1 failing

  1) Check tip amount
       sending in 100
         should return 20:

      AssertionError [ERR_ASSERTION]: 20 == 0
      + expected - actual

      -20
      +0

      at Context.<anonymous> (test/TipTest.js:10:14)
      at processImmediate (internal/timers.js:456:21)

$

GREEN: Modify the Tip.js program to hard-code it to succeed:

function Tip() {
}

Tip.prototype.CalculateTip = function(p1) {

  return 20; // hard-code a result that will SUCCEED

}

module.exports.Tip = Tip;

Run the Mocha test again. This time it succeeds, because the actual and expected results are both 20:

$  mocha

  Check tip amount
    sending in 100
      ✔ should return 20

  1 passing (4ms)

$

REFACTOR: Modify the code by implementing the correct logic for the Tip.js program:

function Tip() {
}

Tip.prototype.CalculateTip = function(p1) {

  // NEW
  let tipAmount = p1 * 0.20
  return tipAmount;

}

module.exports.Tip = Tip;
$

Run the Mocha test and see it succeed with real, correct logic:

$  mocha

  Check tip amount
    sending in 100
      ✔ should return 20

  1 passing (6ms)

$

You have successfully used TDD to develop this first feature of the Tip Calculator program. Add more unit tests to test the program further or add new features.

Your turn

Create a new unit test for the Tip Calculator app that implements this feature:

Feature: Restaurant Tip Calculator
Scenario: Calculate a 25% restaurant tip.
When the restaurant bill is at least `$200`
Then the tip amount is 25% of the restaurant bill

Conclusion

This completes the TDD tutorial with Mocha. Note how TDD occurs in iterations. Establish a test that you expect to fail. Modify the test to make it succeed with the expected value. Finally, implement real logic in your program that passes the test. Repeat the process for each new feature of the program.

Thanks for reading!

Follow me on Twitter @realEdwinTorres for programming tips, software engineering content, and career advice. 😊

Simple Git Branching Tutorial

Edwin Torres — Fri, 14 Jan 2022 16:22:45 +0000

Git Branching Tutorial

Here is a quick tutorial on using branches in Git.

Assumptions

You already have a GitLab/GitHub repo. This tutorial uses a repo named my-repo.
Your repo has one branch named master.
You already cloned the repo to your local computer.
Your repo is clean: git status

Tutorial

Here is a terminal session that demonstrates Git branching. You will create a new branch named my-branch from your master branch. This makes a copy of the master branch. Then, you will make changes to the new branch and push it to your remote GitLab/GitHub server.

From your local computer, open a terminal and go to your local repo and make sure you are on the master branch and the working tree is clean:
```
$  cd my-repo
$  git status  # On branch master? working tree clean?
$
```

Create a new local branch from master and name it my-branch:

$  git checkout -B my-branch  # create new branch
$
$  git status  # you are on the new branch now
$
$  ls  # this branch has the same files as master
$

Switch back and forth between branches. Note that you stay in the same folder:

$  git checkout master
$  git status # now on master branch
$
$  git checkout my-branch
$  git status # now on my-branch
$
$  # when you switch branches, you stay in the same folder. Git changes the branch files for you:
$  pwd
$
$  # shortcut to switch to the previous branch
$  git checkout -
$

Add some files to your new branch:

$  git checkout my-branch
$  echo "print('hello')" > hello.py  # create a new file
$
$  git status  # changes pending in new branch
$
$  # commit files to your new branch locally
$  git add .
$  git commit -m "changes to my new branch" .
$

You created and updated your new branch locally, but it is not yet in the remote GitLab/GitHub server. So, push your local branch to the remote:

$  git checkout my-branch
$  git push origin my-branch  # push to the remote
$
$  # From your browser, look at your new branch in GitHub/GitLab
$  # The master branch is the default, so manually select the my-branch branch to see it
$

Now your new branch exists locally on your computer and remotely in GitLab/GitHub. You can keep your local my-branch branch if you need to make future changes to that branch.

To merge your new branch back into master:

$  git checkout my-branch
$  git status  # make sure it is clean
$
$  git checkout master
$  git status  # make sure it is clean
$
$  # do the merge
$  git checkout master  # check out branch we are merging into
$  git merge my-branch  # merge new branch into master
$  git push origin master  # push the updated master branch to the remote
$

Now that you merged my-branch into master, you may not need my-branch anymore. If you want to delete my-branch from your local computer:

$  git checkout master  # you cannot be on the branch you are deleting
$  git branch -D my-branch # delete my-branch locally
$

To also delete my-branch from the remote GitLab/GitHub server:

$  git checkout master
$  git push origin --delete my-branch  # deletes my-branch from the remote
$

This ends this Git branching tutorial. Use branches to perform parallel work. Delete local branches if you no longer need them. Delete remote branches if you no longer need them, or you've merged them into another long-term branch.

For more information and original content for this blog, see the Git website.

Thanks for reading!

Follow me on Twitter @realEdwinTorres for programming tips, software engineering content, and career advice. 😊

Hello Git: A Beginner's Tutorial on Git and GitLab

Edwin Torres — Sat, 01 Jan 2022 18:28:06 +0000

Introduction

This tutorial is for beginners who are new to Git and GitLab .

Git is a "free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency." Use Git locally on your computer to manage software versions.

GitLab is a DevOps platform. It can host your local Git repos for remote collaboration, and a whole lot more. Some other Git servers are GitHub and Bitbucket.

Register with GitLab and Create a Repo

Register for a GitLab account here or on your private GitLab server.
From a web browser, log into your GitLab account.
Create a new repo:
- Create a new project: https://gitlab.com/projects/new
- Click Create blank project.
- Project name: hello-world
- Click the Create project button.
Your remote GitLab repo is created.

Install Git Locally

Make sure that you have Git locally on your computer.

Check if you already have Git. From your local computer, open a macOS Terminal or Git Bash terminal and enter: git --version. If you have Git, then continue to Establish SSH Access.
Install Git:
- Windows: https://git-scm.com/download/win
- macOS: From the Terminal app, enter git --version and follow instructions to install Xcode Command Line Tools.
Introduce yourself to Git, using your real name and email:

  $  git config --global user.name "Your Name"
  $
  $  git config --global user.email "youremail@mail.com"
  $

For the remainder of this tutorial, "terminal" refers to either the macOS Terminal app or Windows Git Bash terminal.

Establish SSH Access

To access your remote GitLab repos from your local computer, you must first establish SSH access. This requires uploading your public SSH key from your computer to GitLab.

Check if you already have an SSH key:
- From the macOS terminal, enter: cat ~/.ssh/id_rsa.pub | pbcopy
- From the Windows Git Bash terminal, enter: cat ~/.ssh/id_rsa.pub | clip
- If the command succeeds, then your public SSH key is in the clipboard. Otherwise go to the next step.
Create your SSH key if it does not exist:
- Warning: Do NOT perform this step if the ~/.ssh/id_rsa.pub file already exists. This step will create/overwrite these files in your home directory: ~/.ssh/id_rsa ~/.ssh/id_rsa.pub.
- From the terminal, enter the following commands, replacing YOUREMAIL@MAIL.COM with your email address: cd ; ssh-keygen -o -t rsa -b 4096 -C "YOUREMAIL@MAIL.COM"
- Press the Enter key to accept all defaults. Do not specify a password, unless you want to enter a password each time you interact with the remote Git server.
- Go back to Step 1 above to copy your public SSH key to the clipboard.
Add your SSH key to your GitLab account:
- From a web browser, log into your GitLab account.
- Go to SSH Keys: https://gitlab.com/-/profile/keys.
- In the Key textbox, paste your public SSH key from the clipboard.
- Click the Add key button.
You now have SSH access from your local computer to your remote GitLab account.

Use Git Locally and GitLab Remotely

Now try to use Git locally and interact with your remote repos in GitLab.

From a web browser, log into your GitLab account.
Go to your hello-world repo, click the Clone button, and copy the Clone with SSH link to the clipboard.
From your local computer, open a terminal and go (cd) to a directory to work from.
Enter the following command to clone your GitLab repo locally on your computer. Paste the SSH link at the end. For example, if your GitLab username is JohnSmith:
```
git clone git@gitlab.com:JohnSmith/hello-world.git
```
There is now a hello-world folder locally on your computer. From the terminal, go into the folder: cd hello-world
Enter git status to see the current state of the repo. There are no changes.

Create a few local files:

echo "red blue green" > colors.txt
echo "apple cherry watermelon" > fruits.txt

Enter git status to see the current state of the repo. Now there are local changes.

Add the changes to the Git staging area:

git add colors.txt fruits.txt  # or simply: git add .

Commit the changes to the local repo:
```
git commit -m "my first Git commit" .
```

Now the two new files are part of your repo. Push your local changes to the master branch of the remote GitLab repo:

git push origin master
#  if you see an error, you may need to first: 
#  git pull origin master
#  to pull/merge the latest from the remote GitLab repo

git status  # repo is clean

From a web browser, go to your GitLab hello-world repo. Refresh the browser and verify that your local changes made it to the remote server.

Congratulations! You have successfully created a GitLab account and repo, established a local Git repo, and used Git both locally and remotely. Well done! Now learn more advanced Git commands and try them both locally and remotely.

Thanks for reading!

Follow me on Twitter @realEdwinTorres for programming tips, software engineering content, and career advice. 😊

10 Things I'd Tell My Younger Self About Programming

Edwin Torres — Mon, 06 Dec 2021 01:05:53 +0000

Here are 10 Things I'd Tell My Younger Self About Programming:

Don't be scared. It gets easier. Early on in my career, basic programming concepts like loops and arrays were difficult. With time and practice, programming concepts become straightforward.
Work on your communication skills. Communication skills are more important than you think. The way you present yourself to a colleague or customer has a big impact on your career. Write good documentation and emails. Practice presentation skills. Even if you are the most skilled programmer, nobody will give you credit if you don't communicate well.
Earn your master's degree in computer science as soon as possible. I earned my master's degree early on in my career. I wasn't motivated to do it, and I didn't quite see the benefit. But my master's degree has given me many opportunities such as career advancement, teaching, and my doctorate degree. Earning my master's degree is one of the best career moves I have ever made.
Take detailed notes. You are going to learn a lot in this field. The information will be overwhelming at times. Keep detailed notes and refer to them often. This will accelerate your learning and demonstrate your ability to grasp concepts quickly.
Ask questions, but ask them properly. You'll have lots of programming questions throughout your career. Before you ask a question, do your research. Understand the problem. Explain how you are approaching it. Describe your current difficulties. This will help someone help you. And never ask the same question twice! That's what your detailed notes are for.
Find good mentors. Learning from other people is extremely effective. Teaching others benefits you too. Find a good mentor and have frequent technical discussions with that person. Be a mentor and be mentored by your peers. This personal exchange of information will accelerate your career.
Plan your career. There is a saying: dress for the job you want, not the job you have. Think about where you want to be in your career in five years. Start planning for it by finding roles and responsibilities that give you experience for that career move. For example, if your next goal is to lead a development task, then spend some time with a current task leader and learn the role. Try to be a backup for that task leader to get real-world experience.
Avoid obsolescence. Follow the technical industry trends and keep your skills current. Do not simply code in one language for your entire career; if that language becomes obsolete, then so will you. Look for training opportunities in future technologies. Read technical articles, blogs, and social media to keep a pulse on industry trends.
Keep your resume updated. You never know when the right job opportunity might come. One day, you may be forced to find a new job. Keeping your resume updated will make it easier to find that next job.
Start a side gig. Whether it’s a programming blog, book, website, or other personal project, a side gig is an excellent way to hone your skills. The side gig might even become your main gig one day.

Thanks for reading!

Follow me on Twitter @realEdwinTorres for more programming tips. 😀

A Simple 2D Point Class in Java

Edwin Torres — Sun, 28 Nov 2021 21:28:15 +0000

Creating a simple 2D point class in Java is fairly simple. A Cartesian coordinate system uses points in two dimensions along an x-axis and y-axis. Each point has a pair of x and y coordinates along these two axes.

We define a SimplePoint class that has two private properties x and y:

public class SimplePoint {

  private double x,y;

}

To access each property, create two getter methods in the class:

  public double getX() { return x; };

  public double getY() { return y; };

We could also provide setter methods if desired.

A constructor method makes it convenient to create a SimplePoint object at a specific x,y location:

  public SimplePoint(double x1, double y1) {
    x = x1;
    y = y1;
  }

For example, to create two SimplePoint objects at x,y positions 2,1 and 8,2:

    SimplePoint p1 = new SimplePoint(2,1);
    SimplePoint p2 = new SimplePoint(8,2);

Finally, here is a distance() function to calculate the distance between two SimplePoint objects:

  public double distance(SimplePoint p) {
    return Math.sqrt( Math.pow(p.getX()-x,2) + Math.pow(p.getY()-y,2) );
  }

To calculate and output the distance between p1 and p1:

    System.out.println( p1.distance(p2) ); // 6.082762530298219

Here is the complete source code for the SimplePoint class, including the sample main() method:

public class SimplePoint {

  private double x,y;

  public SimplePoint(double x1, double y1) {
    x = x1;
    y = y1;
  }

  public double getX() { return x; };

  public double getY() { return y; };

  public double distance(SimplePoint p) {
    return Math.sqrt( Math.pow(p.getX()-x,2) + Math.pow(p.getY()-y,2) );
  }

  public static void main(String[] args) {
    SimplePoint p1 = new SimplePoint(2,1);
    SimplePoint p2 = new SimplePoint(8,2);

    System.out.println( p1.distance(p2) ); // 6.082762530298219
  }

}

Java makes it easy to represent 2D points. The SimplePoint class is one way to do that. Create SimplePoint objects at specified locations, then use the distance() function to calculate the distances between them.

Thanks for reading.

Follow me on Twitter @realEdwinTorres for more programming tips. 😀

Accessing Elements in 2D Arrays in Java

Edwin Torres — Sun, 28 Nov 2021 20:45:05 +0000

The two-dimensional (2D) array is a useful data structure. Like one-dimensional arrays, 2D arrays work well with for loops.

Here is a 2D array in Java:

int[][] arr = {
  {0, 1, 2, 3, 4},
  {5, 6, 7, 8, 9},
  {10, 11, 12, 13, 14}
};

The int[][] declaration means that arr is a 2D array of int values. Since there are two pairs of [], the array has two dimensions.

Look at this 2D array. It is actually an array of arrays. The array arr has a length of 3. It has three elements, or rows. Each row is an array of length 5:

{0, 1, 2, 3, 4}

{5, 6, 7, 8, 9}

{10, 11, 12, 13, 14}

The first array is arr[0]. The second and third arrays are arr[1] and arr[2] respectively. A for loop can access each of these arrays using an index:

for (int i=0; i < arr.length; i++) {
  int[] row = arr[i];
  System.out.println( Arrays.toString(row) );
}

Here is the output:

[0, 1, 2, 3, 4]
[5, 6, 7, 8, 9]
[10, 11, 12, 13, 14]

The for loop accesses each row. Since the row is also an array, an inner for loop can access each of its elements:

for (int i=0; i < arr.length; i++) {
  int[] row = arr[i];
  for (int j=0; j < row.length; j++) {
    System.out.println(i + "," + j + ": " + arr[i][j]);
  }
}

Here is the output:

0,0: 0
0,1: 1
0,2: 2
0,3: 3
0,4: 4
1,0: 5
1,1: 6
1,2: 7
1,3: 8
1,4: 9
2,0: 10
2,1: 11
2,2: 12
2,3: 13
2,4: 14

In the output, the first number is the row index. The second number is the column index. The third number is the element at that position of the 2D array.

Note how two indexes are required when accessing a single element of the 2D array. For example, arr[1][3] contains the int value 8. The for loop accesses each row in order. Once it has a row, then it uses an inner for loop to access its int values in order.

Here is a complete example:

public class Example {
  public static void main(String[] args) {

    int[][] arr = {
      {0, 1, 2, 3, 4},
      {5, 6, 7, 8, 9},
      {10, 11, 12, 13, 14}
    };

    for (int i=0; i < arr.length; i++) {
      int[] row = arr[i];
      for (int j=0; j < row.length; j++) {
        System.out.println(i + "," + j + ": " + arr[i][j]);
      }
    }

  }
}

When using 2D arrays, use two indexes. The first index is for the row. The second index is for the column. In other words, each element of a 2D array is an array. The first index accesses an array element. Then use a second index to access the elements in that array. To facilitate this, use a for loop with an inner for loop to provide the row and column indexes.

Thanks for reading.

Follow me on Twitter @realEdwinTorres for more programming tips. 😀

DEV Community: Edwin Torres

Using a Switch for Days of the Week

Calculate the Volume of a Cube in Java

Java Input and Arithmetic

Removing Sensitive Data in Git

Using Merge Requests and Feature Branches in your Git Workflow

Introduction

Prerequisites

Step 1 - Protect the main branch

Step 2 - Developers create feature branches

Step 3 - Developers create merge requests

Step 4 - Maintainers review merge requests

Step 5 - Developers update or delete feature branches

Simple Java Scanner Tutorial

Introduction

Prerequisites

Code

Additional Exercise

Simple Test-Driven Development (TDD) With Mocha and Node.js

Overview

TDD With Mocha and Node.js

Prerequisites

Tutorial

Your turn

Conclusion

Simple Git Branching Tutorial

Git Branching Tutorial

Assumptions

Tutorial

Hello Git: A Beginner's Tutorial on Git and GitLab

Introduction

Register with GitLab and Create a Repo

Install Git Locally

Establish SSH Access

Use Git Locally and GitLab Remotely

10 Things I'd Tell My Younger Self About Programming

A Simple 2D Point Class in Java

Accessing Elements in 2D Arrays in Java

Step 1 - Protect the `main` branch