A Bit About Me
Hello! I'm Stephen James, a 4th year student at UB pursuing BS and MS degrees in Computer Science, along with a minor in Mathematics. I have served as a teaching assistant for courses including Introduction to Quantitative Analysis and Reasoning, Digital Systems, Systems Programming, Data Structures, Introduction to Algorithms, and Information Assurance, and have also previously been an academic tutor for a few introductory Mathematics courses (such as Calculus I).
I have been involved with organizations such as my university's ACM student chapter, UB ACM, where I currently serve as the vice chair. Another organization I've been involved with at my university is UBNetDef, where I've helped students with learning more about cybersecurity, participated in competitions such as CCDC and CPTC, and helped with organizing our own cybersecurity competition, Lockdown. I have also helped with managing (both physically and virtually) the groups' infrastructure, which consists of a router/firewall running pfSense, a stack of Dell PowerConnect switches, iSCSI servers for storage running FreeNAS, and a vCenter instance with a few dozen ESXi hosts. Apart from sometimes attending hackathons at other universities, I am one of the lead organizers of UB Hacking, an annual student-run hackathon hosted at my university.
Outside of my involvements on campus, I have spent the summers of 2017 and 2018 as a intern at Google.
In the summer of 2017, I was as an Engineering Practicum Intern and worked on an engineering productivity team. Generally speaking, our primary customers were other engineers and engineering teams within the company. Specifically, I worked on an internal full-stack web application (using Java and Angular Dart) that served as an interface for a sandbox management tool that, among other things, both reduced the time taken for running integration tests and made the results more reliable and consistent.
The majority of my time was spent on facilitating a way for users to graphically create and/edit sandbox configurations, reducing the need for them to be familiar with the configuration languages that the underlying services used. Furthermore, since sandboxes are comprised of components that could have their own dependencies, I also implemented validation to ensure they have all the dependencies met, suggesting components that can be used where possible. The final selection, however, had to be made by the user, because there could be multiple components that can satisfy each dependency, but by providing the most relevant information about each component, users would be able to make their decision more easily.
In the summer of 2018, I returned as a Software Engineering Intern, though with a different team (Funding Choices). For the first half of this internship, I focused on improving the user experience for publishers by making it possible for them to see a summary of the sites they managed through the product. There were publishers managing more than a thousand sites, and there was previously no way for them to access a summary from a centralized location (they would have previously had to visit the page corresponding to each site). I then spent the second half of ths internship designing and implementing a notifications system that supported both stateful notifications (which need to be acknowledged/dismissed) and stateless notificatons (which only show up when certain criteria are met), varying severities, localization, and more.
I certainly enjoyed both experiences; I learned a lot and met great people throughout both internships.
You wanted to know some of the projects that I've worked on? Here is a non-exhaustive list!
I built an aviation weather parser in Python (source code on GitHub). It is able to parse raw/encoded weather reports (METARs/SPECIs) and forecasts (TAFs), as well as their individual components. It can therefore identify values such as the time of observation, the wind direction, the visibility, the cloud ceiling, and even the cloud cover, whether you supply an entire report/forecast or just a specific component!
This parser can also be accessed using the web API, which I created using the Flask web framework.
Have you ever thought about how elevators work? Me too! (You did say yes, right?) I also went ahead and created a simulator (source code on GitHub)! I know that it isn't the most efficient, but I've been preoccupied with classes and other projects, among other things. Maybe one day I'll improve that!
This simulator allows you to not only operate single elevators, but also multiple elevators within a single controller. Imagine being in a building with two or more elevators beside each other, but only one set of buttons from which to call them on the outside. Depending on the direction you wish to go, you press the corresponding button and wait, while one of the elevators will be delegated to handle your call in order to take you to your destination. I have created logic to simulate how that may happen, along with allowing the user to specify particular floors for the elevator to visit (as if you were pressing the buttons on the inside).
The initial version of this software was written entirely in Python, using Tkinter to render the GUI. Considering the highly multi-threaded design, I became a victim of CPython's Global Interpreter Lock.
Before demoing this at the 2016 Computer Science Education Week (CS Ed Week) event hosted by my university's Department of Computer Science and Engineering, however, I decided to rewrite the front-end to be web-based. I retrieved updates about the state of the simulator in JSON (after setting up the backend as a Flask server), and I used data binding via Vue.js to render the updates client-side. By having a browser handle the rendering, I was able to reduce the number of threads running, therefore reducing the effects of CPython's Global Interpreter Lock.
Still being dissatisfied with the speed, I converted the entire backend to use the Go programming language just before demoing again in April 2017 for Accepted Students Day at UB. This allowed for faster response times from the server (over 500 times, in fact). In addition, with Go being great for concurrency, I also achieved much better scalability.
Using Java, I put together an API and a GUI for converting between some commonly-used units of measurement. It currently supports conversions for units of length, mass, and temperature (and again, off to GitHub you go)!
While we're still on Java projects, I may as well mention KeyBricks (and as you might have expected, the source code is also on GitHub). This project initially emerged as a class project I was assigned, but I have since refactored it and added a few new features.
KeyBricks is an actual game, but my version was not intended to fully recreate it, or to even function in entirely the same way. In a nutshell, you'll get points for removing (or "breaking", as the original game says) bricks (for some reason, we called them tiles throughout the class project... I might want to rename that in the spirit of the name of the game). The more bricks you break at a time, the more points you get.
What's your high score?
Radar is a web application that visualizes aircraft on a simulated primary radar screen in near real-time. An airport can be chosen to be at the center of the radar by entering its IATA or ICAO code. The name and weather conditions of that airport will be displayed. Aircraft are positioned on the screen based on both their great circle distance and angle from the airport, and will only be updated when the radar sweep passes over to simulate the behavior of a real-world primary radar. Furthermore, the radar's radius can be adjusted to show larger or smaller distances around the airport, and will directly affect the choice of what aircraft are displayed on the screen.
I'll work on adding a few more here in the near future, but until then, feel free to see some more recent work on GitHub, such as Netscrape, TaskTaskTask, and UB Utils!
If you'd like to get in touch with me, I recommend that you send me an email.