Month: February 2022

Wow! Time has completely flown by and I am now finishing up Week 8 in Capstone. Not only is this nearing the close of the course, but it’s also the close of my time at OSU. I want to hit a quick recap on my team’s project followed by a really quick recap of OSU.

My team’s project is almost complete, at least the minimum viable product (MVP) that meets all user requirements. The final user requirement being implemented this week is the algorithm that ‘grades’ a language learner’s answer against the answer submitted by the content provider. Another teammate worked on the code for the algorithm and it basically uses FuzzyWuzzy, a Python library, which is based on Levenshtein distance. Levenshtein distance is a method to measure the distance between two strings.

So, to summarize what my team was able to accomplish this quarter. We built a mobile app using Expo and React Native. Only 1 out of 4 of us had previous experience building mobile apps, and 1 member had never worked with React. We were able to implement the ability for a registered user to record and store audio files in Google Firebase and allow other users to playback these audio files in the app. Most of the group members, including me, had no previous experience with Firebase or making Firebase queries. We successfully implemented Google’s Speech-to-Text API to convert recorded audio to text. No one in our group had previous experience using this API. Lastly, after this week we will have implemented the ability to score a user’s answer against a stored answer. This was a learning experience for all of us and I think we succeeded.

Lastly, to summarize my time at OSU. It took me exactly two years to complete the program and I still can’t believe how much I’ve grown and learned. I came in with absolutely no programming or computer science experience. I was able to not only build projects to display on my resume, but I was also able to land a summer internship that extended into the school year and ultimately will convert to full-time employment.

Even though this program was fully online, I have enjoyed interacting with the OSU post-bacc community. There are so many involved students, professors, TAs, and alumni that I never felt ‘alone’. This program is certainly what you make of it so, it’s likely not for everyone. However, I would certainly recommend this to anyone interested in computer science and looking to change their career.

I thought it would be interesting to deviate from a focus on the technical skills of computer science and aspiring software engineers and focus on personal qualities instead. We all know that our jobs and careers are not just defined by our technical abilities, but also the ‘soft skills’ or our personal abilities. After all, that’s why interviews exist and why behavioral-type questions are asked.

Over the summer, I held a series of short coffee chats with employees in the company I was interning with. These were early career to senior-level employees. I picked their brains about their career journeys, how they define successful employees, how they approach their jobs, etc.. In this post, I will share some of what I learned.

A team lead within a research development engineering group once told me the top 5 qualities they look for in an ideal engineer. In their opinion, the ideal engineer:

1. Knows how to plan
2. Knows how to write code
3. Knows how to triage defects
4. Has the ability to do code reviews well
5. Works within the environment that’s given

Another team lead shared with me their ideas of a successful employee. They believe that technologies can be taught and learned, but successful employees display:

• Teamwork – ability to work with others
• Initiative – volunteering to do things or taking control of own career
• Learning Ability – know how to learn and what to focus on, how do you keep yourself current?
• Collaboration (to me, this is similar to teamwork, but with outside groups)

Throughout my internship, I also heard from others about the value of mentorship. Below are some more thoughts that employees shared with me:

• “Have confidence in yourself. Everyone is scared.”
• When you don’t know something: “I wasn’t born with that knowledge.”
• Knowing when to ask: “Help me figure out how to do it”
• “When you have a task always try to do it better than the way it was previously done”
• Value stream: “No task today happens in silos. Always try to connect the dots. ”
• “Don’t be afraid of a hard ask. It’s an opportunity for growth if it’s hard”
• “Be comfortable knowing that there will be change. Channel uncertaintly around change into excitment and motivation”

I believe all of these qualities and quotes are helpful to keep in mind. Particularly as I transition how of this phase of being a student and into a full-time employee. I’ve done this once before in my previous career and now I have a chance to do it again. However, this time I have a lot more experience and general business knowledge to bring to the table.

In my internship, I’m starting a project in which the goal is to keep a record of files that store variables used in a system. Currently, the place where these files are stored does not maintain any type of changelog. User changes to these files are not recorded. My project develops a process to monitor and record file changes by utilizing GitHub for version control, Jenkins Pipeline for automation, and Snap Logic to build the files. Since a lot of this is new for me I thought it would be great to run through these technologies and how they could be used to maintain an automated system to monitor, record, and implement file changes.  

Most of us are familiar with using Git and GitHub for version control. Oftentimes remote repositories contain a ‘main’ branch that contains the reviewed and approved code. Source code changes made by users are housed in branches that are merged with the main branch upon approval. Depending on how the repository is set up, a user submitting changes must submit a pull request (PR). Within the pull request various workflow actions, as well as a code review(s), take place. Workflow actions could check for formatting, linting, etc…

Jenkins is a CI/CD automation tool for building, testing, delivering, or deploying software. In Jenkins, a Pipeline can be used to get software or code from a version control system like GitHub to an end-user. A Pipeline is built using a Jenkinsfile which can be written using declarative or scripted syntax. Jenkins declarative syntax is written using Groovy, an object-oriented language for the Java platform. Jenkins can be integrated with GitHub so that a Jenkins Pipeline is triggered when a user merges a PR to a particular branch.

SnapLogic is an Integration Platform as a Service (IPaaS) tool to connect data sources and automate workflows, like ETL (extract, transform, load) flows, through the use of pipelines. SnapLogic can connect and retrieve data from a variety of sources, transform the data, then write files or load data to end-user systems.

With regards to my project, the above-mentioned files will be housed in a GitHub repository so that a record of changes to files can be maintained. When a user wants to make changes to the files, they will submit a PR to merge their changes to main. Once the PR is approved, a Jenkins Pipeline will determine what files are newly added, modified, and/or deleted. These file changes will be mapped to a Groovy object and ultimately output as a JSON string to SnapLogic using the HTTP post method. SnapLogic pipelines will verify the data, then write or delete the files on the end-user.

Just a snapshot of some new technologies I’m working with and how they aid in automation.