0
1
0
0
1
1
0
1
0
1
1
0
1
0
0
1
0
1
1
0
0
0
1
1
0
1
1
0
1
0
0
0
0
1
1
0
0
0
0
1
0
1
1
0
0
1
0
1
0
1
1
0
1
1
0
0
About Me 👋
H
I'm Michael Iwanek - and this is my portfolio website to showcase projects I've completed for personal learning and development.
I'm currently employed as a full stack software engineer, and am a recent graduate from Oregon State University - where I obtained a B.S in Computer Science through an accelerated post-bacc program. My first degree was in accounting, and I successfully switched careers after four years as a CPA in public accounting and government roles.
I first discovered programming by self-teaching myself VBA to automate work tasks, and discovered how much I enjoy working through coding problems and building things. I currently work on full stack applications using languages such as C#/.NET, Python, TypeScript, PostgreSQL, and others as needed for various projects.
Outside of work and school, I enjoy rock climbing, skiing, and PC games. I'm hoping to eventually climb multi-pitch routes and get into back-country skiing one day.
Projects
Please see full-stack Computer Science projects I've completed below, in various programming languages.
PyTorch Image Classification Website - Java Spring Boot/ Flask/ TypeScript
1 of 13
- A full stack machine learning project involving multiple deployed PyTorch computer vision models. A user can choose between a mask-rcnn (Instance Segmentation) model, giving near pixel accurate detection, or fast-rcnn (only bounding boxes). A TypeScript site can be used to upload images or provide the URL of an image to run computer vision analytics on. Bounding boxes and masks produced by the neural network can be dynamically resized by the user.
- The model is deployed to to an AWS EC2 instance, where a Java Spring Boot API handles requests from the front end and sends binary image data to a Flask microservice. The Flask app runs a custom inference.py script I've written which invokes the model. This script loads an image as a NumPy array into the Torch model and returns its predictions as a JSON object. Masks are returned as an array of binary values.
- The Java Spring Boot API takes multi-part-form data from the front end to route to the Flask microservice. From the UI, a user can upload an URL of an image which is downloaded and converted to a blob, then appended to the form data. An image file can also be uploaded from their computer/phone with a file explorer pop up, or by dragging and dropping the file onto the web page.
- After receiving data from the PyTorch model, the front end uses the JavaScript Canvas to plot the bounding boxes and accuracy of the models predictions onto the image provided by the user. The model is capable of analyzing multiple objects in an image and can plot each of these bounding boxes on a supplied image. If an image URL is preferred over an image upload, a user has the option of choosing images I've pre-selected from a drop down, or copying and pasting their own image URL they've found on the internet.
- The model was developed using a Sagemaker/Jupyter Lab Notebook in Python. It was first deployed to an AWS SageMaker endpoint and invoked by an AWS Lambda which directly sends the image as Base64 encoded data to the endpoint. The Lambda is in turn invoked by an AWS API Gateway, which is configured to directly accept binary image data from an Axios post request. Going forward this and Heroku will likely be a backup or turned off due to high costs - and only ran on the EC2 version.
Ski & Rock Climbing E-Commerce Store (.NET/ C#/ TypeScript/ PostgreSQL)
1 of 19
- A complex full-stack website (e.g - REI/Amazon clone) where users can search for and review products, add them to a cart, and submit/pay for an order with a mock PayPal account. An admin dashboard allows for CRUD operations on users, products, and orders without directly editing the PostgreSQL database.
- Implemented TypeScript and Redux for global state management on the front end. A .NET/C# API uses Entity Framework Core and JWT authentication to communicate with a PostgreSQL relational database hosted on AWS RDS. A secondary Express.js API/microservice uses Socket.io to enable bi-directional communication between admins and clients - for order help via a chat button.
- Deployed on an AWS Elastic Container Service (ECS) cluster via serverless AWS Fargate. Implemented a CI/CD pipeline via a GitHub Actions .yml file which re-builds and deploys three docker images to ECR/ECS for the front end/.NET backend/express.js microservice. This runs whenever new commits are pushed to the default branch.
- Deployed Python AWS Lambda Crons with EventBridge rules to shut the site down between 1AM-6AM (to save hosting costs). Added an EventBridge Lambda which publishes to an SNS Topic, to notify me via email if a container crashes.
- Added an EC2 load balancer to redirect HTTP traffic on port 80 to HTTPS port 443. The front-end is served by a Nginx reverse proxy, which is defined in a nginx.conf file ran by the docker container. AWS Route 53 and the AWS Certificate Manager provide an SSL certificate to the domain name backed with 2048 bit RSA encryption.
- Used the PayPal SDK and sandbox accounts to simulate live payments of orders by the website, sending order info to PayPal and marking an order as paid in the PostgreSQL database depending on the external API response.
- Modeled complicated database relationships between products, orders, and users with intersection tables and many-to-many (M:N) relationships in PostgreSQL. For example, products have a (M:N) relationship with orders. A product also has a one-to-many (1:M) relationship with reviews, and a user has a (1:M) relationship with orders.
- Managed the PostgreSQL database via both code first and database first approaches. Initially used Entity Framework (EF core) via commands such as db-scaffold to generate C# models and classes from tables (database first). Then later used EF core database migrations to dynamically generate SQL to make database table updates, after only editing C# models (code first).
- Implemented resource based authorization via C# JSON web token (JWT) middleware in the API, so that users can only access their own data. The JWT contains user data in its payload, which is hashed via the HmacSha256Signature cryptographic algorithm - using a symmetric key only known by the API. This allows the API to pull information from the JWT with confidence that it is not spoofed, as any spoofing would lead to a different JWT signature than what the API would expect from a certain payload.
- Google OAuth2.0 is also incorporated into the application using JWT security, allowing a user to login conveniently with their google account after being registered.
applyYourSelf Job Application Tracker - MERN
1 of 5
- Full-stack MERN web application that allows multiple users to track their job application history on one convenient website from anywhere. Allows jobs to be searched, sorted by date, name, and categorized by application status with full CRUD functionality.
- A dashboard shows statistical data visually via a Bar chart and Sankey chart, showing which jobs led to subsequent interviews and applications per month. Detailed notes can also be added to each job's history.
- Features are implemented by several REST APIs, allowing user registration and login via Express.js routes, such as google OAuth 2.0. Back-end is run on Node.js connected to a MongoDB NoSQL database, with collections mapped to various Mongoose schema for Users/Jobs.
- Uses JWT bearer-tokens to access restricted pages, password hashing (brypt.js), and private API routes using Axios interceptors so users can only access their own data.
- Added various controllers to the APIs for jobs/user routes to implement error handling, user authentication, and not-found middleware. Used Postman to test HTTP requests made with Axios by the front-end to the server and check JSON responses. Features React.js reducers/actions to update the global state (React Context) and various statistics used to generate charts (Sankey, Bar Chart, etc.).
RSA & AES Encryption App - Electron.js, React.js
1 of 4
- Developed an Electron.js (local exe) and web application to allow a user to encrypt/decrypt text with RSA and AES encryption, using front end technologies.
- Displayed RSA/AES keys and ciphertext as encoded in Base64, to allow for bits outside normal character encoding to be viewable as a text string on the website.
- Added tutorials to allow for a user to follow along to the website using a CLI approach and the openssl library. The library is fully compatible with the RSA encryption used by the website, allowing a user to store their private key locally, use the website to encrypt with a public key, and then use AES locally with the CLI to exchange files/text. This approach is completely secure as only text encrypted by the public key is exchanged over the web (the encrypted AES key).
- Implemented a microservice developed by another student to simulate a hybrid encryption scheme, where one uses RSA to exchange an AES key. The RSA key-pair holder sends their public key via an HTTP request to the partner's microservice, which sends back an encrypted AES key, along with random text encrypted with that AES key. These two items can then be decrypted using the website's functionality.
SpaceTau-Flask-and-MySQL-App
1 of 7
- Project programmed in Flask to run Python in a back-end server environment, using a Jinja templating system to render HTML and JavaScript on the front-end.
- Implemented a MariaDB backed MySQL database and designed a schema for this in MySQL Workbench, to support relationships among the database tables. The project serves as a web-based application to a fictional database system for a space launch services company.
- Multiple one-to-many relationships are supported, as well as a many-to-many relationship between spacecraft and parts via an intersection table.
- Added constraints such as ON CASCADE DELETE to automatically allow for child rows to be deleted from a M:N relationship and prevent database anomalies. Added foreign key (FK) constraints to prevent adding nonsensical relationships between tables, such as referencing a FK that doesn't exist.
- The theme of this project is inspired by my interest in NASA / space exploration and Kerbal Space Program (see gameplay video below), which has taught me much about physics and orbital mechanics in a fun way. I've also dabbled in using C# to automate launches in the game with kRPC scripting (remote procedure calls), and eventually plan to use Unity/ C# to create mods for the game with Visual Studio.
Small Shell (smallsh) - C Unix Shell
- Programmed a shell in C similar to the BASH shell, implementing parent/child process handling with the Unix process API. The shell can be ran in interactive mode, repeatedly prompting the user for input, or be fed commands from a file in non-interactive mode.
- The shell repeatedly checks for background processes within the same process group and reports if any have exited along with their PID. The SIGCONT signal is sent to any stopped child background processes by the shell to resume their execution. https://linux.die.net/man/2/waitpid
- Parameter expansion - special shell parameters include $$ for the smallsh process ID GETPID(3), $? for the exit status of the last foreground process, and $! for the most recent background process. Occurrences of ${} allow for variable expansion for a named environment variable.
- Implemented custom behavior for SIGINT and SIGSTP signals, allowing the shell to ignore these signals while allowing child processes to respond via custom signal handlers and sigaction structure.
- Parsed command line input into semantic tokens via word splitting. Implemented redirection operators '<', '>', and '>>' to redirect STDIN and STDOUT to specific files.
Hash Map Data Structure Implementation - Python
1 of 4
- This is the portfolio project for the Oregon State University course CS 261 - Data Structures, which is allowed to be posted to a public GitHub repo. The project implements a Hash Map data structure using two distinct methods to handle table collisions - Open Addressing, and Separate Chaining.
- Open Addressing - In this implementation, the data structure probes for an empty spot in the HashTable's underlying dynamic array if a collision occurs, until it finds an empty spot to insert the element in.
- Separate Chaining - In this implementation, each dynamic array element is a linked list, and additional key/value pairs can be added to the front of the linked list at each array spot in the case that keys hash to the same array index.
- A hash map allows insertion and lookup of values in amortized constant time O(1), due to a potential O(N) resizing cost. Resizing the table is performed in order to keep the table load factor low, which reduces the chance of collisions occurring. In the worst case, all elements could collide in the same bucket, leading to O(N) time complexity. The load factor is expressed as n (number of elements) / m (number of buckets).
Kotlin (Jetpack Compose) - Sacramento City and Flight Search App
- These are two applications from the Oregon State University course CS 492 - Mobile Development, programmed in Kotlin, which is a language derived from Java. These apps also use the Jetpack Compose framework for state/ UI management.
- Sacramento City App - Code is NOT allowed to be posted to a public repo - showing GIF only.
- Flight Search App - This is the portfolio project and is allowed to be posted to a public repo per the Syllabus.
- The Flight Search App persists data using a SQLite database and the Room API, which provides abstraction to the database layer of the app. This allows us to define SQL queries in DAOs (Data Access Objects) to perform CRUD operations more easily. Coroutines are also used so that database actions are asynchronous and don't block the main thread.
- Uses Jetpack Compose features such as data classes, composables, and LazyColumns to enable scrolling through list collections of Categories and Recommendations. Modifiers are used to style the UI. Collections of data used in the app are defined in a DataSource class, holding functions to return items.
- Makes use of the ViewModel architecture component to hold and expose the state displayed by the UI and retain it upon configuration changes. Instead of defining routes with a NavController, the state is used to conditionally render different composable functions/screens. The UI state is defined as a data class in Kotlin which can be accessed by various composables.
- Models for various items in the app are defined in data classes, which are intended to hold data without the boilerplate code needed in Java for getter/setter functions - https://www.baeldung.com/kotlin/data-classes.
C++ Unreal Engine Project Slash
1 of 13
- A project I'm doing for fun from a Udemy course - still in progress. Though my interests are in full stack development, I've always enjoyed PC games and thought it would help my C++ / back end skills to take a deeper dive into a statically typed language.
- Used vector math in C++ to calculate the dot product between two vectors, or the angle between the impact of a weapon strike and the actor's forward vector. By also calculating the cross product, we can use this to play the correct animation for an enemy on hit, so that they stumble in the correct direction depending on which side they've been attacked from. Added other logic to animations such as inverse kinematics, so that a character's skeleton can be correctly positioned when standing on sloped surfaces.
- Created other various classes in C++ to trigger on sphere overlap events, play animations, attach items to sockets, or randomly spawn treasure when an item breaks. Created state machines to allow characters to toggle between running/walking animations based on C++ variables we've exposed to BluePrint. Added a box trace function on weapon meshes, allowing a weapon to determine when it has overlapped with another object.
- Implemented C++ inheritance by adding a HitInterface for various enemies, which an enemy class can inherit from. This allows the weapon class to call a function which could not exist on an actor, the getHit() function, which the enemy class overrides. If the weapon successfully casts an actor to that interface, we know it is a child class of the interface that implements getHit(). This allows us to call getHit() from a pointer, and for a weapon to avoid needing logic for everything it could possibly hit.
OpenGL C++ Solar System Model
1 of 7
- A Solar System model coded in C++ using OpenGL, featuring GLSL fragment & vertex shaders, 8k BMP planet textures, and advanced lighting. Code cannot be posted as this is the final project for CS 450 Computer Graphics at Oregon State University, and is a popular final project choice.
- The vertex and fragment shaders used for rendering planet textures are efficient programs which run directly on the GPU. The vertex shader process individual vertices and outputs the transformed position, while the fragment shader outputs the final RGB color of each pixel after it has been processed by the rasterizer.
- Loaded sphere objects for planets and other objects into OpenGL display lists, which are a stored set of commands that can be executed later with a single function call, reducing the overhead of repeatedly sending commands to the GPU. Added 150 random asteroids to the main asteroid belt and another 150 for Kuiper Belt beyond Neptune, added 8 Planets, Pluto, 4 Moons, and a Galaxy Skybox with vertex and fragment shaders.
- Added equirectangular projection cloud textures to Earth by blending two vec4 (rgba) textures together in the fragment shader. Used a vec2 variable to translate the clouds over the Earth's surface using a sinusoidal function applied to the program's elapsed time.
- Used Kepler's third law to calculate realistic orbital periods for planets based on their orbital radii. This tells us that the square of a planet's orbital period is proportional to the cube of the length of the semi-major axis of its orbit.