Sometimes these tools can get you into trouble in browserland. Infinite loops, app hanging after a crash, or serious performance hit, whatever. The point is that you need to kill chrome quick so you can start it back up and keep working.

After trying to use the GUI way of quitting chrome with great failure, I used to always resort to the command line and figure out some kind of ps aux | grep -i chrome magic sending a kill -9 (sigkill) to one of the billion chrome processes running.

I built this little gem about a year ago with the help of an excellent answer from stackoverflow:

#!/bin/bash
kill -9 $(ps aux | grep -i '[c]hrome' | awk '{print $2}')

Basically, the command finds every process id from the results of the grep search for chrome and applies a kill -9 against it. I have this saved in a file that I can just run whenever I need it.

The post Force Quit Kill all Chrome Windows MacOS appeared first on Ryan McCormick.

Karma autoWatch Workaround

By adding --watch after the ng test in the package.json file (looks like `ng test –watch`) and running `npm run test` from the command line, I was able to make the runner stay in watch mode. This can also be accomplished by running `ng test –watch` from the command line as well.

That is all I have for today, happy coding!

The post SOLVED: Angular 6 CLI Karma Stuck in Single Run | Karma Stops Running appeared first on Ryan McCormick.

This post is to document how I did this for future reference, but will hopefully be useful to other people solving the same problem. I understand that there is an apt package that I can add and do it that way but it is not owned, maintained or controlled by Oracle. Because I am who I am, I do it manually. This is my own opinionated approach and it works. This is meant to be a guide, I take zero responsibilty for any problems you may encounter while performing the next few steps. All of that being said, please post questions/comments if you encounter issues.

Lets get started.

Step #1: Download the Java 8 SDK from Oracle.

Because of the speed at which technology changes and Java is headed toward version 10, I am hesitant to share links. This link may or may not work by the time you are reading this. If in the case it no longer works, visit google and search for ‘Java SE Development Kit 8 Downloads’.

Java SE Development Kit 8 Downloads

I chose to download 8u172, Linux x64, the one ending in .tar.gz. If you are running RHEL (Redhat Enterprise Linux), CentOS or Fedora, you should download the rpm and be aware that these instructions won’t work for you at the point of updating the alternatives. This is a guide for Ubuntu.

Step #2: Move tarball to Installation Reference Location.

The subtitle for this section can be deceiving if you are not familiar with how symlinks or references work. But stay with me here.

Create a directory at /usr/lib called jvm-oracle. You will need to use the sudo command as this directory is at root level:

sudo mkdir /usr/lib/jvm-oracle

Copy your tarball over:
sudo cp ~/Downloads/(name of your tarball) /usr/lib/jvm-oracle

Move into the /usr/lib/jvm-oracle and extract your tarball:
Move into: cd /usr/lib/jvm-oracle
Extract: sudo tar -xvzf (name of tarball)

List out the directory contents and find your extracted folder:
ls -al

You should see a directory like ‘jdk1.8.0_172’ which is mine at the time of this article. Move into your dir and the bin folder with cd and list out the contents.
Move to new dir: cd jdk1.8.0_172. Tip: if you type a part of the directory name and hit the tab key, it should auto complete. If it doesn’t, type a little more of it and try hitting tab again.
Move to bin: cd bin
List out Contents: ls -al

This directory (bin) contains all of the executables you will need to reference for updating your alternatives. Get the path to this directory and copy/paste it into gedit or your favorite text editor.

Step #3: Add to Ubuntu Alternatives.

I like to prepare the next three command lines in a text editor so I can just copy/paste them into the command line and hit enter.

Here are mine, double check the jdk directory name before using them.
NOTE: Be sure to paste them into a text editor before pasting to the command line. And paste/execute one line at a time.

sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm-oracle/jdk1.8.0_172/bin/java 1
sudo update-alternatives --install /usr/bin/javac javac /usr/lib/jvm-oracle/jdk1.8.0_172/bin/javac 1
sudo update-alternatives --install /usr/bin/javaws javaws /usr/lib/jvm-oracle/jdk1.8.0_172/bin/javaws 1

Since references are directly symlinked to your path, you should immediately have the ability to check to see if your update-alternatives commands worked.
Java Runtime Version: java -version
Java SDK Compiler Version: javac -version
Java Web Start Version: javaws -version

You should see version output for the above commands when hitting enter after entering each one. If you don’t, re check your update-alternatives commands.

Step #4: Add JAVA_HOME to your environment.

Here is a fancy command that can be used to append a JAVA_HOME to the end of your .bashrc file. If you manually type, be sure to take notice of single quotes versus backticks. This is very important.
echo $'\nJAVA_HOME='`which java` >> ~/.bashrc

Check to make sure it appended:
cat ~/.bashrc

If you need to change anything, open in vim, nano or gedit to fix:
gedit ~/.bashrc

Alternatively, you can add it manually by opening your .bashrc file and setting JAVA_HOME=/usr/bin/java

Close your terminal, reopen a new one and type echo $JAVA_HOME to ensure your environment var has been properly set. If you don’t see /usr/bin/java for output, close all terminal sessions, open a new terminal session and try the echo $JAVA_HOME again. If you are still having issues, check the entry in your .bashrc file again.

If you want to set a system-wide JAVA_HOME, add to your /etc/environment file. Note: Because /etc/environment is under the root path, you will need to use the sudo command before your editor command.

That is all I have folks. Be sure to post questions/comments. Happy coding!

The post How to Manually Install Java 8 on Ubuntu 18.04 LTS appeared first on Ryan McCormick.

Step 1: Completely Remove All VirtualBox Packages and Folders from Ubuntu

If you are interested in checking out all of the package versions on your system before uninstalling, you can run dpkg -l | grep virtualbox

To uninstall and remove all packages, run sudo apt-get remove virtualbox* --purge

This command does a couple of things:
1. Identifies virtualbox packages to ensure all versions are targeted by using the asterisk wildcard.
2. The purge option also triggers removal of any configuration files.

To also remove all of the VMs stored in the home directory, move to the next step.

Step 2: Remove all VMs from Home Directory

NOTE: The sudo rm command with -rf is a very destructive command. Always pay attention to what your command is doing before hitting enter.

ANOTHER NOTE: This will remove all VMs that have been installed to the default home folder location. If you don’t want to remove VMs, don’t complete this step.

Because “sudo rm -rf” is destructive, check to see if you even need to use the command by locating the files and attempting to delete without sudo.

1. Browse to your home directory (you can usually just type cd and hit enter).
2. run ls -al
3. If you see the directory “VirtualBox VMs”, you can try to delete without sudo first rm -rf ./"VirtualBox VMs" (you need to use double quotes around the folder name because of the space). If you run into file permission problems, you can try to take ownership and then try deleting without sudo sudo chown `whoami` -R ./"VirtualBox VMs" and then try rm -rf ./"VirtualBox VMs". If all else fails, and it makes sense, use sudo: sudo rm -rf ./"VirtualBox VMs".
4. Remove config files from home directory. Technically, when running your apt-get remove with purge, all config files should have been targeted, but it is good to check anyway. From your home directory, change into your .config folder cd .config and look for a folder named VirtualBox. Try removing without sudo at first (since it is located in your home folder, you should have the ability to do so) rm -rf ./VirtualBox.

At this point, all of your previous VirtualBox installation should have been removed.

The post Remove VirtualBox from Ubuntu 16.04 Xenial appeared first on Ryan McCormick.

I wanted to migrate a bunch of old code to an archive drive and because of the size of each “node_modules” directory, I didn’t care to save “node_modules” archives with my old projects (especially since I can just run npm install to reinstall if needed).

Clear all node_modules Directories | Mac and Linux

Since I don’t have any control over how individual users use, input, modify or copy/paste the node_modules nuke command, it is only reasonable that I mention that I take zero responsibility for the outcomes of the use, misuse, etc… you get the picture.

TL;DR: I saved about 5GB after running this command:

1. Open your terminal.
2. Browse to your master project directory or the top level of where you have a bunch of projects stored.
3. Run the command: find . -name "node_modules" -type d -prune -exec rm -rf '{}' +

How it works

Since this blog is driven towards educating about the process of solving problems versus just providing blind answers, lets take some time to break this command down into pieces to examine how it works.

1. find . Instructs the find program to search for files in the current directory ..
2. -name "node_modules" Instructs the find program to search for files named “node_modules”.
3. -type d Instructs the find program to only look for file directories named “node_modules”.
4. -prune Instructs the find program to not descend into the current file/directory for it to exclude child “node_modules” directories. On Mac, since -d was specified, -prune has no effect on the find program’s lookup results (per the man pages). However, on Linux, -prune still instructs the find program to not descend into the current file/directory.
5. -exec rm -rf '{}' + Instructs the find program to execute rm -rf on the matching results. The code '{}' + instructs the command line to be built by appending each selected file name at the end thus invoking the rm -rf command less times than the total number of “node_modules” directory matches. This helps with performance.

And there you have it. As I mentioned above, I saved ~5GB by running this command. If you have a lot of projects, you could easily clear up more than ~5GB.

The post Clear all Node Modules Folders Recursively Mac/Linux appeared first on Ryan McCormick.

I can’t take all of the credit for this. Some awesome people posted the solution for JS imports on stackoverflow. At the very minimum, I am creating this post so I have something to reference later on as well.

Add Spaces Between Import and Braces in Webstorm Settings

1. Open Settings: File > Default Settings
2. Expand Editor Menu on Left
3. Expand Code Style Menu under Editor Menu
4. Click JavaScript or TypeScript if you are using TypeScript
5. Click on the Spaces Tab in the right content area
6. Scroll Down to Within Settings
7. Select ES6 import/export braces
8. Click Apply and Ok to close

Enjoy looking at clean, consistent imports!

The post Webstorm adding spaces between imports and braces | JavaScript and TypeScript appeared first on Ryan McCormick.

I have a really large table with a bunch of fieldnames that I need to query through to make some sample data for another project.

I thought that it would be easiest to quickly grab all of the field names from my target table so I can filter out only the ones I need and not manually type a bunch of field names.

I am sure there are other trivial ways of doing this, but since you found my post, you are probably looking to do what I am doing here.

Get Column Names from Access Recordset with VBA

Sub getFieldNamesFromTable(targetTable As String)
    Dim db As DAO.Database
    Dim rs As DAO.Recordset
    Dim strSQL As String
    
    Set db = CurrentDb
    
    strSQL = "SELECT TOP 1 * FROM " & targetTable
    
    Set rs = db.OpenRecordset(strSQL)
    
    For Each fName In rs.Fields
        Debug.Print fName.Name
    Next fName
    
    'Do While Not rs.EOF
    
    'Loop
    
    db.Close
    Set db = Nothing
    Set rs = Nothing
End Sub

And then to use this method, set up another sub in a module or wherever

Sub tableNamesRunner() 
	getFieldNamesFromTable ("MyAccessDBTableName")
End Sub

The post Get Column Names From Access Database Table with VBA appeared first on Ryan McCormick.

Get Current Ubuntu Version From Command Line

If you are an Ubuntu or Debian user, you can get the latest distro from the command line by running the following:

lsb_release -a

Get Current Distro Version from Command Line Redhat/CentOS/Fedora

CentOS and Fedora are based on Redhat. You can get the current distribution by issuing the following commands:

# CentOS ONLY
cat /etc/centos-release 

# CentOS/Redhat/Fedora
cat /etc/redhat-release 

Get the Current Linux Kernel Version from the Command Line

Sometimes it is helpful to find the latest kernel version of the Linux distro you are running. You can get this info by running:

uname -a

The post How to Get Linux Distro Name and Kernel Version from the Command Line appeared first on Ryan McCormick.

As a workaround, org.apache.http.client.HttpClient can be added as a substitute.

Add Apache HttpClient as a Dependency

Before you get started, you need to add the Apache HttpClient to your classpath manually or via build tool.

If you are using gradle, you can add the following to your build.gradle dependencies (Be sure to check the version).

dependencies {
	compile('org.apache.httpcomponents:httpclient:4.5.3')
}

If you are using Maven, you can add it to your pom.xml:

	org.apache.httpcomponents
	httpclient
	4.5.3

Use Apache’s HttpClient as a Substitute for TestRestTemplate

To highlight the implementation, I have added three steps in the code comments below.

import com.example.Repository.ContactRepository;
import com.example.model.Contact;
import org.apache.http.client.HttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.json.JSONObject;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.client.RestTemplate;

import static junit.framework.TestCase.assertEquals;
import static org.junit.Assert.assertThat;

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class UpdateContactsTest {

    // STEP #1
    // Add the TestRestTemplate
    @Autowired
    private TestRestTemplate restTemplate;
    private RestTemplate patchRestTemplate;
    // END STEP #1

    @Autowired
    private ContactRepository contactRepository;

    private Contact contact1;

    @Before
    public void setup() {
        contact1 = contactRepository.saveAndFlush(new Contact("NotRyan", "McCormick", "555-555-5555"));

        // STEP #2
        // Add Apache HttpClient as TestRestTemplate
        this.patchRestTemplate = restTemplate.getRestTemplate();
        HttpClient httpClient = HttpClientBuilder.create().build();
        this.patchRestTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory(httpClient));
        // End Step #2
    }

    @Test
    public void updateContactOneWithPatch() throws Throwable {
        String resourceUrl = "/api/v1/contacts/" + contact1.getId().toString();

        // Create JSON Object
        // { "firstName": "Ryan" }
        JSONObject updateBody = new JSONObject();
        updateBody.put("firstName", "Ryan");
        
        // STEP #3
        // Use patchRestTemplate to make call with PATCH method
        ResponseEntity responseEntity =
                patchRestTemplate.exchange(resourceUrl, HttpMethod.PATCH, getPostRequestHeaders(updateBody.toString()), Contact.class);

        // Ensure Status Code is 200 OK
        assertEquals(HttpStatus.OK, responseEntity.getStatusCode());

        // Ensure Content-Type is application/json
        assertEquals(MediaType.APPLICATION_JSON_UTF8, responseEntity.getHeaders().getContentType());

        // Ensure that PATCH updated firstname
        // from "NotRyan" to "Ryan"
        Contact updatedContact = responseEntity.getBody();
        assertEquals("Ryan", updatedContact.getFirstName());
        assertEquals("McCormick", updatedContact.getLastName());
    }

    // Moved Over from TestHelper for Blog Post
    public HttpEntity getPostRequestHeaders(String jsonPostBody) {
        List acceptTypes = new ArrayList();
        acceptTypes.add(MediaType.APPLICATION_JSON_UTF8);

        HttpHeaders reqHeaders = new HttpHeaders();
        reqHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);
        reqHeaders.setAccept(acceptTypes);

        return new HttpEntity(jsonPostBody, reqHeaders);
    }

After setting up the TestRestTemplate like the example above, PATCH should now be available.

As always, please comment with questions, suggestions, improvements, etc…

The post SOLVED: Testing PATCH with Spring Boot TestRestTemplate appeared first on Ryan McCormick.

In this post, I will be breaking down a really ugly legacy controller and converting it to controllerAs syntax.

Legacy Ugly Angular Controller Example

It can probably get uglier than this, but this is going to be our starting point.

// File: app.js
var app = angular.module('myApp', []);

app.controller('AppController', ['$scope', '$log', function($scope, $log) {
  $scope.title = 'Welcome to My App';
  $scope.setTitle = function(newTitle) {
    $log.log('New title is ' + newTitle);
    $scope.title = newTitle;
  };
}]);

ControllerAs Conversion

Before we break the above example to controllerAs, we need to analyze to see what it is doing. The example above declares the main app module and sets a controller on it in the same file.

If this was the whole app, it would be just fine but since this scenario is almost never the case, we need to break it out into seperate files.

Create app.module.js file

(function() {
  'use strict';

  angular.module('app', []);

})();

Create app.controller.js file

(function() {
  'use strict';

  angular
    .module('app')
    .controller('AppController', AppController);

  AppController.$inject = ['$log'];

  /* @ngInject */
  function AppController($log) {
    var vm = this;
    vm.title = 'Welcome to My App';
    vm.setTitle = setTitle;
    
    function setTitle(newTitle) {
      $log.log('New title is ' + newTitle);      
      vm.title = newTitle;
    }
  }

})();

Convert to ControllerAs Syntax Summary

So what did we do?

1. Use module setter in app.module.js file and use getter from app.controller.js file. By following this approach, we set the module once and get it from the controller. If we had a directive or service, we would also be only setting the module once in the app.module.js file and getting it once in the respective service or directive file. This approach helps prevent variable collisions and leaks.
2. Wrap all methods in a Javascript Immediately-Invoked Function Expression (IIFE) to prevent global variable scoping and enforce local variable scoping. This approach also helps make code more minifiable.
3. Enable strict mode with 'use strict'. I am not going to go into all of the benefits of strict mode here. There is an excellent article by John Resig ECMAScript 5 Strict Mode, JSON, and More that goes into more detail if you are interested.
4. Use named functions which removes callbacks and nested callbacks to produce more readable code.
5. Use an injection schema that is more conducive to making code minifiable when using a build process with gulp, grunt, webpack, etc…

More ControllerAs Syntax Resources

1. If you are interested in learning more about the controllerAs syntax, I highly recommend the Angular style guide by John Papa
2. I also highly recommend John Papa’s course on Pluralsight: AngularJS Patterns: Clean Code that goes into great detail about each section of the style guide listed above.

Please comment with questions, suggestions, best practices.

The post Refactor Legacy AngularJS Controller to ControllerAs Syntax appeared first on Ryan McCormick.