DEV Community: Denise Pen

Learning Java

Denise Pen — Mon, 25 Feb 2019 19:20:40 +0000

In the past few weeks I have been teaching myself Java. The languages I have worked with in the past (Ruby and Javascript) have been mainly for web development. I've decided that it's time to branch out and learn something new. I realize that Java can also be used for web development but it's also used for so much more.

Below is a list of references I have been using on my journey.

Introductory Book:
Think Java: How To Think Like A Computer Scientist

For anyone considering learning Java, this is the first resource you should examine. It's written by a computer science professor who was unhappy with the huge and complex textbooks first year computer science students were given. This book is only 266 pages (including appendices) and uses the Java language to introduce students to basic computer science ideas. Because it's so short it can be read rather quickly so you get a quick overview of the syntax of the language.

This book was a great intro to Java, object oriented programming in Java, and basic problem solving with the language. The language is presented in a very elementary and thorough way so the basics are extremely easy to absorb. If you're curious about the language and just want a quick peek to see if it's something you want to learn I highly encourage you to give this book a read.

Text Book:
Starting Out With Java

This is a text book used in universities for introductory computer science courses. Unlike the book above, this book is very thick (over 1000 pages) and chock full of detail. However, it is very easy to read. The concepts are presented in depth with accompanying illustrations. The end of the book also covers algorithms and data structures so this book can be used to prep for interviews.

I found myself using this book in tandem with the video course (listed below). Whenever a topic was presented in the video course I would look it up in this book to get more detail.

I have a hard copy of the book but the link above gives you access to the pdf version.

Video Course:
Udemy Java course

When possible, I like to supplement my learning with a video tutorial from Udemy. I am a visual learner and it helps me to see another person writing code, making mistakes, and discussing their approaches to a problem.

This course covers everything from the basic syntax of the language to working with databases, networking, building unit tests, and more.

I am only about 30% of the way through this course but from what I have seen everything is explained thoroughly and the pace is perfect for someone very new to the language. Also, the instructor and his team have responded to questions in less than 24 hours.

As I said, I am just beginning my journey to learn Java so this list is only the beginning. If you have any recommendations to add to my list, please feel free to leave them in the comments below.

Originally published here.

Recursion

Denise Pen — Mon, 18 Feb 2019 20:50:39 +0000

What Is Recursion

Recursion is a process that calls itself. With respect to programming, recursion is a function that calls itself.

How Does It Work?
A recursive function calls itself until it reaches the base case.

The base case is where the recursion ends. Without the base case your function would not know when to stop calling itself. Once the base case is reached the function stops calling itself and returns its final value.

Let's Look At An Example
Let's look at the following example of recursion:

We have a function that counts down from the number given to the function as an argument, until it gets to 1.

The base case instructs the function to return once the number has reached 1
( <=0 ).

The remainder of the function prints out the current value of the number and then decrements it before the countdown function is called again.

This cycle repeats until the number has reached the base case, at which point it prints out "You've reached the end" and the returns and exits the function.

Let's execute the function with a number:

countdown(4);

=> 4
=> 3
=> 2
=> 1
=> You've reached the end

The above function could have been solved with a simple for loop as well:

function countdown(num) {
    for (let i = num; i > 0; i--) {
        console.log(i)
    }
    console.log("You've reached the end")
}

As you can see for this simple example the for loop is much easier to use and understand. However, it is important to become familiar with recursion because is is used extensively in programming. Also, recursion comes up frequently in technical job interviews so take the time now to learn it.

Looking At Linked Lists

Denise Pen — Mon, 11 Feb 2019 15:11:22 +0000

A linked list is a data structure that includes a 'linked' sequence of nodes. Each node contains data.

In a singly linked list each node points to the next node in the linked list:

In a doubly-linked list each node points to the next node as well as the previous node:

In order to access a single node you must traverse the entire linked list until you land on that node.

For example, to find node 4 we must start at node 1, move to node 2, then node 3, and finally to node 4:

This is very different from an array where each value can be found by using it's index, or a dictionary (hash/object) where a value can be found using it's key.

One benefit of a linked list is that you can add a node to the beginning of a linked list using constant time (O(1)). This means that subsequent nodes do not need to be re-indexed as they do in an array. The newest node simply becomes the "head" of the linked list.

Have you ever used linked lists in your applications?

If so why did you choose them over other data structures?

Originally published at http://deniseonaquest.com/looking_at_linked_lists

Tackling Algorithms: Counting Unique Values

Denise Pen — Mon, 04 Feb 2019 01:15:04 +0000

Problem: Given an array of integers, count the number of unique values.

For example, if we have the following array:

[1, 1, 1, 1, 1, 1, 3, 5]

the count of original values is 3 => 1, 3, and 5.

First Solution: Frequency Counter

The first time I attempted this problem I decided to:
1. Create an empty object, and for every integer encountered either
2. Add that integer to the object or, if that integer is already in the object
3. Increment its value by 1.

Here is my code (using javascript):

function countUniqueValues(arr){

  let newObj = {};                  //created new empty object to hold integer values.

  for (let i=0; i<arr.length; i++){ //iterate over the array


      let char = arr[i];

      if ( newObj[char] > 0 ) {     //if the item is already in newObj 
          newObj[char]++            //increment its value by 1
      } else {
          newObj[char] = 1          //if the integer is not already in newObj put it there with a value of 1
      }

  }
  return Object.keys(newObj).length;   //return length of array returned by Object.keys(newObj)
}

Running countUniqueValues([3,3,3,4,4,4,5,5,5,5,5,6]) returns 4. because there are 4 unique values => 3, 4, 5, and 6.

If we want to see the value of newObj at the end of the function we can put *console.log(newObj) before the final return:

...
}
  console.log(newObj)
  return Object.keys(newObj).length;
}

Running countUniqueValues([3,3,3,4,4,4,5,5,5,5,5,6]) prints a newObj value of


newObj = {
     3: 3, 
     4: 3, 
     5: 5,
     6: 1
}

As you can see there are 4 keys in the object: 3, 4, 5, and 6.

At this point all that is left to do is count the number of keys which we accomplish with Object.keys(newObj).length.

Second Solution: Multiple Pointers

(Taken from this course)

To use this method you must start with a sorted array.

Compare the value at the index of i with the value at the index of j.
If they are equal move j ahead until we find something that is not equal to i.
If they are not equal move i up 1 space and put the value of j into i's new place.
Continue to do this until you have gone through the array completely. 'i' will be at the index of the final unique value. If we add 1 to this index number we will have the total number of unique values.

We will use the same array as above: [3,3,3,4,4,4,5,5,5,5,5,6]

Let's walk through the code:

function countUniqueValues(arr) {
    var i=0;

    for (var j=1; j < arr.length; j++) {
        if(arr[i] !== arr[j]){
            i++;
            arr[i] = arr[j]
        }
    console.log(i,j)
    }
    return i + 1;
}

After we have gone completely through the array one time every unique value is at the beginning of the array and 'i' is in the position of the final unique value:

We see that i is at index 3 so we just add 1 to this to get 4 which is the total number of unique values:

return i + 1

Because we are adding 1 to i this become a problem when we are given an empty array, []. If we were to use the above solution we would get a return value of 1. To combat this we can add a check to the beginning of the function to check for empty arrays:

if (arr.length === 0 ) return 0;

The final function is:

function countUniqueValues(arr) {
  if (arr.length === 0 ) return 0;
    var i=0;

    for (var j=1; j < arr.length; j++) {
        if(arr[i] !== arr[j]){
            i++;
            arr[i] = arr[j]
        }
    console.log(i,j)
    }
    return i + 1;
}

As you can see, the second solution to this problem only runs through the array once and there was no need to create an additional object or count the number of keys of that object so this second solution is much more efficient than the first. Although both solutions should have time complexity of O(n), the second solution is an improvement when it comes to space complexity.

How would you approach this problem?

Setting Up Vagrant for a Rails Application: Part 2

Denise Pen — Thu, 24 Jan 2019 04:54:17 +0000

In a previous post we configured the Vagrant File in preparation of using the vagrant box to host a rails application. In this post I will walk through how to configure he vagrant box and include your rails application to it.

After the vagrant file has been created you can simply run vagrant up to start it. To ssh into it simply use the command vagrant ssh and you will see that you are now in your vagrant box. We are now in a fully functioning yet isolated operating system.

Configuring The Vagrant Box

Since I plan to run a rails application in this environment I need to add everything needed to run rails: git, rvm, ruby, rails, nodejs, and Postgresql. I took my instruction for setting up git, rvm, ruby, and rails from this article.

Install git:

sudo apt-get update
sudo apt-get install git

Install curl:

sudo apt-get install curl
\curl -sSL https://get.rvm.io | bash

Load rvm:

source /home/vagrant/.rvm/scripts/rvm
rvm requirements

Install whatever version of Ruby you choose:

rvm install 2.1

Set your Ruby default version:

rvm use 2.1 --default

Verify your Ruby version:

ruby -v

Install rails:

gem install rails

Check your rails version:

rails -v

Install bundler:

gem install bundler

Bundle your gems:

bundle install

Install node js:

sudo apt-get install nodejs

Install Your Database(s) - I used Postgresql

$ sudo apt-get install postgresql libpq-dev
$ sudo su - postgres
$ psql

    postgres=# CREATE USER vagrant;
    postgres=# CREATE DATABASE your_database_name;
    postgres=# GRANT ALL PRIVILEGES ON DATABASE "your_database_name" to vagrant;
    postgres=# \q
$ exit

The database(s) that you created above should have the same name as the database(s) used in your rails application. Database names are set in the database.yml file.
For example, my application's database.yml file has the following setup:

default: &default
    adapter: postgresql
    pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>

development:
    adapter: postgresql
    username: vagrant
    database: main_rest_development

test:
    adapter: postgresql
    username: vagrant
    database: main_rest_test

production:
  <<: *default
  database: main_rest_production

Please keep in mind that the alignment of your text in this file must be perfect or it won't be read correctly!

Once all of this is done your vagrant environment is configured and ready to run your application.

Creating An Application From Scratch

If you will be creating an application from scratch you will need to do that on your local machine.

Performed on you local machine - Not Vagrant

You should open a new tab in your terminal to the same directory where you created your Vagrant file.

To create a new application simply run rails new your-app-name --database=postgresql.

This will create a new application in this directory and the database should be configured with the names and permissions you assigned above.

Performed in Vagrant

To run this application you must go into the other terminal tab where the vagrant box is running. Move (cd) into the '/vagrant_file' directory (or whichever directory you designated as the synced folder in the Vagrant file). Move (cd) into the new app's directory. Run 'bundle install'. Then start your rails server using rails s. Your application should now be running on the port or url you designated.

Using An Existing Application

This must also be performed on the local machine.

Performed on you local machine - Not Vagrant

You should open a new tab in your terminal to the same directory where you created your Vagrant file. If you have an existing application that you want to use you can simply clone the code from github to your local machine:

git clone your_existing_app

You will need to update the database.yml file to have the correct database, and database names.

Performed in Vagrant

To run this application you must go into the other terminal tab where the vagrant box is running.

Move (cd) into the '/vagrant_file' directory (or whichever directory you designated as the synced folder in the Vagrant file).

Move (cd) into the new app's directory.

Run 'bundle install'.

Then start your rails server using rails s. Your application should now be running on the port or url you designated.

When you you are finished running your application you can stop it. Move into the Vagrant's root file and type exit. This will put you back into you local machine.

On your local machine type vagrant destroy and your box is now stopped.

It is quite alot of work to configure the Vagrant box to run your application. However, once configured this box can be used for any other rails application that needs the same setting in the future. It can also be copied and moved to other systems if necessary. Vagrant provides total isolation which will give your apps much needed stability.

Setting Up Vagrant for a Rails Application: Part 1

Denise Pen — Mon, 21 Jan 2019 15:30:09 +0000

Recently I was given a technical challenge that required me to create a rails application inside an isolated environment. I was given the choice of either using a Docker container or a virtual machine.

I didn't have any experience with either of these environments but after doing some research I decided to use a virtual machine (vm). Though they both perform the same task, Vagrant seemed to need less set up to get started.

To begin I downloaded VirtualBox which is the virtualization engine that Vagrant will be built on top of. Then I downloaded Vagrant.

I then created a directory that will be the root of my vagrant environment and cd'd into the directory.

mkdir vagrant_demo
cd vagrant_demo

To initialize this directory to be used with Vagrant you must run 'vagrant init' followed by the name of the base operating system you want to be used in your Vagrant environment. I used 'ubuntu/trusty64' to create a Linux environment.

vagrant init ubuntu/trusty64

The above command creates a VagrantFile in your directory. You receive the following message after running 'vagrant init':

A `Vagrantfile` has been placed in this directory. You are now
ready to `vagrant up` your first virtual environment! Please read
the comments in the Vagrantfile as well as documentation on
`vagrantup.com` for more information on using Vagrant.

This Vagrantfile dictates how your Vagrant environment is configured and can be changed to fit each individual application. Below is a copy of the Vagrantfile we just created:

# -*- mode: ruby -*-
# vi: set ft=ruby :

# All Vagrant configuration is done below. The "2" in Vagrant.configure
# configures the configuration version (we support older styles for
# backwards compatibility). Please don't change it unless you know what
# you're doing.
Vagrant.configure("2") do |config|
  # The most common configuration options are documented and commented below.
  # For a complete reference, please see the online documentation at
  # https://docs.vagrantup.com.

  # Every Vagrant development environment requires a box. You can search for
  # boxes at https://vagrantcloud.com/search.
  config.vm.box = "ubuntu/trusty64"

  # Disable automatic box update checking. If you disable this, then
  # boxes will only be checked for updates when the user runs
  # `vagrant box outdated`. This is not recommended.
  # config.vm.box_check_update = false

  # Create a forwarded port mapping which allows access to a specific port
  # within the machine from a port on the host machine. In the example below,
  # accessing "localhost:8080" will access port 80 on the guest machine.
  # NOTE: This will enable public access to the opened port
  # config.vm.network "forwarded_port", guest: 80, host: 8080

  # Create a forwarded port mapping which allows access to a specific port
  # within the machine from a port on the host machine and only allow access
  # via 127.0.0.1 to disable public access
  # config.vm.network "forwarded_port", guest: 80, host: 8080, host_ip: "127.0.0.1"

  # Create a private network, which allows host-only access to the machine
  # using a specific IP.
  # config.vm.network "private_network", ip: "192.168.33.10"

  # Create a public network, which generally matched to bridged network.
  # Bridged networks make the machine appear as another physical device on
  # your network.
  # config.vm.network "public_network"

  # Share an additional folder to the guest VM. The first argument is
  # the path on the host to the actual folder. The second argument is
  # the path on the guest to mount the folder. And the optional third
  # argument is a set of non-required options.
  # config.vm.synced_folder "../data", "/vagrant_data"

  # Provider-specific configuration so you can fine-tune various
  # backing providers for Vagrant. These expose provider-specific options.
  # Example for VirtualBox:
  #
  # config.vm.provider "virtualbox" do |vb|
  #   # Display the VirtualBox GUI when booting the machine
  #   vb.gui = true
  #
  #   # Customize the amount of memory on the VM:
  #   vb.memory = "1024"
  # end
  #
  # View the documentation for the provider you are using for more
  # information on available options.

  # Enable provisioning with a shell script. Additional provisioners such as
  # Puppet, Chef, Ansible, Salt, and Docker are also available. Please see the
  # documentation for more information about their specific syntax and use.
  # config.vm.provision "shell", inline: <<-SHELL
  #   apt-get update
  #   apt-get install -y apache2
  # SHELL
end

This file is written in the Ruby programming language and as you can see most of it is commented out. The only lines not commented out are the lines to configure the vagrant box (or operating system):

Vagrant.configure("2") do |config|
    config.vm.box = "ubuntu/trusty64"
end

In order to define other aspects of your virtual machine you can modify the Vagrant file as needed. If no modifications are made default settings are used. There are 5 specs in this file that can be modified:

-config.vm.box - This defines the operating system of your virtual machine and for our app we used ubuntu/trusty64.

-config.vm.provider- This defines the vm provider or base for our vagrant environment. We are using VirtualBox. We can also modify the memory and number of cpu's needed for the vm. For my rails app I increased the memory from the default value to 4G:

config.vm.provider "virtualbox" do |vb|
    vb.memory = "4096"
end

If you needed more cpu's you could use:

config.vm.provider "virtualbox" do |vb|
    vb.cpus = 2
end

-config.vm.network - This is how your host computer sees your vagrant box and application. Here you can configure the ip address and ports for your application.
Since rails applications default to port 3000 I updated this network setting:

 config.vm.network "forwarded_port", guest: 3000, host: 3000

Where the guest is the vm and the host is our computer.

-config.vm.synced.folder - This is where you define how the files on your virtual machine (your Vagrant box) will access files from the host (your computer). This allows you to create and alter your project files on your computer without having to do it in the virtual machine. These files will then be automatically synced with the Vagrant box if desired. I used the following:

config.vm.synced_folder ".", "/vagrant_files"

The first argument "." points to the current directory on our computer or the 'vagrant_demo' directory. This is where we will put our rails application and tells our vagrant box to use these files. The second argument, "/vagrant" is the directory we want to be built on the vm to house our rails application. In essence our files are on both our computer and in the vm but we can alter them on our computer and they will be automatically housed and synced on the vm in the "/vagrant_files" directory. You can name this directory whatever you want. I just used "/vagrant_files" for simplicity.

-config.vm.provision - This is the heart and soul of the Vagrantfile. This is where we define how we want to set up the virtual environment. We can instruct the vm to retrieve and install any applications, gem, modules, or whatever we need here. In the above automatically generated Vagrantfile we see an example of this:

config.vm.provision "shell", inline: <<-SHELL
     apt-get update
     apt-get install -y apache2
   SHELL

Notice that because this is a linux machine we can use normal linux commands to define and set up our environment.

The final version of the Vagrant File is:

Vagrant.configure("2") do |config|

  config.vm.box = "ubuntu/trusty64"
  config.vm.network "forwarded_port", guest: 3000, host: 3000
  config.vm.synced_folder ".", "/vagrant_files"
  config.vm.provider "virtualbox" do |vb|
    vb.memory = "4096"
  end

Once we have defined the Vagrantfile we can use the command vagrant up and this will get our vagrant box up and running.

In my next blog post I will describe how to add the rails application to your vagrant box.

Express HTTP Requests

Denise Pen — Thu, 17 Jan 2019 18:41:30 +0000

What's the best way to make an HTTP request in express? Using 'request', 'fetch', 'axios' or something else?

Console.table()

Denise Pen — Mon, 14 Jan 2019 16:21:25 +0000

Like all javascript programmers I will frequently throw a console.log into my code. I find it so much faster to log to the console than to deal with debugger for quick sanity checks. Recently I came across console.table which blew my mind and won a permanent place in my heart.

What Is It?

It's exactly what it sounds like - it allows you to log your data to the console as a table. Let's say we have the following array:

let people = ["Frank", "Mary", "Bob"]

If we use console.log we get this output in the console:

["Frank", "Mary", "Bob"]

However, with console.table we get:

You can see that we get a list of each item in the array as well as the item's index (or position in the array).This might seem like overkill for such a simple array but console.table can also be used for objects. In fact the Mozilla Web Documents state:
If data is an array, then its values will be the array indices. If data is an
object, then its values will be the property names.

Let's look at an object:

let courses = { math: "calculus", science: "biology", language: "french" }

console.log gives us this:

while console.table gives us this:

Now, an array of objects:

Let's look at the following array:

let students = [ { name: "Beth", course: "Math", age: 25 }, { name: "Adam", course: "English", age: 29 }, { name: "Amy", course: "Physics", age: 32 }, ]

console.log will return:

console.table returns:

This is fantastic because now our complicated array of objects is in an easy to read table. For me, it's so much easier to understand and grapple with data when it's in tabular form.

One Last Thing...

When using console.table you can also restrict the columns that are shown in the table. Continuing with the array of objects used above, if we only want the student's names and ages logged out we could use the following:

console.table(students, ["name", "age"])

to return:

As you can see, console.table gives you a few options to quickly review and analyze your data on the fly.

What other debugging tools have you stumbled across that could be helpful?