Diploma in Systems Design and Full-Stack Development

Introduction to Computational Thinking – Fundamentals of Computing – History and Evolution of Computers – Identification of Computational Problems – Problem Analysis Techniques – Components of a Computer System – Hardware and Software Overview – Introduction to Programming Languages – Compiled vs Interpreted Languages. Algorithms and Problem Solving – Definition and Characteristics of Algorithms – Building Blocks of Algorithms: Statements and Expressions, State and Variables, Control Flow Mechanisms, Functions and Procedures – Algorithm Notations: Pseudo Code (Syntax and Conventions), Flow Charts (Symbols and Drawing Techniques), Programming Language Representation – Algorithmic Problem-Solving Strategies: Sequential Approach, Iterative Approach, Recursive Approach – Introduction to Algorithm Complexity (Time and Space).

Introduction to Programming Environment – Setting up Development Environment (IDE: Eclipse/PyCharm/VS Code) – Writing, Compiling, and Executing First Program – Understanding the Structure of Java and Python Programs – Comments, Documentation, and Code Readability. Variables and Data Types – Identifiers (Naming Conventions and Rules) – Variables (Declaration, Initialization, and Assignment) – Primitive Data Types: Numeric Types (int, float, double, long), Character Type (char, String basics), Boolean Type (true/false) – Type Conversion (Implicit and Explicit Casting) – Constants and Literals. Operators and Expressions – Arithmetic Operators – Relational/Comparison Operators – Logical Operators – Assignment Operators – Bitwise Operators – Operator Precedence and Associativity. Control Flow Statements – Conditional Statements: if, if-else, if-elif-else/if-else if-else, Nested if, switch-case/match-case – Looping Statements: while, do-while, for, for-each, Nested loops – Jump Statements: break, continue, pass.

Functions/Methods – Introduction to Modular Programming – Function Definition and Declaration – Function Parameters and Arguments – Pass by Value, Pass by Reference – Return Values and Return Types – Function Overloading (Java) – Default and Keyword Arguments (Python) – Variable Scope – Recursion: Base Case and Recursive Case – Lambda Functions. Arrays/Lists – Introduction to Arrays – Array Declaration and Initialization – Accessing Array Elements – Multi-dimensional Arrays – Common Array Operations – Python Lists – List Comprehensions. Strings – String Declaration and Initialization – String Immutability – String Operations: Concatenation, Comparison, Slicing – String Methods – String Formatting.

Introduction to OOP – Programming Paradigms – Principles of OOP – Advantages of OOP. Classes and Objects – Class Definition – Creating Objects – Constructors: Default, Parameterized, Overloading, __init__ – Instance Variables vs Class Variables – Instance Methods vs Class Methods vs Static Methods – this/self reference – Destructor and Garbage Collection. Encapsulation – Data Hiding – Access Modifiers – Getter and Setter Methods – Properties. Inheritance – Concept of Inheritance – Types: Single, Multilevel, Hierarchical, Multiple – Method Overriding – super keyword – Abstract Classes. Polymorphism – Method Overloading – Method Overriding – Duck Typing.

Exception Handling – Introduction to Errors and Exceptions – Types of Errors – Exception Hierarchy – Handling Exceptions: try-catch/try-except, Multiple catch/except blocks, finally block, try-with-resources/with statement – Throwing Exceptions – Custom Exceptions – Best Practices. File Handling – Types of Files – File Opening Modes – Reading from Files – Writing to Files – File Pointer and Seeking – Working with CSV Files – Working with JSON Files. Introduction to Modules and Packages – Built-in Modules – Creating Custom Modules – Importing Modules – pip and Package Management.

Experiment 1: Setting up development environment (JDK, Python, IDE) and writing Hello World programs. Experiment 2: Programs using variables, data types, and operators. Experiment 3: Programs using conditional statements (if-else, switch-case). Experiment 4: Programs using loops (for, while, do-while). Experiment 5: Programs using functions/methods with different parameter passing techniques. Experiment 6: Programs using recursion. Experiment 7: Programs using arrays and lists. Experiment 8: Programs using strings and string manipulation. Experiment 9: Programs demonstrating OOP concepts – classes, objects, constructors. Experiment 10: Programs demonstrating inheritance and polymorphism. Experiment 11: Programs implementing exception handling. Experiment 12: Programs for file handling – reading, writing, CSV and JSON processing.

Introduction to Data Structures – Definition and Need for Data Structures – Classification: Primitive vs Non-Primitive, Linear vs Non-Linear, Static vs Dynamic – Abstract Data Types (ADT) – Data Structure Operations. Algorithm Analysis – Definition of Algorithm – Characteristics of a Good Algorithm – Performance Analysis: Time Complexity, Space Complexity – Asymptotic Notations: Big O (O), Omega (Ω), Theta (Θ) – Best Case, Worst Case, Average Case – Common Time Complexities: O(1), O(log n), O(n), O(n log n), O(n²), O(2ⁿ). Recursion – Recurrence Relations – Solving using Substitution Method, Master Theorem – Tail Recursion.

Arrays – Array Representation in Memory – One-dimensional and Multi-dimensional Arrays – Address Calculation – Sparse Matrices – Dynamic Arrays: ArrayList (Java), List (Python). Linked Lists – Introduction – Types: Singly Linked List, Doubly Linked List, Circular Linked List, Circular Doubly Linked List – Operations: Traversal, Insertion, Deletion, Searching, Reversing – Header Linked Lists – Polynomial Representation – Comparison: Arrays vs Linked Lists. Applications – Implementing Stacks and Queues – Polynomial Operations – Sparse Matrix Representation – Memory Management.

Stacks – Stack ADT – Implementation: Array-based, Linked List – Operations: push(), pop(), peek(), isEmpty(), isFull() – Applications: Expression Evaluation and Conversion (Infix to Postfix, Postfix Evaluation), Parenthesis Matching, Function Call Management, Backtracking, Undo Mechanism. Queues – Queue ADT – Implementation: Array-based, Linked List – Types: Simple Queue, Circular Queue, Double-ended Queue (Deque), Priority Queue – Applications: CPU Scheduling, Print Spooling, BFS, Buffer Management.

Introduction to Trees – Tree Terminology – Binary Trees: Full, Complete, Perfect, Skewed – Binary Tree Representation – Traversals: Inorder, Preorder, Postorder, Level Order – Construction from Traversals. Binary Search Trees – BST Properties – Operations: Search, Insertion, Deletion – Inorder Successor and Predecessor. Balanced Trees – AVL Trees: Balance Factor, Rotations (LL, RR, LR, RL), Insertion and Deletion – Introduction to Red-Black Trees, B-Trees, B+ Trees. Heap – Max Heap and Min Heap – Heap Operations – Building Heap – Heap Sort – Priority Queue using Heap.

Graphs – Graph Terminology – Types of Graphs – Representations: Adjacency Matrix, Adjacency List, Edge List – Traversals: BFS, DFS – Applications: Dijkstra's Algorithm, Bellman-Ford, Prim's Algorithm, Kruskal's Algorithm, Topological Sorting. Searching – Linear Search, Binary Search, Interpolation Search, Jump Search, Exponential Search. Sorting – Bubble Sort, Selection Sort, Insertion Sort, Merge Sort, Quick Sort, Heap Sort, Counting Sort, Radix Sort, Bucket Sort – Stability in Sorting – Lower Bound: O(n log n). Hashing – Hash Functions – Collision Resolution: Open Addressing, Separate Chaining – Load Factor and Rehashing.

Experiment 1: Array operations and complexity analysis. Experiment 2: Singly and Doubly Linked List implementation. Experiment 3: Stack implementation using array and linked list. Experiment 4: Queue implementation – Linear, Circular, Priority Queue. Experiment 5: Expression evaluation and conversion. Experiment 6: Binary Tree implementation with traversals. Experiment 7: Binary Search Tree operations. Experiment 8: AVL Tree implementation with rotations. Experiment 9: Heap implementation and Heap Sort. Experiment 10: Graph representation and traversals (BFS, DFS). Experiment 11: Shortest path algorithms (Dijkstra's). Experiment 12: Sorting algorithms comparison and analysis.

Evolution of Software Development Methodologies – Waterfall Model and Its Limitations – Introduction to Agile – Agile Manifesto: Four Values and Twelve Principles – Benefits of Agile – Agile vs Traditional Approaches – Types of Agile Frameworks: Scrum, Kanban, XP, Lean – Choosing the Right Framework – Agile Mindset and Culture – Common Misconceptions about Agile.

Introduction to Scrum – Scrum Theory: Empiricism, Transparency, Inspection, Adaptation – Scrum Values: Commitment, Courage, Focus, Openness, Respect. Scrum Team – Product Owner: Responsibilities, Skills – Scrum Master: Responsibilities, Servant Leadership – Development Team: Self-organizing, Cross-functional. Scrum Events – Sprint: Definition, Time-boxing, Sprint Goal – Sprint Planning – Daily Scrum – Sprint Review – Sprint Retrospective. Scrum Artifacts – Product Backlog – Sprint Backlog – Increment – Definition of Done.

Product Vision and Roadmap – Creating Product Vision Statement – Product Roadmap Development – Release Planning. User Stories – Writing Effective User Stories (INVEST Criteria) – User Story Format: As a [user], I want [feature], So that [benefit] – Acceptance Criteria – Story Splitting Techniques. Backlog Management – Backlog Grooming/Refinement – Prioritization Techniques: MoSCoW, Value vs Effort Matrix, WSJF – Estimation Techniques: Story Points, Planning Poker, T-Shirt Sizing – Velocity Calculation and Forecasting.

Introduction to Kanban – Kanban Principles and Practices – Visualizing Work: Kanban Board – Limiting Work in Progress (WIP) – Managing Flow – Making Policies Explicit – Implementing Feedback Loops – Collaborative Improvement. Kanban Metrics – Lead Time, Cycle Time, Throughput – Cumulative Flow Diagram – Little's Law. Lean Software Development – Lean Principles: Eliminate Waste, Amplify Learning, Decide Late, Deliver Fast, Empower Team, Build Integrity, Optimize Whole – Types of Waste in Software Development – Value Stream Mapping.

Agile Project Management Tools – Jira: Projects, Boards, Backlogs, Sprints, Reports – Trello: Boards, Lists, Cards, Power-Ups – Azure DevOps: Boards, Repos, Pipelines – Asana, Monday.com (Overview) – Tool Selection Criteria. Agile Metrics and Reporting – Burndown Charts, Burnup Charts – Velocity Charts – Sprint Reports – Release Reports. Scaling Agile – Challenges in Scaling – SAFe (Scaled Agile Framework) Overview – LeSS (Large-Scale Scrum) Overview – Scrum of Scrums – Choosing a Scaling Framework.

Project Scope: Students will work on a complete software development project from requirements gathering to deployment. Projects should demonstrate: Programming skills in Java/Python – Implementation of appropriate data structures – Application of algorithms – Agile project management practices. Deliverables: Project Proposal – Sprint Planning Documents – Source Code with Documentation – User Manual – Project Presentation – Sprint Retrospective Reports. Suggested Project Areas: Console-based applications – Data processing tools – Algorithm visualization – Game development – Library management system – Student information system – Inventory management.

Enterprise Application Development Overview – Characteristics of Enterprise Applications: Scalability, Reliability, Security, Performance – Monolithic vs Microservices Architecture – Multi-tier Architecture – MVC Pattern – API-First Development. Maven – Introduction to Maven – Project Structure – Project Object Model (POM) – Maven Lifecycle: clean, compile, test, package, install, deploy – Dependency Management – Maven Plugins. Gradle – Gradle vs Maven – build.gradle Structure. Python Package Management – pip – requirements.txt – Virtual Environments: venv, virtualenv, conda – pipenv and Poetry.

Introduction to Spring Ecosystem – Dependency Injection (DI) and Inversion of Control (IoC) – Spring Boot vs Spring Framework – Spring Initializr – Project Structure – application.properties/application.yml – Spring Boot DevTools. Core Concepts – Spring Beans and IoC Container – Annotations: @Component, @Service, @Repository, @Controller, @Autowired, @Configuration, @Bean, @Value, @Profile – Component Scanning – Bean Scopes: Singleton, Prototype, Request, Session. Configuration – Profiles for Different Environments – Environment Variables – Logging: SLF4J and Logback.

Introduction to REST – REST Principles – HTTP Methods: GET, POST, PUT, PATCH, DELETE – HTTP Status Codes. Spring Web MVC for REST – @RestController – @RequestMapping and Shortcuts – @PathVariable, @RequestParam, @RequestBody – ResponseEntity – Content Negotiation. Building CRUD APIs – Designing Resource URLs – DTO Pattern – Entity to DTO Mapping – Pagination and Sorting. Exception Handling – @ExceptionHandler, @ControllerAdvice – Custom Exception Classes. API Documentation – Swagger/OpenAPI – SpringDoc OpenAPI.

Introduction to Flask – Flask vs Django – Flask Micro-framework Philosophy – Application Structure – Blueprints for Modular Applications – Configuration Management. Routing and Views – URL Routing – HTTP Methods – Request Object – Response Object. Building REST APIs – Flask-RESTful Extension – Resource Classes – Request Parsing – Error Handling – CORS. Flask Extensions – Flask-SQLAlchemy, Flask-Migrate, Flask-Marshmallow, Flask-JWT-Extended, Flask-CORS. Template Rendering – Jinja2 Basics – Template Inheritance – Static Files.

Introduction to Version Control – Git Overview – Git Repository: git init, git clone – Git Workflow: Working Directory, Staging Area, Repository – Basic Commands: git add, git commit, git status, git log, git diff. Branching and Merging – Creating and Switching Branches – Merging Branches – Merge Conflicts and Resolution – Branch Strategies: Git Flow, GitHub Flow, Trunk-based Development. Remote Repositories – GitHub, GitLab, Bitbucket – Remote Operations: git push, git pull, git fetch – Fork and Clone – Pull Requests – Code Review. Advanced Git – Git Stash, Rebase, Cherry-pick, Tags, .gitignore, Git Hooks.

Experiment 1: Maven project setup and dependency management. Experiment 2: Spring Boot application with dependency injection. Experiment 3: Building REST APIs with Spring Boot. Experiment 4: Spring Boot with database (Spring Data JPA). Experiment 5: Exception handling and validation in Spring Boot. Experiment 6: Flask application setup and routing. Experiment 7: Building REST APIs with Flask-RESTful. Experiment 8: Flask with database (Flask-SQLAlchemy). Experiment 9: Authentication using JWT in Flask/Spring Boot. Experiment 10: Git basics – init, add, commit, branch. Experiment 11: Git collaboration – push, pull, merge, conflicts. Experiment 12: API documentation with Swagger/OpenAPI.

Introduction to Database Systems – What is a Database? – DBMS – Advantages of DBMS over File Systems – Three-Schema Architecture – Data Independence. Relational Database Model – Relational Model Concepts: Relation, Tuple, Attribute, Domain – Keys: Super Key, Candidate Key, Primary Key, Foreign Key, Composite Key – Relational Integrity Constraints – Relational Algebra Operations. Entity-Relationship Modeling – Components of ER Diagram: Entities, Attributes, Relationships, Cardinality – Weak Entities – Converting ER Diagram to Relations.

Introduction to SQL – DDL, DML, DCL, TCL – MySQL/PostgreSQL Setup. Data Definition Language – CREATE, ALTER, DROP, TRUNCATE – Data Types – Constraints – CREATE INDEX. Data Manipulation Language – INSERT, SELECT, UPDATE, DELETE – WHERE, ORDER BY, LIMIT – DISTINCT. Advanced SQL – Aggregate Functions – GROUP BY, HAVING – Subqueries – CASE Expressions – Set Operations. Database Normalization – Functional Dependencies – Normal Forms: 1NF, 2NF, 3NF, BCNF – Denormalization.

SQL Joins – Types: INNER, LEFT OUTER, RIGHT OUTER, FULL OUTER, CROSS, SELF JOIN – Multiple Table Joins. Views – Creating Views – Updatable Views – Advantages. Stored Procedures and Functions – Parameters, Local Variables, Control Structures – Creating Functions – Exception Handling. Triggers – Types: BEFORE/AFTER, INSERT/UPDATE/DELETE – Use Cases. Transactions – ACID Properties – Transaction Control: BEGIN, COMMIT, ROLLBACK, SAVEPOINT – Isolation Levels – Concurrency Issues – Locking.

Introduction to NoSQL – CAP Theorem – BASE vs ACID – When to Use NoSQL – Types: Key-Value, Document, Column-Family, Graph. MongoDB – Document Model – Collections and Documents – BSON Format – Installation. CRUD Operations – insertOne, insertMany, find, findOne, updateOne, updateMany, deleteOne, deleteMany. Query Operators – Comparison, Logical, Array, Element Operators. Aggregation Pipeline – $match, $group, $sort, $project, $limit. Indexing – Single Field, Compound, Text Index. Data Modeling – Embedding vs Referencing – Schema Design Patterns.

Introduction to Redis – In-Memory Data Stores – Use Cases: Caching, Session Management, Real-time Features, Message Queues. Redis Data Structures – Strings, Lists, Sets, Sorted Sets, Hashes. Redis Operations – Key Expiration: EXPIRE, TTL – Key Management – Transactions: MULTI, EXEC, DISCARD. Redis Pub/Sub – Publish/Subscribe Pattern. Redis in Applications – Caching Layer – Session Storage – Rate Limiting – Leaderboards – Real-time Counters. Database Security Basics – Authentication, Authorization – SQL Injection Prevention – Data Encryption.

Experiment 1: MySQL/PostgreSQL installation and basic operations. Experiment 2: Database design from ER diagram to schema. Experiment 3: Complex SQL queries with joins and subqueries. Experiment 4: Stored procedures, triggers, and transactions. Experiment 5: Views and index optimization. Experiment 6: MongoDB setup and CRUD operations. Experiment 7: MongoDB aggregation and indexing. Experiment 8: MongoDB schema design and relationships. Experiment 9: Redis installation and data structure operations. Experiment 10: Implementing caching with Redis. Experiment 11: Redis Pub/Sub and session management. Experiment 12: Integrating databases with Spring Boot/Flask applications.

Software Development Lifecycle Evolution – Waterfall Limitations – Agile Practices – Gap Between Development and Operations. Introduction to DevOps – What is DevOps? – DevOps Principles: Culture of Collaboration, Automation, Measurement, Sharing – DevOps Lifecycle: Plan, Code, Build, Test, Release, Deploy, Operate, Monitor. DevOps Culture – Breaking Down Silos – Shared Responsibility – Continuous Improvement – Feedback Loops. Version Control Best Practices – Git Workflows: Git Flow, GitHub Flow, Trunk-Based Development – Code Review Process – Pull Request Best Practices. Automation Fundamentals – Why Automate? – Areas of Automation: Build, Test, Deployment.

Introduction to Containers – Containers vs Virtual Machines – Benefits of Containerization. Docker Fundamentals – Docker Architecture: Docker Client, Docker Daemon, Docker Registry – Installing Docker – Docker CLI: docker run, ps, images, pull/push, exec, logs, stop/start/rm. Docker Images – Image Layers and Caching – Dockerfile: FROM, RUN, COPY/ADD, WORKDIR, ENV, EXPOSE, CMD/ENTRYPOINT – Building Images – Multi-stage Builds – Best Practices. Docker Containers – Container Lifecycle – Container Networking: Bridge, Host Networks – Container Volumes: Bind Mounts, Named Volumes. Docker Compose – docker-compose.yml Structure – Multi-container Applications – Docker Compose Commands. Docker Hub – Pushing and Pulling Images – Image Tagging and Versioning.

Continuous Integration (CI) – CI Principles and Benefits – CI Best Practices. Continuous Delivery and Deployment – CD vs Continuous Deployment – Deployment Pipeline Stages – Release Strategies: Rolling Updates, Blue-Green Concepts. GitHub Actions Fundamentals – Workflows, Jobs, and Steps – Workflow YAML Syntax: name, on, jobs, runs-on, steps. GitHub Actions in Detail – Triggers: push, pull_request, schedule – Using Actions Marketplace – Environment Variables and Secrets – Matrix Builds – Caching Dependencies – Artifacts. Building CI Pipelines – CI for Java/Maven Projects – CI for Python Projects – Running Automated Tests – Code Quality Checks. Building CD Pipelines – Deploying to Cloud from GitHub Actions – Environment Management – Rollback Strategies.

Introduction to Cloud Computing – Cloud Service Models: IaaS, PaaS, SaaS – Deployment Models – Benefits of Cloud Computing. Google Cloud Platform Overview – GCP Global Infrastructure: Regions and Zones – GCP Console and Cloud Shell – GCP Free Tier – Setting up GCP Account. GCP Compute Services – Compute Engine: VMs, Machine Types – App Engine: Platform as a Service – Cloud Run: Serverless Containers. GCP Storage Services – Cloud Storage: Buckets, Objects, Storage Classes – Persistent Disk. GCP Database Services – Cloud SQL: Managed MySQL/PostgreSQL – Firestore: NoSQL Document Database – Cloud Memorystore: Managed Redis. GCP Networking Basics – VPC – Firewall Rules – Load Balancing Concepts.

Deploying Applications to GCP – Deployment Options Overview – Deploying to Compute Engine – Deploying to App Engine – Deploying Containers to Cloud Run – Using Container Registry. GCP Identity and Access Management – IAM Concepts: Users, Service Accounts, Roles, Permissions – Principle of Least Privilege – Creating Service Accounts. CI/CD with GCP – Cloud Build Overview – Integrating GitHub with Cloud Build. Monitoring with Cloud Operations – Cloud Monitoring: Metrics, Dashboards, Uptime Checks – Cloud Logging: Log Viewer, Log-based Metrics – Setting up Alerts. Application Security Basics – Secret Manager – Security Best Practices. Cost Management – Understanding GCP Pricing – Billing and Budgets.

Project Scope: Students will develop a complete enterprise application demonstrating: Full-stack development with Spring Boot/Flask – Database integration (SQL and NoSQL) – RESTful API design – Containerization with Docker – CI/CD pipeline using GitHub Actions – Cloud deployment (AWS/Azure/GCP) – Agile project management throughout. Deliverables: Project Proposal and Architecture Design – Sprint Planning and Progress Reports – Source Code Repository (GitHub) – Docker and Kubernetes Configurations – CI/CD Pipeline Configuration – Cloud Deployment Documentation – API Documentation – User Manual and Technical Documentation – Final Presentation and Demo – Project Retrospective Report. Suggested Project Areas: E-commerce platform – Social media application – Healthcare management system – Learning management system – IoT dashboard – Booking/reservation system – Financial management application.