IST 311: Java Data Structures, OOP & Software Engineering Foundations

Redacted Academic Case Study

Overview

#

This project collection summarizes selected academic work from IST 311, a software design and development course focused on programming foundations, object-oriented thinking, data structures, testing, debugging, and development workflow.

The purpose of including this collection in my portfolio is to show the software engineering foundation behind my cybersecurity, ServiceNow, vulnerability management, and technical lab work.

This page does not publish raw source archives, full academic submissions, or complete solution files. Instead, it summarizes the technical concepts, implementation areas, design work, and lessons learned in a portfolio-safe format.

Why This Matters

#

Cybersecurity work often requires more than tool usage. Strong analysts and consultants benefit from understanding how software is structured, how data moves through systems, how logic is tested, and how implementation decisions affect performance.

This project collection demonstrates foundational software engineering concepts that support:

• security automation thinking
• vulnerability workflow design
• data structure reasoning
• debugging and troubleshooting
• script and code review
• platform configuration logic
• technical problem decomposition
• clearer communication with developers and engineering teams

Concept Map

#

Work Included

#

Java Data Structures

#

This project collection included work with several core data structures and related implementation concepts:

• arrays
• linked lists
• doubly linked lists
• stacks
• queues
• binary search trees
• red/black trees
• heaps
• graphs

The work reinforced how different data structures affect access, search, insert, delete, traversal, ordering, and performance.

Doubly Linked List Operations

#

I created visual and implementation-focused work around doubly linked list operations, including:

• append
• insert
• delete
• push
• pop
• search
• previous and next node relationships
• time complexity reasoning

This helped reinforce how pointer-style relationships affect insertion, deletion, traversal, and search behavior.

Queue Implementation

#

I worked on queue implementation concepts using Java, including node-based ordering, enqueue/dequeue behavior, and first-in, first-out logic.

This reinforced the importance of predictable data flow and helped connect abstract data structures to practical workflow design.

Binary Search Tree Implementation

#

I worked with binary search tree concepts including insertion, recursive search, traversal, validation, and recovery logic.

The implementation work included concepts such as:

• adding nodes recursively
• searching for target values
• in-order traversal
• validating whether a tree follows BST ordering rules
• identifying invalid node relationships
• swapping node values
• attempting to repair a damaged tree structure

This helped reinforce recursive reasoning, tree ordering, and how structural assumptions affect correctness.

Binary Search Tree Operations

#

I also created diagram-based work showing common binary search tree operations, including:

• inserting into an empty tree
• inserting into a balanced tree
• inserting into a poorly balanced tree
• deleting elements
• deleting leaf nodes
• deleting nodes with children
• searching for values

A key lesson from this work was understanding that balanced trees can support efficient search behavior, while poorly balanced trees can degrade toward linked-list-like performance.

Red/Black Tree Operations

#

I created a red/black tree operations diagram showing insertion, deletion, search, color balancing, and rotation-related concepts.

This helped connect tree-balancing rules to performance and reinforced why self-balancing trees are useful when predictable search efficiency matters.

Heap and Graph Concepts

#

The broader IST 311 work also included heap and graph-related practice.

Graph-related work reinforced how vertices, edges, and relationships can model connected systems. This is especially relevant to cybersecurity because many security problems involve relationships between users, systems, services, assets, permissions, and network paths.

Heap-related work reinforced priority-oriented structure and helped support broader algorithmic reasoning.

Big-O Complexity Analysis

#

I created Big-O analysis work comparing common data structures and reasoning through which structures fit different problems.

Examples included:

• using a stack-like structure for browser back functionality
• using list or tree-style structures for game move modeling
• using graph structures to represent social network relationships
• comparing access, search, insert, and delete behavior across different data structures

This helped reinforce that implementation choices should be based on expected operations, not just convenience.

UML and Object-Oriented Design

#

The course also included UML and class design work.

I worked with LMS-style class modeling involving concepts such as:

• courses
• assignments
• professors
• attributes
• methods
• class relationships
• responsibility boundaries

This supported object-oriented thinking and helped reinforce how systems can be broken into classes, responsibilities, and interactions.

CRC Cards

#

I also practiced CRC card modeling.

CRC cards helped organize:

• class responsibilities
• class collaborators
• how system objects interact
• where behavior belongs
• how responsibilities should be separated

This was useful because it shifted the focus from just writing code to thinking about design responsibility and collaboration between components.

Git and Development Workflow

#

The course included Git and local repository workflow practice.

This included setting up a local development environment, using Git tooling, working in IntelliJ IDEA, and building habits around version-controlled development.

Debugging and Unit Testing

#

The work included debugging practice in IntelliJ IDEA and exposure to test-oriented development workflows.

This helped reinforce:

• breakpoint-based debugging
• inspecting values at runtime
• understanding program state
• validating expected behavior
• using tests to support implementation confidence

Skills Demonstrated

#

This project collection demonstrates:

• Java programming fundamentals
• object-oriented programming
• class and method design
• UML interpretation and modeling
• CRC card modeling
• data structure implementation
• algorithmic complexity reasoning
• recursive problem solving
• debugging with breakpoints
• unit testing exposure
• Git setup and version-control workflow
• technical diagramming
• academic project documentation
• problem-to-structure analysis

Security Relevance

#

Although this was not a cybersecurity-specific project, the concepts are directly useful in cybersecurity work.

Data structures, debugging, workflow logic, testing, and object-oriented thinking support:

• understanding application behavior
• reading and interpreting code
• writing small automation scripts
• reasoning about performance
• troubleshooting technical workflows
• understanding how platform logic is structured
• communicating technical implementation details clearly
• analyzing how data relationships appear in systems
• thinking through how security tools organize findings, assets, users, and events

For ServiceNow SecOps and Vulnerability Response work specifically, this kind of foundation supports understanding how records, relationships, workflows, assignment logic, and remediation states are structured inside a platform.

What I Would Improve Today

#

If I revisited this work today, I would improve it by:

• adding cleaner README files for each implementation
• separating production code and test code more consistently
• improving naming conventions
• adding more unit tests and edge cases
• documenting expected inputs and outputs
• adding diagrams directly into project README files
• using Git branches and commit history more intentionally
• removing IDE-specific files from any public repository
• improving code comments where needed
• connecting data structure behavior to cybersecurity use cases
• adding small security-focused examples, such as asset graphs or vulnerability-priority queues

Portfolio Note

#

This page is a sanitized case study.

Raw source files, full academic submissions, private filenames, screenshots with personal identifiers, and full solution archives are not published. The purpose is to demonstrate foundational software engineering knowledge without turning the portfolio into a homework repository.