ICS H32 Fall 2026, Project 0B: Square One

Introduction

In this course, you will continue to develop the programming skills you began building in your prior coursework, by learning Python and also by honing an ever-sharpening focus on solving larger, more complex problems at a level of quality that edges closer to work done by professionals. While the projects we'll work on this quarter might be simple for someone who has years of prior experience, we will nonetheless attack these problems with the same approach that a professional software engineer might. We'll consider each problem in its full depth, think about how to work on it incrementally, spend some time testing our solution to ensure that it works correctly, and make sure that we've got the little details correct and not just the big ideas. Larger programs that solve real-world problems succeed or fail on being completely correct, and even a one-character mistake in input or output can sometimes make all the difference, so we need to get accustomed to that level of scrunity, so that we can apply it when it is warranted.

This project asks you to do two things:

Set up your development environment, so you will be ready to work on your projects this quarter.
Write a short program and submit it, to ensure that you're aware of the mechanisms of the course — how to write short Python programs, how to submit your work — and so you can become acclimated to how automated testing will be used to grade at least some of your work this quarter.

Setting up your development environment

It is very common in real-world software development jobs to be given, at the outset of a new job, a list of tools that you will be required to use. Flexibility is great, and it's nice to be able to choose one's own toolset, but, unfortunately, many software tools introduce constraints on how a program can be written, how its components can be arranged, what functions can be called, what documentation can be written and how, what additional software it can be combined with, how it can be "built" to be distributed to end users, and so on. So, like it or not, real-world software development usually requires at least some of the tools to be set in stone and used by all members of a team, even if not all members have the same preferences; this is simply a reality that software developers have to face, because smooth collaboration in a team environment is usually more important than satisfying every individual's whim. (While your work in this course is individual, you'll nonetheless be working with a team of course staff, who won't be able to support everyone's individual tools and bespoke preferences.)

Since we will be poking our heads into a fair number of darker "real-world" corners in this course, it becomes necessary for us to agree on the set of development tools that we'll use. Not only will it be important to agree on the right tools, but it will be important to agree to use the right versions of those tools, as each differs in not-insignificant ways. One goal of this project is to introduce you to those tools, provide instructions on how to install and configure them on your own machines, and get you ready to use them for your work this quarter.

Writing a short program

This project will also require you to write and submit a short program. Unlike most of our projects, we're less concerned about how you solve the problem than we normally will be. There are no points for what we call "quality of solution," meaning that issues like style, organization of your program, and so on, are not relevant on this project. All that matters is that the program works, but that is a very precise requirement: The output of your program has to be correct to the character to receive full credit. Paying attention to the exact requirements, then, will be paramount.

Getting started

Your first task is to complete the Python Setup for ICS H32 notes, if you haven't already. If you haven't, then do that now, then come back to this afterward.

Each project will begin with a starting point, which will include a combination of provided Python code, with any other necessary tools to use for setup and submission. The starting point is provided in the form of a Git repository, which you'll open and set up in Visual Studio Code, just like you did with the ICSH32.Playground repository in the Python Seutp for ICS H32 notes.

Starting a new project

To start a new project, click the link titled To start your project in Visual Studio Code at the top of the page. For convenience, I'll duplicate that link below.

Click here to start your project in Visual Studio Code

Follow the steps that you followed to set up your ICSH32.Playground repository:

After opening your new project folder, designate it as trusted.
Run the setup script in a Terminal window.

Having done those things, you're ready to begin work. To do that, though, you'll need to know what you need to do, so read on!

The program

Your program is required to read a single line of input from the user (without printing any input prompt), which is expected to be a positive integer n (i.e., n will be neither zero nor negative). You can freely assume that your program will be given a positive integer, and it's not important what you do in any other case; we'll only test your program with positive integer input. You can also freely assume that n will not be greater than 999.

After reading the input, your program will print a downward block diagonal of size n. The precise format of a downward block diagonal is best demonstrated with an example. If the input to the program was 4, the output would look like this:


+-+
| |
+-+-+
  | |
  +-+-+
    | |
    +-+-+
      | |
      +-+

A few additional requirements apply:

There must be no whitespace (e.g., spaces or tabs) at the end of each line of output.
There must be a newline on the end of each line, including the last one.

This is a complete specification of the structure of a downward block diagonal; the description is enough to solve the problem, so we will not be answering any additional questions about its structure. However, we are providing a tool that will give you a basic understanding of whether your program is reading the correct input and generating output in the correct format.

Naming and organizational requirements

How you organize your program is, for the most part, up to you, with a couple of requirements that you'll need to follow.

Your program must be written entirely in a single Python module, in a file named project0b.py, which you'll find in the src directory. Note that capitalization and spacing are important here (i.e., no letters in the filename are capitalized and there are no spaces); they're part of the requirement. The file must be named exactly project0b.py.
Executing your project0b module — in a Python shell must cause your program to read its input and then print its output. It must not be necessary to call a function manually to make your program run.

Other than that, anything goes; you can organize your solution in any way you'd like. Note that future projects will take what we call "quality of solution" a lot more seriously, but the name of the game in this warm-up project is simply to submit a program that works.

Sanity-checking your output

We are also providing a tool that you can use to sanity-check whether you've followed the basic requirements above. It will only give you a "passing" result in these circumstances:

You're running the program on Python 3.14, as opposed to a different version.
You've named your file project0b.py.
Executing that module is enough to execute your program.
Your program reads its input and generates character-by-character correct input for one test scenario.

Note that additional test inputs will be used when we grade your project. The way to understand the sanity checker's output is to think of it this way: Just because the sanity checker says your program passes doesn't mean it's perfect, but if you cannot get the sanity checker to report that your program passes, it surely will not pass all of our automated tests.

You'll find the sanity checker in the tools directory. One way to run the sanity checker is to start a Terminal window, then enter these commands.


# If you're running Windows, enter these commands...
cd tools
python -m project0b_sanitycheck

# If you're running macOS or Linux, enter these commands...
cd tools
python3 -m project0b_sanitycheck

How we will grade your submission

Unlike other projects, this project will be graded on a 2-point scale, with the 2 points being allocated completely to whether or not you submitted something that meets all of the above requirements. The following rubric will be used:

If all of our automated tests pass, you will receive 2 points.
If any of our automated tests pass (i.e., at least one of them passes, even if all the others fail), you will receive 1.5 points.
If none of our automated tests pass, but you did submit a file named project0b.py, you will receive 1 point.
If you did not submit a file named project0b.py, but you did submit a Python module in a file whose name ends in .py, you will receive 0.5 points.
If you did not submit a Python module at all, you will receive 0 points.

Deliverables

Submit your project0b.py (and no others) to Canvas. There are a few rules to be aware of.

You're responsible for submitting the version of your project that you want graded prior to the deadline. Contacting us afterward and telling us that you accidentally submitted the wrong version will not be grounds for a resubmission under any circumstances.
When grading your program, we'll grade only the most recent submission. We will not negotiate about which submission will be graded, or, for example, grade multiple of your submissions and "take the highest score."
You're responsible for making a submission in order to receive credit, which means you'll want to be sure that you've remembered to submit your work and verified in Canvas that it's been received. A later claim of having forgotten to submit your work or having misremembered the due date will not be grounds for a resubmission under any circumstances.
The determination of whether your work has been submitted before the deadline is the time it was submitted to Canvas. Neither timestamps on local copies of your files nor timestamps in other places (e.g., emails or online storage) are considered evidence of completion prior to the deadline under any circumstances.

Can I submit after the deadline?

This project is not included in the late work policy for this course. The objective is not just that you do this one, but that you do it early enough to be of benefit, so it needs to be completed during the initial days of the course and submitted before the due date above. Submissions beyond that deadline will not be considered under any circumstances.

The late work policy for this course — which does not apply to this project, but applies to most of the others — is described in the section titled Late work at this link.

What do I do if Canvas adjusts my filename?

Canvas will sometimes modify your filenames when you submit them (e.g., by adding a numbering scheme like -1 or a long sequence of hexadecimal digits to its name). In general, this is fine; as long as the file you submitted has the correct name prior to submission, we'll be able to obtain it with that same name, even if Canvas adjusts it.