Programming, problem solving, and algorithms

CPSC 203, 2025 W2

January 8, 2026

Announcements

• Website live – please let me know if you see errors!

• POTW starts next week! https://us.prairielearn.com/pl/course_instance/202804

• Labs start next week. Answer the qualtrics survey!!

• Enroll in CPSC203 on PrairieTest: https://us.prairietest.com

Summary

In this introductory class, we use metaphors and abstractions to characterize problem decomposition, code as a communication mechanism, and computational efficiency. We continue our exploration of the idea of elegance, making connections to problem solving and code. Then, we learn a mechanism for measuring efficiency, and talk briefly about why it’s important to consider. The discussion about efficiency is followed by a diversion into color representation. Finally, we look at some code! The day concludes with a sequence of Python examples designed to clear the cobwebs on lists – our first data structure!

Learning outcomes

1. We connect the idea of “elegance” to common items and to software design!

2. The time it takes to solve a problem is one way of measuring the size of a problem. That time can often be described by simple mathematical function.

Elegance: Continuing the discussion

On Tuesday we introduced elegance as a conceptual metaphor for software engineering.

We looked at the scissors example—form perfectly matched to function, with no unnecessary complexity.

Today, we’re going to dig deeper into this idea:

• What does elegance look like across different contexts?
• How do we define it more precisely?
• How does this apply to the way we solve problems in computing?

Elegance

Find 2 images, one which exemplifies your definition of elegance, and another, of the same type of subject, which decidedly does not.

1. Navigate to the Elegance Gallery: https://tinyurl.com/eleganceGallery2025w2

2. Claim an available slide by entering a title.

3. Upload your images, and then you’re done!

4. I will move slides to the COMPLETED section of the gallery.

10:00

(Gallery walk)

Your turn: Elegance—definition

Gallery: https://tinyurl.com/eleganceGallery2025w2

After looking at the images in the gallery, reflect and write a short definition of the word elegance:

https://forms.gle/MUkpWeGBdxYfnJT37

05:00

Elegance in software design

How does this apply to the way we solve problems in computing?

Ingenuity:

Simplicity:

1. INGENUITY — The problems themselves are no longer straightforward examples of things we’ve seen before. Class is about creating a larger set of tools and the confident deployment of them.
2. SIMPLICITY — Our software should be considered to be a means of communicating with other humans who want to know how we have solved the problem. Humans are not good readers, but they think they are good programmers, so if they cannot understand our solution, then they will just rewrite it! (Complexity gives people a reason not to connect).

For further reading: https://www.smithsonianmag.com/arts-culture/how-steve-jobs-love-of-simplicity-fueled-a-design-revolution-23868877/

Simplicity is the ultimate sophistication. It takes a lot of hard work to make something simple, to truly understand the underlying challenges and come up with elegant solutions. […] It’s not just minimalism or the absence of clutter. It involves digging through the depth of complexity. To be truly simple, you have to go really deep. […] You have to understand the essence of a product in order to be able to get rid of the parts that are not essential.

— Steve Jobs

Handcraft

Handcraft

Metaphor for software development—ingenuity, function, simplicity, resource constraints. But also a direct parallel. Knitting patterns, in particular, are communicated using language very similar to Python, so our first experiences are going to exploit the metaphor.

• Quilt—patterns
• Crochet—2 different kinds
• Paper—Friend’s artistry

Knitting

The language used to communicate patterns uses exactly the same fundamental constructs as Python!!!

Knitting: examples

Show \(40 \times 40\), but then transition into \(n \times n\)—“one difference between a knitting project and our problems we solve”

Axis of algorithmic quality includes

Quantifying the Task

1. If we describe one dimension of a square rag by \(n\), how much work is done by the knitter? ____________
2. If we have enough yarn for 36,000,000 stitches, what is the largest rag we could make? ____________
3. If each stitch takes a second, what is the largest rag we could make in one evening? ____________
4. If it takes an evening to make a \(40 \times 40\) rag, how long will it take to make an \(80 \times 80\) rag? ____________
5. If it takes time \(t\) to make an \(n\) by \(n\) rag, how long will it take to make a \(3n \times 3n\) rag? ____________

General idea: quantify the size of the problem (\(n\)) and consider the cost of our task as that size increases.

05:00

Draw the parabola in 4. Point out that quadratic is slower than exponential growth.

Quantifying the Task

If we are solving a problem ____________ for a given input, we can parameterize the running time of the solution by the size of the input.

We usually denote this input size using the variable \(n\).

Discussion:

First blank: or write an algorithm

1. In this example we choose to label \(n\) as the side-length
2. We don’t care so much about units, so we communicate using the largest order term so a scarf which is always 3\(n\) x \(n\) takes time 3\(n^2\) to knit, we ignore the 3 when we’re talking about algorithms. It’s the squared part that really determines how long we’ll have to wait. We say that the variable term “dominates”.
3. Sometimes we have more than one parameter

Handcraft and Code

Knitting model:

• Side length is \(n\)

• One stitch is a unit of work

• \(n\) rows, \(n\) stitches per row

• Total work is \(n^2\)

def knit_square_print(n): for r in range(n): row = “” for c in range(n):
row += ‘X’
print(row)

script: walk through existing code. counting stitches is the same as counting time.

which line is executed most frequently? how many times is outer forloop executed? how many times is line (inner for loop) executed?

let’s demonstrate the work with ascii art! change code incrementally produce one row at a time. (add empty row) for each column, add a “stitch” row done, so print it out.

have we done more work? a little, but the most frequent line happens the same number of times.

Quantifying the Task

Suppose we can knit 10¹² stitches per second…

	10	100	1000	10,000	1012
\(n\)	10-11s	10-10 s	10-9 s	10-8 s	1 s
\(n \log n\)	10-11 s	10-9 s	10-8 s	10-7 s	40 s
\(n^2\)	10-10 s	10-8 s	10-6 s	10-4 s	1012 s
\(n^3\)	10-9 s	10-6 s	10-3 s	1 s	1024 s
\(2^n\)	10-9 s	1018 s	10289 s

The amount of computation we do inside our algorithm actually matters!

Why does this matter?

Annotate:

1. Each stitch takes a tiny tiny fraction of a second 1/10¹² = 10^-12 (fastest machine is 415 x 10¹⁵).
2. \(n\) is size parameter for our computation.
3. \(T(n)\) is the amount of time our computation takes.

Choose one to illustrate if our rag/data size is 1000, and we need to compute n³ steps/stitches (like knitting a cube!!), then the total time is 1000³/10¹² = 10^-3 a thousandth of a second. Nbd.

BUT let’s look at bigger data. 10¹² (~128gb pretty big) 10¹² mm = 1M km, 384,400 km to the moon. 149M km to the sun. So knitting something that big would take 10¹² s = ~32000 years. The sun will long since have burnt out by 10¹⁸ s

Punchline—we don’t want to do \(2^n\) amount of computation, and we need creative approaches for big data.

Recap—we’ve seen a problem whose size we characterize by \(n^2\), we’ll see problems whose time we characterize by \(n\), for sure, and later in the term, we’ll see a problem which is very simply stated, whose size we characterize by \(2^n\). 🙁

NOTE: \(\log\) is \(\log_2\). And \(\log 1000 = 10\).

Words and Ideas

• Elegance

• Growth of simple functions over time

• Representing complexity of a problem using time

• Running time of a Python function