The big recent Python news is that assignment expressions have been accepted forPython 3.8. This was apparently so contentious and charged a processthat in its wake Guido van Rossum has stepped down as Python'sBDFL .I don't have any strong feelings on assignment expressions forreasons beyond the scope of this entry, but today I want to thinkabout how soon I could possibly use them in my Python code, andthen how soon I could safely use them (ie how soon they will beeverywhere I

Like most filesystems, ZFS faces the file attribute problem . It has a bunch of file attributes,both visible ones like the permission mode and the owner and internalones like the parent directory of things and file generation number , and itneeds to store them somehow. But rather than using fixed on-diskstructures like everyone else, ZFS has come up with a novel storagescheme for them, one that simultaneously deals with both differenttypes of ZFS dnodes wanting differentsets of attributes and the need to evolve attributes over time

In pretty much every Unix filesystem and many non-Unix ones, files(and more generally all filesystem objects) have a collection ofvarious basic attributes, things like modification time, permissions,ownership, and so on, as well as additional attributes that thefilesystem uses for internal purposes ( eg ). This means that every filesystemneeds to figure out how to store and represent these attributes ondisk (and to a lesser extent in memory). This presents two problems,an immediate one and a long term one

ZFS has an idea of 'properties' for both pools and filesystems. To quotefrom the Illumos zfs manpage :

Properties are divided into two types, native properties and user-defined(or "user") properties. Native properties either export internalstatistics or control ZFS behavior. [...]

Filesystem properties are used to control things like whethercompression is on, where a ZFS filesystem is mounted, if it isread-only or not, and so on. One of those properties is called sharenfs ;

Let's start with my tweet :

I have no brain, but at least I can work out what this math in my oldcode actually means, something I didn't bother to do when I wrote theoriginal code & comments years ago. (That was a mistake, but maybe Ididn't actually understand the math then, it just looked good.)

For the almost authentic experience I'm going to start with thecode and its comments that I was looking at and explain it afterward.

I was recently moving some old Python 2 code to Python 3 (due to a recent decision ). Thisparticular code is sufficiently old that it has (or had) a numberof my old Python code habits , and inparticular it made repeated use of list .sort() with comparisonfunctions. Python 3 doesn't support this; instead you have to tell .sort() what key to use to sort the list.For a lot of the code the conversion was straightforward and obviousbecause it was

At one level, we're planning for our new fileserver environment tobe very similar to our old one. It will still use ZFS and NFS, ourclients will treat it the same, and we're even going to be reusingalmost all of our local management tools more or less intact. Atanother level, though, it's very different because we're droppingour SAN in this iteration. Our currentenvironment is an iSCSI-based SANusing HDs, where every fileserver connects to two iSCSI

About a year ago I wrote about our decision to restrict whatlanguages we use to develop internal tools and mentioned that one of the languages we picked was Python. Atthe time, I mostly meant Python 2 (although we already had onePython 3 program even then, which I sort of had qualms about ). Since I now believe in usingPython 3 for new code , I decided thatthe right thing for us to do was explicitly consider the issueand reach a decision , ratherthan just tacitly winding up in

In casual conversation about CAs, it's common for people to talkabout whether you trust a CA (or should) and whether a CA istrustworthy. I often bristle at using 'trust' in these contexts,but it's been hard to articulate why. Today, in a conversationon HN prompted by my entry on the first imperative of commercial CAs , I came up with a useful explanation.

Let's imagine that there's a new CA that's successfully set itselfup as a