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 273, column 0: Non-html tag: picture [help]

have.</p><div class="figurep"><a href="https://nedbatchelder.com/code/misc/r ...

Source: https://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/202404/my_flexbox_layout.html"/><rdf:li resource="https://nedbatchelder.com/blog/202404/try_it_functionclass_coverage_report.html"/><rdf:li resource="https://nedbatchelder.com/blog/202403/is_this_for_autistic_people.html"/><rdf:li resource="https://nedbatchelder.com/blog/202403/does_python_have_pointers.html"/><rdf:li resource="https://nedbatchelder.com/blog/202402/updated_multiparameter_interactive_jupyter_notebook.html"/><rdf:li resource="https://nedbatchelder.com/blog/202402/one_way_to_package_python_code_right_now.html"/><rdf:li resource="https://nedbatchelder.com/blog/202401/i_am_at_liberty.html"/><rdf:li resource="https://nedbatchelder.com/blog/202401/you_probably_dont_need_to_learn_c.html"/><rdf:li resource="https://nedbatchelder.com/blog/202401/randomly_subsetting_test_suites.html"/><rdf:li resource="https://nedbatchelder.com/blog/202312/coveragepy_with_sysmonitoring.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/202404/my_flexbox_layout.html">
<title>My flexbox layout</title>
<link>https://nedbatchelder.com/blog/202404/my_flexbox_layout.html</link>
<dc:date>2024-04-19T06:59:32-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[I recently had to reverse engineer the layout of this site. I created it
once upon a time, but had forgotten the details, and to save myself the work
five years from now when I have to do it again, I’m noting down what I learned
about how it works.For pedagogical purposes, I made a simplified example of the layout:
<a href="https://nedbatchelder.com/files/toystell.html">toystell.html</a>. The layout depends on CSS’s
<a rel="external noopener" href="https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_flexible_box_layout/Basic_concepts_of_flexbox">flexbox</a> capabilities. The full implementation on this
site includes a responsive layout that changes as the width of the browser
shrinks, but the simple example doesn’t include that.There are five components to the layout: logo, banner, sidebar, content, and
footer. The skeleton of the HTML is:<blockquote class="code"><pre class="html"><body>
     <header id="banner">Top Banner</header>
     <main id="content">Content</main>
     <aside id="sidebar">Sidebar</aside>
     <footer id="footer">Footer</footer>
     <header id="logo"></header>
 </body>
 </pre></blockquote>Notice that the order of the elements in the HTML isn’t the same as the order
they appear on the page. Flexbox makes this possible. We start by making the
body element a centered flex container:<blockquote class="code"><pre class="css">body {
     max-width: 55rem;
     margin: 0 auto 1rem;
     display: flex;
     flex-flow: row wrap;
 }
 body > * {
     flex: 1 100%;
 }
 </pre></blockquote>The container is set to hold flex items in rows that wrap. We’re going to
end up with three rows: the banner, the sidebar and content, and the footer. The
default flex spec for elements in the body is to take the full width of the
container, though this will only apply to the banner and footer.First the logo is positioned absolutely with a specific height and width.
It’s not participating in the flex layout at all, but the other elements will be
adjusted to fit neatly around it. It’s square, so its height and width are the
width of the sidebar:<blockquote class="code"><pre class="css">:root {
     --side-width: 10rem;
 }
 #logo {
     position: absolute;
     width: var(--side-width);
     height: var(--side-width);
     background-image: url(https://placehold.co/400/orange/white?text=Logo);
     background-size: contain;
 }
 </pre></blockquote>Then the banner is added as a fixed-height flexbox item. But if we simply do
that, its left edge will be in the same position as the logo’s left edge, and
they will overlap. To prevent this and make them abut nicely, we give the
banner a left margin equal to the logo’s width:<blockquote class="code"><pre class="css">:root {
     --banner-height: 4rem;
 }
 #banner {
     order: 1;
     height: var(--banner-height);
     margin-left: var(--side-width);
 }
 </pre></blockquote>Next comes the fixed-width sidebar. The banner took the full width of the
container, so the natural place for the sidebar is just under the banner at the
left edge. But we need it lower than that, just under the logo’s bottom edge.
To make that work, we give it a top margin of enough to push it down:<blockquote class="code"><pre class="css">#sidebar {
     order: 2;
     flex: 0 var(--side-width);
margin-top: calc(var(--side-width) - var(--banner-height));
 }
 </pre></blockquote>All of the flex items were told to take the full width, but the sidebar is
our one element that has a fixed width. The top margin is the difference
between the height of the logo and the height of the banner.The content will fit next to the sidebar under the banner just where we want
it. “flex: 1 0” means it starts with zero width, but gets all of the remaining
space in the flex row, so it’s width grows to take the remaining space:<blockquote class="code"><pre class="css">#content {
     order: 3;
     flex: 1 0;
 }
 </pre></blockquote>Last comes the footer. It needs a left margin like the banner did so that it
won’t overlap the sidebar, and we give the sidebar a negative bottom margin to
scooch it up to avoid the height of the footer:<blockquote class="code"><pre class="css">:root {
     --footer-height: 3rem;
 }
 #sidebar {
     margin-bottom: calc(0rem - var(--footer-height));
 }
 #footer {
     order: 4;
     margin-left: var(--side-width);
     height: var(--footer-height);
 }
 </pre></blockquote>I’ve skipped other parts that are in the toy sample, like how each item has
carefully chosen borders to form the narrow gutters in the layout. These are
just the broad strokes of how the five big boxes negotiate the space in their
unusual way. The full site includes responsiveness, and uses
<a rel="external noopener" href="https://sass-lang.com/">Sass</a> compiled to CSS to do some of the heavy lifting.Better CSS wizards than me probably see better ways to do it, but it
works.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202404/try_it_functionclass_coverage_report.html">
<title>Try it: function/class coverage report</title>
<link>https://nedbatchelder.com/blog/202404/try_it_functionclass_coverage_report.html</link>
<dc:date>2024-04-15T16:02:00-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[I’ve added experimental function and class coverage reports to coverage.py.
I’d like <a href="https://github.com/nedbat/coveragepy/issues/780" rel="external noopener">feedback</a>
about whether they behave the way you want them to.I haven’t made a PyPI release. To try the new reports, install coverage from
GitHub. Be sure to include the hash:<blockquote class="code"><pre>$ python3 -m pip install git+https://github.com/nedbat/coveragepy@f10c455b7c8fd26352de#egg=coverage==0.0 </pre></blockquote>Then run coverage and make an HTML report as you usually do. You should
have two new pages, not linked from the index page (yet).
“htmlcov/function_index.html” is the function coverage report, and the classes
are in “htmlcov/class_index.html”.I had to decide how to categorize nested functions and classes. Inner
functions are not counted as part of their outer functions. Classes consist of
the executable lines in their methods, but not lines outside of methods, because
those lines run on import. Each file has an entry in the function report for
all of the lines outside of any function, called “(no function)”. The class
report has “(no class)” entries for lines outside of any classes.The result should be that every line is part of one function, or the “(no
function)” entry, and every line is part of one class, or the “(no class)”
entry. This is what made sense to me, but maybe there’s a compelling reason to
do it differently.The reports have a sortable column for the file name, and a sortable column
for the function or class. Where functions or classes are nested, the name is a
dotted sequence, but is sorted by only the last component. Just like the
original file listing page, the new pages can be filtered to focus on areas of
interest.You can look at some sample reports:<ul>
<li><a href="https://nedbatchelder.com/files/sample_coverage_html_beta">Usual file report</a></li>
<li><a href="https://nedbatchelder.com/files/sample_coverage_html_beta/function_index.html">Function report</a></li>
<li><a href="https://nedbatchelder.com/files/sample_coverage_html_beta/class_index.html">Class report</a></li>
</ul>It would be helpful if you could give me
<a href="https://github.com/nedbat/coveragepy/issues/780" rel="external noopener">feedback on the
original issue</a> about some questions:<ul>
<li>Is it useful to have “(no function)” and “(no class)” entries or is it just
distracting pedantry? With the entries, the total is the same as the file
report, but they don’t seem useful by themselves.</li>
<li>Does the handling of nested functions and classes make sense?</li>
<li>Should these reports be optional (requested with a switch) or always
produced?</li>
<li>Is it reasonable to produce one page with every function? How large does a
project have to get before that’s not feasible or useful?</li>
<li>And most importantly: do these reports help you understand how to improve
your code?</li>
</ul>This is only in the HTML report for now, but we can do more in the future.
Other <a href="https://github.com/nedbat/coveragepy/issues/780" rel="external noopener">ideas
about improvements</a> are of course welcome. Thanks!
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202403/is_this_for_autistic_people.html">
<title>Is this for autistic people?</title>
<link>https://nedbatchelder.com/blog/202403/is_this_for_autistic_people.html</link>
<dc:date>2024-03-20T11:46:00-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[Special Olympics swimming season started this past weekend. A new athlete
joined us, a young boy I’ll call Bryan. He asked me a question that has stuck
with me.Bryan is 12 or so, with the slightly goofy look of a boy growing into his
body. He has braces on his too-large teeth. It was his first time swimming with
us, so we needed to show him the locker room, how to get out to the pool, and so
on. He was serious and inquisitive about all of these things that were new to
him.We got out on the deck and started stretching with the other athletes, most
of whom don’t look like Bryan. They are older and have a variety of
intellectual disabilities. Bryan surveyed the group then turned to me and asked
the question: “is this for autistic people?”I had only just met Bryan. I didn’t know his formal diagnosis (or if he even
had one), and I didn’t know how he thought of himself. When he asked the
question, I didn’t know if he was including himself in the category of autistic
people or not, so I wanted to answer carefully.Did he mean, “are autistic people allowed here?” or, “is this only for
autistic people?” Maybe he meant, “are all of these swimmers autistic?” or even,
“will being here mean I am autistic?”I told him that it was for autistic people, that my own son Nat was here and
Nat is autistic. Bryan accepted this in his sober way and continued on with the
practice.Later I talked with his mom about the question and asked her if Bryan
identified as autistic. She said that he did, but it was a recent awareness for
him. In school he’s in a typical integrated classroom.Bryan did well at the practice, and called me “Coach Ned.” His mom was
really appreciative of the group as a whole and was clearly pleased.I’ve been thinking about Bryan and his question: “is this for autistic
people?” He’s young, and finding his way in the world in so many ways. We all
need to figure out who we are, what groups we belong to, where we fit. We all
encounter difficulties in one way or another working all that out, and it’s
a life-long process. Bryan has a lot to work on. I hope it isn’t too hard.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202403/does_python_have_pointers.html">
<title>Does Python have pointers?</title>
<link>https://nedbatchelder.com/blog/202403/does_python_have_pointers.html</link>
<dc:date>2024-03-11T07:27:22-04:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[People sometimes ask, “Does Python have pointers?” I hate to be the typical
senior engineer, but this is one of those questions where the answer is, it
depends what you mean by pointer.The classic definition of a pointer is: a variable that holds the address
of something else and that you can use to work with that something else.
In very broad pseudo-code, it would be something like this:
<blockquote class="code"><pre>myvar = SOMETHING; mypointer = get_address_of(myvar); print(get_value_via_pointer(mypointer)); ## output is SOMETHING </pre></blockquote>This is useful because we can use a pointer to refer to data, setting the
pointer in one part of the code with whatever logic we need to decide what data
it should point to. Then elsewhere we can use the pointer without having to know
what it’s referring to or how the decision was made. The pointer gives us an
indirection that lets us separate concerns and write more modular code.Many programming languages provide a pointer facility like this. For
example, in C, the get_address_of() operation is ampersand, and the
get_value_via_pointer() operation is star, and our code snippet would be:<blockquote class="code"><pre class="c">int myvar = 17;
 int *mypointer = &myvar;
 print_int(*mypointer);      // outputs 17
 </pre></blockquote>Other languages like C++, C#, Go, Rust, Pascal, and even Fortran have similar
capabilities.OK, so what about Python? In one sense, Python doesn’t have a pointer
concept like this. You could say that get_address_of() is provided by Python’s
id() function, since (in CPython at least) it returns the memory address of the
data:<blockquote class="code"><pre class="python">myvar = 17
 mypointer = id(myvar)   # ** not useful
 </pre></blockquote>But Python has no inverse operation: there’s no get_value_via_pointer()
that can get you myvar given mypointer.So Python doesn’t have the classic pair of operations to be able to work with
pointers explicitly. But on the other hand, every variable in Python
is a pointer, because variables in Python are <a href="https://nedbatchelder.com/text/names1.html">names
that refer to objects</a>.In Python, our simple example looks like this:<blockquote class="code"><pre class="python">myvar = 17
 mypointer = myvar
 print(mypointer)    # outputs 17
 </pre></blockquote>When someone asks, does Python have pointers, perhaps the best answer is: it
doesn’t have explicit pointers like some other languages, but everything is
implicitly a pointer. So you have the power of pointers to use when you need
them: you can have multiple data structures, then assign a variable to one you
choose, and use the variable later. You’ve achieved the separation of “which
data” from “work with the data” that pointers provide.Maybe this is yet another case of
<a href="https://nedbatchelder.com/blog/202301/same_words_different_meanings.html">Same words, different meanings</a>.Note:<ul>
<li>Some languages like C also allow pointer arithmetic to adjust a pointer from
one item in an array to another. Python’s references don’t allow for that.</li>
<li>Python’s standard library provides <a rel="external noopener" href="https://docs.python.org/3/library/ctypes.html">ctypes</a>, which
is great for interfacing with native C code, exposing details there including C
pointers. This does not count as Python having explicit pointers.</li>
</ul>
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202402/updated_multiparameter_interactive_jupyter_notebook.html">
<title>Updated multi-parameter interactive Jupyter notebook</title>
<link>https://nedbatchelder.com/blog/202402/updated_multiparameter_interactive_jupyter_notebook.html</link>
<dc:date>2024-02-12T14:21:11-05:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[A few years ago I wrote
<a href="https://nedbatchelder.com/blog/201610/multiparameter_jupyter_notebook_interaction.html">Multi-parameter Jupyter notebook interaction</a> about a
Jupyter notebook. It worked at the time, but when I dusted it off recently, it
didn’t. I’ve renovated it and cleaned it up a little, and now it works
again.It’s a <a rel="external noopener" href="/code/misc/retirement_sample2.ipynb">Jupyter notebook</a> with a simulation of
late-career money flows to figure out possibilities for retirement. It uses
widgets to give you sliders to adjust parameters to see how the outcome changes.
It also lets you pick one of the parameters to auto-plot with multiple values,
which gives a more visceral way to understand the effect different variables
have.<div class="figurep"><a href="https://nedbatchelder.com/code/misc/retirement_sample2.ipynb"><figure><picture><source type="image/webp" srcset="https://nedbatchelder.com/iv/webp/pix/retirement_sliders2.png.webp"><img src="https://nedbatchelder.com/pix/retirement_sliders2.png" alt="Screenshot of the sliders and resulting plot of outcomes" width="1122" height="1456"></picture></figure></a></div>You can <a rel="external noopener" href="/code/misc/retirement_sample2.ipynb">get the notebook itself</a> if you like.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202402/one_way_to_package_python_code_right_now.html">
<title>One way to package Python code right now</title>
<link>https://nedbatchelder.com/blog/202402/one_way_to_package_python_code_right_now.html</link>
<dc:date>2024-02-10T06:50:00-05:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[A year or so ago, I couldn’t find a step-by-step guide to packaging a Python
project that didn’t get bogged down in confusing options and choices, so I wrote
my own: <a rel="external noopener" href="https://github.com/nedbat/pkgsample">pkgsample</a>. After I wrote it, I found the
<a rel="external noopener" href="https://packaging.python.org/en/latest/tutorials/packaging-projects/">PyPA Packaging Python Projects tutorial</a>, which is
very good, so I never made a post here about my sample.Since then, I’ve shown my sample to people a number of times, and they liked
it, so I guess it’s helpful. Here’s what I wrote about it back when I first created it:• • •The Python packaging world is confusing. There are decades of history and
change. There are competing tools, with new ones arriving frequently. I don’t
want to criticize anyone, let’s just take it as a fact of life right now.But I frequently see questions from people who have written some Python code,
and would like to get it packaged. They have a goal in mind, and it is not to
learn about competing tools, intricate standards, or historical artifacts.
They are fundamentally uninterested in the mechanics of packaging. They just
want to get their code packaged.There are lots of pages out there that try to explain things, but they all
seem to get distracted by the options, asking our poor developer to choose
between alternatives they don’t understand, with no clear implications.I’m also not criticzing the uninterested developer. I am that developer! I
don’t know what all these things are, or how they compete and overlap: build,
twine, hatch, poetry, flit, wheel, pdm, setuptools, distutils, pep517, shiv,
<a rel="external noopener" href="https://packaging.python.org/en/latest/key_projects/">etc</a>, <a rel="external noopener" href="https://chadsmith.dev/python-packaging/">etc</a>.I just want someone to tell me what to do so my code will install on users’
machines. Once that works, I can go back to fixing bugs, adding features,
writing docs, and so on.So I wrote <a rel="external noopener" href="https://github.com/nedbat/pkgsample">pkgsample</a> to be the instructions I
couldn’t find. It’s simple and stripped down, and does not ask you to make
choices you don’t care about. It tells you what to do. It gives you one way to
make a simple Python package that works right now. It isn’t THE way. It’s A way.
It will probably work for you.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202401/i_am_at_liberty.html">
<title>I am at liberty</title>
<link>https://nedbatchelder.com/blog/202401/i_am_at_liberty.html</link>
<dc:date>2024-01-30T09:08:00-05:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[As of a few weeks ago, I am between gigs. Riffing on some corporate-speak
from a <a rel="external noopener" href="https://2u.com/newsroom/2u-inc-announces-leadership-transition/">recent press release</a>: “2U and I have mutually
determined that 2U is laying me off.”I feel OK about it: work was becoming increasingly frustrating, and I have
some severance pay. 2U is in a tough spot as a company so at least these
layoffs seemed like an actual tactic rather than another pointless
please-the-investors move by companies flush with profits and cash. 2U
struggling also makes being laid off a more appealing option than remaining
there after a difficult cut.<a href="https://edx.org" rel="external noopener">edX</a> was a good run for me. We had a noble
mission: educate the world. The software was mostly open source
(<a href="http://openedx.org" rel="external noopener">Open edX</a>), which meant our efforts could
power education that we as a corporation didn’t want to pursue.Broadly speaking, my job was to oversee how to do open source well. I loved
the mission of education combined with the mission of open source. I loved
seeing the community do things together that edX alone could not. I have many
good friends at 2U and in the community. I hope they can make everything work
out well, and I hope I can do a good job staying in touch with them.I don’t know what my next gig will be. I like writing software. I like
having developers as my customers. I am good at building community both inside
and outside of companies. I am good at helping people. I’m interested to hear
ideas.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202401/you_probably_dont_need_to_learn_c.html">
<title>You (probably) don’t need to learn C</title>
<link>https://nedbatchelder.com/blog/202401/you_probably_dont_need_to_learn_c.html</link>
<dc:date>2024-01-24T06:38:49-05:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[On <a href="https://hachyderm.io/@nedbat/111789013210403320" rel="external noopener">Mastodon I
wrote</a> that I was tired of people saying, “you should learn C so you can
understand how a computer really works.” I got a lot of replies which did not
change my mind, but helped me understand more how abstractions are inescapable
in computers.People made a number of claims. C was important because syscalls are defined
in terms of C semantics (they are not). They said it was good for exploring
limited-resource computers like Arduinos, but most people don’t program for
those. They said it was important because C is more performant, but Python
programs often offload the compute-intensive work to libraries other people have
written, and these days that work is often on a GPU. Someone said you need it to
debug with strace, then someone said they use strace all the time and don’t know
C. Someone even said C was good because it explains why NUL isn’t allowed in
filenames, but who tries to do that, and why learn a language just for that
trivia?I’m all for learning C if it will be useful for the job at hand, but you can
write lots of great software without knowing C.A few people repeated the idea that C teaches you how code “really” executes.
But C is an abstract model of a computer, and modern CPUs do all kinds of things
that C doesn’t show you or explain. Pipelining, cache misses, branch
prediction, speculative execution, multiple cores, even virtual memory are all
completely invisible to C programs.C is an abstraction of how a computer works, and chip makers work hard to
implement that abstraction, but they do it on top of much more complicated
machinery.C is far removed from modern computer architectures: there have been 50 years
of innovation since it was created in the 1970’s. The gap between C’s model and
modern hardware is the root cause of famous vulnerabilities like Meltdown and
Spectre, as explained in
<a href="https://dl.acm.org/doi/pdf/10.1145/3212477.3212479" rel="external noopener">C is Not a
Low-level Language</a>.C can teach you useful things, like how memory is a huge array of bytes, but
you can also learn that without writing C programs. People say, C teaches you
about memory allocation. Yes it does, but you can learn what that means as a
concept without learning a programming language. And besides, what will Python
or Ruby developers do with that knowledge other than appreciate that their
languages do that work for them and they no longer have to think about it?Pointers came up a lot in the Mastodon replies. Pointers underpin concepts in
higher-level languages, but you can
<a href="https://nedbatchelder.com/text/names1.html" rel="external noopener">explain those concepts as
references</a> instead, and skip pointer arithmetic, aliasing, and null pointers
completely.A question I asked a number of people: what mistakes are
JavaScript/Ruby/Python developers making if they don’t know these things (C,
syscalls, pointers)?”. I didn’t get strong answers.We work in an enormous tower of abstractions. I write programs in Python,
which provides me abstractions that C (its underlying implementation language)
does not. C provides an abstract model of memory and CPU execution which the
computer implements on top of other mechanisms (microcode and virtual memory).
When I made a wire-wrapped computer, I could pretend the signal travelled
through wires instantaneously. For other hardware designers, that abstraction
breaks down and they need to consider the speed electricity travels. Sometimes
you need to go one level deeper in the abstraction stack to understand what’s
going on. Everyone has to find the right layer to work at.<a href="https://hachyderm.io/@agocke/111791030850237121" rel="external noopener">Andy Gocke said
it well</a>:<blockquote><div>When you no longer have problems at that layer, that’s when you can
stop caring about that layer. I don’t think there’s a universal level of
knowledge that people need or is sufficient.</div></blockquote><a href="https://toot.cat/@idlestate/111793957024682587" rel="external noopener">“like jam or
bootlaces” made another excellent point</a>:<blockquote><div>There’s a big difference between “everyone should know this” and
“someone should know this” that seems to get glossed over in these kinds of
discussions.</div></blockquote>C can teach you many useful and interesting things. It will make you a
better programmer, just as learning any new-to-you language will because it
broadens your perspective. Some kinds of programming need C, though other
languages like Rust are ably filling that role now too. C doesn’t teach you how
a computer really works. It teaches you a common abstraction of how computers
work.Find a level of abstraction that works for what you need to do. When you
have trouble there, look beneath that abstraction. You won’t be seeing how
things really work, you’ll be seeing a lower-level abstraction that could be
helpful. Sometimes what you need will be an abstraction one level up. Is your
Python loop too slow? Perhaps you need a C loop. Or perhaps you need numpy array
operations.You (probably) don’t need to learn C.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202401/randomly_subsetting_test_suites.html">
<title>Randomly sub-setting test suites</title>
<link>https://nedbatchelder.com/blog/202401/randomly_subsetting_test_suites.html</link>
<dc:date>2024-01-14T09:39:32-05:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[I needed to run random subsets of my test suite to narrow down the cause of
some mysterious behavior. I didn’t find an existing tool that worked the way I
wanted to, so I cobbled something together.I wanted to run 10 random tests (out of 1368), and keep choosing randomly
until I saw the bad behavior. Once I had a selection of 10, I wanted to be able
to whittle it down to try to reduce it further.I tried a few different approaches, and here’s what I came up with, two tools
in the coverage.py repo that combine to do what I want:<ul> <li>A pytest plugin (<a rel="external noopener" href="https://github.com/nedbat/coveragepy/blob/master/tests/select_plugin.py">select_plugin.py</a>) that
lets me run a command to output the names of the exact tests I want to
run,</li>
<li>A command-line tool (<a rel="external noopener" href="https://github.com/nedbat/coveragepy/blob/master/lab/pick.py">pick.py</a>) to select random
lines of text from a file. For convenience, blank or commented-out lines are
ignored.</li>
</ul>More details are in the comment at the top of
<a rel="external noopener" href="https://github.com/nedbat/coveragepy/blob/master/lab/pick.py">pick.py</a>, but here’s a quick example:<ol>
<li>Get all the test names in tests.txt. These are pytest “node” specifications:
<blockquote class="code"><pre>pytest --collect-only | grep :: > tests.txt </pre></blockquote>
</li>
<li>Now tests.txt has a line per test node. Some are straightforward:
<blockquote class="code"><pre>tests/test_cmdline.py::CmdLineStdoutTest::test_version tests/test_html.py::HtmlDeltaTest::test_file_becomes_100 tests/test_report_common.py::ReportMapsPathsTest::test_map_paths_during_html_report </pre></blockquote>
but with parameterization they can be complicated:
<blockquote class="code"><pre>tests/test_files.py::test_invalid_globs[bar/***/foo.py-***] tests/test_files.py::FilesTest::test_source_exists[a/b/c/foo.py-a/b/c/bar.py-False] tests/test_config.py::ConfigTest::test_toml_parse_errors[[tool.coverage.run]\nconcurrency="foo"-not a list] </pre></blockquote>
</li>
<li>Run a random bunch of 10 tests:
<blockquote class="code"><pre>pytest --select-cmd="python pick.py sample 10 < tests.txt" </pre></blockquote>
We’re using <code>--select-cmd</code> to specify the shell command that
will output the names of tests. Our command uses <code>pick.py</code>
to select 10 random lines from tests.txt.
</li>
<li>Run many random bunches of 10, announcing the seed each time:
<blockquote class="code"><pre>for seed in $(seq 1 100); do echo seed=$seed pytest --select-cmd="python pick.py sample 10 $seed < tests.txt" done </pre></blockquote>
</li>
<li>Once you find a seed that produces the small batch you want, save that batch:
<blockquote class="code"><pre>python pick.py sample 10 17 < tests.txt > bad.txt </pre></blockquote>
</li>
<li>Now you can run that bad batch repeatedly:
<blockquote class="code"><pre>pytest --select-cmd="cat bad.txt" </pre></blockquote>
</li>
<li>To reduce the bad batch, comment out lines in bad.txt with a hash character,
and the tests will be excluded. Keep editing until you find the small set of
tests you want.</li>
</ol>I like that this works and I understand it. I like that it’s based on the
bedrock of text files and shell commands. I like that there’s room for
different behavior in the future by adding to how pick.py works. For example,
it doesn’t do any bisecting now, but it could be adapted to it.As usual, there might be a better way to do this, but this works for me.
]]></description>
</item>
<item rdf:about="https://nedbatchelder.com/blog/202312/coveragepy_with_sysmonitoring.html">
<title>Coverage.py with sys.monitoring</title>
<link>https://nedbatchelder.com/blog/202312/coveragepy_with_sysmonitoring.html</link>
<dc:date>2023-12-27T18:03:33-05:00</dc:date>
<dc:creator>Ned Batchelder</dc:creator>
<description><![CDATA[New in Python 3.12 is <a rel="external noopener" href="https://docs.python.org/3/library/sys.monitoring.html">sys.monitoring</a>, a
lighter-weight way to monitor the execution of Python programs.
<a href="https://pypi.org/project/coverage/7.4.0" rel="external noopener">Coverage.py 7.4.0</a> now
can optionally use sys.monitoring instead of
<a rel="external noopener" href="https://docs.python.org/3/library/sys.html#sys.settrace">sys.settrace</a>, the facility that has underpinned
coverage.py for nearly two decades. This is a big change, both in Python and in
coverage.py. It would be great if you could try it out and provide some
feedback.Using sys.monitoring should reduce the overhead of coverage measurement,
often lower than 5%, but of course your timings might be different. One of the
things I would like to know is what your real-world speed improvements are
like.Because the support is still a bit experimental, you need to define an
environment variable to use it: <code>COVERAGE_CORE=sysmon</code>.
Eventually, sys.monitoring will be automatically used where possible, but for
now you need to explicitly request it.Some things won’t work with sys.monitoring: plugins and dynamic contexts
aren’t yet supported, though eventually they will be. Execution will be faster
for line coverage, but not yet for branch coverage. Let me know how it works
for you.This has been in the works since at least March. I hope I haven’t forgotten
something silly in getting it out the door.
]]></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//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//nedbatchelder.com/blog/rss.xml

Home · About · News · Docs · Terms