COMP 536 Syllabus
Computational Modeling for Scientists | Spring 2026
Course Information
| Instructor | Dr. Anna Rosen |
| alrosen@sdsu.edu | |
| Office | Physics 239 |
| Office Hours | Mondays 11:00 am–12:00 pm (and by appointment) |
| Class meetings | Mon/Wed 5:30–6:45 pm |
| Location | PS 240 |
| Course website | https://astrobytes-edu.github.io/comp536-sp26 |
| Platforms: (where things happen) |
Canvas (announcements, gradebook) Course website (course materials, handouts, assignments) GitHub Classroom (project submissions) |
| Virtual COMP 536 AI Tutor: (for studying, enhanced learning) |
COMP 536 NotebookLM Notebook (Grounded in course materials only. Invitation via your SDSU email.) |
Start Here
- Where to find things: check Canvas + the course website (links above).
- Weekly cadence: projects are posted Tuesdays; come to class on Wednesday having reviewed the requirements so lab time can be focused and productive.
- Deadlines: short projects are generally due Tuesdays 11:59 pm PT; Project 4 is due Friday Apr 17, 2026 at 11:59 pm PT because of spring break; final project due Wed May 13, 2026 (11:59 pm PT).
- Reflections: Growth Memos are due with each short project; the Growth Synthesis is due with the final project.
- Getting help: see Getting Help (Office Hours). Before emailing, check this syllabus and recent Canvas announcements.
Course Description
This course introduces numerical methods and computational techniques applied to scientific modeling. It begins with an overview of the Python programming language covering programming fundamentals, modular programming, classes and object-oriented programming (OOP), algorithm design, and best practices. The course then explores computational methods for scientific computing and numerical modeling, including exploratory data analysis and visualization, numerical differentiation and integration, root-finding, model fitting, solving ordinary and partial differential equations, and Monte Carlo methods. Course assignments, implemented in Python, will apply these methods to scientific problems in physics and related domains.
The course format consists of formal lectures on Mondays and a lab section on Wednesdays, where students work on computing projects that apply the lecture topics. Students should bring laptops to class for hands-on activities. Projects are implemented in Python, use git version control, and are submitted through GitHub Classroom.
Student Learning Outcomes
By the end of this course, students will be able to:
Implement computational models in Python using modular design, functions with clear interfaces, and object-oriented programming (OOP) when appropriate — producing code that is readable, testable, and reproducible.
Analyze, validate, and visualize results using the scientific Python ecosystem (e.g.,
NumPy,SciPy,pandas,matplotlib) and create plots that make assumptions, units, and failure modes visible.Apply core numerical methods — including numerical integration, root-finding, optimization/model fitting, Monte Carlo sampling, and solving ordinary differential equations — to model scientific phenomena and quantify error, stability, and convergence.
Build and validate simulations of complex systems, including N-body dynamics and Monte Carlo radiative transfer, using invariants and sanity checks (e.g., conservation laws, limiting cases, controlled randomness) to establish correctness.
Design reproducible computational experiments (parameter sweeps, benchmarking, and scaling studies) and make defensible tradeoffs between correctness, stability, performance, and clarity.
Translate a working baseline model into modern accelerated workflows (e.g.,
JAX) by managing precision, vectorization, and JIT compilation, and by reporting evidence-based performance and correctness comparisons.Build and evaluate an emulator (surrogate model) for simulation outputs (e.g., a neural network), including training/validation discipline and clear reporting of accuracy, uncertainty, and where the surrogate breaks down.
Communicate computational work professionally through code documentation, READMEs, and concise research-style writing — clearly explaining design decisions, verification evidence, and limitations.
Use AI tools responsibly and transparently (per course policy): treat AI as a tutor and verification assistant, not a solution engine; document meaningful usage; and independently verify outputs so that submissions reflect your own understanding.
Where these outcomes are assessed: Short Projects (1–4), Final Project, and the accompanying Growth Memos/Growth Synthesis.
Grading & Assessments
| Component | Weight |
|---|---|
| Scholarly Engagement (lecture + lab participation) | 10% |
| Lab Checkpoints (mini-deadlines) | 10% |
| Short Projects (4 total; 10% each) | 40% |
| Growth Memos (4 total; 2.5% each) | 10% |
| Final Project (JAX N-body + emulator) | 25% |
| Growth Synthesis (final reflection) | 5% |
Important Dates and Course Schedule
The project calendar (assigned dates + deadlines) is listed in Projects Overview. Additional week-by-week topic notes will be posted on the course website. (VERIFY: link/location to be announced.)
Grading scale
The instructor may, at their discretion, curve project grades and final course grades. These percentages represent guaranteed thresholds — earning the stated percentage guarantees at least that grade. The instructor reserves the right to adjust borderline grades upward based on effort, improvement, and engagement. Click here for SDSU’s explanation of grades.
| Letter grade | Percent range | Explanation |
|---|---|---|
| A | 93–100% | Outstanding |
| A- | 90–92% | |
| B+ | 87–89% | |
| B | 83–86% | Praiseworthy |
| B- | 80–82% | |
| C+ | 77–79% | |
| C | 73–76% | Average |
| C- | 70–72% | |
| D+ | 67–69% | |
| D | 63–66% | Minimally Passing |
| D- | 60–62% | |
| F | Below 60% | Failure |
Late Work & Extensions
- One free extension per semester: request at least 24 hours before the deadline to receive a 2-day grace period with no penalty.
- GitHub Classroom deadlines are enforced: the project repo closes at the deadline. If you use your one free extension (per the policy above), I will extend/reopen the GitHub Classroom deadline one time.
- No late submissions beyond the free extension: if you miss the deadline without having arranged your free extension in advance, the submission is not accepted (unless there is a documented emergency).
Regrade Requests
- Submit a request within 7 calendar days of the grade release.
- Provide a $$200-word written justification that references the rubric and the assignment expectations.
- I will re-evaluate the entire submission; the score may go up, down, or remain unchanged.
Course Components
Per SDSU policy, students are expected to spend at least 6 hours per week (a minimum of 2 hours per course credit hour/unit) on coursework outside of class, including reading, project work, and preparation for lab time. Click here for SDSU’s explanation of Credit Hour or Unit..
In this section:
- Projects Overview
- Scholarly Engagement
- Lab Checkpoints
- Short Projects
- Final Project
- Growth Memos
- Growth Synthesis
Projects Overview (Short Projects + Final Project)
Projects are the core of COMP 536. The goal is not “getting code to run once”—it’s learning how to design, debug, verify, and explain computational models you actually understand. In an era where AI can generate plausible-looking code quickly, the bar has shifted: what matters is high-level computational thinking (systems design, correctness, verification, and scientific judgment). The project structure in this course is designed to build those skills deliberately.
Structure (Spring 2026):
- 4 short projects (Projects 1–4)
- 1 final project that combines JAX N-body (fast simulation) + an emulator (a learned surrogate model built on top of your simulator)
Why JAX in the final project: by the end of the semester, the bottleneck is repeated evaluation—generating enough verified simulation output to explore parameter space and build an emulator. JAX matters because it makes repeated runs feasible via JIT compilation and vectorization, and it supports modern scientific workflows where differentiable, composable code is an advantage.
Schedule (minimum info; details posted on the course website):
Projects are posted on Tuesdays. You are expected to have reviewed the project requirements before class on Wednesday, so lab time can be focused and productive.
Short projects are generally due Tuesdays at 11:59 pm PT. For Spring 2026, Project 4 is due Friday, Apr 17, 2026 at 11:59 pm PT because of spring break. The final project is due Wednesday, May 13, 2026 at 11:59 pm PT (about 3.5 weeks after assignment).
| Project | Assigned | Due | Duration |
|---|---|---|---|
| Project 1 | Tue Jan 27, 2026 | Tue Feb 10, 2026 | 2 weeks |
| Project 2 | Tue Feb 10, 2026 | Tue Mar 3, 2026 | 3 weeks |
| Project 3 | Tue Mar 3, 2026 | Tue Mar 24, 2026 | 3 weeks |
| Project 4 | Tue Mar 24, 2026 | Fri Apr 17, 2026 | 3 weeks + spring-break extension |
| Final Project (JAX N-body + emulator) | Sat Apr 18, 2026 | Wed May 13, 2026 | About 3.5 weeks |
Collaboration (encouraged, informal): you are strongly encouraged to work with classmates during lab time and outside class to discuss ideas, debug, and compare strategies. However, what you submit must reflect your own understanding and your own implementation. You should be able to explain your code choices and verification steps clearly. AI use must follow the course policy: AI Use & Growth Mindset Policy.
Peer collaboration & pair programming (guardrails):
- Allowed: discussing strategy; whiteboarding equations and algorithm design; sharing tests you wrote (not solution code).
- Not allowed: sharing solution code or copying any code blocks (even if you “worked together”).
- Required: credit collaborators and list contributions in your project
README.md(who you worked with and what you discussed).
Scholarly Engagement (10%)
Scholarly engagement in COMP 536 means showing up prepared and making your thinking visible in both lecture and lab. In practice, that includes asking good questions, contributing to discussion, and demonstrating professional modeling behaviors during lab time: debugging systematically, verifying results (sanity checks/tests), communicating clearly, and being able to explain your code.
Engagement is assessed weekly through observable behaviors in lecture and lab, including progress on assignment mini-deadlines/checkpoints designed to prevent procrastination.
| Instructor Score | Observable weekly behaviors |
|---|---|
| 5/5 | Prepared and on time; contributes in lecture and lab; asks targeted questions; collaborates productively; can explain their code decisions; uses debugging + verification habits (small tests, sanity checks); consistently meets mini-deadlines/checkpoints. |
| 4/5 | Prepared with steady effort; participates regularly; collaborates respectfully; asks questions when stuck; usually meets checkpoints; minor issues (occasional lateness, quieter weeks, or thinner verification). |
| 3/5 | Inconsistent prep or participation; engages when prompted; limited questions/discussion; uneven lab follow-through and/or missed checkpoints. |
| 2/5 | Frequently unprepared, disengaged, or off-task; minimal participation in lab/lecture; repeated missed checkpoints; habits impede learning. |
| 1/5 | Rare engagement when present; does not participate in lab/lecture work in a meaningful way. |
| 0/5 | Habitually absent or habitually disengaged; no meaningful engagement evidence. |
Note: This rubric is a guideline. Your score reflects overall scholarly contribution, not a single “style” of being present.
Classroom Norms & Participation (Professional Scientific Community): We are all members of a professional academic community. Treat classmates and the instructor with respect. Spirited, courteous debate about ideas is welcome, but disrespectful behavior is not. Because active reasoning is the point of being in the room, off-task device use during lecture/lab is distracting and will negatively affect your Scholarly Engagement score.
I will not take formal attendance, but I will notice patterns. If you are absent often, habitually late, or frequently miss lab/lecture participation opportunities, your Scholarly Engagement score will be lower. Please arrive on time; repeated tardiness is disruptive and will negatively affect your score.
Lab Checkpoints (10%)
To help you build strong habits (and avoid last-minute marathons), projects include small, low-stakes mini-deadlines/checkpoints. These are designed to keep you moving and to make your progress visible.
Checkpoints may include items like:
- setting up your repository and environment,
- a “first working run” (even if minimal),
- an initial verification plot/test,
- a short progress note describing what you tried and what you plan next.
These are graded primarily on completion and professionalism. Details and exact checkpoint requirements will be posted with each project.
Short Projects (40% total; 10% each)
There are four short projects, each worth 10%.
Each short project submission includes:
- a code repository with a runnable workflow (README + reproduction instructions),
- verification evidence (tests/sanity checks/diagnostics),
- a short, formal research memo describing methods + results + figures,
- a Growth Memo (see below).
Short projects are graded on scientific/numerical correctness, verification discipline, reproducibility, and clarity of communication (including your memo and your ability to explain your code).
Research memo format (short projects):
- Submit as a PDF in your project repo.
- Single-spaced, with 2–3 pages of text (not counting figures/references).
- Include (at minimum): literature citations, methods, results, and discussion.
Growth memo format (short projects):
- Submit as a PDF in your project repo.
Final Project (25%)
The final project synthesizes the course: a JAX-native N-body simulator using Leapfrog integration, rebuilt from the validated physics and workflow of Project 2, plus an emulator built on top of simulation outputs.
Final project submissions include:
- a code repository with a reproducible end-to-end pipeline,
- a longer, formal research report (requirements posted with the project),
- a Growth Synthesis reflection (see below).
Final projects are graded on correctness, evaluation methodology, reproducibility, and scientific communication. You should expect to defend your design and verification choices.
The final-project code path should include:
- a JAX-native Leapfrog N-body simulator that reuses the physics model, validation logic, and scientific workflow from Project 2,
- clear evidence that students rebuilt the simulator in JAX-native form rather than wrapping or lightly porting an old non-JAX implementation,
- validation that the simulator behaves sensibly before it is used to generate emulator training data,
- an emulator trained on simulation outputs rather than on a black-box external simulator.
Research report format (final project):
- 5–7 pages.
- Formal scientific writeup including background + motivation, methods, results, and conclusions.
Growth Memos (10% total; 4 \(\times\) 2.5%)
Growth Memos are short reflections that build metacognition—thinking about how you learn so you can improve your workflow, debugging habits, and verification discipline over time. Write these in an informal, memo-like voice (not an essay). Honesty and specific evidence matter more than polished prose.
You will submit four Growth Memos, one due with each short project (2.5% each).
Each memo should include:
- evidence of how your work evolved (what you tried, what failed, what you changed),
- 2–3 recurring patterns + likely causes,
- 2–3 concrete next-step habits (“When I…, I will…”),
- a verification plan (how you will know your code/results are correct),
- brief AI/collaboration reflection and disclosure (even if “none”).
Growth Synthesis (5%)
The Growth Synthesis is a final reflection submitted with your final project. It asks you to synthesize your learning across the semester: how your habits changed, how your verification strategies matured, and what you can now do that you could not do at the start of the course.
Academic Integrity & Generative AI Policy
All submitted work in this course must reflect your own understanding. Collaboration is strongly encouraged to discuss concepts and strategies. However, what you submit must be written independently and must represent your unique reasoning. Copying solutions (from classmates, the internet, generative AI, or solution manuals) is not permitted. Violations of academic integrity will be handled according to university procedures and may be reported to the Center for Student Rights and Responsibilities.
Generative AI (ChatGPT, Gemini, Claude, etc.)
AI coding tools are now part of the landscape, and their popularity has raised the bar for high-level (systems) computational thinking: you’re valued for judgment—designing, verifying, and debugging models you actually understand—not for producing code quickly. The staged three‑phase rules are intentional so you build those skills first; trying to shortcut that learning (including by cheating) will backfire in this course and beyond.
For full details (including the staged, three‑phase rules and documentation expectations), read: AI Use & Growth Mindset Policy.
- AI is optional. You can earn full credit without using AI.
- Understanding is required. If you can’t explain it, don’t submit it.
- No AI refactoring / restructuring of your solution unless explicitly assigned.
- No AI-written core solution code (the algorithmic logic that produces the result).
- Struggle first, then ask. For coding help, do ~20–30 minutes of productive effort (try, check docs, minimal repro, hypothesis) before using AI.
- Disclose meaningful AI use whenever a submission asks for AI/collaboration disclosure, and follow the course AI documentation requirements.
Allowed (study support): - Asking questions to clarify your own notes or assigned readings. - Generating practice questions (not answers to assigned problems). - Getting a concept explained at a different level for studying.
Allowed (graded work, within the course AI policy): - Debugging guidance and verification support (after productive struggle). - Limited help with docstrings/comments and plot formatting when permitted by phase.
Not allowed (graded work): - Generating or rewriting the core logic of your solution. - Rewriting your code structure so it’s no longer clearly your work. - Submitting AI-generated reasoning you cannot reproduce on your own.
Generative AI can produce fluent explanations and plausible-looking solutions that are subtly wrong. In a quantitative, model-based course, “sounds right” is not a standard of truth. If you don’t have the quantitative discipline to verify an AI output, you risk learning the wrong thing confidently.
To support effective studying, I will provide course-specific tools grounded in course materials only (lecture notes, textbook, vetted sources). This includes a private COMP 536 NotebookLM notebook (invitation via your email address linked to Canvas). This resource is intended as study aids—not solution engines.
Course Materials (Sharing Policy)
Lecture notes, slides, projects, and course handouts are the intellectual property of the instructor. You may use course materials for your own educational purposes in this course, but you may not reproduce, distribute, share, or post them on any public platform (e.g., Chegg, Course Hero, Discord servers, public GitHub repos) without written permission.
Unauthorized recording or redistribution of class sessions or office hours is prohibited.
Communication & Getting Help
All course-related communication should be sent through Canvas messaging when possible. Include “COMP 536” in the subject line. I aim to respond within 24-48 hours on weekdays. Before emailing, check this syllabus and recent Canvas announcements.
If you encounter difficulties with the assignments or find yourself falling behind, please seek help immediately by:
- Posting your questions on the course Canvas discussion page.
- Speaking with the instructor during class or office hours (preferred).
- Collaborating with classmates (while ensuring your final submission reflects your own understanding).
Getting Help (Office Hours)
Office hours are for learning — bring what you’ve tried (notes, attempts, questions) and we’ll work from there. I’ll often guide you by asking questions so you build your own problem-solving skills. You’re welcome to come even if you’re not sure what to ask or have non-course related questions.
Fostering a Growth Mindset
A growth mindset is the belief that intelligence, abilities, and talents are malleable and can be developed through effort and persistence, not fixed traits you’re born with. This mindset is key for succeeding in this course. In COMP 536, you’ll encounter challenging concepts that may initially seem overwhelming. This is normal and expected: it means you’re learning.
Trust the process, embrace the challenge, and discover that you’re capable of doing hard things.
Diversity and Inclusivity Statement
I consider this classroom to be a place where you will be treated with respect, and I welcome individuals of all ages, backgrounds, beliefs, ethnicities, genders, gender identities, gender expressions, national origins, religious affiliations, sexual orientations, ability, and other visible and non-visible differences. All members of this class are expected to contribute to a respectful, welcoming and inclusive environment for every other member of the class.
Essential Student Information
For essential information about student academic success, please see the SDSU Student Academic Success Handbook.
SDSU provides disability-related accommodations via Student Disability Services: https://sds.sdsu.edu (email: sds@sdsu.edu). Please allow 10–14 business days for processing.
Class rosters are provided to the instructor with the student’s legal name. Please let the instructor know if you prefer an alternate name and/or gender pronoun.
If you need to be absent from class for a religious observance, please notify me in writing during the first two weeks of the semester so that we can make any necessary arrangements.
Land Acknowledgement
San Diego State University sits on Kumeyaay land. The Kumeyaay people have lived in this region for over 10,000 years and continue to live here today.
Your Responsibility
This syllabus constitutes our course contract. You are responsible for reading and understanding all policies stated here.