Projects & Portfolio

Audio Visualizers

I created a simple audio visualizer created to test Web Audio API functionality with multiple choices of 2D graphics.

Using the experience I gained from the first audio visualizer, I developed an augmented reality audio visualizer with more detailed options to configure a specific 3D visualization, user login and more.

In the video below is the the prototype, but the features have not changed much.

During my RBC work term, it was decided from the beginning of the term that I would be working on a project with a team of co-op students, two developers and two business systems analysts. The goal was to develop an app called Now Mobile, and the app was to be a mobile version of an already existing platform within the ServiceNow product suite. It resolved a business need for work during travel, since opening up an app during commute or a business trip was more efficient than booting up a laptop.

Working together with the Now Mobile team as a developer co-op student, we designed a mobile application that would allow internal RBC employees to request items, read knowledge articles, approve requests and delegate tasks to other employees when they are away. Using the app builder available within the ServiceNow platform and JavaScript syntax, we created new components, debugged existing ones and rearranged the UI so that it would match RBC branding. The final application was presented to executives after it entered the final stages of testing, and the feedback was overwhelmingly positive.

Through the process of creating the Now Mobile application, I learned about the ServiceNow platform, how to work with another developer in a team, and all the formal stages of software development. App builder documentation, free ServiceNow courses, and fellow employees who took time out of their day to help me when I had trouble were all helpful in my journey to develop the mobile application. I believe if I had the chance to recreate the artifact, I might remove some redundant changes and speed up the solving of early technical issues, but overall, it would not change all that much.

import groovy.json.JsonSlurper
import groovy.json.JsonOutput

String project = "" // change to project key
String auth = "" // change to authentication string
String url = "" // change to root/domain string

String inUrl = "${url}search?jql=project=${project}"
def inConnection = inUrl.toURL().openConnection()
inConnection.addRequestProperty("Authorization", "Basic ${auth}")
inConnection.addRequestProperty("Accept", "application/json")
inConnection.addRequestProperty("Content-Type", "application/json")

inConnection.setRequestMethod("GET")
inConnection.doInput = true
inConnection.doOutput = false
inConnection.connect()

JsonSlurper json = new JsonSlurper()
def projMap = json.parseText(inConnection.content.text)

def epicMap = [:]

for (issue in projMap.issues) {
    def epic = issue.fields.customfield // change customfield to Epic Link field ID
    def effort = issue.fields.customfield // change customfield to Effort field ID
    print issue.key + "\t" + effort + "\t" + epic
            
    if (epic != null && effort != null) {
        if (epicMap.containsKey(epic) == false) {
            epicMap[epic] = effort
        } else {
            epicMap[epic] += effort
        }
    }
    println "\t" + epicMap
}
            
epicMap.each{
    epic, time ->

    String outUrl = "${url}issue/${epic}"
    def outConnection = outUrl.toURL().openConnection()
    outConnection.addRequestProperty("Authorization", "Basic ${auth}")
    outConnection.addRequestProperty("Accept", "application/json")
    outConnection.addRequestProperty("Content-Type", "application/json")
              
    outConnection.setRequestMethod("PUT")
    outConnection.doInput = true
    outConnection.doOutput = true
              
    String update = """
    {
      "fields" : {
        "customfield" : ${time}
      }
    }""" // change customfield to Estimated Time field ID
              
    outConnection.outputStream.withWriter{
        t.write(update)
        it.flush()
    }
              
    outConnection.connect()
              
    try {
        outConnection.content.text
    } catch (IOException e) {
        try {
            ((HttpURLConnection)outConnection).errorStream.text
        } catch (Exception ignored) {
            throw e
        }
    }
}

During my Innovapost work term, it was decided from the first goal planning meeting that I would be showcasing the research and knowledge gained during the first month of work by creating a small program. Calculating the estimated time for an epic was a useful endeavour that tied all the topics and that no one had yet created anything for, so the task was assigned to me.

Working independently as a DevOps engineer co-op student, I created an application that could be run from command line using Groovy and the Jira REST API. Using the “GET” request method from the URLConnection class, I requested JSON content to parse using JsonSlurper into a map. The map was then iterated through, and the estimated times for each story within the epic were added together and sent back to update the proper field in the parent epic using the “PUT” method. The final application was presented to the team during one of the daily stand-up meetings, and no flaws were picked out.

Through the process of creating the Estimated Time application, I learned about REST APIs, how to connect to URLs with an application, the Groovy language and how it ties to Java. Groovy and Jira Cloud REST API documentation, sample code in GitHub repositories and confused forum posters were all helpful in my journey to complete the estimated time application. I believe if I had the chance to recreate the artifact, I might remove some redundant code and clean up the formatting, but overall, it would not change all that much.