Faculty Syllabus

Students will construct progressively complex websites that incorporate the intermediate-level use of the technologies: HTML, CSS, JavaScript, Spring Boot, Java, PostgreSQL

1. Understand how to iterate through and reference values in JavaScript arrays and objects
2. Demonstrate how to manipulate browser DOM with JavaScript and jQuery.
3. Describe the importance of APIs and how data from third parties can be used locally in an application.
4. Demonstrate basic understanding and differences between fetch and node-fetch.
5. Discuss the importance and uses for client-side and server-side architecture.
6. Construct backend severs.
7. Describe the request-response cycle.
8. Understand CRUD functionality
9. Compare and contrast GET and POST methods
10. Build a website using server-side rendering and EJS templating for components
11. Provide fake and real time data to an application for debugging purposes.
12. Compose dynamic sites using DOM and APIs

How to Pass ITSE 2302

In our previous course ITSE 1311, everything was competency-based: you had to fully master one area before moving on, and the system unlocked the next section only after you hit the required score. That approach worked like building blocks—each step depended on the one before it.

This 4-week course works differently. Instead of waiting for you to “unlock” the next stage, the course follows a fixed schedule with real deadlines. Everyone moves forward together, and your assignments and assessments must be submitted by the posted due dates. Think of it less like a self-paced ladder and more like a group project on a timeline—you’ll need to stay on track each week to keep up.

This is the same set up as INEW 2334.

About Assessment Attempts and Projects (including Capstone)

For this course, you have two attempts for each end-of-competency assessment. However, your score will be based on the average of both attempts.

Make sure to submit deliverables in correct format. Failure to do so may result in a 10% deduction on grades.

Capstone Competency: Start Planning Early

The Capstone is the exception to the sequence. You’re not required to finish it right away, but you should review it early. It outlines your final project, and understanding what’s expected ahead of time will help you stay focused and organized throughout the course.

Follow the Sequence — It’s There for a Reason

This course is set to a forced sequence, which means you must complete each section in order. Skipping ahead or jumping around will either be blocked by the LMS or result in confusion if you just click "completed". The material has been carefully arranged to build your skills step-by-step and taking shortcuts will only create unnecessary setbacks. Stick to the path and trust the process. You’ll be glad you did.

To "complete" each section, there may be a button or checkbox to click saying you are done with that section.

Pace Yourself — But Stay on Schedule

You’re welcome to move quickly through the course, but please note that Competency deadlines are firm. Once a due date passes for that competency, you will not be able to go back and submit. Be sure to manage your time wisely and stay on top of all requirements.

📅 Due Dates & Deadlines

All due dates are listed in Blackboard Ultra and linked to the calendar tool 🗓️. You're responsible for checking this calendar regularly. Late work policies still apply.

This course is flexible in pace, but that flexibility requires excellent time management skills. You can work ahead — but not behind.

We will be utilizing a combination of online and in-class resources.

COMPETENCY 1 - ORIENTATION and SERVERS

Students will build a strong foundation in how clients and servers interact through requests, responses, and routing. They explore client types and their connections to servers, while analyzing the request–response cycle. Routing is studied for its role in access control and security, leading into the MVC design pattern with Spring Boot. Students also learn how APIs and JSON enable system communication and how URL encoding ensures safe data transfer. The module concludes with a hands-on CRUD challenge. Additionally, students review the syllabus, schedule, and course structure to clarify expectations, while learning how the Software Development Life Cycle (SDLC) guides software creation, deployment, and maintenance.

COMPETENCY 2 - SPRING BOOT - AN INTRODUCTION

Students will learn how to configure Spring Boot projects using Gradle and essential dependencies, establishing a strong foundation for full-stack development. They will implement entity, repository, service, and controller layers to build database-driven applications, while applying Flyway migrations to manage schema changes and seed data effectively. Students will also gain hands-on experience with PostgreSQL containers using Docker Compose, ensuring a persistent and reliable development environment. Along the way, they will practice troubleshooting issues in Flyway, Gradle, and Docker by analyzing logs, integrate IntelliJ’s database tools for schema inspection, and organize project files into a clear, maintainable package structure.

COMPETENCY 3 - SPRING BOOT SERVER

Throughout this competency, students will practice building a backend application on their own. They will configure Spring Boot with Gradle and dependencies, create a Docker container for PostgreSQL, and use IntelliJ tools to inspect schemas. After establishing a database connection, they will define entities and seed initial data. Students will then design DTOs for safe request/response handling and implement full CRUD operations—Create, Read, Update, and Delete—while documenting their work. This guided progression offers a complete, hands-on walkthrough of backend development essentials.

COMPETENCY 4 - REACT

In this competency, students will revise their Spring Boot project so it can connect to a React frontend. Students will identify and use the four CRUD operations (Create, Read, Update, Delete) exposed by the API, configure a React project with routing and layout, and implement API calls with Axios. They will display data in a dynamic table, add features to modify records through interactive UI patterns, and evaluate state management strategies for handling CRUD workflows between React and Spring Boot.

CAPSTONE

In this competency, students will design a normalized PostgreSQL database with at least two related tables and seed it with widget entries, including support for negative quantities for backorders. They will implement a Spring Boot backend that provides full RESTful CRUD operations to manage this data. On the frontend, students will develop React components and pages that connect to the API, display widget data, provide forms for creating and editing, and handle errors without crashing. They will also apply consistent branding and UX principles by using a chosen color palette, logo, and clear navigation. Finally, students will compose a troubleshooting guide that documents API usage and solutions with AI-assisted clarity.

Introduction

In this course, Generative AI (GAI) tools—such as ChatGPT, Copilot, Bard, and similar platforms—can be powerful aids for learning and creativity. I support their responsible, transparent, and ethical use when it enhances understanding and does not replace your own critical thinking or original work. In fact, you will have AI assignments which must be completed before starting other course work.

Used correctly, these tools can help you explore ideas, understand terminology, and see multiple approaches to solving a problem. Used incorrectly, they can hide gaps in understanding and produce work that looks correct but is not. This policy sets clear expectations so you can use these tools in ways that strengthen your skills and protect academic integrity.

Rationale

In the world today, being able to use AI is a must. Even in non-programming roles, the understanding and uses of AI are inescapable and required for all jobs eventually. But to use it correctly, you need to understand what it can do and how it can be used to break things very easily. Imagine GAI as a 6-foot chainsaw that everyone now has. But do you need a 6-foot chainsaw for everything? Use it responsibly.

In technical fields, AI can speed up learning, but it can also amplify mistakes. AI can generate insecure code, misleading explanations, and incorrect citations with high confidence. Learning to verify outputs, recognize limitations, and document your process is part of professional readiness. This course treats AI literacy as a real-world skill that must be practiced with discipline and good judgment.

Definition

For this course, GAI refers to any technology that can generate text, code, images, audio, or other media in response to prompts, including—but not limited to—OpenAI ChatGPT, Google Gemini, GitHub Copilot, DALL·E, and similar AI-driven content creation tools. If you must tell the system what to do, chances are it is AI and falls under this category. Applications like Grammarly and Zotero are great for typos, grammar, and citations BUT they do not always work! Please double check your citation submissions!

This definition includes tools embedded inside editors, browsers, learning platforms, and search engines when they produce generated output rather than simply retrieving sources. If a tool is “suggesting” full sentences, paragraphs, solutions, or code blocks based on prompts or context, it is included. When in doubt, treat the tool as GAI and disclose its use so there is no confusion later.

Resources

• Review the tool’s terms of service and privacy settings.
• Cross-check AI-generated content with authoritative sources.
• Use AI output only as a starting point, not as a final submission, unless noted in assignments and assessments.
• Apply proper citations when AI output informs your work.

For technical topics, “authoritative sources” means official documentation, standards, reputable textbooks, and instructor-provided materials. If AI provides a claim, you should be able to verify it independently. Keep brief notes about what you asked, what you received, what you accepted or rejected, and why. This habit strengthens learning and makes disclosure easy.

Assessment

Unless otherwise noted, all assignments must reflect your own comprehension and skills. AI assistance must be disclosed as a formal APA 7 citation when used. See Resources link for how to use APA 7 properly.

Disclosure is required whether AI helped you generate content, refine wording, produce code, summarize sources, or brainstorm approaches. If AI influenced your final submission in any meaningful way, cite it. Your grade depends on demonstrating your understanding, so you should be prepared to explain and defend your choices, your code, and your reasoning without relying on the tool during grading.

Penalties

Failure to follow this policy—including failure to disclose AI use—will be treated as a violation of the college’s academic integrity policy. Penalties may include a zero for the assignment, additional work, or escalation to the Academic Integrity Committee.

This includes submitting AI-generated work as if it were entirely your own, using AI during restricted activities, or presenting generated output that you do not understand. Penalties may also apply when citations are missing, misleading, or intentionally vague. If you are unsure whether your use requires disclosure, disclose it. Transparency protects you.

Exceptions

Specific assignments may prohibit AI use entirely (e.g., in-class exams) or require it (e.g., AI prompt engineering exercises). Such exceptions will be clearly stated in the assignment instructions.

When AI is prohibited, you must complete the work without AI assistance, including drafting, rewriting, or “checking” your work with a tool. When AI is required, you must follow the stated workflow, including documenting prompts and outputs, and meeting any citation or submission rules. If instructions conflict, the assignment instructions take precedence.

Usage Permissions

Please closely read requirements for all assignments and submissions as they differ from one to the next.

Some tasks will allow AI for brainstorming but not for final wording. Other tasks may allow AI-generated starter code but require you to modify, test, and explain it. In all cases, you are responsible for the final product you submit, including correctness, security, and clarity. If an assignment requires disclosure details, follow that format exactly.