FEED Validator

for Atom and RSS and KML

Congratulations!

This is a valid RSS feed.

Recommendations

This feed is valid, but interoperability with the widest range of feed readers could be improved by implementing the following recommendations.

line 31, column 0: description should not contain aria-label attribute (15 occurrences) [help]
```
from a nice guy named Mark.<h1 id="h_how_to_write_nice_code_in_research" ...
```

line 89, column 0: Non-html tag: picture (16 occurrences) [help]

100 through 140:</p><div class="figurep"><figure><picture><img src="https:// ...

line 134, column 0: description should not contain data-source attribute [help]

<a href="https://genart.social/@hamoid/115125620138280715" rel="external noo ...

Source: https://www.nedbatchelder.com/blog/rss.xml

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="https://nedbatchelder.com/rssfull2html.xslt" media="screen" ?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns="http://purl.org/rss/1.0/">
<channel rdf:about="https://nedbatchelder.com/blog">
<title>Ned Batchelder's blog</title>
<link>https://nedbatchelder.com/blog</link>
<description>Ned Batchelder's personal blog.</description>
<dc:language>en-US</dc:language>
<image rdf:resource="https://nedbatchelder.com/pix/rss-banner.gif"/>
<items>
<rdf:Seq>
<rdf:li resource="https://nedbatchelder.com/blog/202510/side_project_advice.html"/><rdf:li resource="https://nedbatchelder.com/blog/202510/natural_cubics_circular_simplex.html"/><rdf:li resource="https://nedbatchelder.com/blog/202509/hobby_hilbert_simplex.html"/><rdf:li resource="https://nedbatchelder.com/blog/202509/testing_is_better_than_dsa.html"/><rdf:li resource="https://nedbatchelder.com/blog/202508/finding_unneeded_pragmas.html"/><rdf:li resource="https://nedbatchelder.com/blog/202508/starting_with_pytests_parametrize.html"/><rdf:li resource="https://nedbatchelder.com/blog/202507/coveragepy_regex_pragmas.html"/><rdf:li resource="https://nedbatchelder.com/blog/202507/coverage_7100_patch.html"/><rdf:li resource="https://nedbatchelder.com/blog/202507/2048_iterators_and_iterables.html"/><rdf:li resource="https://nedbatchelder.com/blog/202506/math_factoid_of_the_day_63.html"/>
</rdf:Seq>
</items>
</channel>
<image rdf:about="https://nedbatchelder.com/pix/rss-banner.gif">
<title>Ned Batchelder's blog</title>
<link>https://nedbatchelder.com/blog</link>
<url>https://nedbatchelder.com/pix/rss-banner.gif</url>
</image>
<item rdf:about="https://nedbatchelder.com/blog/202510/side_project_advice.html">
<title>Side project advice</title>
<link>https://nedbatchelder.com/blog/202510/side_project_advice.html</link>
<dc:date>2025-10-30T06:23:13-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[Last night was a <a rel="external noopener" href="https://about.bostonpython.com/">Boston Python project night</a> where I
had a good conversation with a few people that was mostly guided by questions
from a nice guy named Mark.<h1 id="h_how_to_write_nice_code_in_research">How to write nice code in research<a class="headerlink" aria-label="Link to this header" href="#h_how_to_write_nice_code_in_research"></a></h1>Mark works in research and made the classic observation that research code is
often messy, and asked about how to make it nicer.I pointed out that for software engineers, the code is the product. For
research, the results are the product, so there’s a reason the code can be and
often is messier. It’s important to keep the goal in mind. I mentioned it might
not be worth it to add type annotations, detailed docstrings, or whatever else
would make the code “nice”.But the more you can make “nice” a habit, the less work it will be to do it
as a matter of course. Even in a result-driven research environment, you’ll be
able to write code the way you want, or at least push back a little bit. Code
usually lives longer than people expect, so the nicer you can make it,
the better it will be.<h1 id="h_side_projects">Side projects<a class="headerlink" aria-label="Link to this header" href="#h_side_projects"></a></h1>Side projects are a good opportunity to work differently. If work means messy
code, your side project could be pristine. If work is very strict, your side
project can be thrown together just for fun. You get to set the goals.And different side projects can be different. I develop
<a href="https://coverage.readthedocs.io" rel="external noopener">coverage.py</a> very differently
than <a href="https://nedbatchelder.com/blog/202510/natural_cubics_circular_simplex.html">fun math art
projects</a>. Coverage.py has an extensive test suite run on many versions of
Python (including nightly builds of the tip of main). The math art projects
usually have no tests at all.Side projects are a great place to decide how you want to code and to
practice that style. Later you can bring those skills and learnings back to a
work environment.<h1 id="h_forgive_yourself">Forgive yourself<a class="headerlink" aria-label="Link to this header" href="#h_forgive_yourself"></a></h1>Mark said one of his difficulties with side projects is perfectionism. He’ll
come back to a project and find he wants to rewrite the whole thing.My advice is: forgive yourself. It’s OK to rewrite the whole thing. It’s OK
to not rewrite the whole thing. It’s OK to ignore it for months at a time. It’s
OK to stop in the middle of a project and never come back to it. It’s OK to
obsess about “irrelevant” details.The great thing about a side project is that you are the only person who
decides what and how it should be.<h1 id="h_how_to_stay_motivated">How to stay motivated<a class="headerlink" aria-label="Link to this header" href="#h_how_to_stay_motivated"></a></h1>But how to stay motivated on side projects? For me, it’s very motivating that
many people use and get value from coverage.py. It’s a service to the community
that I find rewarding. Other side projects will have other motivations: a
chance to learn new things, flex different muscles, stretch myself in new
ways.Find a reason that motivates you, and structure your side projects to lean
into that reason. Don’t forget to forgive yourself if it doesn’t work out the
way you planned or if you change your mind.<h1 id="h_how_to_write_something_people_will_use">How to write something people will use<a class="headerlink" aria-label="Link to this header" href="#h_how_to_write_something_people_will_use"></a></h1>Sure, it’s great to have a project that many people use, but how do you find
a project that will end up like that? The best way is to write something that
you find useful. Then talk about it with people. You never know what will catch
on.I mentioned my <a href="https://pypi.org/project/cogapp/" rel="external noopener">cog</a> project,
which I first wrote in 2004 for one reason, but which is now being used by other
people (including me) for different purposes. It
<a href="https://nedbatchelder.com/blog/202201/cog_resurgence.html">took years to catch on</a>.Of course there’s no guarantee something like that will happen: it most
likely won’t. But I don’t know of a better way to make something people will
use than to start by making something that you will use.<h1 id="h_other_topics">Other topics<a class="headerlink" aria-label="Link to this header" href="#h_other_topics"></a></h1>The discussion wasn’t as linear as this. We touched on other things along the
way: unit tests vs system tests, obligations to support old versions of
software, how to navigate huge code bases. There were probably other tangents
that I’ve forgotten.Project nights are almost never just about projects: they are about
connecting with people in lots of different ways. This discussion felt like a
good connection. I hope the ideas of choosing your own paths and forgiving
yourself hit home.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202510/natural_cubics_circular_simplex.html">
<title>Natural cubics, circular Simplex</title>
<link>https://nedbatchelder.com/blog/202510/natural_cubics_circular_simplex.html</link>
<dc:date>2025-10-21T07:14:23-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[This post continues where <a href="https://nedbatchelder.com/blog/202509/hobby_hilbert_simplex.html">Hobby Hilbert Simplex</a> left
off. If you haven’t read it yet, start there. It explains the basics of Hobby
curves, Hilbert sorting and Simplex noise that I’m using.<h1 id="h_animation">Animation<a class="headerlink" aria-label="Link to this header" href="#h_animation"></a></h1>To animate one of our drawings, instead of considering 40 lines, we’ll think
about 140 lines. The first frame of the animation will draw lines 1 through 40,
the second draws lines 2 through 41, and so on until the 100th frame is lines
100 through 140:<div class="figurep"><figure><picture><img src="https://nedbatchelder.com/pix/fluidity/linear_hobby.gif" alt="Swoopy lines flowing across the image, but with occasional jumps" width="600" height="600" class="hairline"></picture></figure></div>I’ve used a single Hilbert sorter for all of the frames to remove some
jumping, but the Hobby curves still hop around. Also the animation doesn’t loop
smoothly, so there’s a giant jump from frame 100 back to frame 1.<h1 id="h_natural_cubics">Natural cubics<a class="headerlink" aria-label="Link to this header" href="#h_natural_cubics"></a></h1>Hobby curves look nice, but have this unfortunate discontinuity where a small
change in a point can lead to a radical change in the curve. There’s another way
to compute curves through points automatically, called natural cubic curves.
These curves don’t jump around the way Hobby curves can.Jake Low’s <a rel="external noopener" href="https://www.jakelow.com/blog/hobby-curves">page about Hobby curves</a> has interactive
examples of natural cubic curves which you should try. Natural cubics don’t
look as nice to our eyes as Hobby curves. Below is a comparison. Each row has
the same points, with Hobby curves on the left and natural cubic curves on the
right:<div class="figurep"><figure><picture><source type="image/webp" srcset="https://nedbatchelder.com/iv/webp/pix/fluidity/hobby_vs_cubic.png.webp"><img src="https://nedbatchelder.com/pix/fluidity/hobby_vs_cubic.png" alt="On the right are nice blobby shapes, on the left are the same points but connected with sometimes pointy awkward curves" width="1200" height="1800" class="hairline"></picture></figure></div>The “natural” cubics actually have a quite unnatural appearance. But in an
animation, those quirks could be a good trade-off for smooth transitions. Here’s
an animation with the same points as our first one, but with natural cubic
curves:<div class="figurep"><figure><picture><img src="https://nedbatchelder.com/pix/fluidity/linear_cubic.gif" alt="A flowing animation with pointier curves, only one jump at the end" width="600" height="600" class="hairline"></picture></figure></div>Now the motion is smooth except for the jump from frame 100 back to frame 1.
Let’s do something about that.<h1 id="h_circular_simplex">Circular Simplex<a class="headerlink" aria-label="Link to this header" href="#h_circular_simplex"></a></h1>So far, we’ve been choosing points by sampling the simplex noise in small steps along
a horizontal line: use a fixed u value, then take tiny steps along the v axis.
That gave us our x coordinates, and a similar line with a different u value gave
us the y coordinates. The ending point will be completely unrelated to the
starting point. To make a seamlessly looping animation, we need our x,y values
to cycle seamlessly, returning to where they started.We can make our x,y coordinates loop by choosing u,v values in a circle.
Because the u,v values return to their starting point in the continuous simplex
noise, the x,y coordinates will return as well. We use two circles: one for the
x coordinates and another for the y. The circles are far from each other to
keep x and y independent of each other. The size of the circle is determined by
the distance we want for each step and how many steps we want in the loop.Here are three point paths created two ways, with linear sampling on the
right and circular sampling on the left. Because simplex provides values between
-1 and 1, the points wander within a square:<div class="figurep"><figure><picture><source type="image/webp" srcset="https://nedbatchelder.com/iv/webp/pix/fluidity/point_trails.png.webp"><img src="https://nedbatchelder.com/pix/fluidity/point_trails.png" alt="On the right, three trails of points that don't form a closed loop. On the left, three closed loops but still with interesting random shapes" width="1200" height="600" class="hairline"></picture></figure></div>It can get a bit confusing at this point: these traces are not the curves we
are drawing. They are the paths of the control points for successive curves. We
draw curves through corresponding sets of points to get our animation. The first
curve connects the first red/green/blue points, the second curve connects the
second set, and so on.Using circular sampling of the simplex noise, we can make animations that
loop perfectly:<div class="figurep"><figure><picture><img src="https://nedbatchelder.com/pix/fluidity/circular_5.gif" alt="A smoothly looping animation" width="600" height="600" class="hairline"></picture></figure></div><div class="figurep"><figure><picture><img src="https://nedbatchelder.com/pix/fluidity/circular_9.gif" alt="A smoothly looping animation" width="600" height="600" class="hairline"></picture></figure></div><div class="figurep"><figure><picture><img src="https://nedbatchelder.com/pix/fluidity/circular_25.gif" alt="A smoothly looping animation" width="600" height="600" class="hairline"></picture></figure></div><h1 id="h_colophon">Colophon<a class="headerlink" aria-label="Link to this header" href="#h_colophon"></a></h1>If you are interested, the code is available on GitHub at
<a href="https://github.com/nedbat/fluidity" rel="external noopener">nedbat/fluidity</a>.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202509/hobby_hilbert_simplex.html">
<title>Hobby Hilbert Simplex</title>
<link>https://nedbatchelder.com/blog/202509/hobby_hilbert_simplex.html</link>
<dc:date>2025-09-26T08:14:04-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[I saw a generative art piece I liked and wanted to learn how it was made.
Starting with the artist’s Kotlin code, I dug into three new algorithms, hacked
together some Python code, experimented with alternatives, and learned a lot.
Now I can explain it to you.It all started with this post by
<a href="https://genart.social/@hamoid/115125620138280715" rel="external noopener">aBe on Mastodon</a>:<blockquote class="mastodon-post" lang="en" cite="https://genart.social/@hamoid/115125620138280715" data-source="fediverse">
I love how these lines separate and reunite. And the fact that I can express this idea in 3 or 4 lines of code.For me they’re lives represented by closed paths that end where they started, spending part of the journey together, separating while we go in different directions and maybe reconnecting again in the future.<a href="https://genart.social/tags/CreativeCoding" rel="nofollow noopener" class="mention hashtag" target="_blank">#CreativeCoding</a> <a href="https://genart.social/tags/algorithmicart" rel="nofollow noopener" class="mention hashtag" target="_blank">#algorithmicart</a> <a href="https://genart.social/tags/proceduralArt" rel="nofollow noopener" class="mention hashtag" target="_blank">#proceduralArt</a> <a href="https://genart.social/tags/OPENRNDR" rel="nofollow noopener" class="mention hashtag" target="_blank">#OPENRNDR</a> <a href="https://genart.social/tags/Kotlin" rel="nofollow noopener" class="mention hashtag" target="_blank">#Kotlin</a>
<figure><figure><img src="https://media.hachyderm.io/cache/media_attachments/files/115/125/620/285/265/947/small/5a73d40e6a4a81c1.png" alt="80 wobbly black hobby curves with low opacity. In some places the curves travel together, but sometimes they split in 2 or 3 groups and later reunite. Due to the low opacity, depending on how many curves overlap the result is brighter or darker." width="480" height="480"></figure></figure>
<footer>
— aBe (@hamoid@genart.social) <a href="https://genart.social/@hamoid/115125620138280715" rel="external noopener"><time datetime="2025-08-31T21:59:13.000Z">8/31/2025, 5:59:13 PM</time></a>
</footer>
</blockquote>The drawing is made by choosing 10 random points, drawing a curve through
those points, then slightly scooching the points and drawing another curve.
There are 40 curves, each slightly different than the last. Occasionally
the next curve makes a jump, which is why they separate and reunite.Eventually I made something similar:<div class="figurep"><figure><picture><source type="image/webp" srcset="https://nedbatchelder.com/iv/webp/pix/fluidity/repro_139.png.webp"><img src="https://nedbatchelder.com/pix/fluidity/repro_139.png" alt="An image similar to the one from Mastodon, with smoky sinuous curves" width="600" height="600" class="hairline"></picture></figure></div>Along the way I had to learn about three techniques I got from the Kotlin
code: Hobby curves, Hilbert sorting, and simplex noise.Each of these algorithms tries to do something “natural” automatically, so
that we can generate art that looks nice without any manual steps.<h1 id="h_hobby_curves">Hobby curves<a class="headerlink" aria-label="Link to this header" href="#h_hobby_curves"></a></h1>To draw swoopy curves through our random points, we use an algorithm
developed by John Hobby as part of Donald Knuth’s Metafont type design system.
Jake Low has a <a rel="external noopener" href="https://www.jakelow.com/blog/hobby-curves">great interactive page for playing with Hobby
curves</a>, you should try it.Here are three examples of Hobby curves through ten random points:<div class="figurep"><figure><picture><source type="image/webp" srcset="https://nedbatchelder.com/iv/webp/pix/fluidity/hobby_unsorted.png.webp"><img src="https://nedbatchelder.com/pix/fluidity/hobby_unsorted.png" alt="Red random points connected by green lines then with a curve through all ten." width="600" height="200" class="hairline"></picture></figure></div>The curves are nice, but kind of a scribble, because we’re joining points
together in the order we generated them (shown by the green lines). If you
asked a person to connect random points, they wouldn’t jump back and forth
across the canvas like this. They would find a nearby point to use next,
producing a more natural tour of the set.We’re generating everything automatically, so we can’t manually intervene
to choose a natural order for the points. Instead we use Hilbert sorting.<h1 id="h_hilbert_sorting">Hilbert sorting<a class="headerlink" aria-label="Link to this header" href="#h_hilbert_sorting"></a></h1>The Hilbert space-filling fractal visits every square in a 2D grid.
<a rel="external noopener" href="https://doc.cgal.org/latest/Spatial_sorting/index.html">Hilbert sorting</a> uses a Hilbert fractal traversing
the canvas, and sorts the points by when their square is visited by the fractal.
This gives a tour of the points that corresponds more closely to what people
expect. Points that are close together in space are likely (but not guaranteed)
to be close in the ordering.If we sort the points using Hilbert sorting, we get much nicer curves. Here
are the same points as last time:<div class="figurep"><figure><picture><source type="image/webp" srcset="https://nedbatchelder.com/iv/webp/pix/fluidity/hobby_sorted.png.webp"><img src="https://nedbatchelder.com/pix/fluidity/hobby_sorted.png" alt="The same three examples of ten points, but the curves make more sense now" width="600" height="200" class="hairline"></picture></figure></div>Here are pairs of the same points, unsorted and sorted side-by-side:<div class="figurep"><figure><picture><source type="image/webp" srcset="https://nedbatchelder.com/iv/webp/pix/fluidity/hilbert_compared.png.webp"><img src="https://nedbatchelder.com/pix/fluidity/hilbert_compared.png" alt="Comparing the scribbles and the nice curves" width="400" height="800" class="hairline"></picture></figure></div>If you compare closely, the points in each pair are the same, but the sorted
points are connected in a better order, producing nicer curves.<h1 id="h_simplex_noise">Simplex noise<a class="headerlink" aria-label="Link to this header" href="#h_simplex_noise"></a></h1>Choosing random points would be easy to do with a random number generator,
but we want the points to move in interesting graceful ways. To do that, we use
simplex noise. This is a 2D function (let’s call the inputs u and v) that
produces a value from -1 to 1. The important thing is the function is
continuous: if you sample it at two (u,v) coordinates that are close together,
the results will be close together. But it’s also random: the continuous curves
you get are wavy in unpredictable ways. Think of the simplex noise function as
a smooth hilly landscape.To get an (x,y) point for our drawing, we choose a (u,v) coordinate to
produce an x value and a completely different (u,v) coordinate for the y. To
get the next (x,y) point, we keep the u values the same and change the v values by
just a tiny bit. That makes the (x,y) points move smoothly but interestingly.Here are the trails of four points taking 50 steps using this scheme:<div class="figurep"><figure><picture><source type="image/webp" srcset="https://nedbatchelder.com/iv/webp/pix/fluidity/point_motion.png.webp"><img src="https://nedbatchelder.com/pix/fluidity/point_motion.png" alt="Four trails of red dots showing how the randomness creates unpredictable but interesting paths" width="400" height="400" class="hairline"></picture></figure></div>If we use seven points taking five steps, and draw curves through the seven
points at each step, we get examples like this:<div class="figurep"><figure><picture><source type="image/webp" srcset="https://nedbatchelder.com/iv/webp/pix/fluidity/small_runs.png.webp"><img src="https://nedbatchelder.com/pix/fluidity/small_runs.png" alt="Drawing curves through the points, widely spaced to show the construction" width="600" height="300" class="hairline"></picture></figure></div>I’ve left the points visible, and given them large steps so the lines are
very widely spaced to show the motion. Taking out the points and drawing more
lines with smaller steps gives us this:<div class="figurep"><figure><picture><source type="image/webp" srcset="https://nedbatchelder.com/iv/webp/pix/fluidity/large_runs.png.webp"><img src="https://nedbatchelder.com/pix/fluidity/large_runs.png" alt="More lines to move toward the look we want" width="600" height="300" class="hairline"></picture></figure></div>With 40 lines drawn wider with some transparency, we start to see the smoky
fluidity:<div class="figurep"><figure><picture><source type="image/webp" srcset="https://nedbatchelder.com/iv/webp/pix/fluidity/larger_runs.png.webp"><img src="https://nedbatchelder.com/pix/fluidity/larger_runs.png" alt="Now we're getting the original effect" width="600" height="300" class="hairline"></picture></figure></div><h1 id="h_jumps">Jumps<a class="headerlink" aria-label="Link to this header" href="#h_jumps"></a></h1>In his Mastodon post, aBe commented on the separating of the lines as one of
the things he liked about this. But why do they do that? If we are moving the
points in small increments, why do the curves sometimes make large jumps?The first reason is because of Hobby curves. They do a great job drawing a
curve through a set of points as a person might. But a downside of the
algorithm is sometimes changing a point a small amount makes the entire curve
take a different route. If you play around with the interactive examples on
<a rel="external noopener" href="https://www.jakelow.com/blog/hobby-curves">Jake Low’s page</a> you will see the curve can unexpectedly
take a different shape.As we inch our points along, sometimes the Hobby curve jumps.The second reason is due to Hilbert sorting. Each of our lines is sorted
independently of how the previous line was sorted. If a point’s small motion
moves it into a different grid square, it can change the sorting order, which
changes the Hobby curve even more.If we sort the first line, and then keep that order of points for all the
lines, the result has fewer jumps, but the Hobby curves still act
unpredictably:<div class="figurep"><figure><picture><source type="image/webp" srcset="https://nedbatchelder.com/iv/webp/pix/fluidity/first_line_runs.png.webp"><img src="https://nedbatchelder.com/pix/fluidity/first_line_runs.png" alt="The same two sets of points as the last figure. Fewer jumps, but still with some discontinuities" width="600" height="300" class="hairline"></picture></figure></div><h1 id="h_colophon">Colophon<a class="headerlink" aria-label="Link to this header" href="#h_colophon"></a></h1>This was all done with Python, using other people’s implementations of the
hard parts:
<a href="https://github.com/ltrujello/Hobby_Curve_Algorithm/blob/main/python/hobby.py" rel="external noopener">hobby.py</a>,
<a href="https://pypi.org/project/hilbertcurve/" rel="external noopener">hilbertcurve</a>, and
<a href="https://pypi.org/project/super-simplex/" rel="external noopener">super-simplex</a>. My code
is on GitHub
(<a href="https://github.com/nedbat/fluidity" rel="external noopener">nedbat/fluidity</a>), but it’s a
mess. Think of it as a woodworking studio with half-finished pieces and wood
chips strewn everywhere.A lot of the learning and experimentation was in
<a href="https://github.com/nedbat/fluidity/blob/main/play.ipynb" rel="external noopener">my Jupyter
notebook</a>. Part of the process for work like this is playing around with
different values of tweakable parameters and seeds for the random numbers to get
the effect you want, either artistic or pedagogical. The notebook shows some of
the thumbnail galleries I used to pick the examples to show.I went on to play with animations, which led to other learnings, but those
will have to wait for another blog post.
Update: I animated these in <a href="https://nedbatchelder.com/blog/202510/natural_cubics_circular_simplex.html">Natural cubics, circular Simplex</a>.

]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202509/testing_is_better_than_dsa.html">
<title>Testing is better than DSA</title>
<link>https://nedbatchelder.com/blog/202509/testing_is_better_than_dsa.html</link>
<dc:date>2025-09-22T12:04:08-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[I see new learners asking about “DSA” a lot. Data Structures and Algorithms
are of course important: considered broadly, they are the two ingredients that
make up all programs. But in my opinion, “DSA” as an abstract field of study
is over-emphasized.I understand why people focus on DSA: it’s a concrete thing to learn about,
there are web sites devoted to testing you on it, and most importantly, because
job interviews often involve DSA coding questions.Before I get to other opinions, let me make clear that anything you can do to
help you get a job is a good thing to do. If grinding
<a rel="external noopener" href="https://leetcode.com/">leetcode</a> will land you a position, then do it.But I hope companies hiring entry-level engineers aren’t asking them to
reverse linked lists or balance trees. Asking about techniques that can be
memorized ahead of time won’t tell them anything about how well you can work.
The stated purpose of those interviews is to see how well you can figure out
solutions, in which case memorization will defeat the point.The thing new learners don’t understand about DSA is that actual software
engineering almost never involves implementing the kinds of algorithms that
“DSA” teaches you. Sure, it can be helpful to work through some of these
puzzles and see how they are solved, but writing real code just doesn’t involve
writing that kind of code.Here is what I think in-the-trenches software engineers should know about
data structures and algorithms:<ul>
<li>Data structures are ways to organize data. Learn some of the basics: linked
list, array, hash table, tree. By “learn” I mean understand what it does
and why you might want to use one.</li>
<li>Different data structures can be used to organize the same data in different
ways. Learn some of the trade-offs between structures that are similar.</li>
<li>Algorithms are ways of manipulating data. I don’t mean named algorithms
like Quicksort, but algorithms as any chunk of code that works on data and
does something with it.</li>
<li>How you organize data affects what algorithms you can use to work with the
data. Some data structures will be slow for some operations where another
structure will be fast.</li>
<li>Algorithms have a “time complexity” (Big O): <a rel="external noopener" href="/text/bigo.html">how the code
slows as the data grows</a>. Get a sense of what this means.</li>
<li>Python has a number of built-in data structures. Learn how they work, and
the time complexity of their operations.</li>
<li>Learn how to think about your code to understand its time complexity.</li>
<li>Read a little about more esoteric things like <a rel="external noopener" href="https://systemdesign.one/bloom-filters-explained/">Bloom
filters</a>, so you can find them later in the unlikely case you need them.</li>
</ul>Here are some things you don’t need to learn:<ul>
<li>The details of a dozen different sorting algorithms. Look at two to see
different ways of approaching the same problem, then move on.</li>
<li>The names of “important” algorithms. Those have all been implemented for
you.</li>
<li>The answers to all N problems on some quiz web site. You won’t be asked
these exact questions, and they won’t come up in your real work. Again: try a
few to get a feel for how some algorithms work. The exact answers are not what
you need.</li>
</ul>Of course some engineers need to implement hash tables, or sorting algorithms
or whatever. We love those engineers: they write libraries we can use off the
shelf so we don’t have to implement them ourselves.There have been times when I implemented something that felt like An
Algorithm (for example, <a href="https://nedbatchelder.com/blog/201707/finding_fuzzy_floats.html">Finding fuzzy floats</a>), but it was
more about considering another perspective on my data, looking at the time
complexity, and moving operations around to avoid quadratic behavior. It wasn’t
opening a textbook to find the famous algorithm that would solve my problem.Again: if it will help you get a job, deep-study DSA. But don’t be
disappointed when you don’t use it on the job.If you want to prepare yourself for a career, and also stand out in job
interviews, learn how to write tests:<ul>
<li>This will be a skill you use constantly. Real-world software means writing
tests much more than school teaches you to.</li>
<li>In a job search, testing experience will stand out more than DSA depth. It
shows you’ve thought about what it takes to write high-quality software instead
of just academic exercises.</li>
<li>It’s not obvious how to test code well. It’s a puzzle and a problem to
solve. If you like figuring out solutions to tricky questions, focus on how to
write code so that it can be tested, and how to test it.</li>
<li>Testing not only gives you more confidence in your code, it helps you write
better code in the first place.</li>
<li>Testing applies everywhere, from tiny bits of code to entire architectures,
assisting you in design and implementation at all scales.</li>
<li>If pursued diligently, testing is an engineering discipline in its own
right, with a fascinating array of tools and techniques.</li>
</ul>Less DSA, more testing.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202508/finding_unneeded_pragmas.html">
<title>Finding unneeded pragmas</title>
<link>https://nedbatchelder.com/blog/202508/finding_unneeded_pragmas.html</link>
<dc:date>2025-08-24T17:28:12-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[To answer a <a rel="external noopener" href="https://github.com/nedbat/coveragepy/issues/251">long-standing coverage.py feature request</a>, I
threw together an experiment: a tool to identify lines that have been excluded
from coverage, but which were actually executed.The program is a standalone file in the coverage.py repo. It is unsupported.
I’d like people to try it to see what they think of the idea. Later we can
decide what to do with it.To try it: copy <a rel="external noopener" href="https://github.com/nedbat/coveragepy/blob/master/lab/warn_executed.py">warn_executed.py</a> from
GitHub. Create a .toml file that looks something like this:<blockquote class="code"><pre class="toml"><div class="source"># Regexes that identify excluded lines:
 warn-executed = [
     "pragma: no cover",
     "raise AssertionError",
     "pragma: cant happen",
     "pragma: never called",
     ]
 
 # Regexes that identify partial branch lines:
 warn-not-partial = [
     "pragma: no branch",
     ]
 </div>
</pre></blockquote>These are exclusion regexes that you’ve used in your coverage runs. The
program will print out any line identified by a pattern and that ran during your
tests. It might be that you don’t need to exclude the line, because it ran.In this file, none of your coverage settings or the default regexes are
assumed: you need to explicitly specify all the patterns you want flagged.Run the program with Python 3.11 or higher, giving the name of the coverage
data file and the name of your new TOML configuration file. It will print the
lines that might not need excluding:<blockquote class="code"><pre class="shell"><div class="source">$ python3.12 warn_executed.py .coverage warn.toml
 </div>
</pre></blockquote>The reason for a new list of patterns instead of just reading the existing
coverage settings is that some exclusions are “don’t care” rather than “this
will never happen.” For example, I exclude “def __repr__” because some
__repr__’s are just to make my debugging easier. I don’t care if the test suite
runs them or not. It might run them, so I don’t want it to be a warning that
they actually ran.This tool is not perfect. For example, I exclude “if TYPE_CHECKING:” because
I want that entire clause excluded. But the if-line itself is actually run. If
I include that pattern in the warn-executed list, it will flag all of those
lines. Maybe I’m forgetting a way to do this: it would be good to have a way to
exclude the body of the if clause while understanding that the if-line itself is
executed.Give <a rel="external noopener" href="https://github.com/nedbat/coveragepy/blob/master/lab/warn_executed.py">warn_executed.py</a> a try and comment on
<a rel="external noopener" href="https://github.com/nedbat/coveragepy/issues/251">the issue</a> about what you think of it.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202508/starting_with_pytests_parametrize.html">
<title>Starting with pytest’s parametrize</title>
<link>https://nedbatchelder.com/blog/202508/starting_with_pytests_parametrize.html</link>
<dc:date>2025-08-13T06:14:46-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[Writing tests can be difficult and repetitive. Pytest has a feature called
parametrize that can make it reduce duplication, but it can be hard to
understand if you are new to the testing world. It’s not as complicated as it
seems.Let’s say you have a function called <code>add_nums()</code> that adds up a list of
numbers, and you want to write tests for it. Your tests might look like
this:<blockquote class="code"><pre class="python"><div class="source">def test_123():
     assert add_nums([1, 2, 3]) == 6
 
 def test_negatives():
     assert add_nums([1, 2, -3]) == 0
 
 def test_empty():
     assert add_nums([]) == 0
 </div>
</pre></blockquote>This is great: you’ve tested some behaviors of your <code>add_nums()</code>
function. But it’s getting tedious to write out more test cases. The names of the
function have to be different from each other, and they don’t mean anything, so
it’s extra work for no benefit. The test functions all have the same structure,
so you’re repeating uninteresting details. You want to add more cases but it
feels like there’s friction that you want to avoid.If we look at these functions, they are very similar. In any software, when
we have functions that are similar in structure, but differ in some details, we
can refactor them to be one function with parameters for the differences. We can
do the same for our test functions.Here the functions all have the same structure: call <code>add_nums()</code> and
assert what the return value should be. The differences are the list we pass to
<code>add_nums()</code> and the value we expect it to return. So we can turn those
into two parameters in our refactored function:<blockquote class="code"><pre class="python"><div class="source">def test_add_nums(nums, expected_total):
     assert add_nums(nums) == expected_total
 </div>
</pre></blockquote>Unfortunately, tests aren’t run like regular functions. We write the test
functions, but we don’t call them ourselves. That’s the reason the names of the
test functions don’t matter. The test runner (pytest) finds functions named
<code>test_*</code> and calls them for us. When they have no parameters, pytest can
call them directly. But now that our test function has two parameters, we have
to give pytest instructions about how to call it.To do that, we use the <code>@pytest.mark.parametrize</code> decorator. Using it
looks like this:<blockquote class="code"><pre class="python"><div class="source">import pytest
 
 @pytest.mark.parametrize(
     "nums, expected_total",
     [
         ([1, 2, 3], 6),
         ([1, 2, -3], 0),
         ([], 0),
     ]
 )
 def test_add_nums(nums, expected_total):
     assert add_nums(nums) == expected_total
 </div>
</pre></blockquote>There’s a lot going on here, so let’s take it step by step.If you haven’t seen a decorator before, it starts with <code>@</code> and is like a
prologue to a function definition. It can affect how the function is defined or
provide information about the function.The parametrize decorator is itself a function call that takes two arguments.
The first is a string (“nums, expected_total”) that names the two arguments to
the test function. Here the decorator is instructing pytest, “when you call
<code>test_add_nums</code>, you will need to provide values for its <code>nums and</code>
<code>expected_total parameters</code>.”The second argument to <code>parametrize</code> is a list of the values to supply
as the arguments. Each element of the list will become one call to our test
function. In this example, the list has three tuples, so pytest will call our
test function three times. Since we have two parameters to provide, each
element of the list is a tuple of two values.The first tuple is <code>([1, 2, 3], 6)</code>, so the first time pytest calls
test_add_nums, it will call it as test_add_nums([1, 2, 3], 6). All together,
pytest will call us three times, like this:<blockquote class="code"><pre class="python"><div class="source">test_add_nums([1, 2, 3], 6)
 test_add_nums([1, 2, -3], 0)
 test_add_nums([], 0)
 </div>
</pre></blockquote>This will all happen automatically. With our original test functions, when
we ran pytest, it showed the results as three passing tests because we had three
separate test functions. Now even though we only have one function, it still
shows as three passing tests! Each set of values is considered a separate test
that can pass or fail independently. This is the main advantage of using
parametrize instead of writing three separate assert lines in the body of a
simple test function.What have we gained?<ul>
<li>We don’t have to write three separate functions with different names.</li>
<li>We don’t have to repeat the same details in each function (<code>assert</code>,
<code>add_nums()</code>, <code>==</code>).</li>
<li>The differences between the tests (the actual data) are written succinctly
all in one place.</li>
<li>Adding another test case is as simple as adding another line of data to the
decorator.</li>
</ul>
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202507/coveragepy_regex_pragmas.html">
<title>Coverage.py regex pragmas</title>
<link>https://nedbatchelder.com/blog/202507/coveragepy_regex_pragmas.html</link>
<dc:date>2025-07-28T12:04:12-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[<a rel="external noopener" href="https://coverage.readthedocs.io/">Coverage.py</a> lets you indicate code to exclude from
measurement by adding comments to your Python files. But coverage implements
them differently than other similar tools. Rather than having fixed syntax for
these comments, they are defined using regexes that you can change or add to.
This has been surprisingly powerful.The basic behavior: coverage finds lines in your source files that match the
regexes. These lines are excluded from measurement, that is, it’s OK if they
aren’t executed. If a matched line is part of a multi-line statement the
whole multi-line statement is excluded. If a matched line introduces a block of
code the entire block is excluded.At first, these regexes were just to make it easier to implement the basic
“here’s the comment you use” behavior for pragma comments. But it also enabled
pragma-less exclusions. You could decide (for example) that you didn’t care to
test any <code>__repr__</code> methods. By adding <code>def __repr__</code> as an exclusion
regex, all of those methods were automatically excluded from coverage
measurement without having to add a comment to each one. Very nice.Not only did this let people add custom exclusions in their projects, but
it enabled third-party plugins that could configure regexes in other interesting
ways:<ul>
<li><a href="https://pypi.org/project/covdefaults/" rel="external noopener">covdefaults</a> adds a
bunch of default exclusions, and also platform- and version-specific comment
syntaxes.</li>
<li><a href="https://pypi.org/project/coverage-conditional-plugin/" rel="external noopener">coverage-conditional-plugin</a>
gives you a way to create comment syntaxes for entire files, for whether other
packages are installed, and so on.</li>
</ul>Then about a year ago, <a rel="external noopener" href="https://github.com/nedbat/coveragepy/pull/1807">Daniel Diniz contributed a
change</a> that amped up the power: regexes could match multi-line patterns.
This sounds like not that large a change, but it enabled much more powerful
exclusions. As a sign, it made it possible to support <a rel="external noopener" href="https://coverage.readthedocs.io/en/latest/changes.html#version-7-6-0-2024-07-11">four
different feature requests</a>.To make it work, Daniel changed the matching code. Originally, it was a loop
over the lines in the source file, checking each line for a match against the
regexes. The new code uses the entire source file as the target string, and
loops over the matches against that text. Each match is converted into a set of
line numbers and added to the results.The power comes from being able to use one pattern to match many lines. For
example, one of the four feature requests was <a rel="external noopener" href="https://github.com/nedbat/coveragepy/issues/118">how to exclude an
entire file</a>. With configurable multi-line regex patterns, you can do this
yourself:<blockquote class="code"><pre>\A(?s:.*# pragma: exclude file.*)\Z </pre></blockquote>With this regex, if you put the comment “# pragma: exclude file” in your
source file, the entire file will be excluded. The <code>\A</code> and <code>\Z</code>
match the start and end of the target text, which remember is the entire file.
The <code>(?s:...)</code> means the <a rel="external noopener" href="https://docs.python.org/3/library/re.html#re.S">s/DOTALL</a> flag is in
effect, so <code>.</code> can match newlines. This pattern matches the entire source
file if the desired pragma is somewhere in the file.Another requested feature was <a rel="external noopener" href="https://github.com/nedbat/coveragepy/issues/1803">excluding code between two
lines</a>. We can use “# no cover: start” and “# no cover: end” as delimiters
with this regex:<blockquote class="code"><pre># no cover: start(?s:.*?)# no cover: stop </pre></blockquote>Here <code>(?s:.*?)</code> means any number of any character at all, but as few as
possible. A star in regexes means as many as possible, but star-question-mark
means as few as possible. We need the minimal match so that we don’t match from
the start of one pair of comments all the way through to the end of a different
pair of comments.This regex approach is powerful, but is still fairly shallow. For example,
either of these two examples would get the wrong lines if you had a string
literal with the pragma text in it. There isn’t a regex that skips easily over
string literals.This kind of difficulty hit home when I added a new default pattern to
exclude empty placeholder methods like this:<blockquote class="code"><pre class="python"><div class="source">def not_yet(self): ...
 
 def also_not_this(self):
     ...
 
 async def definitely_not_this(
     self,
     arg1,
 ):
     ...
 </div>
</pre></blockquote>We can’t just match three dots, because ellipses can be used in other places
than empty function bodies. We need to be more delicate. I ended up with:<blockquote class="code"><pre>^\s*(((async )?def .*?)?\)(\s*->.*?)?:\s*)?\.\.\.\s*(#|$) </pre></blockquote>This craziness ensures the ellipsis is part of an (async) def, that the
ellipsis appears first in the body (but no docstring allowed, doh!), allows for
a comment on the line, and so on. And even with a pattern this complex, it
would incorrectly match this contrived line:<blockquote class="code"><pre class="python"><div class="source">def f(): print("(well): ... #2 false positive!")
 </div>
</pre></blockquote>So regexes aren’t perfect, but they’re a pretty good balance: flexible and
powerful, and will work great on real code even if we can invent weird edge
cases where they fail.What started as a simple implementation expediency has turned into a powerful
configuration option that has done more than I would have thought.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202507/coverage_7100_patch.html">
<title>Coverage 7.10.0: patch</title>
<link>https://nedbatchelder.com/blog/202507/coverage_7100_patch.html</link>
<dc:date>2025-07-24T19:03:27-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[Years ago I greeted a friend returning from vacation and asked how it had
been. She answered, “It was good, I got a lot done!” I understand that feeling.
I just had a long vacation myself, and used the time to clean up some old issues
and add some new features in <a rel="external noopener" href="https://pypi.org/project/coverage/">coverage.py v7.10</a>.The major new feature is a configuration option,
<a rel="external noopener" href="https://coverage.readthedocs.io/en/latest/config.html#run-patch"><code>[run] patch</code></a>. With it, you specify named
patches that coverage can use to monkey-patch some behavior that gets in the way
of coverage measurement.The first is <code>subprocess</code>. Coverage works great when you start your
program with coverage measurement, but has long had the problem of how to also
measure the coverage of sub-processes that your program created. The existing
solution had been a complicated two-step process of creating obscure .pth files
and setting environment variables. Whole projects appeared on PyPI to handle
this for you.Now, <code>patch = subprocess</code> will do this for you automatically, and clean
itself up when the program ends. It handles sub-processes created by the
<a rel="external noopener" href="https://docs.python.org/3/library/subprocess.html#module-subprocess">subprocess</a> module, the
<a rel="external noopener" href="https://docs.python.org/3/library/os.html#os.system">os.system()</a> function, and any of the
<a rel="external noopener" href="https://docs.python.org/3/library/os.html#os.execl">execv</a> or <a rel="external noopener" href="https://docs.python.org/3/library/os.html#os.spawnl">spawnv</a> families of
functions.This alone has spurred <a rel="external noopener" href="https://bsky.app/profile/did:plc:yj4vzsbzzkpswr7x5yagzhhx/post/3luqfffiiqk27">one user to exclaim</a>,<blockquote><div>The latest release of Coverage feels like a Christmas present!
The native support for Python subprocesses is so good!</div></blockquote>Another patch is <code>_exit</code>. This patches
<a rel="external noopener" href="https://docs.python.org/3/library/os.html#os._exit">os._exit()</a> so that coverage saves its data before
exiting. The os._exit() function is an immediate and abrupt termination of the
program, skipping all kinds of registered clean up code. This patch makes it
possible to collect coverage data from programs that end this way.The third patch is <code>execv</code>. The <a rel="external noopener" href="https://docs.python.org/3/library/os.html#os.execl">execv</a> functions
end the current program and replace it with a new program in the same process.
The <code>execv</code> patch arranges for coverage to save its data before the
current program is ended.Now that these patches are available, it seems silly that it’s taken so long.
They (mostly) weren’t difficult. I guess it took looking at the old issues,
realizing the friction they caused, and thinking up a new way to let users
control the patching. Monkey-patching is a bit invasive, so I’ve never wanted
to do it implicitly. The patch option gives the user an explicit way to request
what they need without having to get into the dirty details themselves.Another process-oriented feature was contributed by Arkady Gilinsky: with
<code>--save-signal=USR1</code> you can specify a user signal that coverage will
attend to. When you send the signal to your running coverage process, it will
save the collected data to disk. This gives a way to measure coverage in a
long-running process without having to end the process.There were some other fixes and features along the way, like better HTML
coloring of multi-line statements, and more default exclusions
(<code>if TYPE_CHECKING:</code> and <code>...</code>).It feels good to finally address some of these pain points. I also closed
some stale issues and pull requests. There is more to do, always more to do,
but this feels like a real step forward. Give <a rel="external noopener" href="https://coverage.readthedocs.io/en/7.10.0/changes.html#version-7-10-0-2025-07-24">coverage
7.10.0</a> a try and let me know how it works for you.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202507/2048_iterators_and_iterables.html">
<title>2048: iterators and iterables</title>
<link>https://nedbatchelder.com/blog/202507/2048_iterators_and_iterables.html</link>
<dc:date>2025-07-15T06:52:29-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[I wrote a <a rel="external noopener" href="https://github.com/nedbat/odds/blob/master/2048/2048.py">low-tech terminal-based version</a> of the
classic <a rel="external noopener" href="https://play2048.co/">2048 game</a> and had some interesting difficulties
with iterators along the way.2048 has a 4×4 grid with sliding tiles. Because the tiles can slide
left or right and up or down, sometimes we want to loop over the rows and
columns from 0 to 3, and sometimes from 3 to 0. My first attempt looked like
this:<blockquote class="code"><pre class="python"><div class="source">N = 4
 if sliding_right:
     cols = range(N-1, -1, -1)   # 3 2 1 0
 else:
     cols = range(N)             # 0 1 2 3
 
 if sliding_down:
     rows = range(N-1, -1, -1)   # 3 2 1 0
 else:
     rows = range(N)             # 0 1 2 3
 
 for row in rows:
     for col in cols:
         ...
 </div>
</pre></blockquote>This worked, but those counting-down ranges are ugly. Let’s make it
nicer:<blockquote class="code"><pre class="python"><div class="source">cols = range(N)                 # 0 1 2 3
 if sliding_right:
     cols = reversed(cols)       # 3 2 1 0
 
 rows = range(N)                 # 0 1 2 3
 if sliding_down:
     rows = reversed(rows)       # 3 2 1 0
 
 for row in rows:
     for col in cols:
         ...
 </div>
</pre></blockquote>Looks cleaner, but it doesn’t work! Can you see why? It took me a bit of
debugging to see the light.<code>range()</code> produces an iterable: something that can be iterated over.
Similar but different is that <code>reversed()</code> produces an iterator: something
that is already iterating. Some iterables (like ranges) can be used more than
once, creating a new iterator each time. But once an iterator like
<code>reversed()</code> has been consumed, it is done. Iterating it again will
produce no values.If “iterable” vs “iterator” is already confusing here’s a quick definition:
an iterable is something that can be iterated, that can produce values in a
particular order. An iterator tracks the state of an iteration in progress. An
analogy: the pages of a book are iterable; a bookmark is an iterator. The
English hints at it: an iter-able is able to be iterated at some point, an
iterator is actively iterating.The outer loop of my double loop was iterating only once over the rows, so
the row iteration was fine whether it was going forward or backward. But the
columns were being iterated again for each row. If the columns were going
forward, they were a range, a reusable iterable, and everything worked fine.But if the columns were meant to go backward, they were a one-use-only
iterator made by <code>reversed()</code>. The first row would get all the columns,
but the other rows would try to iterate using a fully consumed iterator and get
nothing.The simple fix was to use <code>list()</code> to turn my iterator into a reusable
iterable:<blockquote class="code"><pre class="python"><div class="source">cols = list(reversed(cols))
 </div>
</pre></blockquote>The code was slightly less nice, but it worked. An even better fix
was to change my doubly nested loop into a single loop:<blockquote class="code"><pre class="python"><div class="source">for row, col in itertools.product(rows, cols):
 </div>
</pre></blockquote>That also takes care of the original iterator/iterable problem, so I can get
rid of that first fix:<blockquote class="code"><pre class="python"><div class="source">cols = range(N)
 if sliding_right:
     cols = reversed(cols)
 
 rows = range(N)
 if sliding_down:
     rows = reversed(rows)
 
 for row, col in itertools.product(rows, cols):
     ...
 </div>
</pre></blockquote>Once I had this working, I wondered why <code>product()</code> solved the
iterator/iterable problem. The <a rel="external noopener" href="https://docs.python.org/3/library/itertools.html#itertools.product">docs have a sample Python
implementation</a> that shows why: internally, <code>product()</code> is doing just
what my <code>list()</code> call did: it makes an explicit iterable from each of the
iterables it was passed, then picks values from them to make the pairs. This
lets <code>product()</code> accept iterators (like my reversed range) rather than
forcing the caller to always pass iterables.If your head is spinning from all this iterable / iterator / iteration talk,
I don’t blame you. Just now I said, “it makes an explicit iterable from each of
the iterables it was passed.” How does that make sense? Well, an iterator is an
iterable. So <code>product()</code> can take either a reusable iterable (like a range
or a list) or it can take a use-once iterator (like a reversed range). Either
way, it populates its own reusable iterables internally.Python’s iteration features are powerful but sometimes require careful
thinking to get right. Don’t overlook the tools in itertools, and mind your
iterators and iterables!• • •Some more notes:1: Another way to reverse a range: you can slice them!<blockquote class="code"><pre class="python"><div class="source">>>> range(4)
 range(0, 4)
 >>> range(4)[::-1]
 range(3, -1, -1)
 >>> reversed(range(4))
 <range_iterator object at 0x10307cba0>
 </div>
</pre></blockquote>It didn’t occur to me to reverse-slice the range, since <code>reversed</code> is
right there, but the slice gives you a new reusable range object while reversing
the range gives you a use-once iterator.2: Why did <code>product()</code> explicitly store the values it would need but
<code>reversed</code> did not? Two reasons: first, <code>reversed()</code> depends on the
<code>__reversed__</code> dunder method, so it’s up to the original object to decide
how to implement it. Ranges know how to produce their values in backward order,
so they don’t need to store them all. Second, <code>product()</code> is going to need
to use the values from each iterable many times and can’t depend on the
iterables being reusable.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202506/math_factoid_of_the_day_63.html">
<title>Math factoid of the day: 63</title>
<link>https://nedbatchelder.com/blog/202506/math_factoid_of_the_day_63.html</link>
<dc:date>2025-06-16T00:00:00-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[63 is a <a rel="external noopener" href="https://en.wikipedia.org/wiki/Centered_octahedral_number">centered octahedral number</a>. That means if you
build an approximation of an octahedron with cubes, one size of octahedron will
have 63 cubes.In the late 1700’s <a rel="external noopener" href="https://en.wikipedia.org/wiki/Ren%C3%A9_Just_Ha%C3%BCy">René Just Haüy</a> developed a theory
about how crystals formed: successive layers of fundamental primitives in
orderly arrangements. One of those arrangements was stacking cubes together to
make an octahedron.Start with one cube:<div class="figurep"><img src="https://nedbatchelder.com/code/diagrams/hauy/0.svg" alt="Just one lonely cube"></div>Add six more cubes around it, one on each face. Now we have seven:<div class="figurep"><img src="https://nedbatchelder.com/code/diagrams/hauy/1.svg" alt="Seven cubes as a crude octahedron"></div>Add another layer, adding a cube to touch each visible cube, making 25:<div class="figurep"><img src="https://nedbatchelder.com/code/diagrams/hauy/2.svg" alt="25 cubes arranged like an octahedron five cubes wide"></div>One more layer and we have a total of 63:<div class="figurep"><img src="https://nedbatchelder.com/code/diagrams/hauy/3.svg" alt="63 cubes arranged like an octahedron seven cubes wide"></div>The remaining numbers in <a href="https://oeis.org/A001845" rel="external noopener">the sequence</a>
less than 10,000 are 129, 231, 377, 575, 833, 1159, 1561, 2047, 2625, 3303,
4089, 4991, 6017, 7175, 8473, 9919.63 also shows up in the <a rel="external noopener" href="https://en.wikipedia.org/wiki/Delannoy_number">Delannoy numbers</a>: the
number of ways to traverse a grid from the lower left corner to upper right
using only steps north, east, or northeast. Here are the 63 ways of moving on a
3×3 grid:<div class="figurep"><img src="https://nedbatchelder.com/code/diagrams/delannoy3.svg" alt="63 different ways to traverse a 3x3 grid"></div>(Diagram from <a href="https://en.wikipedia.org/wiki/File:Delannoy3x3.svg" rel="external noopener">Wikipedia</a>)In fact, the number of cubes in a Haüy octahedron with N layers is the same
as the number of Delannoy steps on a 3×N grid!Since the two ideas are both geometric and fairly simple, I would love to
find a geometric explanation for the correspondence. The octahedron is
three-dimensional, and the Delannoy grids have that tantalizing 3 in them. It
seems like there should be a way to convert Haüy coordinates to Delannoy
coordinates to show how they relate. But I haven’t found one...• • •Colophon: I made the octahedron diagrams by asking Claude to write a
<a href="https://nedbatchelder.com/code/diagrams/hauy/hauy_oct.py">Python program</a> to do it.
It wasn’t a fast process because it took pushing and prodding to get the
diagrams to come out the way I liked. But Claude was very competent, and I
could think about the results rather than about projections or color spaces. I
could dip into it for 10 minutes at a time over a number of days without having
to somehow reconstruct a mental context.This kind of casual hobby programming is perfect for AI assistance. I don’t
need the code to be perfect or even good, I just want the diagrams to be nice.
I don’t have the focus time to learn how to write the program, so I can leave it
to an imperfect assistant.
]]></description>
</item>
</rdf:RDF>

If you would like to create a banner that links to this page (i.e. this validation result), do the following:

Download the "valid RSS" banner.
Upload the image to your own server. (This step is important. Please do not link directly to the image on this server.)
Add this HTML to your page (change the image src attribute if necessary):

<a href="http://www.feedvalidator.org/check.cgi?url=https%3A//www.nedbatchelder.com/blog/rss.xml"><img src="valid-rss.png" alt="[Valid RSS]" title="Validate my RSS feed" /></a>

If you would like to create a text link instead, here is the URL you can use:

http://www.feedvalidator.org/check.cgi?url=https%3A//www.nedbatchelder.com/blog/rss.xml

Home · About · News · Docs · Terms