Software Design & Engineering

Artifact Description

This artifact represents the Software Design & Engineering enhancement of my CS-499 capstone project. The original artifact was a basic Python CRUD module from CS-340: Client/Server Development, created in October 2025. For Milestone Two (January 2026), I transformed this simple 52-line script into a production-ready, 300+ line module that demonstrates professional software engineering principles.

52 → 300+ Lines of Code

2 → 4 CRUD Operations

Basic → Professional Error Handling

Hardcoded → Secure Configuration

Download Enhancement Narrative (DOCX)

Before and After Comparison

Original Version (CS-340)

Basic Create and Read operations only
Hardcoded database credentials
Minimal error handling
Limited input validation
Basic print statement logging
No documentation standards
52 lines of code

Enhanced Version (CS-499)

Complete CRUD operations (Create, Read, Update, Delete)
Secure configuration with environment variables
Comprehensive error handling with structured logging
Input validation and security checks
Professional documentation with docstrings and type hints
Context manager support for resource management
300+ lines of production-ready code

Key Improvements Implemented

Complete CRUD Implementation: Added comprehensive Update and Delete methods with proper validation and atomic operations
Security Hardening: Removed hardcoded credentials, implemented environment variable configuration, and added input sanitization
Professional Error Handling: Replaced basic print statements with structured logging and specific exception handling
Code Quality Enhancements: Added comprehensive documentation with docstrings, type hints following PEP 484, and PEP 8 compliance
Additional Features: Implemented count method, context manager support, and comprehensive testing framework

Code Enhancement Preview

Below is a sample of the enhanced code showcasing professional software design patterns:

# Enhanced CRUD Module with professional error handling
def create(self, data: Dict[str, Any]) -> ObjectId:
    """Create a new animal record with comprehensive validation."""
    self.logger.info("Creating new animal record")
    
    # Input validation
    if not data or not isinstance(data, dict):
        raise ValueError("Data must be a non-empty dictionary")
    
    # Required fields validation
    required_fields = ['name', 'animal_type', 'breed']
    missing_fields = [field for field in required_fields if field not in data]
    
    if missing_fields:
        raise ValueError(f"Missing required fields: {', '.join(missing_fields)}")
    
    # Add timestamp for tracking
    data_with_metadata = data.copy()
    data_with_metadata['created_at'] = datetime.utcnow()
    
    try:
        insert_result = self.collection.insert_one(data_with_metadata)
        self.logger.info(f"Successfully created animal record with _id: {insert_result.inserted_id}")
        return insert_result.inserted_id
    except PyMongoError as e:
        self.logger.error(f"Database error during create: {e}")
        raise

View Full Enhanced Code View Original Code Narrative DOCX

Course Outcomes Demonstrated

This enhancement directly addresses multiple CS-499 course outcomes:

Outcome 4

Well-founded Techniques: Used industry-standard practices including environment variables for configuration, comprehensive logging, and type hints for maintainability.

Outcome 5

Security Mindset: Proactively addressed security vulnerabilities through secure credential management and input validation to prevent injection attacks.

Outcome 2

Professional Communication: Implemented comprehensive documentation with docstrings, examples, and clear error messages.

Outcome 3

Algorithmic Principles: Designed logical flow for update/delete operations with proper transaction handling.

Reflection on the Enhancement Process

Learning Experience

This enhancement taught me the critical importance of designing software with production requirements in mind from the beginning. I learned how small design decisions, like hardcoding credentials, can have significant security implications. The process of implementing environment variable configuration gave me practical experience with the 12-factor app methodology.

Challenges Faced

One significant challenge was balancing comprehensive error handling with code readability. Initially, my error handling became so verbose that it obscured the main logic. Through iterative refinement, I learned to create helper methods and use Python's exception hierarchy effectively.

Improvement Metrics

Code Maintainability: Increased from basic script to modular, documented professional code
Security: Eliminated hardcoded credentials and implemented input validation
Error Handling: Transformed from print statements to structured logging with specific exceptions
Documentation: Added comprehensive docstrings, type hints, and usage examples

Unexpected Insights

The most rewarding insight was understanding how professional software engineering practices make subsequent enhancements easier. This solid foundation enabled me to seamlessly add algorithmic features in Milestone 3 and database optimizations in Milestone 4.