Anthony McCormack

Professional Self-Assessment

Welcome to my ePortfolio. This portfolio represents the culmination of my journey through the Computer Science program at Southern New Hampshire University, where I am completing a Bachelor of Science in Computer Science with a concentration in Software Engineering. Completing this program while serving as a Programmer Analyst at Amazon has given me a rare perspective: I apply what I learn in the classroom directly to production systems that operate across 50+ fulfillment centers nationwide. Combined with a decade of leadership as a U.S. Army Staff Sergeant and a Bachelor of Science in Homeland Security from Liberty University, my coursework in software engineering has sharpened my ability to architect reliable, secure, and scalable solutions. Building this ePortfolio has helped me crystallize my professional identity at the intersection of operations technology and software engineering, and it showcases the depth and breadth of the skills I bring to any development team.

Collaborating in a Team Environment

Effective collaboration has been a constant throughout my career. At Amazon, I lead cross-functional tool development on the ADCO TPS team, where I coordinate with Area Managers, operations leads, and engineering partners to build monitoring dashboards and automation systems used across the Sub Same Day Delivery network. I led site and multi-site SEV1/SEV2 incident calls, which required real-time coordination between technical and non-technical stakeholders under high pressure, reducing incident resolution times by 30%. In the military, I managed the welfare and performance of 42 Soldiers as a Platoon Sergeant, and my platoon was voted the #1 Unmanned Aircraft platoon in the U.S. Army in 2015 after I established SOPs that saved the unit over $50 million. Within the CS program, CS 250 (Software Development Lifecycle) reinforced version control workflows, code review practices, and Agile methodologies that I now use daily in professional development, while CS 255 (System Analysis and Design) taught me to gather and translate stakeholder requirements into actionable technical specifications through UML diagrams and system design documents.

Communicating with Stakeholders

Translating technical concepts for diverse audiences is one of my strongest competencies. At Amazon, the tools I build, including Risk Dashboard 2.0 and the United Flow Planner, are consumed by operations managers who need actionable insights without understanding the underlying code. I design Slack webhook integrations that deliver real-time alerts in plain language and build dashboards that surface complex capacity and throughput data through intuitive visualizations. CS 319 (UI/UX Design and Development) strengthened my ability to design interfaces from the user's perspective, while CS 465 (Full Stack Development I) required me to communicate architectural decisions across the entire application stack. In this capstone, my code review video demonstrates my ability to walk through a codebase methodically, identify deficiencies, and articulate a clear enhancement plan. Throughout the program I practiced professional documentation standards, from PEP 8 formatting and Javadoc annotations to detailed change histories, ensuring that my code communicates its intent to future maintainers as clearly as it communicates results to end users.

Data Structures and Algorithms

My coursework in data structures and algorithms built the analytical foundation I rely on when optimizing real-world systems. MAT 230 (Discrete Mathematics) provided the mathematical rigor behind algorithmic analysis, and CS 300 (DSA: Analysis and Design) gave me hands-on experience implementing and evaluating trees, hash tables, graphs, and sorting algorithms by their Big-O complexity. CS 210 (Programming Languages) broadened my perspective on how different language paradigms approach data manipulation, from object-oriented Java to functional patterns. At Amazon, this knowledge directly informs the throughput monitoring tools I develop, where choosing the right data structure can mean the difference between a dashboard that loads in milliseconds and one that lags under production data volumes. The algorithmic enhancements I made to the DataGridActivity artifact, introducing HashMap-based O(1) lookups and a custom MergeSort implementation, demonstrate my ability to move beyond "it works" to "it works efficiently at scale."

Software Engineering and Databases

The program deepened my understanding of software design principles and database architecture far beyond what I had learned through self-teaching on the job. CS 320 (Software Test, Automation QA) taught me to think in terms of testability and code coverage, while CS 350 (Emerging Sys Arch & Tech) introduced me to embedded systems design and hardware-software integration on the Raspberry Pi platform. CS 230 (Operating Platforms) reinforced how to design software that accounts for the underlying operating environment, and CS 465 (Full Stack Development I) gave me end-to-end experience connecting front-end interfaces to back-end services. Professionally, I have applied these principles by migrating established userscript-based tools to AWS infrastructure using CDK, Lambda, and deployment pipelines, increasing both reliability and scalability. On the database side, DAD 220 (Intro to Structured Database Environments) established my foundation in SQL and relational design, CS 340 (Client/Server Development) extended that into server-side database programming, and CS 360 (Mobile Architect & Programming) challenged me to manage SQLite databases within the constraints of a mobile application. The enhancements I made to DatabaseHelper.java, normalizing to Third Normal Form and implementing proper foreign key relationships, reflect the kind of disciplined schema design that prevents data anomalies in production systems.

Security

Security is not an afterthought in my work; it is a foundational design constraint. My Bachelor of Science in Homeland Security from Liberty University provided a broad understanding of threat modeling and risk assessment, while the CS program gave me the technical tools to implement defensive measures in code. CS 305 (Software Security) taught me to identify and mitigate common vulnerabilities from the OWASP Top 10, CS 405 (Secure Coding) reinforced secure development practices at the implementation level, and CS 410 (Software Reverse Engineering) gave me the ability to analyze compiled code for hidden vulnerabilities, a skill that deepens my understanding of how attackers exploit software. At Amazon, I operate within a security-first culture where every code review, every deployment pipeline, and every data access pattern is evaluated for vulnerabilities. In this capstone, I demonstrated a security mindset by replacing plain-text password storage with BCrypt hashing, eliminating SQL injection vectors through parameterized queries, and implementing defensive programming patterns with try-catch-finally blocks for proper resource cleanup. These are not academic exercises; they are the same practices I apply daily when building tools that handle operational data across Amazon's fulfillment network.

Portfolio Summary

The three artifacts in this portfolio were selected to demonstrate complementary facets of computer science. Together, they tell a cohesive story of growth from functional code to professional-grade software. Artifact One (Thermostat.py), originally developed in CS 350 (Emerging Sys Arch & Tech), showcases software design and engineering through the refactoring of a procedural embedded systems controller into a modular, object-oriented architecture using the Observer Pattern. Artifact Two (DataGridActivity.java), originally developed in CS 360 (Mobile Architect & Programming), demonstrates algorithms and data structures through the introduction of HashMap-based constant-time lookups and a custom MergeSort implementation that replaced naive iteration and default sorting. Artifact Three (DatabaseHelper.java), also from CS 360, addresses databases and security through schema normalization to Third Normal Form, BCrypt password hashing, and comprehensive SQL injection prevention. Each artifact began as working coursework and was enhanced to meet industry standards, mirroring the professional trajectory from "code that runs" to "code that is engineered to last."

Code Review

Before enhancing my artifacts, I conducted a comprehensive code review to identify areas for improvement in security, functionality, and design.

Artifact One: Software Design and Engineering

Enhancements Made:

• Refactored procedural structure into modular, object-oriented design
• Transformed hardcoded GPIO pin mappings into configurable parameters
• Implemented the Observer Pattern to decouple sensor logic from display and LED feedback
• Updated documentation to professional standards with PEP 8 formatting

Narrative:

The artifact I selected for this enhancement is a Python-based environmental control system, originally developed during my coursework in CS 350. At its core, the program interfaces with a Raspberry Pi to poll an AHTx0 temperature and humidity sensor, manages a three-state thermostat (off, heat, cool), and outputs real-time data to a 16x2 LCD display. It also handles hardware interrupts via physical buttons to cycle states and adjust temperature setpoints.

I chose to include this artifact in my ePortfolio because it represents a complex integration of hardware abstraction and software logic. In my professional role as a Programmer Analyst at Amazon, I see firsthand how critical it is to move beyond simple scripting and into robust software engineering. This project showcases my ability to manage state machines and threaded processes. To improve the artifact, I focused on reducing technical debt by refactoring the original procedural structure into a modular, object-oriented design.

Through these enhancements, I met the planned course outcomes. For CS-499-04 (Software Engineering and Design), I implemented the Observer Pattern to decouple the temperature sensor logic from the display and LED feedback systems, ensuring that adding new features won't require a total rewrite of the core sensor logic. For CS-499-02 (Communications), I updated the internal documentation to meet professional standards, including a detailed change history and consistent PEP 8 formatting.

The process of refactoring this artifact was an exercise in planning for scalability. One of the primary challenges I faced was managing the threading for the pulsing LED indicators without interfering with the timing of the I2C sensor polling. I learned that while procedural code is often easier to write initially, an object-oriented approach provides the stability needed for long-term maintenance. This project reinforced my security mindset as I implemented more robust error traps to handle potential hardware failures or sensor noise.

Artifact Two: Algorithms and Data Structures

Enhancements Made:

• HashMap implementation for O(1) lookups (improved from O(n) ArrayList iteration)
• Custom MergeSort algorithm with guaranteed O(n log n) stable sorting
• Dual-structure synchronization maintaining data integrity across HashMap and ArrayList
• Documented Big-O notation in Javadoc comments with justified design decisions

Narrative:

The artifact is the Inventory Manager application (DataGridActivity.java), originally developed during CS 360: Mobile Architecture and Programming. The application was created as an Android mobile app that enables users to manage inventory items through CRUD operations with a SQLite database backend. The original implementation used a simple ArrayList for in-memory data management and relied on Android's default sorting mechanisms.

I selected this artifact for my ePortfolio because it provided an ideal foundation to demonstrate proficiency in algorithms and data structures. The original code, while functional, had measurable inefficiencies that presented clear opportunities for optimization. By introducing a HashMap that maps item IDs to their objects, lookups now execute in constant time O(1) instead of the original O(n) iteration. This improvement becomes increasingly significant as inventory size grows.

Rather than relying on built-in sorting or implementing a simpler but less efficient algorithm like Bubble Sort O(n²), I implemented MergeSort from scratch. This provides O(n log n) time complexity in all cases, maintains stability by preserving the relative order of items with equal titles, and demonstrates understanding of recursive divide-and-conquer problem decomposition.

Implementing the HashMap alongside the ArrayList taught me that optimization often involves trade-offs. The HashMap provides O(1) lookups but requires additional memory and synchronization overhead. Understanding when this trade-off is worthwhile versus when it adds unnecessary complexity is a critical skill. The challenges I faced included ensuring the ArrayList and HashMap remained consistent after operations, and careful handling of edge cases in the merge logic. This enhancement transformed a functional but inefficient inventory manager into a demonstration of algorithmic best practices.

Artifact Three: Databases

Enhancements Made:

• Normalized schema to Third Normal Form (3NF) with categories table
• Implemented BCrypt password hashing (no plain text storage)
• Added SQL parameterization to prevent injection attacks
• Wrapped operations in try-catch-finally for defensive programming

Narrative:

The artifact is DatabaseHelper.java, the data access layer for an Android inventory management application I developed during CS 360: Mobile Architecture and Programming in 2025. This class manages all SQLite database operations including user authentication and inventory CRUD functionality.

I selected this artifact because it demonstrates growth in database design and security implementation. I improved it by normalizing the schema to Third Normal Form with a separate categories table linked via foreign key, implementing BCrypt password hashing to eliminate plain text password storage, ensuring all queries use SQL parameterization to prevent injection attacks, and adding try-catch-finally blocks with proper cursor cleanup for defensive programming.

These enhancements meet the outcomes I planned in Module One. For CS-499-04, I applied well-founded techniques including BCrypt hashing, SQL parameterization, and 3NF normalization. For CS-499-05, I developed a security mindset by anticipating SQL injection, credential theft, and timing attacks in my design decisions.

Through this process, I learned why best practices matter beyond just knowing what they are. Implementing BCrypt taught me the security-performance tradeoff of work factors, and schema refactoring required thinking through real usage scenarios. The main challenge was maintaining backward compatibility, which I solved by creating deprecated wrapper methods.

Resume

Professional Summary

Operations technology leader with 10+ years of combined military and corporate experience spanning warehouse operations, software development, and team leadership. Proven track record of building proprietary automation tools and monitoring dashboards that drive measurable improvements across 50+ fulfillment centers. Combines a BS in Homeland Security, an in-progress BS in Software Engineering, and hands-on expertise in JavaScript, Python, Java, and AWS to bridge the gap between operations strategy and technical execution. Decorated Army veteran (Bronze Star Medal) with experience leading high-stakes missions and large cross-functional teams.

Technical Skills

Professional Experience

Military Service

Education