Dylan Jager-Kujawa
Nacogdoches, TX
Full Stack Web Developer

I graduated from Stephen F. Austin State University in May 2017 with a B.S. in Computer Science and Modern Languages.

Key Info:

  • First Major: Computer Science
  • Second Major: Modern Languages (French Specialization)
  • GPA: 3.631


  • President of SFA Upsilon Pi Epsilon Delta Chapter
  • Former Secretary, then President of SFA French Club


  • President's List Fall 2011, Spring 2012, Spring 2015, Fall 2015
  • School of Honors member
  • University Scholar
  • Magna Cum Laude

Topics of Study

Computer Science

  • Event-Driven Programming (.NET)
  • Data Structures (Java)
  • Computer Organization and Architecture (C, Assembly)
  • Software Engineering
  • Requirements Engineering
  • Object-Oriented Programming (C++)
  • Algorithm Analysis
  • Organization of Programming Languages (BASH, SQL, Prolog, LISP, etc.)
  • Operating System Design
  • Cyber and Code Security
  • Database Management Systems (Theory, SQL)
  • Discrete Structures
  • Ethics in Computer Science


  • French Conversation
  • Advanced French Composition and Grammar
  • Francophone World
  • French Film
  • Advanced French Conversation (Study Abroad)
  • Contemporary French Culture (Study Abroad)
  • Introduction to French Literature
  • 19th Century French Literature
  • European Popular Culture, 1500-1800
  • French Canadian Literature

Robert Half Technology

Web Developer

St. Louis, MO • 2018-Present

I am currently working as a full-stack web development contractor under Robert Half's Salaried Professional Service.

Elliott Electric Supply

Web Developer

Nacogdoches, TX • 2016-2018


  • Quickly learned ASP.NET and ASP.NET MVC on the job, with ver little prior exposure to the platform.
  • Was able to track particularly difficult bugs with very little prior knowledge of the applications in question.
  • Am currently in the process of migrating our continuous integration builds from TFS 2012's XAML build system to the new TFS 2015 vNext system.

SFA Math & Statistics

Research Assistant

Nacogdoches, TX • 2017


  • Set up git repository, trained other developers in version control basics.
  • Managed the repository as conflicts arose, providing assistance to developers as necessary.
  • Created a custom input module for Unity's EventSystem which accepts input from a gamepad, adding a new method of interaction to the app.

VR Calculus

Android App

After graduation, I worked with my former professors to create the SFA VR Calculus app, which gives 3D tutorials of various Calculus concepts in a virtual representation of various locations on SFA's campus.

The project is implemented in Unity 5 (C#) using the Google CardBoard VR framework. Primarily, I assisted with version control (git), however I was also given various scripting tasks, mainly the custom input module for accepting gamepad input to manipulate the graphs.

Personal Site

This website is actually a custom jekyll theme, which is currently a work in progress. The theme is built using Semantic UI as the frontend framework, and is divided into welcome, bio, and default layouts, though more will likely follow.

The theme is still heavily tied into my own personal site, so I'll need to generalize it before I can post any source.

Team Foundation Server 2015 Migration

At Elliott, we use continuous integration builds for all of our in-house software. Previously, this was done using TFS 2012's XAML-style builds, where a XAML workflow would build the solution using MSBuild, and then call a custom assembly for deployment.

The new TFS 2015 build system is incompatible with these XAML builds. The 'vNext' system uses a modular, drag-and-drop approach, grouping common build actions into tasks. On the build agent, these tasks are actually powershell or javascript (Node.js) scripts. I adapted our previous build assemblies into .NET-based powershell cmdlets, and created build tasks for each of our deployment steps.

Build Status Page

Click here for a semi-functional mockup

I was dissatisfied with built in build status page, which displays all builds in the order they completed, with no option to view the latest of each build. Meaning there is no way to quickly determine if a given build script is currently passing or failing. Using the TFS 2015 REST APIs, I created my own build status page with the following features:

  • The status of all builds across all team projects are visible on one page, with team projects separated into a tabbed view.
  • Failed builds are highlighted and displayed at the top of the page, to immediately determine which builds are failing.
  • Error logs from failed builds can be displayed in a modal view, which gives a quick overview of what might be causing the build to fail.
  • Build entries have links to the definition, the latest build, and the relevant changeset.

Perhaps the best feature is a carryover from a previous build status page, written before I started: a database is maintained with the latest "breaking" changeset, i.e. the first changeset in the latest line of failed builds. Using this database, failed builds display not the changeset that queued the latest build, but the changeset that actually broke the build.

The new build status page is implemented in Knockout.js, using jQuery ajax to call the TFS API, with Twitter's Bootstrap framework for quick styling. More information on the build migration and screenshots of the build status page will likely be posted soon.

Compiler Project (Organization of Programming Languages)


The compiler project was a two-part lab (only the second iteration is hosted on GitHub) wherein we created a language and specified a context-free grammar, based on a simple description of the language requirements given to us. From there, we implemented a simple interpreter in two parts:

  • the scanner, which reads the input programs and returns a sequence of tokens
  • the parser, which reads the tokens, and runs the code line by line, generating an error list if necessary

Operating System Labs


This was a 5-part assignment spanning the duration of the semester wherein various topics related to operating system design were explored. The topics for each lab were:

  • Machine/Operating System Overview
  • Concurrency/Multiprogramming
  • Virtual Memory/Paging
  • Process Scheduling
  • File Management

To implement these labs, we had to build a simple virtual hardware program, based on the professor's specifications, and then build a simple operating system to run on top of our "hardware." The operating system itself was implemented in the higher-level language as well, though the hardware system does include an ISA, "memory" (16-bit words, 256 words of memory total), and a "hard disk." Thus, users of the operating system may run programs that actually do execute on the "hardware" system, not directly in the higher-level language it was written in.

The GitHub repository has all five versions of the lab, with each version saved as a release, including all source code and a copy of the report submitted for grading.