Software Innovation Lab at Oregon State University

Welcome to the Software Innovation Lab. The lab is made up of students in the Software Engineering Track of the M.S. in Computer Science program.

Founded by Dr. Will Braynen, the lab has produced elevent projects, successfully defended as part of a Master's of Science degree in Computer Science. Six of which are open source. Look for the open-source logo below:

The lab's mission is twofold. The first is to produce socially beneficial software. The second is bridging the gap between industry and campus by (a) leveraging industry-relevant in-high-demand (non-sunsetting) technologies and by (b) developing the mindset of a software engineer. In particular, our lab focuses on full-stack architecture (both in-the-cloud and local but containerized) and tooling, where tooling is both technical (e.g. git, proxies, debuggers, and profilers) and conceptual (e.g. branching strategies, design patterns, inversion of control and SOLID principles of design, decoupling, testability, observability, and stateless security). Our lab's alumni have been hired by Amazon, Tesla, Intel, and a number of startups.

For cost and funding information, see the relevant department page.

Project Reports

Project reports for our defended M.S. projects (except non-thesis research reports). Our lab's official latex template can be found here.

2024

Graduation and Placement Trends in Philosophy Graduate Programs Using Automatic Web Scraping
Vladiszlav Pauk
PDF | GitHub
A non-thesis research report.

LegalAid: Legal Case Processing and Scheduling Software
Mahesh Narpat Chand
Committee: Bailey (chair), Sarma, and Hundhausen

Plants for Urbanites
Po-Hsuan (Aeliana) Shen
PDF | GitHub
Committee: Bailey, Braynen, Burnett, and Edmunds (Dept of Horticulture)
Tech stack: Swift, SwiftUI, AWS (API Gateway, Lambda, DynamoDB, S3), REST
Abstract. Plants for Urbanites is a mobile application that helps users purchase plants that fit their home environment by (1) measuring the light from the environment, (2) placing a virtual box on the Augmented Reality screen to calculate the approximate preferred plant size, (3) simulating indoor arrangements by placing the plant’s 3D model in the user’s home environment. This project was done in collaboration with the OSU Horticulture Department to validate the plant data. The Plants for the Urbanites builds on usability research from a HCI team project I led in an HCI course. The technologies it leverages are AWS serverless services (API Gateway, Lambda, and DynamoDB) and, for the frontend, ARKit with RealityKit on the iOS platform.

2023

Flow Magic: Screen Flow Simplified
Kedar Dhere
PDF | GitHub
Committee: Braynen, Bailey, Termehchy
Tech stack: Swift, SwiftUI, React.js, React Flow, REST
Abstract. Flow Magic is a tool, composed of a software development kit (SDK) and a web portal, that allows real-time modifications to an iOS mobile application’s screen flow without requiring code redeployment. ‘Screen flow’ refers to the sequence and navigation between various screens in an application. Traditionally, the screen-flow changes in a mobile appli- cation involve a lengthy process where the product owner creates a ticket, developers make code changes, and the rebuilt binary is submitted to the App Store, Apple’s application marketplace, for approval. Flow Magic streamlines this process by eliminating developer intervention and App Store verification, thereby allowing product owners to directly implement and push changes to production.

LabelFlicks
Anita Ruangrotsakun
PDF | Demo video | GitHub: backend, desktop
Committee: Braynen, Burnett, Lee
Tech stack: Svelte, FastAPI (Python, REST), TensorFlow, Figma, Swagger
Abstract. Using supervised machine learning (ML) to train a computer vision model typically requires human annotators to label objects in images and video. Given a large training dataset, this can be labor intensive, presenting a significant bottleneck in the model-development process. LabelFlicks is an open-source desktop application that aims to address this pain point with three helpful ML-assisted features: (1) a streamlined preprocessing pipeline to convert videos into a series of frames, (2) pre-labeling of video frames using an object detection model, pre-trained on the COCO dataset, that ships with LabelFlicks, (3) an ML-assisted human-in-the-loop workflow for correcting bounding box labels. For each frame of the video(s) provided by the user, LabelFlicks produces a text file containing labeled bounding boxes in the COCO annotation format. These datasets can be analyzed (e.g. for finding biases in data slices) or used to train or finetune an object detection model of your choice using model training tools such as PyTorch or TensorFlow.

SpotFinder: a dedicated parking app for campus parking
Shreya Dhume
PDF | GitHub
Committee: Braynen, Bailey, Termehchy
Tech stack: Kotlin on Android, REST, node.js for a mock server, Swagger. (QE focused: PR checks, unit-testable code, code coverage, etc.)
Abstract. SpotFinder is the mobile frontend of a parking system that helps drivers find a parking spot on campus. (The backend piece of the parking system was developed by others in the lab as part of a previous project.) Finding parking can be viewed as both a search problem and a coordination problem. The search problem is finding parking lots with availability and then performing a sort-and-filter on the search results (e.g. given some cost function). The coordination problem is avoiding having two drivers try to park in the same spot. For example, if there are 5 drivers, but only 3 available spots in parking lot A and 2 available spots in parking lot B, then five people should not be directed towards the same parking lot. SpotFinder solves the search problem by computing the most suitable parking lot based on real-time availability and the user’s estimated time to reach the parking lot. The coordination problem is solved using a soft-reservation concept. Rather than a firm commitment, this approach temporarily holds a parking spot to ensure that two people are not directed to the same spot, improving the odds of securing a parking spot.

Metadev: Metadata Driven ERP Development Framework
Supreeth Suresh Avadhani
PDF | GitHub | npm Registry
Committee: Braynen, Bailey, Termehchy
Tech stack: AngularJS, Java and PostgreSQL, OpenAI's Chat Completion API (with a custom model)
Abstract. Metadev is an open-source framework that facilitates the generation of complete Enterprise Resource Planning (ERP) applications through metadata. By 'metadata' I mean module-specification files from which Metadev produces a full-stack ERP system. ERP systems are a type of software which helps businesses to manage their day-to-day operations; for example, an ERP might be used to maintain employee records. The metadata can be written manually, generated from a text prompt, or using Metadev’s Graphical User Interface (GUI). The framework’s goal is to make implementing ERP systems affordable and simple for small businesses and non-profit organizations.

Yet Another Coding Platform (YACP): An Innovative Adaptive Platform for Personalized Learning of Data Structures and Algorithms
Rohit Nair
[PDF]
Committee: Braynen, Bailey, Termehchy
Tech stack: Next.js, MaterialUI, Supabase, Vercel, Judge0, Prisma, NextAuth.js, Figma, Swagger
Abstract. YACP (Yet Another Coding Platform) is a web-based application that utilizes spaced repetition and active recall, both cognitively informed pedagogical techniques, to help professional and student software developers prepare for technical interviews. These types of interviews are common in today’s workplace and are based on Data Structures and Algorithms (DSAs). DSAs are fundamental concepts in computer science education and skills critical for technical interviews, encompassing problem-solving, analytical reasoning, and coding proficiency. The platform tracks the user’s progress, where progress is a function of five variables: (1) time to solve, (2) the number of hints accessed, (3) whether the user looked at the solution, (4) the number of times the user ran their proposed solution against test cases, and (5) the number of failed test cases in the last run. Problem revisits are then scheduled using a multi-dimensional adaptation of the SuperMemo2 spaced-repetition algorithm.

HawkerHub: A community-driven hawker discovery platform
Anush Suresh Kumar
[PDF]
Committee: Braynen, Bailey, Termehchy
Tech stack: Flutter and Dart, REST, AWS (AWS Serverless Application Model, DynamoDB, S3, Lambda), Google Maps Platform, Figma, Swagger
Abstract. Technology has played a significant role in transforming the way businesses operate in recent years. It has helped businesses reach an extensive consumer base, improve operations, and increase revenue. Thanks to online food-delivery systems, restaurants can now reach customers who may not have been able to visit their brick-and-mortar locations. In developing countries, however, because of the low literacy rate and lack of awareness, the adoption of technology by small businesses, hawkers, and street vendors is slow. These small businesses, street vendors, and hawkers need their community’s support to sustain and grow. HawkerHub is a crowd-sourced, community-driven hawker discovery and indexing mobile application focused on enabling technology for street vendors, hawkers, and small businesses. This application, built on a mobile platform, aims to gather current and accurate information on these vendors to locate them quickly. It is an all-inclusive mobile application with an easy-to-use UI and simple and rapid contribution steps. By adopting these technologies, hawkers can focus on what they do best serving the community while leaving the rest to technology.

2022

SmartPark
Chay Nandam
PDF | GitHub
Tech stack: AWS (API Gateway, AWS Lambda, EC2, S3), MongoDB and PyMongo, Docker, Python, YOLOv4 and YOLOv5
Abstract. There is no online system to track the occupancy of a parking lot and advise if parking space is available at any given point in time. The CCTV cameras installed in the parking lots require manual effort to monitor and update the empty slots' information. It is intended to design a system that can track the parking lot occupancy automatically without human intervention presenting the empty/full parking spaces in the parking lot through a cloud-based online system. SmartPark is a concrete implementation built to solve this problem. This implementation provides an API (Application Programming Interface) to get occupancy information of nearby parking lots in real time based on the user's GPS location. This API is built with computer vision intelligence and Amazon web services in the backend. Any Web or mobile client can consume this API to get the list of nearby available parking lots and also the occupancy information such as the number of vacant parking spaces, number of vehicles and location details of each lot. If a mobile/web application wants to find available parking lots nearby a particular location, this API can be used to get a list of available parking lots nearby that location and also to get the occupancy information of one particular parking lot from the list of available parking lots.

Share What You Can
Amulya Gangam
PDF | GitHub
Committee: Braynen, Rose, Bailey
Tech stack: Kotlin on Android, Firebase, ML OCR on mobile device.
Abstract. Food is our primary source of nourishment. However, with the growing population, there has been a substantial increase in food waste by both restaurants and individuals. Share What You Can is an Android application designed to tackle this problem. The application operates as a two-sided marketplace to which donors upload images of and details about surplus food they want to share with receivers. Donors advertise that they have food by uploading images of the food they want to donate with an additional description that includes the food details. Receivers go through the donors’ posts and, if they like some food item from the listings, then they can request it. Moreover, food expiration dates are rarely considered in most food-sharing applications. To avoid the possibility of donating expired food, Share What You Can allows donors to scan expiration dates, ensuring only fresh food is shared.

Reshape, an Android Solution
Siri Chandana Gangam
[PDF]
Committee: Braynen, Rose, Bailey
Tech stack: Kotlin, ReactJS, Firebase
Abstract. Reshape is a platform that enables you to rearrange the screens of an Android mobile application without having to make any changes to the underlying source code and so without having to re-upload the build to an app marketplace. This can help reduce development costs and speed up deployment. This is similar to A/B-testing solutions available today, but with a focus on reshaping screen flows on the fly, which is a feature currently absent from those solutions. While Reshape is a prototype built for Google’s Android platform and so focuses on obviating the need to re-upload to Google Play, Google’s app marketplace, it is a proof of concept that is not specific to Google Play and Android. The same idea can be applied to Apple’s App Store and iOS, or in principle to any other distribution platform. Reshape includes a Software Development Kit (SDK), a web portal, and a backend that connects the two. The web portal shows a screen flowchart for the mobile application, which reflects the actual order in which the screens Dr. Will Braynen appear in the mobile application. Using the web portal, the Product Owner can change the screen order without having to lean on the help of a software developer. The Android SDK has the logic to rearrange the screens of the Android mobile application based on the order received from the web portal via Reshape’s backend.

See Emotion, Play Music
Swetha Jayapathy
[PDF]
Committee: Braynen, Bailey, De Amicis
Abstract. Sound is said to have healing power over the human body by inducing certain vibrations into the cells of the body. Music is one such element in our everyday lives. Listening to music may increase the release of pleasure-causing substances in the brain, which ultimately helps to reduce stress-causing hormone production in the body. Researchers have proved that there is a connection between music and mood. It is observed that people tend to become overwhelmed with certain emotions by repeatedly listening to the same kind of music. In certain situations, this may seem to affect the state of mind of a person. SEPM (See Emotion, Play Music) is a software that captures the current mood of a person by analyzing their facial expressions and recommends songs that help one lift their state of mind. If a person's current mood is sad, then SEPM helps uplift the person's mood by suggesting songs that are in a neutral mood range. In the same way, if a person's mood is neutral, it suggests songs with a mood range that is slightly higher than neutral and thereby helps in uplifting their state of mind. SEPM connects to the Spotify API and retrieves the user's data. SEPM then generates a customized playlist depending on the user's current mood, which can then be saved and retrieved. SEPM also has other features such as getting the user's top tracks, top artists, library, and recently played tracks. In real- time, this software would be a game-changer in many people's lives, uplifting their moods and carrying them forward energetically through the day.

Our process

Standards (and Expectations)

An MS project will, in the end, require (1) a codebase, (2) a project report, and serve to develop certain professional (3) skills (both technical skills and soft skills).

Also note that if you are not present on Slack (e.g. unresponsive to DMs or miss announcements in the #si-lab channel), you are missing from our lab because Slack is our lab's main communication tool. Plus you are highly encouraged to attend your labmates' sprint demos and come to your labmates' defenses (to show support or out of sheer intellectual curiosity).

1. Codebase

The codebase, or the contribution to one, needs the following.

1. Industry conventions. For example, semver or calver for versioning. (Note that you can use git tags and that many package managers supports semantic versioning.) Conventions are important because they help reduce information and communication costs, as well as help solve coordination problems.
2. Utilize docstrings, but also, first and foremost, name things in a meaningful way that follows industry conventions.
   • For example, "ParkingLotService" is a much better name than than "Service" (because too generic and too broad).
   • Learn and use the idea of self-documenting code (because code evolves but comments go stale).
   • A REST API specifies a collection of resources and actions you can perform on those resources. That means that you do not want to have a `POST /createPet` or `GET /getPet/{id}` or `PATCH /updatePet/{id}` endpoints. Instead, you want a resource called `pet` and `GET` and `PATCH` to be the CRUD operations you can perform on that resource. So, you want `POST /pet`, `GET /pet/{id}` and `PATCH /pet/{id}`.
3. A modern project-management process; that is, been developed using:
   • a product requirements document (a PRD) but not waterfalled
   • a gannt chart
   • tickets (e.g. Jira or GitHub)
   • all Scrum ceremonies with two-week sprints
4. A git repository:
• A README file. (Please learn and use markdown; btw, Slack and Confluence also support markdown.)
• a clear git history that was put together over a lengthy period via pull requests.
• The cloud repository should have relevant PR checks (e.g. unit tests, does it build, a linter). This will also help increase awareness of what CI/CD is and what it's for.
• A code-coverage badge
• It can make sense to have more than one repo. For example, Signal might have Signal-Desktop, Signal-Backend, Signal-iOS, Signal-Android, Signal-WebFrontend
5. Showcase an awareness of modern techniques:
• a modern architecture and design patterns. For example, MVVM (e.g. instead of MVC?), coroutines (or async-await) instead of completion handlers.
• But also not only does the concurrency technique matter, but your code should be threadsafe. Graduating with a master's in computer science, you should know what threadsafety
6. Testability, modularization, decoupling:
• If your mobile or web client needs to talk to a backend, then please architect your solution using a REST API, GraphQL, or gRPC. It is tempting to use an SDK (e.g. a Firebase SDK or an AWS SDK) or even use server-side rendering (e.g. Django's views). However, our aim is to learn decoupling techniques.
• If you have a mobile or web client, it should be unit testable. (If not pure functional programming, then think inversion of control / dependency inversion in SOLID principles.)
• Unit tests with decent code coverage. (Include a code coverage report; maybe modify the latex template to include a testability section?)
• If a client-server model, then component testable and decoupled. This is similar to unit testable, but where a unit is not a class/struct, but a process (so, the entire client). So, for example, implement a mock server which serves static JSON (e.g. S3 if only GETs, or express.js/node.js). Resource IDs should just be hardcoded into the route in the mock server (e.g. endpoint `GET /pet/{id}` can be mocked with a route `GET /pet/1` and `GET /pet/2`, where resource id 1 is for the happy path and resource id 2 is for the rainy day scenario or edge case). this also means that server-side rendering is off the table, even though it is easier to POC in; instead, use a REST API or GraphQL or gRPC; please do not use SOAP unless you have a really good reason to--otherwise, comes across as dated.)
• An example: a service should be behind an interface/protocol. This is a common omission.
• If a REST API, then need Swagger docs (e.g. OpenAPI 3).
7. Demonstrate an awareness of other modern architectural patterns, frameworks/technologies, and best practices:
• If using a backend database, then something that has good market value. Not MySQL, but instead DynamoDB or at least MongoDB. Also, an ORM instead of raw SQL statements.
• Images and videos and other large artifacts should not be stored in a database. Instead, the database could contain a link to them, but the assets themselves should be in S3 or similar.
• A web client should use a modern framework (not use raw html/css/javascript). Examples of acceptable frameworks: Svelte, Vue, Next.js, React (with Redux or without), Angular. Electron if building a desktop client is okay.
• A mobile client should not poll. Instead, push notifications or streaming (e.g. a WebSocket). Probably same for any client.
• You can choose something like Supabase instead of AWS. But it needs to be a conscious decision.
• REST (or similar) over Firebase. Firebase is for smaller shops. So if aiming for bigger salaries and H1B sponsorship, then need REST or similar, not Firebase.
• Use modern in-demand programming languages, not sunsetting ones. For example, Kotlin over Java, Swift over Objective C, Golang over PHP, and perhaps even Rust over C/C++.
• Hmm, javascripters should be aware of Typescript?
8. The feature set you should implement depends on what makes sense of your product. For example, authentication/authorization (e.g. user login) might be critical for a certain type of chat app, but might make no sense for an app that solicits anonymous feedback by crowdsourcing some evaluation task. Similarly, push notifications or offline mode (e.g. caching on the mobile device in its SQL database) in a mobile application might be essential for a POC/MVP of one type of product, but not critical for another.

2. Project Report

1. Use our lab's official latex template.
2. Diagrams:
• UML for classes (or similar)
• An entity relationship diagram (ERD) for relationships in a database
• Sequence diagrams
• Architecture diagram for full-stack architecture
• Architecture diagram for the backend. If AWS, then use these icon set: https://aws.amazon.com/architecture/icons
3. Be sciency rather than salesy. Compare the following abstracts: ...coming soon...
4. The abstract should be one paragraph and well written. Solicit feedback from advisor.
5. The quality of citations: a newspaper reporting the results of a scientific study is not a quality citation because (a) it is not an original source and (b) the author of the newspaper article is presumably a journalist and not an expert in the relevant field (that is, not a scientist). A journalist might, however, be the appropriate expert and an original source in some other scenario.
6. Final copy should be submitted to ScholarsArchive@OSU

This is not meant as a list of necessary and sufficient conditions for a successful project. But it is a good default checklist. Your project might not, however, follow a client-server model. Also, the project really needs to come together as a whole. For example, if there is less technical or social innovation, then clean professional execution matters more. But if your project is truly innovative, then you might be able to get away with something that's more like a POC than an MVP.

3. Skills

1. Learn how to touch type. Doing these exercises thirty minutes a day will teach you: https://www.typingclub.com. Learn the home row first and once you master it, and only once you master it, level up to exercises that use more than just the home row.
2. The ability to consume (that is, read and understand) professional technical documentation. So, for example, rather than rely purely on stackoverflow and youtube videos, you should get to the point where you actually successfully make use of the following kinds of docs: Coroutines guide and Kotlin coroutines on Android (if doing Android/Kotlin development), Swift and URLSession or Core Data and Combine (if doing iOS/Swift development). There are also good professional blog articles. For example: Creating a single-table design with Amazon DynamoDB
3. The ability to produce technical documentation. This is why, above, we include `README.md` for your git repository and a Swagger doc for your REST API.
4. Comfort with git commands and a conceptual understanding of how it works. For example, rebase vs. merge commits given that rebase rewrites history (which is important to understand), git patches, staging area, and how git is a directed acyclical graph (DAG). You will know how to use git from both the command line and from a GUI client that has diff viewer built in (e.g. Fork, SourceTree, Tower).
5. Debugging skills. This includes knowing how to use a debugger (setting breakpoints, etc). Please don't debug purely by using print statements when you can use a debugger.
6. Time-management skills and the ability to manage one's own project.
7. Learning skills.
8. Written and oral communication skills. The biggest piece of writing you will do will be your project report. At the other extreme of granularity, there is also Slack etiquette (e.g. using threads in a group channel and at least reacting with an emoji to someone's message in a group channel to signal that you saw and read their message.)

The motivation behind these standards is to make sure that you can get a good job, have a fruitful career, and be able to talk to colleagues while interviewing.

Project-based learning

To be a member of the SI Lab, you have to be enrolled in the Software Engineering Track in our M.S. in Computer Science program. To complete the Software Engineering Track, in addition to graduate coursework in Computer Science, you have to complete a software-engineering project of your choice in the SI Lab. Examples of different types of projects:

• Prosocial entrepreneurship (e.g. an app that helps single parents or helps drivers find parking on campus)
• Tooling for software developers (e.g. Postwoman or Proxyman)
• Technical innovation (e.g. a UDP version of Multipath TCP)
• A website that might help visualize, inform, understand or track some social development (e.g. noise pollution or homelessness)

Example 1. Software made for governments and businesses is notoriously less user friendly than consumer-grade software. You decide to change that, at least for the city of Corvallis. You design a software application to help make the Corvallis public transportation system be more user friendly. You do this by helping the Corvallis Transit System track the live locations of public buses and more effectively communicate that information to bus riders. You also expose this live data as a REST API. Collaborating with Google, you get the live data to appear in Google Maps (which currently uses schedules for Corvallis rather than live data), but leave the REST API endpoints publicly accessible for Corvallis residents too (e.g. to encourage local innovation and k-12 interest in coding).

Example 2. To help people coordinate and stay in touch, you take advantage of peer-to-peer network communication among mobile devices (e.g. see here for iOS and here for Android) to turn mobile phones into a mesh network during a natural disaster that knocks out the local internet service provider. You then use a distributed hash table and an overlay network to efficiently share photos of their cats or, should the situation become more dire, of missing loved ones to help with search and rescue. (And yes, somehow this doesn't just drain everyone's batteries; perhaps we assume that those who partake keep their phones plugged in.)

Example 3. You want to make VoIP handoff not only reliable but also smooth when transitioning from WiFi to cellular. You research this, experiment a bit, and come up with a novel solution. You implement a prototype. Notably, given that it is for VoIP applications, you do this for UDP, not just TCP.

Example 4. Problem: Social media platforms exacerbate polarization instead of aiding in rational political discourse. Premise: A social media platform that does better would do so by at least one, if not all three of the major moral theories: (a) it would yield better outcomes (e.g. it would result in less polarization), (b) it would be a place where people treated each other with respect, and (c) it would be where people were (behaved?) more virtuous. Question: What would a social media platform like that look like? Your solution: You build a POC to illustrate, conduct an experiment by launching it, and then write up your findings in your project writeup.

Example 5. Problem: Homelessness is on the rise. You start looking for user-friendly online sources that would help understand it and track its development in the US and Canada. You might imagine some sort of map, along with resources for the unhoused population (though how would they access them there?), agencies trying to help them, and anyone having researchy questions. You are inspired by questions such as: How long have they been living on the street? What percentage of them are women or children? What percentage have mental health problems (and as a result of having become unhoused or vice versa)? What percentage are military veterans? What is the age distribution? Are disability benefits enough to afford rent, food and transportation (e.g. a car) in the area or nearby? Do unhoused folks come from the same state (e.g. having lost the roof over their head) or from other states? If I were unhoused, how would I receive prescription medication or a state-issued ID if I didn't have one? Your solution: You start finding sources for this data (e.g. from online sources, studies, local agencies that work with the unhoused population locally), consolidating it all in one place, and communicating it in a way that is user friendly and easy to understand. Moreover, you get inspired by data visualization (e.g. the d3.js library and UW's Interactive Data Lab. You build an amazing and helpful website.

Example 6. After reading a journalist's coverage of privacy in tech, worried about privacy, you create a website that makes it easier for mobile developers to audit and create concise, easy to read, privacy policies when leveraging third-party dependencies (e.g. Google's Firebase SDK or Crashlytics or Alamofire).

Example 7. You also create a tool with which end users can easily audit the apps on their mobile phones; for example, what data is an app actually sending and to whom and when? Perhaps you even recruit a faculty member from OSU's Cybersecurity Group to also serve on your commitee and get additional ideas and help from that group.

Example 8. You improve software-development tooling. For example, you create a UI git client that specializes in a specific branching model and visualizes one's workflow in a way that you find more intuitive. Or perhaps you add a feature to a proxy tool (e.g. see here or here) to support rewrite rules for gRPC.

Example 9. You make yet another app. But your app does something that is helpful to the local community or some affected population (e.g. folks with allergies or single moms or the homeless or those trying to help them). You work with members of the relevant user group to (a) make sure your product actually addresses their pain points and needs, and (b) ship your product “into the wild” so that it is still in production today and is actually getting used by people.

Example 10. You make yet another website. But your website helps understand and visualize some social trend that you have been reading about. For example, it helps track noise pollution. To help yourself collect data, you leverage your undergraduate electronics degree to make a bunch of waterproof noise-meter boxes that you install around town and combine your data from another public source.

See examples

Past Works in Progress

People

M.S. Alumni

Po-Hsuan (Aeliana) Shen
Kedar Dhere, Barclays
Anita Ruangrotsakun, Momento
Shreya Dhume, Tesla
Supreeth Suresh Avadhani, Happy Companies
Rohit Nair, Sayari
Anush Suresh Kumar, Intel
Chay Nandam, Autonomize AI -> Relgo Networks -> Bizly -> IBM
Siri Chandana Gangam, Amazon
Amulya Gangam, Amazon
Swetha Jayapathy, Viasat -> The Home Depot

More Lab Members

Alexis Deviney
Bhagyashree Rajdeep Basudkar
Jennifer Wolfe
Kedar Dhere
Mahesh Narpat Chand
Matthew Pacey
Pang Fa (Ben) Chou
Pavan Sai Nallagoni
Preet Dhiren Tibrewala
Radhika Gupte
Sai Bhaskar Kumpatla
Samisha Khurana
Souvik Das
Subramanya Keshavamurthy
Sumer Patel
Upanshu Chaudhary
Vinootha Ginjala
Vladiszlav Pauk
Wadood Adam
Yatin Kumar
Zexian Li

Research Software Engineers Alumni

Tianle Yuan
Yun Han

Undergraduate Interns Alumni

Kateryna Melnykova (Kyiv Polytechnic Institute). In collaboration with Johannes Gutenberg University of Mainz, Germany (PI: Dr. Vladimir Pascalutsa)

Industry Mentors

Rex Posadas, backend
Ziad Hamdieh, iOS
Morgan Lutz, Android

Our values

The Software Innovation Lab aspires to the following five values.

• 1. Software engineering is a distinct discipline

  Software Engineering is a distinct discipline. At one polar extreme, it is not mere coding or “programming”. Consider software architecture, for example, which might not require the architect to write a single line of code. At the other polar extreme, it is not computer science, even if computer science is its parent discipline. Nor is it applied computer science, just as civil engineering is not applied physics.
  
  In higher education, this means that there are two gaps between industry and the traditional university. The first gap is between theory and practice. The second gap is between the discipline of software engineering and the discipline of computer science. The topics and courses we teach mirror the division of labor in our respective fields and so the courses in a software-engineering department would presumably mirror the division of labor in software engineering (e.g. backend development, frontend development, mobile development, DevOps, QA engineering, data engineering), not in computer science. The aim of this track is to bridge these two gaps.
  
  While OSU does not have a software engineering department, OSU's computer science department does offer undergraduate courses from both the field of computer science and the field of software engineering, both on the Corvallis campus, as well as the Cascades campus Bend, Oregon. But insofar as the Software Engineering Track is a software engineering track in a computer science department, pursuing the MSCS degree via this track is, in part, an interdisciplinary experience (which in turn presents opportunities for cross pollination).
  
  Whatever implications the distinctness of software engineering has for higher education and research institutions, software engineering is its own profession and its own discipline. This observation in turn raises questions of professional duties and responsibilities.

• 2. Transparency

  Whether running a tech firm or a university program, transparency is important. Transparency can be important for both institutional trust and for economic markets in which information isn't free and ubiquitous. For a variety of reasons, it is important for an education program to be transparent about how much it costs, what the risk is to an education consumer who invests time and labor into their education (and often money, either directly or via opportunity costs), and what realistic payoff the person investing can expect.
  
  For example, what is a program's attrition rate, do folks get good jobs in their field after completing the program, do students incur too much debt, and how long does the program typically take? So, we recently started keeping track of the track's performance statistics.
  
  Even if such transparency makes no difference to your decision making (although it likely will make a difference to some), I believe it is important in and of itself.

• 3. Thoughtful innovation

  When it comes to technology, there are two types of innovation: (1) the engineering details of a technology, and (2) the impact a technology has on society. In this track we pursue projects along either of these dimensions.
  
  Innovation is not simply change, but implies positive change. But even positive change can be disruptive. Being well adapted to the society within which one lives is an important part of wellbeing. Disruptions, however, can be bad for adaptation if a person has adapted to the previous state of things and is having trouble re-adapting. In fact we know that software tech has also brought with it a number of social problems, just as it has brought efficiency gains and made our lives better in other ways. Software firms and products are largely unregulated, at least in the United States (e.g. consider privacy).
  
  All this places some nonnegligible degree of responsibility on our profession and on us as members of that profession—on us as “technologists” to be thoughtful in our innovating. Thoughtful innovation aims to promote our wellbeing and keep our institutions healthy.

• 4. Helpfulness

  Try to be helpful to your colleagues, to your end users, and to society at large. As a student, that might mean, if your labmate is stuck, volunteering to help them by teaching them how to instead of writing or debugging for them. Don't hand over code. Instead, pair code. Sit down to figure out a problem together. Offer to tutor. Review each other's work and give each other friendly feeeback, e.g. via pull requests.
  
  Try to represent the interests of your end users and the interests of society, in your designs and implementations and, as your career grows, the kinds of products you choose to work on.
  
  As a working professional, helpfulness might mean mentoring as good mentorship is hard to come by. And as your advisor, my job is to try to be helpful to you in your professional growth. In short, try to be helpful to your classmates, your labmates, your colleagues, to your end users, and to society at large.

• 5. Professional integrity

  Once you graduate, you will represent Oregon State and our program and this very track. No pressure:).
  
  Professional integrity is about trust and trustworthiness. In a professional context, trustworthiness is in turn about professional competency and professional character. As your advisor, I have to be able to trust you. Your colleagues have to be able to rely on you. End users and the public at large have to be able to trust us as they rely on us. Given the information asymmetries that specialization and expertise bring, this is especially important. Being able to trust your mechanic, your doctor, and your banker is important. This is no different. Moreover, for employers to be able to trust OSU's grades and OSU's diploma and for our track's reputation to mean something is also important.
  
  Imagine a doctor who cheated his way through medical school; would you want to receive medical care from this medical professional? Your professional integrity, qua this program, includes academic integrity; please do not cheat and pass the work of others as your own. Instead, give credit, cite, do not talk or exchange stationary during an exam, and come to office hours and maybe ask your classmates for tutoring help if you need help. You will use this opportunity to learn things and acquire new skills, so that you don't cut corners and build a Ford Pinto once you are released back into the wild. We spend a lifetime learning how to build quality products that improve people's lives.
  
  Being trusted and being trustworthy are not the same thing, but hopefully they align.

Statistics (and Discussion)

Essentials

The program typically takes two years. In 2022 and 2023, everyone had a job offer in hand prior to graduation and a few folks in the lab even left the program prematurely, graduating with an MEng degree instead because they had a lucrative job offer. However, you had to be proactive and apply to jobs openings yourself. Not everyone found an internship (53% in 2022, 15% in 2023). In the 2023-2024 academic year, the tech job market took a turn for the worst, perhaps correcting for the overhiring that had taken place during the covid timeframe. As the lab had not accepted any new students for the 2023-2024 academic year in part because of this downturn in the market, we do not have any statistics beyond the above timeframe.

Re. our placement record above: both full-time and internship roles have mostly been software-development roles. A few folks had an interest and prior experience as quality engineers (that is, doing test automation rather than doing manual QA) and so have obtained those roles instead. We have not yet had anyone focus on CI/CD and SRE, but that would also fit within the purview of the lab.

There is currently no job or internship placement per se as folks have to look for both themselves. Because searching for internships and jobs can be time consuming and takes time away from studies—a serious opportunity cost—we are working on improving this and building out a pipeline.

Attrition in the track/lab was about 11% in 2022 (and similar in 2023, but still have to calculate). Attrition has mostly been caused by folks receiving job offers and preferring to take those job offers over staying in school.

Work produced

In 2022, the Software Engineering Track (formerly known as the Software Innovation Track) graduated four members of the Software Innovation Lab. In 2023, so far, 6 members of the lab graduated. Graduating in this track requires defending a master's project. This means that so far the lab has had 10 such defended projects; see here. Of the 10 projects, 6 are open source.

Our graduates get good jobs

In 2024:

• TBD
• Barclays
• (One person transferred to the AI group.)

In 2023:

• Momento
• Tesla
• Happy Companies
• Sayari
• Intel
• (One person left the track to join industry.)
• (One person transferred advisors.)

In 2022:

• Autonomize AI
• Amazon (2)
• (Additionally, two more people left the track to join Amazon.)
• The Home Depot (initial advisor: Kishore Bamidipatti)

The field. The median pay in 2020 among software developers, quality assurance analylists, and testers in the U.S. nationwide: $110,140 per year, with 22% job growth projected by 2030 compared to 2020 (source: BLS). For numbers above average compensation, see levels.fyi, but beware of seletion bias. We are still gathering a sufficiently large data sample to post meaningful statistics for the lab, but we believe we are better than average. That said, while everyone so far has gone to work in the private sector, the explicit mission of the lab is neither to place folks in the private sector (as "industry" could have a broader definition) nor necessarily to maximize their total compensation packages.

What we can say so far. 100% of our lab's students were able to secure full-time work either as software developers or as quality engineers in software development (depending on which career track they are more interested in). The job market was very hot in 2022 and has noticeably slowed down going into 2023 (e.g. Amazon had layoffs and Google had a hiring freeze). However, despite the economic slowdown, our graduates were able to find work (before graduating) both years and, moreover, total compensation for our graduates has continued to be in the six figures. Compensation packages seem to be a function of the following factors: (1) on average, FAANG companies pay noticeably more, (2) past work experience and the quality of marketable skills the person has developed, (3) whether the person had two offers they were able to negotiate against one another, and (4) how prepared the person was for technical interviews (including coding interviews). That said, market conditions in a given year have very high impact on the number of job openings (e.g. Amazon overhired and then had to correct in the following year).

Internships

Internships are important. Making an impression during your internship can lead to a job offer from that employer. An internship looks good on a resume to other employers as well.

In 2023, 15% of the students in our lab secured internships so far. They interned at the following companies:

• Amazon
• Forbes
• Limio (in London)
• Vegas.com

In 2022, 53% of the students in our lab secured internships. They interned at the following companies:

• Amazon
• DAT Freight & Analytics
• Intel
• Pride Places
• Sayari
• Stripe
• Tesla
• United Healthcare / OptumLabs