The Cat's Whisker

Things I made in 2023: A Year of Knits, Crochet, and 3D Creations

2024-01-01T00:36:34Z

I have continued to knit in 2023, and I also reminded myself how to crochet. As usual, check the Ravelry link for the pattern, more photos, and more details of each project. You can view all 13 of the projects mentioned below at once: 2023 Projects on Ravelry

Click any of the images below for bigger versions. And as always, thank you to my sister for making everything look better with her modeling and photography!

Table of Contents

Beware the Mighty Septopus!
Pom poms
The big projects
Crochet
- Doilies!
- Yellow Hex Christmas Stocking
Bonus: 3D Prints
Up next

Beware the Mighty Septopus!

At the end of last year’s roundup I had finished a single octopus colorwork mitten for my sister. I finished the pair, and also a sweater to go with them!

Both cephalopod designs (the mittens by Emily Peters and the sweater by Maia E. Sirnes) feature tentacles that wrap around the entire piece.

I lined the mittens with polar fleece — which was the first and, unfortunately, last thing I used my sewing machine for in 2023.

For both pieces I managed the floats using ladderback jacquard. The small mittens were a good practice for the sweater. In both projects I started the ladders using the lifted increase method, but those are visible in several places on the rightside of the sweater and I wish I had tried using the backwards loop cast on method mentioned in the ysolda tutorial (linked above).

The inside of the sweater showing my ad hoc ladderbacks

Ravelry Project: Mindy’s Mighty Septopus
Ravelry Project: Octopus Mittens

Pom poms

Before finishing the mittens and sweater, I made a couple of beanies out of a single skein of closeout ($3) acrylic yarn. (The hat on the left in the photo is Snap by Tin Can Knits which I made as a beta tester for their new app)

In the fall I went on a road/hiking trip in the American Southwest. We stayed in Roswell, NM, on our first night, so I found and made an alien-themed beanie pattern before leaving.

Like the octopus pieces, I managed the floats in the colorblocks between and within the alien faces with ladderback jacquard.

I don’t really want to believe

While in the car I cast on for a second hat: the Sockhead Slouch Hat by Kelly McClure. It is a slouchy stockinette cap meant to be done with a single skein of sock yarn. I chose the Tiger Lily sock yarn because its turquoise and rust colors remind me of the Southwest.

I worked on the hat several nights in my tent during a 4-day, 70-mile hike on the Arizona Trail, more on the drive back through New Mexico, and finally finished the day we arrived home.

Winter hiking in Arizona is nice, except the sun sets so early that we were at camp for many hours before bed every night. It was nice to have a project to work on. I highly recommend something portable and stockinette like this pattern for winter hiking.

Unfortunately I didn’t take any photos of it while working on the trail, but my sister was kind enough to model it when we got home. Despite it having no pom pom, this has become my most-worn hat I’ve made… but even the superwash merino sock yarn can become quite itchy to me!

Kelly also has a Sockhead Cowl pattern to match the hat which looks like it could work like a neck gator (I wear my Buffs all the time), so I am definitely planning on making one of those.

Ravelry Project: O’go bulky hats
Ravelry Project: Roswell Cap
Ravelry Project: Sockhead on the Arizona Trail

The big projects

While I think the Embrace Octopus sweater is the most visually striking project of the year, once I calculated the gauge to work with lighter yarn (including some modifications to the charts), the actual knitting went pretty quickly. I did finish three projects that took significant amounts of time.

Cholla’s Bahama Blanket

I started this in the summer of 2022 and didn’t finish until February 2023. In 2020 I finished two Tunisian crochet throw blankets, so working on this one felt quite familiar. Though this is my first chevron pattern.

I made this one for my sister’s cat Cholla.

Ravelry Project: Cholla’s Bahama Blanket

Oceanspray Shawl

The Oceanspray shawl is about 81,000 stitches. The first two thirds of the pattern are mostly stockinette (with some yarnovers), which drag on a bit, but the payoff is the elm leaf edging.

18" x 12"

I also did a little lace kerchief in the same yarn. (I still have several skeins of the green Alpaca Cloud yarn left, so another large lace shawl is probably in the queue for 2024.)

Ravelry Project: Oceanspray
Ravelry Project: Ostrich Feather Lace Kerchief

The Book Exchange Book Exchange Cardigan

Years ago, before I really knew how to knit (at least before I had made any garments), I received book Knitting Brioche as a gift. From the patterns in the back I selected the Book Exchange Cardigan as one I would like to try some day. Later, about a year and a half ago, WEBS was having a sale on Cascade 220 ($8/100g) so I bought 10 skeins with that cardigan in mind. This October I actually cast on. I had one gauge mishap and had to restart after almost finishing the back… but I finally finished (and it fits)!

This cardigan has saddle shoulders and a cowl collar

I haven’t even calculated how many stitches this cardigan contains, but it took me over 3 months of dedicated knitting and 820g (1.8 lb) of wool. The Cascade 220 yarn is actually soft enough for me to wear, it fits (even buttoned up), the brioche fabric is fluffy, and it has pockets! It is my favorite garment I’ve made for myself so far.

In the book, Nancy says the pattern is named after a used bookstore she frequented in Amsterdam. In a synchronicitous turn of events I finished the cardigan on December 20th, and my family had decided that we would (for the first time) do a "white elephant" style book exchange on Christmas Eve as our Christmas gathering this year. So I got to wear my new Book Exchange to a book exchange.

Ravelry Project: The Book Exchange Book Exchange Cardigan

Crochet

I haven’t crocheted (except for Tunisian) since completing some simple crochet beanies back in 2019, so I decided to do some small projects to remind myself how.

One thing I discovered after completing most of the projects below is that I had been crocheting wrong! I was creating the new stitch to the left of the stitch below (with the right side facing). But the usual way is to create the stitch to the right of the stitch in the previous row. My way not only introduces more left-leaning bias when worked in the round, but it can be more difficult especially right before chains that tend to be very tight. I don’t know if I always crocheted that way, or if I only just recently re-taught myself wrong 🤷

For reference, Shelley Husband has a blog post on where to insert when creating stitches (think of rightside stitches as a capital letter P, “The circley bit of the P is where you poke your hook if you’re working into the stitch”): How to work into a stitch (and around, and between and…)

Doilies!

Clockwise from top-left: Dawnglow by Julia Hart with 2.25mm hook, Boo! by Marsha Glassner with 1.75mm hook, Dawnglow #2 with 1.75mm hook, Elise by Grace Fearon with Clover 1.75mm hook

Thread crochet has always looked impressive to me, so I decided to get back into crochet by trying to make some doilies (using #10 thread). I have been happy to find active designers publishing modern doily patterns. These three in particular have many patterns I’d like to try:

Grace Fearon — She has 157 designs on Ravelry and several print books.
Julia Hart — 104 designs on Ravelry
Irina Maleeva — 31 designs on Ravelry

One thing I learned from my first attempt (which turned out much larger than expected) is that you can’t trust the size stamped on cheap steel hooks! I measured the ones I had with some calipers, and not only were many of the sizes wrong, they weren’t even monotonic: some of the smaller sizes were actually larger in diameter than the ones that were supposed to be several sizes larger than them. I ended up buying a set of Clover steel hooks which are much more accurate (and ergonomic).

So far my favorite result is a textured doily called Elise by Grace Fearon that I did in a soft blue thread. But my most impressive is a two-color version of Marsha Glassner’s Halloween themed ghost doily I worked out how to do.

For Christmas I made some snowflakes following an Irina Maleeva pattern. The best one (fewest mistakes) was done in sparkly white fingering weight wool rather than cotton thread.

Ravelry Project: Four Practice Doilies
Ravelry Project: Two-tone Boo!
Ravelry Project: Christmas Ariel snowflakes

Yellow Hex Christmas Stocking

30 years ago my mom crocheted hexagon Christmas stockings for me and my four siblings. At some point my youngest sister’s stocking went missing. This year my mom and I decided to make a replacement.

New stocking (right) next to reverse-engineered old stocking

The original pattern could not be found. I found several similar patterns including this free one on Ravelry, but none of them were the same. So I reversed the pattern from one of the old completed stockings. My mom’s toe hexes are laid out differently than any of the other patterns I found: to get a round toe she seamed the pointy bits to the inside.

We made it using whatever worsted acrylic that was in my stash (most of it I inherited from my mom or sisters and is probably 20 years old itself!) plus some sparkly white sock yarn (held double). All of the old stockings are made from red, white, and green, but I actually really like the bright colors of this and it suits my sister’s personality.

Ravelry Project: Yellow Hex Replacement Christmas Stocking

Bonus: 3D Prints

Just before Christmas a friend gave me a 3D printer he no longer has time to use (an Ender 3 Pro)!

I have zero prior experience with 3d printing, but my very first print was successful: a little BMO character from Adventure Time (I scaled it to 25% before printing, so it is only about 1" across).

But my attempts at printing were not always immediately successful. In particular any model with small-diameter features on the first layer would often not adhere. After spending hours leveling and re-leveling, I found that the most effective thing was usually to wash the build surface with soap and water (and not merely wipe it with isopropyl).

To increase the ratio of my time spent printing vs leveling, I replaced the build surface with a PEI surface (which is great because once the bed cools down the prints pop right off), replaced the bed-leveling springs with stiff silicone spacers (as recommended in several reddit threads), and installed a CR Touch “auto bed leveling” sensor which replaces the Z-axis limit switch with a sensor that can always zero to the surface of the print bed. To take full advantage of the CR Touch I upgraded the printer’s firmware to a version of Marlin that supports mesh-based auto leveling (I used the pre-built firmware by Shiny Upgrades; they also have a good general guide here: Ender 3 Pro Starter Guide).

I still have tons to learn, but I am now getting reliable first layer adhesion even for models with tiny circles. Overall, hobby 3d printing feels closely adjacent to yarn crafts. Except it is cheaper ($20/kg of PLA filament vs $200/kg of wool yarn) and faster (a large print can take 24 hours plus some setup time, while a large knitting project can take 24 weeks or more, all of it labor intensive).

There are currently several competing model/project database websites (Thingiverse, Printables, Thangs, …), though none of them are as feature-complete as Ravelry is for yarn crafts. I like the look-and-feel of Printables best, but Thingiverse has more models and its database of makes (“projects” in Ravelry terms) prompts for more metadata which I like. For now I’m using both.

— Thingiverse Make: Adventure Time BMO

Print-in-place

A springy gecko and a print-in-place shark

One of the coolest classes of designs made possible by 3d printing are so-called “print-in-place” models which have multiple parts joined by hinges printed as a single piece. Once the model is finished it can articulate with no assembly required. So far I’ve tried a hammer head shark and a 30-segment snake model, and they both worked perfectly.

Printables Make: Articulated Hammerhead Shark
Printables Make: Articulated Bone Dragon

Card kit

Another technique is to design models which print flat and then snap together into a 3d shape like this Christmas-themed X-Wing fighter.

Thingiverse Make: Snowflake X-Wing Kit Card Ornament

Vase mode

Vase mode (or “Spiralize Outer Contour” in Cura) is a way of printing vase-like models without a Z seam. The print nozzle continues around in a seamless spiral rather than printing discrete layers. This is analogous to crocheting continuously in the round instead of joining each round with a slipstitch.

I printed this pencil holder in some ombre filament I got as a Christmas gift (Creality Ender-PLA+ in colorway “Colourful”). I love how it turned out! Though it is a bit squishy… I should have probably increased the extrusion width to 0.6mm (with my 0.4mm nozzle). I will try that on future vase-mode prints.

Printables Make: Wavy Pencil Holder

Cookie cutters

By far the most pracitcal prints I’ve made so far are cookie cutters! The most popular is the fat unicorn.

Printables Make: Unicorn cookie cutter

Up next

In 2024 I hope to focus even more on knitting. Most immediately that means probably making a pair of Cookie A’s Monkey Socks, but more long term I intend to complete at least Level 1 of The Knitting Guild Association’s Master Hand Knitter program. I haven’t signed up yet, but I just registered as a TKGA member while writing this post!

I also hope to dedicate time to creating some knitting CAD tools.

In addition to knitting and crochet, I have a growing queue of sewing projects. I already have all of the materials for the Fremont tote bag, so that will probably be first up!

2023 Denver Open

2023-08-11T19:16:30Z

I had the opportunity to play in the Denver Open 2023 chess tournament (along with almost 200 other players!) I played in the U1800 section, winning 4 games and losing 1 to tie (with 7 other people!) for the 2nd place prize pool (I got $100). This is my best tournament performance so far; my rating increased from 1501 to 1574. My rating is still provisional until I play two more rated games. I’m hoping to be close to 1600 after my next tournament.

Figure 1. Round 5 just before my opponent sacs a rook. Photo by John Brezina.

For an overview of the event see DCC 2023 Denver Open report on the Denver Chess Club’s site. For the official results and crosstable see the 2023 Denver Open USCF event page

Below are my five games with a few notes.

Round 1

My first opponent was rated 1141, almost 500 points lower than me, so I was hoping for a non-taxing, preferably short game to give me time to relax in my hotel room before the more difficult rounds later in the day. Instead I got a 3+ hour game where I was paranoid the entire time I would mess up the end game and draw (or lose).

I had the white pieces and played 1.e4. She played a French, so I played the Advance since that’s the only variation I know comfortably. But she exchanged lightsquare bishops on b5 and then left her queen on that diagonal preventing me from castling. It was uncomfortable, but she underestimated my knight moves and lost 2 pawns before we traded down to an endgame. I made several mistakes in the conversion but managed to stop her pawns and push mine to victory.

Round 2

In the second round I had the black pieces against a 1700. This time I played the French and they played the King’s Indian Attack. I don’t know how to play against the KIA so I just mirrored white and fianchettoed my bishop as well. I think I had a worse understanding of the position for most of the game, but we got to a point where they could trade their bishop for my bishop or for my knight and they chose my knight (27..Bxc4?). That decision left them with weak lightsquares, me with a strong lightsquare bishop, and suddenly I was the one making threats against their king. They resigned with a Mate-in-1 on the board.

Round 3

The last round of the day and I was hoping for a good pairing to give me a chance of a perfect 3-0. Instead I got the black pieces against the highest rated player in the U1800 section. This was another King’s Indian Attack. Ugh. Whatever I did in Round 2 against a similarly rated opponent seemed to work, so I once again went for a setup where I fianchettoed my kingside bishop.

I never really felt in control this game, and I got into some tactical trouble, but calculated out a tenacious defense that saved a piece that I was proud of. Unfortunately the resulting position was worse and more tactically dangerous for black than I realized (until I was once again losing a piece with no way out). I resigned after 24 moves.

Round 4

The next morning I was paired with the white pieces against a 1234-rated player. Out of the opening I won one of their center pawns, but in compensation they got a tremendous amount of activity. I think we were about equal (though I would need several moves to develop my bishops), when he decided to try an exchange sacrifice with 17…Rxb2?! It was exciting but turned out to be unsound and I soon capitalized on their weak back rank; they resigned with Mate-in-1 on the board.

Round 5

Last round. I have white again. If I win then I probably get some prize money. We both played some opening inaccuracies, but I saw a chance to sacrifice a pawn for a strong positional advantage. I had to calculate a bunch of knight moves which hurt my poor little brain, but it worked: out of the opening I was down a pawn but +5.5 according to Stockfish!

I continued to restrict my opponent’s moves until they finally sacrificed an entire rook just to be able to move their pieces. Out of all of the tournament games I’ve played so far, this one felt by far the most like I was playing real, positional chess.

Knit & Crochet Finished Object Roundup 2020-2022

2023-01-01T06:57:46Z

I’m currently bringing in the new year while knitting a mitten. Here’s a quick look back at how I got here. (As usual, check the Ravelry link for the pattern, more photos, and more details of each project.)

2020 The Year of Blankets

In 2019 I wrote about how I started to knit again and finished a few projects (my first pair of socks and some hats) after having learned years earlier but never having finished anything other than a scarf. I had hoped that was the start of my knitting momentum, but I did even less in 2020.

Tunisian Crochet Blankets

Although I knit very little in 2020, I did experiment with Tunisian crochet and finished two blankets! I liked the first one so much that I made another one for my sister at the end of the year. They are both just Tunisian full stitch with a single crochet edge. The yarn I used is Premier Yarn’s Puzzle, which is a very soft and fuzzy bulky acrylic. The Tunisian full stitch texture works well with it, and the blankets are like very cozy chain mail.

Ravelry Project: RGB Blanket
Ravelry Project: Christmas Blanket

Doubleknit Potholder

I did knit one thing! A doubleknit potholder I made for my sister who raises chickens (that’s a hen duplicate stitched into one of the green diamonds). I designed the colorwork chart. It is my first real attempt at doubleknitting, using cotton yarn (so it can be used as a potholder without melting or burning), in a rush for Christmas, and unsurprisingly the tension is pretty wonky. It still gets used to this day, but it is even less square than when it was new.

Ravelry Project: Marshall Potholder

2021 More Crochet Experiments

Toe-up socks

Again I didn’t end up knitting much in 2021, but I did complete a pair of plain toe-up socks which [mostly] fit their intended recipient and were overall much better than my first attempt at socks.

Ravelry Project: Toe-Up Plan Mom Socks

Knit-brim Crochet hats

I also made a couple of hats where I crocheted (or Tunisian crocheted in the case of the honeycomb one) the hat body and knit the ribbed brim. I really like the combination of Tunisian for the top of the hat and knit for the rib; I will experiment with that further.

Ravelry Project: Kit Rib Crochet Beanie
Ravelry Project: Honeycomb Beanie v1

Tunisian scarf

I also designed a tunisian simple stitch scarf for my sister. My intention was to surface cross stitch a graphic into the scarf (using the grid created by the tunisian simple stitches), but the scarf had too much curl. I’ve designed a second version as a tube, to be crocheted in the round (which I think will be easier than working flat anyway), to solve the curling issue (and to more easily add pockets) that I need to get started on some day.

Ravelry Project: Daisy Scarf Prototype

2022 The Year of Sweaters!

This year is the year where I finally feel like I’ve become a knitter! I made my first sweater(s), first colorwork socks, first lace, first mittens.

Socks and Mittens

I branched out into some more complicated socks, including some lacey patterns (like this design by Wendy Johnson) and a colorwork pattern. This first pair was meant to be a Christmas gift but I didn’t finish it until January. This is the first time I have bought some fancy hand-dyed yarn (from an Etsy seller) for a project. (The yarn ended up producing some flashing/inadvertant stripes; oh well :shrug:)

Ravelry Project: Daisy Seaweed Socks

With the left over yarn I made a short pair of socks for another sister. This one uses the free A Thousand Vines pattern by Nancy Pelletier, which I had to modify to make a bit larger in circumference.

Ravelry Project: A Thousand Vines (but larger)

I also made some mittens that incorporate the same lace pattern from the Seaweed Socks pattern (one pair without the yarnovers, to make it a little warmer).

Ravelry Project: Daisy Seaweed Mittens

These socks are from a free colorwork pattern using some Universal Bella Cash yarn I got on sale. I’m very happy with how they turned out.

Ravelry Project: Sweet Dumplin' Socks

Echo Flower Shawl

I’m not even sure what a shawl is for, but I came across several free patterns of impressive-looking lace I want to try. First up is this Echo Flower Shawl pattern by Jenny Johnson Johnen. The pattern incudes a full shawl as well as a smaller “shoulderette” which I made. My first lace pattern… it was fun to see it open up with blocking.

Ravelry Project: Echo Flower Shawl

Sweaters

I finally made a sweater! I first bought some bulky wool yarn to try a circular yoke design, but then I got on sale some worsted-weight acrylic yarn and decided to make a Flax by Tin Can Knits (a very popular topdown, seamless raglan). I still haven’t gotten to the bulky colorwork sweater.

Ravelry Project: first sweater! (colorblock Flax with brioche mittcuffs)

I wanted to make a T-shirt, and I got some rustic linen/wool/cotton yarn on sale that I thought might work. The pattern uses Phrancko’s seamless set-in sleeve construction (https://phrancko.com/). I also attempted a patch pocket. It turns out the yarn is both heavier and itchier than I expected, so it is more like a short-sleeve sweater and I haven’t worn it much.

Ravelry Project: Nerdy Hippie Tee

For my birthday I got some Aran-weight wool yarn that I made into an Aran sweater following Caryn Shaffer’s free Handsome Chris Pullover pattern (it is based on the sweater featured in the Knives Out movie). This was my first seamed garment.

Ravelry Project: a handsome chris for chris

Shadow Knit Potholder

I have plans to make a shadow knit sweater. To practice that technique, I made this potholder. The idea is that when viewed straight on it looks like horizontal stripes, but when viewed at an acute angle, vertical stripes appear.

Ravelry Project: Shadow Knit Potholder

Hats

My sister brought me a skein of wool yarn from a trip to Spain, and I used it to make a couple of cabled hats designed by Irina Dmitrieva.

Ravelry Project: Spanish Iced Hat
Ravelry Project: Spanish Pinecone Hat

Maybe my favorite hat I’ve made, with its fun and warm double-thick brim. It was designed by Kristine Byrnes for the Seamen’s Church Institute’s Christmas At Sea program. I made this one out of leftover yarn from my Flax sweater.

Ravelry Project: 1898 Hat

Up next

I knit my sister one of these octopus mittens (based on the beautiful pattern by Emily Peters). I’m currently working on the second one. And then early next year the plan is to make a matching Embrace Octopus Sweater! We already bought the yarn.

Tournament Report: DCC Fall Classic 2022

2022-10-24T01:45:58Z

Background

I played my very first over-the-board tournament at the 2019 Denver Open. I did surprisingly well in the U1800 section at that tournament, getting 3 points our of 5, and finishing with a rather optimistic provisional USCF rating of 1615. I wrote a full report: Tournament Report: Denver Open 2019 (my first chess tournament!)
Later that year I had the chance to compete in a rapid tournament (game in 25 minutes with a 5 second delay). I won two and lost two games to finish in the middle of the pack. At least one of my losses was to the overall winner of the tournament. I wrote a much-less thorough report of that event: Tournament Report: DCC Rapid
The Denver Open was canceled for the next two years because of Covid19, but I did manage to play the 1-day, 3-round “DCC Nearly Normal Tournament” in June, 2021. I lost my first two rounds (my oponent during Round 2, where I let a nice opening advantage slip away, commentated our game in the DCC database: Jason McEwen (1761) - Chris Burkhardt (1615)), and then the tournament software gave me a bye for round 3. Apparently a bye was good for 1 point, so at least I didn’t get last place, though my rating dropped to 1523. The tournament director said that if I wanted to I could play a rated game against a player in the lower section who was also given a bye, and I accepted. I had a relatively short game against a 635 rated player. I won, but the game got reported to the USCF as a loss for me, dropping my provisional rating further to 1409. I contacted the tournament director who in turn contacted USCF, but it has been three years and it is still not corrected. Oh well.
The Denver Open returned in May, 2022, and I played (along with a friend from our local chess group)! I felt sorry for my opponents facing me with an erroneously low rating, but I was confident I would be able to get my rating back to where it should be. I was playing in the U1800 section and my friend in the U1400; we were hoping we would both win some cash. I won 2, lost 3, finished in 42nd place (toward the bottom), and my rating dropped to 1370. My chess club friend didn’t do much better. Chess is hard! In my first game I blundered a totally winning endgame to a loss (a 21 point blunder according to stockfish). Lichess study for my Denver Open 2022 games.

Figure 1. Black to move and lose. Round 1 at Denver Open 2022

Fall Classic 2022

That brings us to the Fall Classic this October. I played in the U1600 section (I paid $15 extra to play one section up), and my brother-in-law played in the U1400 section as his first ever over-the-board tournament! I wrote in my first tournament report, over three years ago, that I had meant to study endgames (read De la Villa’s 100 Endgames You Must Know) but didn’t get around to it. I still haven’t. Though I think my openings are better just from playing games on lichess and looking at the database afterwards.

Many of my tournament losses have been from better positions that I just couldn’t hang on to. My goal in the Fall Classic was to stay focused even when I have a winning position. I’m happy with how I did on that front. I won all the games I was winning, and managed a draw in one of the games I was losing. According to the lichess analysis, I played over 90% accuracy in every game (which means that only 10% of my moves made me more likely to lose).

I scored 3.5 out of 5.0, good enough for 6th place in my section and a rating boost to 1501 (a tournament performance of 1642). I drew the game against the eventual winner of the section; I was losing the whole time, but he let me find a draw in the king-and-pawn endgame. If I had won my last round I would have gotten 2nd place; instead I lost after playing the opening poorly and got no prize. But it was still my best tournament to date!

Saturday

The first two rounds on Sunday were game in 90 minutes with a 10 second delay. The remaining round and the two rounds on Sunday were game in 90 with a 30 second increment.

Round 1 (white)

All set for battle and my unrated opponent (his first USCF tournament, and his first otb tournament in a long time) made a blunder in the opening and I won in about 10 minutes. Afterward he and I played a couple of games out in the hotel lobby; he won the first and I won the second.

White to move and get a decisive advantage in the position below:

My brother-in-law’s first game went on for about 3 hours… so I had plenty of time to wander around and do some knitting before lunch and Round 2.

Round 2 (black)

My opponent in this round was the highest rated player in our section and would go on to win. A friend from my local chess group warned me that he liked to play in a very aggressive style; I was definitely on my back foot the entire time and felt lucky to get a draw.

Round 3 (white)

My turn to play against the French. My opponent made a knight sacrifice on move 11 which scared me at first, but I eventually saw what he missed: that I could just block the follow-up check and I’m fine. I not only held on to my material advantage after that, but managed to find a tactic and win another piece, and then his queen. At that point I forgot that I had a bishop and kept missing checkmates. My opponent finally resigned rather than wait any longer for me to figure out how to win.

Sunday

Round 4 (black)

I have the black pieces and play the French, and my opponent just let’s me control the center giving me a comfortable position. They then blundered a bishop and I took my time to convert for the win.

Round 5 (white)

If I win this I get prize money. If I draw or lose, I get nothing. My opponent is from Russia (I think?) and has no USCF rating. He plays the Pirc defense, and I put my pieces where he can chase them with his pawns and then continue with the initiative for the entire game. I spent a lot of time trying to dig myself out of the resulting bad position, unsuccessfully, and ended up playing a losing endgame on increment.

Other reports

Denver Chess Club report

Race Report: Imogene Pass Run 2022

2022-10-22T02:45:46Z

Race Information

The Imogene Pass Run is a 17.1 mile mountain race between the Colorado towns of Ouray and Telluride by way of a 13,134 foot pass (climbing over 5,000 feet in the first ten miles). The first time I ran it was in 2018. I was already in training for my hometown marathon that fall, so I was in good shape and finished it in about 3h20m. I ran it again in 2019; I’d done less running since my marathon and my little sister beat me to the top of the pass that year. I had to race her all the to the finish. 3h30m. The 2020 race was canceled for Covid and I skipped 2021 because I was even further out of shape (though my sisters ran it!). I came back this September to try to beat my 2018 time.

Figure 1. The race with only one hill

Pre-race

The weather forecast was looking good early in the week, but by the night before the race it was calling for possible snow in the morning at the pass and thunderstorms wall afternoon. I brought a handheld water bottle, one birthday cake flavor Gu packet, a jacket, a hat, and gloves in a running vest; I did put my gloves on near the top when my hands got cold (and kept them on all the way down to protect my hands if I fell), but we ended up having another year with clear weather for the entire race! Except there was some smoke (from fires in Wyoming?) which I didn’t notice but was bothering some of the runners.

I don’t know my splits for my previous runs, so I wasn’t sure what my strategy should be, but for whatever reason I had in mind “60 minutes to Lower Camp Bird, 90 minutes to Upper Camp Bird, 1h15m to the pass.” If I managed that pace, I thought a 3h05m finish might be possible — though my real goal was just to beat my 3h20m PR.

Start to Lower Camp Bird aid station (mile 5)

I thought I started more toward the front of the crowd this year, but I got stuck in standstill traffic at the first offroad shortcut. My chip time was 18 seconds after the gun time at the start. Next time I will start even closer to the front.

But otherwise I felt great to the Lower Camp Bird aid station at about 8km. I got there in about 53 minutes; I’m sure that must be much faster than previous years (and 7 minutes ahead of my mental schedule). I was constantly being surprised by how much downhill there is in the first 10K. (I think I wrote that same thing in my 2018 race report — apparently I forgot.) I grabbed a cookie at the aid station and kept going.

Beyond the aid station there was a ranger warning us that a moose kept crossing the road just ahead and told us not to yell at it. I never saw the moose, but my sister’s boyfriend (who was already several minutes ahead of me) did! He said it was a huge bull; when he saw it, it was looking down at the road wanting to cross but unsure of all the runners.

Lower Camp Bird to Upper Camp Bird aid station (mile 7.6)

With the steeper sections up to Upper Camp Bird I quickly went from feeling good to feeling like my legs were very heavy. I walked much more than I wanted to, but I couldn’t get myself to run even on some of the shallower grades when I thought I would be able to.

This section was a little bit discouraging; I had done more mountain running this year than in any of my previous Imogene Pass Runs, but my legs were evidently not ready for the steep hills after running hard for the first 10K. But I still made it to Upper Camp Bird in 91 minutes, still about on schedule! (I think about the same time I got there in 2018, so I already lost all my gains by running the first 10k faster.)

I got some m&ms from the food table and kept going to see how quickly I could get to the pass.

Upper Camp Bird to Imogene Pass Summit (mile 10.0)

From Upper Camp Bird to the summit was purely a hike, except at the few downhill bits. I didn’t even pretend to be on a run. My lungs felt surprisingly good — the whole hike felt much easier than previous years (yay for actually training at altitude this year!). But my legs were so tired that it still took me 52 minutes to get to the pass (only a minute faster than my slow 2019 year and probably a couple of minutes slower than my 2018 run). If I was going to beat my 2018 time it would have to be by beating my previous downhill time.

At the pass I drank some electrolyte drink, ate my gu (which was not easy with my cold hands), then headed down the hill.

The Descent: Summit to Finish Line (mile 17.1)

The downhill felt much faster than I expected. In previous years I had to brake most of the first few miles; this year I just ran over the rocks. My legs felt tired, and I’m sure my form wasn’t great, but I never felt like I had to slow down to avoid falling. Maybe another benefit of doing several mountain runs in preparation this year?

Unfortunately it didn’t last. After about 5k I could feel my quadriceps, especially my right leg, twitch a few times and threaten to cramp. It got progressively worse. With 5k to go my right calf was also on the verge of cramping. I slowed way down in an attempt to prevent cramping and being forced to walk. I did some calculations and knew if I could hold my current pace I would be close to my PR.

By the time I hit the streets of Telluride I tried to speed up for a final sprint and my right calf and quads immediately started to cramp. I slowed to a jog to the finish line. If it had been a few hundred meters further I might not have made it.

Disappointing because of how well the descent started. I definitely pushed my legs to the limits of what I had trained them for (and probably didn’t eat enough — it’s only 17 miles, but I forget that it is over 3 hours so I should treat it more like a marathon), but I still finished in 3:19:29… a new PR by a few seconds!

Quit Your Job Like Andrew Kelley

2021-08-23T14:11:59Z

The CoRecursive podcast has a great recent interview with Andrew Kelley, the creator of the Zig programming language, where he talks about quitting his job and working on open source full time (Episode #67):

Adam: Once you did quit, was it everything that you thought it would be?

Andrew: First of all, I’ve never been happier. Second of all, I realized that the freedom that I have has allowed me to open my mind up to just other, even just different politics and ways of thinking about society and how the world works. It’s harder to think about maybe more radical ways that society could run when you have to play the game, and you’re spending 40 or plus hours per week clocked in and just like doing the labor.

Not only was it everything I thought I would be, but once I tasted this freedom, I know I will never have a boss again. I will go start a farm if I have to. My sense of self-worth has just skyrocketed and I just, I don’t even want to be subject to another person’s domain anymore. I want everyone to feel this way. I want everyone to feel they get to decide what they do with their life and no one’s going to tell them what they have to do.

Adam: Did you have a really bad boss?

Andrew: Actually, no. […] I think that’s why I realized that I never want to have a boss again is that I had a good one and I still really hated it.

I Hate Magento

2021-08-22T13:30:18Z

Sometimes I think I hate Magento for being so overly complex, slow, resource-intensive, and feature-poor yet bloat-rich that only Adobe could be interested in it. Then I think of the poor people paying me to maintain and write extensions for it.

— Comment seen on hacker news

I’ve inherited the maintenance duties for a retail shop’s website which is powered by some open-source PHP software called Magento. (Magento was purchased by Adobe a few years ago and they offer value-added commercial and hosted versions called Adobe Commerce). According to the marketing copy, “Magento is a feature-rich eCommerce platform solution that offers merchants complete flexibility and control over the functionality of their online channel. Magento’s search engine optimization, catalog management, and powerful marketing tools give merchants the ability to create sites that provide an unrivaled shopping experience for their customers.” And according to Wikipedia, “More than 100,000 online stores have been created on this platform. The platform code has been downloaded more than 2.5 million times, and $155 billion worth of goods have been sold through Magento-based systems in 2019. Two years ago, Magento accounted for about 30% of the total market share.”

I’ve now had time to work with this Magento site from several perspectives over the span of a few years (including a less-than-smooth migration from Magento 1.9 to Magento 2.3) — as a consultant managing product data via the Admin interface, as a sysadmin deploying and hosting a Magento-based site, as a developer making minor modifications and fixes as needed by my client, as a user of the customer-facing site — and it has continually impressed me: I’ve never before used software that provides such a poor experience to administrators, developers, and users alike.

Where I’d expect an eCommerce framework to provide a simple frontend interface that implements basic shopping cart functionality as a starting point to build on, Magento provides a default theme with a product description page which requests over 4MB of HTML/CSS/JS including 200+ JavaScript files (really). Modifying the theme, like all Magento customization (see below), is cumbersome to an unreasonable degree. As far as I can tell, the only sane way to have a performant and maintainable Magento website would be to write a complete frontend using a modern framework and communicate with Magento solely through its REST API. In fact the general rule of successful Magento deployment seems to be to use as little of Magento as possible.

Where I’d expect a catalog management interface with an emphasis on importing and exporting product data, Magento provides a painfully slow product browser and editor for torturing copywriters and an anemic and convoluted product export tool unsuitable for any real reporting or feed generation. My solution lately has been to write programs which get data from the REST API to update reports in Google Sheets rather than trying to use or extend the Admin panel. (Magento’s product import tool is fine.)

Where I’d expect a “feature-rich eCommerce platform solution that offers merchants complete flexibility and control over the functionality of their online channel” to have an ergonomic and well-documented extension interfaces, Magento provides an over-engineered and convoluted plugin system wired together with XML files (with little reference documentation) and PHP code generated from classes you provide which interact with the core system’s classes (which have no reference documentation).

Where I’d expect to find at the morally murky nexus of a commercial online retail platform that barely works out of the box, preoccupation with marketing and “SEO”, and the extraction of labour from programmers in developing countries (including under the guise of “open source”) an ecosystem of commercial plugins that are both expensive and risky to install, Magento delivers. So if the base install of Magento seems too stable, secure, and inexpensive to you, you could always head over to the Magento Marketplace and find any extension you need written by software developers questioning their career choices.

I don’t mean to denigrate the hard work of the open-source contributors who have helped create Magento. In fact while I don’t understand what motivates them, I admire, in some ways, the sheer tenacity and self-denial it must take to continue to spend time on such a project. From what I can tell by browsing github and the Magento StackExchange (which — and I know this is going to sound hyperbolic — is probably the lowest quality stackexchange site I’ve seen), many developers are Indian or otherwise work outside of North America, so I’m guessing the fragility of Magento has created some demand for affordable PHP developers. And I know it is some sort of broken windows fallacy, but if Magento’s convoluted architecture can provide some paying gigs or job security to those developers I guess that’s something positive, at least.

I think most of Magento’s issues — including its poor performance, poor security record, and high cost to customize and maintain — stem from two core defects: a lack of documentation and a fundamentally flawed software architecture.

If Magento had good documentation, then almost no matter how terrible its design, developers would be able to figure out to make it do what they need. Now, the organization of its documentation has improved since Adobe took over (see https://devdocs.magento.com/). But from the perspective of a PHP developer, what is documented is severely lacking. Lots of mostly useless high level descriptions, a few code examples, but no real documentation of the Magento source code and the classes/interfaces it provides.

Unlike the documentation, which Adobe could improve if they cared (but if they did, then I think they would have by now), the architecture of Magento cannot even be fixed. The entire framework is based around convoluted (which makes its lack of documentation hit harder) XML configuration files and a dynamic dependency injection system. The way it works is that plugins declare dependencies on PHP interfaces and then the Magento code generator (the bin/magento setup:di:compile command) generates the actual plugin code with the dependencies instantiated. It’s the sort of overkill system that makes large enterprise Java applications, developed by teams using a statically typed language with excellent tooling, difficult to reason about and maintain; to adopt that architecture for a PHP shopping cart application is utter madness.

I have not taken the time to investigate its performance bottlenecks, and I hope I never do, but the generated PHP code which supports such a dynamic plugin system no doubt contributes to how slow Magento is. And Magento is slow. Behind an asynchronous reverse proxy on an over-sized ec2 instance, I’m pretty sure my client’s website could be DoS’d by any mischievous kid with a cable modem if it weren’t for Cloudflare. Even with Cloudflare’s firewall a single malicious bot can bring the site to a crawl.

The ‘solution’ Magento offers to its performance problems is more and more layers of cache. First, the administrator must generate static files (CSS, etc.) with the bin/magento setup:static-content:deploy command. Then there is a cache system for various bits of data Magento calculates and which often, inexplicably, needs to be manually refreshed. But it is still slow so it is usually recommend that you also run Magento behind a caching reverse-proxy like Varnish and/or a dedicated key-value cache based on redis. It would be funny if it weren’t real software that I have to maintain.

Worse, the unnecessary complexity makes it more difficult both to understand code execution paths and to make changes to the code base: a recipe for security vulnerabilities.

There are some good things about Magento, of course. Its one saving grace, in my opinion, is its Swagger-based REST API which makes it possible to implement most required functionality outside of Magento itself. And Swagger/OpenAPI is self-documenting, so the Magento devs are not able to make it as difficult as they’ve made the PHP API. But even that has been a source of suffering. In fact my main use-case for it, reporting on current inventory quantity for all products, is not even possible by default because the /V1/products endpoint does not return stock information despite what the documentation claims. That bug has been reported several times (eg #24418), but the response from the maintainers is that the correct way to get stock information is to make a call to /V1/products and then make an additional http request for each returned product (thousands or tens of thousands in my case). (Luckily there are some workarounds. I wrote cristoper/mage_qtyext, a very simple plugin which adds a “qty” field to the product results; I also found menacoders/Stock-Info-API-searchCriteria which adds all stock information to the results.) There are also SOAP and GraphQL APIs which I’ve not investigated (except to find out that the GraphQL API by default also does not offer a way to get stock information for the entire inventory).

Personally, the prospect of developing solutions for my Magento-bound client confronts me as a depressing time sink. I’m convinced Magento will never be anything but expensive to maintain, slow, and insecure. I don’t recommend it for new projects.

I found this 2015 article from the Magento 1 days which complains about mostly the same things: Magento: why complex doesn’t mean good

See also for Spotify users: Magento 2 Rage Tracks

Deranged Sinterklaas: The Math and Algorithms of Secret Santa

2020-12-07T07:00:00Z

Secret Santa

Secret Santa is a traditional Christmas gift exchanging scheme in which each member of a group is randomly and anonymously assigned another member to give a Christmas gift to (usually by drawing names from a container). It is not valid for a person to be assigned to themself (if someone were to draw their own name, for example, all the names should be returned to the jar and the drawing process restarted).

Given a group of a certain size, how many different ways are there to make valid assignments? What is the probability that at least one person will draw their own name? What is the probability that two people will draw each other’s names? What is a good way to have a computer make the assignments while guaranteeing they are generated with equal probability among all possible assignments?

It turns out that these questions about secret santa present good motivation for exploring some of the fundamental concepts in combinatorics (the math of counting). In the sections below we will take a look at a bit of that math and algorithms that allow us to answer the questions we posed above. The final section presents a simple command-line program that allows generating and anonymously sending secret santa assignments via email so that we no longer need to go through the tedious ordeal of drawing names from a hat.

Table of Contents

Secret Santa
Math
- Permutations
- Derangements
Algorithms
Sinterbot2020
- Installation
- Usage

Math

Permutations

As an example let’s take a group of five friends who we will represent by the first initial of their names as a set: $\{\mathrm{\,S, C, A, L, M\,}\}$. The elements of this set of people, like the elements of any set, can be arranged in different orders. For example, the order of the elements as we just happened to write them $(\mathrm{S\; C\; A\; L\; M})$ is one arrangement, and we can also shuffle them around to get a different arrangement like $(\mathrm{C\; A\; M\; L\; S})$.

Each ordered arrangement is called a permutation of the set. How many permutations can be made from a set with $n$ elements? It is straight-forward to count. We can choose any element of the set to be in the first position of the permutation, so there are $n$ choices, which leaves $n-1$ choices for the second position, $n-2$ choices for the third position, and so on until for the $n\text{th}$ (and therefore last) position of the permutation there is only one element of the set remaining to choose from.

Multiplying the number of choices for each position of the permutation gives the total number of possible permutations: $n(n-1)(n-2)\dots(1).$ In other words, the product of all positive integers less than or equal to $n$. That product is known as the factorial of $n$ and is written $n!$:

\[\begin{align*} n! &= n(n-1)(n-2)\cdots (n-(n-1))\\ &= 1 \cdot 2 \cdots n\\ \end{align*}\]

So there are $5! = 5 \cdot 4 \cdot 3 \cdot 2 \cdot 1 = 120$ ways to permute a set of five friends. Writing any two of those permutations in two-line notation with one above the other allows us to read off a secret santa assignment for the group:

\[\begin{equation} \label{eq:perm} \begin{pmatrix} \mathrm{S} & \mathrm{C} & \mathrm{A} & \mathrm{L} & \mathrm{M} \\ \mathrm{C} & \mathrm{A} & \mathrm{M} & \mathrm{L} & \mathrm{S} \\ \end{pmatrix} \end{equation}\]

If we read the top line of as the list of gift givers and the bottom line as the gift recipients, then each santa is assigned to give a gift to the person in the bottom line directly beneath them. So $\mathrm{S}$ gives a gift to $\mathrm{C}$ who gives a gift to $\mathrm{A}$ and so forth.

Figure 1. Graphical representation of the cycles of the permutation $\eqref{eq:perm}$. Arrows point from santas to gift recipients.

A permutation of santas (or anything else) can be represented as a directed graph, as in Figure 1, or more compactly by listing its cycles: $(\mathrm{S\; C\; A\; M})(\mathrm{L})$. To see that the cycle notation is equivalent to the graph, read each cycle from left to right and insert the implied arrow from the last element back to the first: $(\mathrm{S \to C \to A \to M \to S})(\mathrm{L \to L})$. Note that any 1-cycles can be implied and are usually left out when writing a permutation in cycle notation, so an equivalent way to write our example permutation is simply as $(\mathrm{S\; C\; A\; M})$.

But note also that a permutation containing any 1-cycles defines an invalid secret santa assignment! The example permutation above has $\mathrm{L}$ giving a gift to herself, which is against the rules.

Derangements

A permutation with no 1-cycles — in other words, a permutation in which no element is left in its original position so that the entire set has been de-arranged — is called a derangement. One way to derange our example group of secret santas is

\[\begin{equation} \label{eq:der} \begin{pmatrix} \mathrm{S} & \mathrm{C} & \mathrm{A} & \mathrm{L} & \mathrm{M} \\ \mathrm{C} & \mathrm{A} & \mathrm{S} & \mathrm{M} & \mathrm{L} \\ \end{pmatrix} \end{equation}\]

Or equivalently, decomposed into its cycles, $(\mathrm{S\; C\; A})(\mathrm{M\; L})$.

So the problem of generating a valid secret santa assignment is equivalent to generating a derangement. Some algorithms for uniformly generating random derangements are presented in the next section. But first we need a way to calculate $D_n$, the number of derangements that can be made from a set with $n$ elements.

Counting derangements is a trickier than counting unrestricted permutations. We proceed by counting the permutations with at least one 1-cycle, the non-derangements. First we’ll define the subsets $H_p$ to contain all of the permutations on $n$ with the $p^{\text{th}}$ element fixed in its original position (an element that stays in its original position in a permutation is called a “fixed point”). This gives $n$ such subsets $\mathrm{(}H_1 \ldots H_n\mathrm{)}$ each containing $(n-1)!$ permutations (because with one element fixed, there are $(n-1)!$ ways to permute the remaining elements).

We know that the subsets $H_p$ contain only non-derangements since every member has a fixed point. And since together the $H_p$ contain every non-derangement with the $p^{\text{th}}$ element fixed, we know that they contain all possible non-derangements. That means to find $D_n$ we just need to subtract the size of the union of all the $H_p$ subsets from the total number of permutations (which we know is $n!$):

\[\begin{equation} \label{eq:up} D_n = n! - \left\lvert \bigcup H_p \right\rvert \\ \end{equation}\]

But finding the size of $\cup H_p$ is not straightforward. If we simply multiply the number of subsets by their size $n\cdot(n-1)!$ we over count because the subsets $H_p$ are not disjoint: some non-derangements belong to more than one subset. Specifically, every pair of subsets of $H_p$ share $(n-2)!$ permutations with at least two fixed points; every 3-tuple of subsets share $(n-3)!$ permutations with at least three fixed points; and so on.

To visualize this, it helps to draw out each $H_p$ for a small set. The table below shows each $H_p$ subset for the set $\{\,a, b, c, d\,\}$:

$H_1$

$H_2$

$H_3$

$H_4$

abcd

abdc

adcb

acbd

cbad

bacd

acdb

cbda

bdca

bcad

adbc

dbac

dacb

cabd

adcb

dbca

cbad

Notice that the first column, $H_1$, has "a" fixed in the first position; the second column has "b" fixed in the second position; etc. Note also that the $H_1$ and $H_2$ columns share every permutation with the first and second position fixed ("abcd" and "abdc").

To weed out the duplicates, we need to subtract the number of permutations with at least two fixed points multiplied by the number of pairs of $H_p$ subsets. But that will leave us with an under count because it will result in some permutations with three or more fixed points being excluded, so we must add those back in. We need to continue this inclusion-exclusion process until we’ve considered the number of permutations which fix all $n$ elements in $H_p$ taken $n$ at a time:

\[\begin{equation*} \label{eq:binom} \left\lvert \bigcup H_p \right\rvert = \binom{n}{1}(n-1)! - \binom{n}{2}(n-2)! + \binom{n}{3}(n-3)! - \cdots (-1)^n \binom{n}{n}(n-n)! \end{equation*}\]

where $\binom{n}{k}$ gives the binomial coefficients which you may remember from math class can be interpreted as the number of ways to choose $k$ objects from a set of $n$ objects when order doesn’t matter. It can be written in terms of factorials:

\[\begin{equation*} \binom{n}{k} = \frac{n!}{(n-k)!k!} \end{equation*}\]

Now we can calculate the number of possible non-deranged permutations. To get $D_n$, we just subtract it from the total number of possible permutations. When we substitute the expression for $\lvert \bigcup H_p \rvert$ into equation \eqref{eq:up} then expand the binomial coefficients and factorials, this becomes:

\[\begin{eqnarray} \notag D_n & = & n! - \frac{n!}{1!} + \frac{n!}{2!} - \frac{n!}{3!} + \cdots + (-1)^n \\ \notag & = & n!\left(1 - \frac{1}{1!} + \frac{1}{2!} - \frac{1}{3!} + \cdots + (-1)^n \frac{1}{n!}\right) \\ \label{eq:dn} & = & n!\sum_{k=0}^n(-1)^k\frac{1}{k!} \end{eqnarray}\]

And we’ve answered our first question: Given a group of size $n$, there are $D_n =n!\sum_{k=0}^n(-1)^k\frac{1}{k!}$ ways to make a valid secret santa assignment. To calculate the number of valid assignments between our five example friends, then, we have

\[\begin{eqnarray*} D_5 & = & 5!\left(1 - \frac{1}{1!} + \frac{1}{2!} - \frac{1}{3!} + \frac{1}{4!} - \frac{1}{5!}\right) \\ & = & 120 \left(1 - 1 + \frac{1}{2} - \frac{1}{6} + \frac{1}{24} - \frac{1}{120}\right) \\ & = & 120 \left(\frac{44}{120}\right) \\ & = & 44 \end{eqnarray*}\]

The first nine values of $D_n$ are listed in the table below.

\(n\)	1	2	3	4	5	6	7	8	9
\(D_n\)	0	1	2	9	44	265	1,854	14,833	133,496

$n$

$D_n$

265

1,854

14,833

133,496

This is OEIS sequence A000166. The number $D_n$ is known as the subfactorial of $n$ (usually written $!n$). It is also a special case of the rencontres numbers which enumerate partial derangements (derangements with specified numbers of 1-cycles).

Notice that the summation in equation $\eqref{eq:dn}$ is the $n^{\text{th}}$ partial Maclaurin expansion of $e^{-1}$, so that

\[\begin{equation*} \lim_{n \to \infty} D_n = \frac{n!}{e} \end{equation*}\]

Because the series converges rather quickly, $\frac{n!}{e}$ is a good approximation even for even small values of $n$.

The probability that a permutation is a derangement is $D_n$ divided by the number of all possible permutations $n!$. This answers the second question asked in the introduction: The probability that at least one secret santa participant will draw their own name is $1 - \frac{D_n}{n!} \approx 1 - \frac{1}{e} \approx 63\%$. That may seem high, but the mean of the geometric distribution is $e$ so you can expect to draw a valid derangement after 2 or 3 attempts (restarting each time someone draws their own name). There is a nearly 99% chance of having drawn a derangement after 10 attempts $(1 - (1 - \frac{1}{e})^{10} \approx 98.9\%)$.

Beyond counting mere derangements there are more elaborate constraints and questions we could consider, the sorts of things investigated by statistics of random permutations and generating functions. We haven’t even answered the third question from the introduction yet (“What is the probability that two people will draw each other’s names?”). I hope to return to this article in the future when I have more time and a better grasp of combinatoric tools to look into some of those questions.

If my explanation above of how to derive $D_n$ was not clear, don’t worry. Counting derangements is frequently used as an example application of the inclusion-exclusion principle, so better explanations can be found on the web and in almost any introductory combinatorics textbook. See, for example, Professor Howard Haber’s handout on the inclusion-exclusion principle [PDF]. There are also several other methods for deriving and proving the formula for $D_n$, including those that first derive the recurrence relation $D_n = (n-1)(D_{n-1} + D_{n-2})$ and then solve it by iteration or by the method of generating functions. For a solution via generating functions see Jean Pierre Mutanguha’s “The Power of Generating Functions”.

Algorithms

[A]lmost as many algorithms have been published for unsorting as for sorting!

— Donald Knuth

We’ll use Python to explore some algorithms for generating random derangements. The functions given below are sometimes simplified to get the main ideas across; the complete versions can be found in alogrithms.py in the github repository. To keep things simple, all of the functions operate only on permutations of the set of integers from 0 to n-1. If we’d like to permute a set of some other n objects (like santas) we can then use those integers as indexes into the list of our other objects.

Utilities

There are a few utility functions that we might want while exploring and debugging our algorithms. First of all, the ability to calculate $D_n$, the number of derangements in a set of size $n$. Here is a straightforward translation of $\eqref{eq:dn}$ to Python:

Dn()

import math
from decimal import Decimal

def Dn(n: int):
    # Use Decimal to handle large n accurately
    # (by large, I mean n>13 or so...
    # factorials get big fast!)
    s = 0
    for k in range(n+1):
        s += (-1)**k/Decimal(math.factorial(k))
    result = math.factorial(n) * s
    return Decimal.to_integral_exact(result)

[int(Dn(i)) for i in range(9)]
>> [1, 0, 1, 2, 9, 44, 265, 1854, 14833]

Next up is a way to generate all $n!$ permutations of a set. Several algorithms for generating permutations are well-known. Most classic is an algorithm which produces permutations in lexicographical order described by Knuth in 7.2.1.2 Algorithm L. Other techniques produce all permutations by only swapping one pair of elements at a time (see the Steinhaus-Johnson-Trotter algorithm which Knuth gives as Algorithm P).

But in our case the Python standard library provides a function for generating permutations (in lexicographical order) so we’ll just use that:

import itertools
list(itertools.permutations([0,1,2]))

>> [(0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0)]

Another helpful function would be a way to decompose permutations into their cycles to make them easier to visualize (taking $(0, 1, 2,\cdots, n-1)$ to be the identity permutation). To find the cycles in a permutation, start with the first element and then visit the element it points to (the element in its position in the identity permutation), and then visit the element that one points to and so on until we get back to the first element. That completes a cycle containing each of the elements visited, add it to a list. Now start over with the first unvisited element. Repeat until there are no more unvisited elements.

Below is an implementation of that algorithm. It requires storage for the list of cycles (the cycles variable), a way to keep track of unvisited elements (the unvisited variable, which starts as a copy of the input but has elements removed as they are visited), and a way to keep track of the first element in a cycle so that we know when we’ve returned to it (the variable called first below):

decompose()

def decompose(perm):
    cycles = []
    unvisited = list(perm)

    while len(unvisited):
        first = unvisited.pop(0)
        cur = [first]
        nextval = perm[first]
        while nextval != first:
            cur.append(nextval)
            # Remove each element from unvisited
            # once we visit it
            unvisited.pop(unvisited.index(nextval))
            nextval = perm[nextval]
        cycles.append(cur)

    return cycles

As an example, let’s see the cycles in $\{1, 2, 4, 3, 0\}\mathrm{:}$

decompose([1,2,4,3,0])

>> [[1, 2, 4, 0], [3]]

Notice this agrees with the same cycles we found way back in our first example of a permutation (where $\mathrm{S}=0, \mathrm{C}=1, \mathrm{A}=2, \mathrm{L}=3, \mathrm{M}=4$) $\eqref{eq:perm}$.

Finally, it will be handy to have a function that can test whether a permutation is a derangement or not. One way to do that would be to call decompose() on the permutation and then check if there are any 1-cycles in the decomposition. The nice thing about that method is that it generalizes so we could use it to check if the permutation contains any cycles $\leq m$ for any $m$.

But if we only care about derangements (the case where $m=1$), it is simpler (and faster) to just iterate over the elements of the permutation and check if they are in their original position. If any are, we can immediately return False, the permutation is not a derangement.

check_deranged()

def check_deranged(perm):
    for i, el in enumerate(perm):
        if el == i: return False
    return True


check_deranged([1,2,4,3,0])
>> False

decompose([1,3,4,2,0])
>> [[1, 3, 2, 4, 0]] # Notice no 1-cycles

check_deranged([1,3,4,2,0])
>> True

How not to generate derangements

The first time I sat down to write a secret santa algorithm, my instinct was to try a backtracking approach and ended up with something like the code below. The idea behind the backtracker is to iteratively build a derangement by randomly selecting an element from the identity arrangement, and then checking if the resulting partial permutation is a derangement. If it is not a derangement, undo (backtrack) the last choice and try again. If it is a derangement, randomly choose one of the remaining elements and check again. Repeat until you’ve deranged all $n$ elements:

backtracker()

import random
def backtracker(n):
    if n == 0: return []
    remaining = list(range(n))
    perm = []

    # backtrack until solution
    while len(perm) < n:
        perm.append(random.choice(remaining))
        if not check_deranged(perm):
            if len(remaining) == 1:
                # we're down to the last two elements
                # just swap them to get a derangement
                perm[-1], perm[-2] = perm[-2], perm[-1]
                return perm
            # undo last choice
            perm.pop(-1)
        else:
            remaining.remove(perm[-1])
    return perm

# Use it to generate a derangement and view the cycles:
perm = backtracker(5)
perm, decompose(perm)
>> ([1, 2, 0, 4, 3], [[1, 2, 0], [4, 3]])

As written, backtracker() is fast and will produce any possible derangement (and in only ~20 lines of Python), so it could be used for secret santa. However, as the decades fly by your friends might begin to suspect that the same assignments seem to be ‘randomly’ generated fairly often. They would be right: backtracker() does not produce derangements with uniform probability. Even though each element in the derangement is chosen from the remaining elements of the input set with uniform probability, the number of possible derangements is dependant on which numbers happen to have been chosen first.

For example, let’s look at the probability that backtracker() will produce $(5, 0, 1, 2, 3, 4).$ The first number can be anything but 0, so there are $6-1=5$ ways to choose that. The second number can be any of the remaining 5 numbers except 1, so there are 4 ways to choose that. The third number can be any of the remaining 4 numbers except 2 which leaves 3 possibilities. The fourth element can be any of the remaining numbers except for 2 which leaves 2 possibilities. The fifth element can not be 4, so there is only one way to derange the last two elements. If we take the product of those probabilities we get $\frac{1}{5} \cdot \frac{1}{4} \cdot \frac{1}{3} \cdot \frac{1}{2} = \frac{1}{120}.$

If you do a similar calculation for the probability that backtracker() would produce $(2, 3, 5, 4, 0, 1)$ you should get $\frac{1}{360}.$ Not only are the probabilities for generating those two derangements significantly different from each other but they also both differ from the expected probability of $\frac{1}{265}$ if every one of the $D_6$ derangements had an equal probability of being generated. I generated 10,000 derangements of length 6 with backtracker(), and sure enough $(5, 0, 1, 2, 3, 4)$ was generated 94 times while $(2, 3, 5, 4, 0, 1)$ was generated only 20 times. The graph below shows a plot of counts for every 6-derangement over the 10,000 runs:

Figure 2. Count of each derangement produced after running backtracker() 10,000 times with $n = 6$. It is clearly not choosing derangements uniformly. The grey line shows the expected count if each derangement were generated with uniform probability ($1/D_6\cdot 10000 \approx 37.7$)

Instead of building derangements by randomly selecting elements and checking if the result is a derangement, we could simply generate all possible permutations, filter out the non-derangements, and then randomly select one of the derangements to return. The nice thing about that approach is that we could enforce any other constraints we want in the filter step (maybe we want a minimum cycle length or have a “blacklist” of people who should not be assigned to each other) and we can still be confident we would select a valid secret santa assignment with uniform probability (since we have generated all of them it is easy to select one at random).

generate_all()

import random
def generate_all(n):
    potential = []
    perms = itertools.permutations(range(n))
    for p in perms:
        if check_constraints(p, m, bl):
            potential.append(p)
    return random.choice(potential)

Below you can see a bar graph of the counts after producing 10,000 derangements of length 6 with generate_all(). It looks much more uniform than backtracker() at least. One tool we can use to gauge how closely our counts match what we should expect from a uniform distribution is the chi-squared statistic:

\[\begin{equation*} \chi^2 = \sum\frac{(O_i - E_i)^2}{E_i} \end{equation*}\]

where $O_i$ are our observed counts and $E_i$ are the expected counts for each derangement (which in our case is $1/D_6\cdot 10000 \approx 37.7$). For my data I calculated $\chi^2 \approx 261.75$. If we check that against the chi-squared cumulative distribution function with k-1 degrees of freedom (where k is the number of data points, 265 in this case), we get a p-value of about 0.53. The p-value is the probability that our $\chi^2$ value would be least 261.75 if our counts were uniformly distributed. Usually if p<0.05 it would be prudent to question whether the data fits a uniform distribution. On the other hand if p>0.99 or so we could be confident it is uniform, but we might question whether it is random. A p-value of 0.53 should leave us confident that generate_all() randomly generates derangements with uniform or very nearly uniform probability.

Figure 3. Count of each derangement produced after running generate_all() 10,000 times with $n = 6$. $\chi^2 \approx 261.75$ and the chi-squared test p-value ≈ 0.53. The grey line shows the expected count if each derangement were generated with uniform probability ($\approx 37.7$)

But there are two major problems with generate_all(): it is slow (because we have to generate all $n!$ permutations), and it uses a lot of memory (because we have to store all $D_n$ derangements). $D_{12} = 176,214,841$, for example, so even if we implemented our permutations in some memory efficient way (say an array of one byte per element), we would need over 1GB of memory just to store all of the derangements before returning one. Running generate_all() with $n>11$ runs my desktop out of RAM after about a minute and crashes the Python interpreter. And in the grand scheme of things 12 is not such a huge number.

How to generate derangements

We can do better than the backtracker and generate_all algorithms above by combining the best aspects of each: generate a single random permutation and check if it is a derangement. If it is, return it; otherwise, try again by generating another random permutation. That should be much more efficient than generating and storing all possible derangements, and as long as we can generate permutations with uniform probability we will also generate derangements with uniform probability.

A well-known algorithm for creating a random permutation by shuffling a given arrangement is to simply select one of the elements at random, set that as the leftmost element of the permutation, and then repeat by selecting one of the remaining elements at random until all of the elements have been selected. This is known as the Fisher-Yates shuffle named for two statisticians who described a paper-and-pen method for shuffling a sequence in 1938. The computer version of the algorithm — popularized in Chapter 3 of Knuth’s The Art of Computer Programming (“Algorithm P (Shuffling)”) — usually shuffles an array in place. It does this by iterating through the array from left to right swapping the element at the index with a random element to the right of the index. Once an element has been swapped left it is in its position in the generated permutation. Repeat to the end. For a good visualization of Fisher-Yates (and how it compares to less efficient algorithms) see Mike Bostock’s Fisher-Yates Shuffle.

The shuffle_rejection() algorithm below repeatedly shuffles a list using Fisher-Yates until the resulting permutation is a derangement:

shuffle_rejection()

def shuffle_rejection(n):
    perm = list(range(n))
    while not check_deranged(perm):
      # Fisher-Yates shuffle:
      for i in range(n):
          k = random.randrange(n-i)+i # i <= k < n
          perm[i], perm[k] = perm[k], perm[i]
    return perm

Notice that in the Fisher-Yates algorithm the range of the random index k includes the index of the current element i. In other words, elements can swap with themselves creating a 1-cycle. That is necessary, of course, to generate all possible permutations. If the algorithm is changed so that k ranges only from $i < k < n$ so that it does not include i, then the algorithm will produce only permutations with a single n-cycle. This is known as Sattolo’s algorithm, and it generates n-cycles with uniform probability.

The bar graph above summarizes the results of generating 10,000 derangements of size 6 with shuffle_rejection(). It appears to be uniform as expected. It is also fast and simple, which makes it perfectly suitable for generating secret santa assignments (and is, in fact, what I use in sinterbot, my secret santa tool).

Figure 4. Count of each derangement produced after running shuffle_rejection() 10,000 times with $n = 6$. $\chi^2 \approx 278.9$ and the chi-squared test p-value ≈ 0.25.

One inelegance of shuffle_rejection() is that it generates any number of random permutations just to throw them away. It is possible that it would never actually generate a derangement and just keep generating and rejecting permutations all day. In reality derangements are common enough that that is not a practical concern (it finds close to 20,000 derangements of length 6 per second on my old desktop). But is there a way to directly generate derangements with uniform probability without needing to backtrack or reject non-deranged permutations?

Yes. In 2008 Martínez et al. published one such algorithm (“Generating Random Derangements,” 234-240). It is similar to Sattolo’s algorithm, but instead of joining every element into a single n-cycle, it will randomly close cycles at a specific probability which ensures a uniform generation of derangements. Here is a nice set of slides that goes through their algorithm step by step.

Jörg Arndt provides an easier to follow (in my opinion) version of the algorithm in his 2010 thesis Generating Random Permutations. (It’s a short book that includes several useful algorithms.) This Python implementation more closely follows his version:

rand_derangement()

def rand_derangement(n):
    perm = list(range(n))
    remaining = list(perm)
    while (len(remaining)>1):
        # random index < last:
        rand_i = random.randrange(len(remaining)-1)
        rand = remaining[rand_i]
        last = remaining[-1]

        # swap to join cycles
        perm[last], perm[rand] = perm[rand], perm[last]

        # remove last from remaining
        remaining.pop(-1)

        p = random.random() # uniform [0, 1)
        r = len(remaining)
        prob = r * Dn(r-1)/Dn(r+1)
        if p < prob:
            # Close the cycle
            remaining.pop(rand_i)
    return perm

Figure 5. Count of each derangement produced after running rand_derangement() 10,000 times with $n = 6$. $\chi^2 \approx 261.1$ and the chi-squared test p-value ≈ 0.54.

Arndt’s implementation is in C with a precomputed lookup table for the ratio calculated on the prob = r * Dn(r-1)/Dn(r+1) line. Even then he reports it is only slightly faster than the rejection method. This Python implementation is actually about twice as slow as the rejection method in my tests.

But one advantage of generating derangements directly as in rand_derangement() is that it can be generalized to generate derangements with minimum cycle lengths. Arndt shows how that can be done in his thesis.

There are other ways to generate random derangements that I’ve not covered in this post. Earlier this year J. Ricardo G. Mendonça published two new algorithms for [almost-]uniformly generating random derangements: “Efficient generation of random derangements with the expected distribution of cycle lengths,” Computational and Applied Mathematics 39, no. 3 (2020): 1-15.

Sinterbot2020

sinterbot is a little command line program (Python 3.5+) that helps to manage secret santa assignments. With sinterbot you can generate a valid secret santa assignment for a list of people and email each person their assigned gift recipient without ever revealing to anybody (including the operator of sinterbot) the full secret list of assignments.

Source code and more usage instructions: https://github.com/cristoper/sinterbot

sinterbot allows specifying some extra constraints such as minimum cycle length or a blacklist of people who should not be assigned to each other.

Installation

pip install sinterbot

Usage

First create a config file with a list of participants' names and email addresses. The config file may also specify constraints for minimum cycle length and a blacklist. See sample.conf for a full example:

# xmas2020.conf
Santa A: user1@email.tld
Santa B: user2@email.tld
Santa C: user3@email.tld
Santa D: user4@email.tld
Santa E: user5@email.tld

The format is Name: emailaddress. Only the email addresses need to be unique.

Then run sinterbot derange to compute a valid assignment and save it to the config file:

$ sinterbot derange xmas2020.conf
Derangement info successfully added to config file.
Use `sinterbot send sample.conf -c smtp.conf` to send emails!

sinterbot will not allow you to re-derange a config file without passing the --force flag.

Now if you want you can view the secret santa assignments with sinterbot view xmas2020.conf. However, if you’re a participant that would ruin the suprise for you! Instead you can email each person their assignment without ever seeing them yourself.

First create a file to specify your SMTP credentials:

# smtp.conf
SMTPEmail: yourname@gmail.com
SMTPPass: yourgmailpassword
SMTPServer: smtp.gmail.com
SMTPPort: 587

(If you do not know what SMTP server to use but you have a gmail account, you can use gmail’s SMTP server) using values like those exemplified above.)

Then run the sinterbot send command, giving it the smtp credentials file with the -c option, to send the emails:

$ sinterbot send xmas2020.conf -c smtp.conf
Send message to user1@email.tld!
Send message to user2@email.tld!
Send message to user3@email.tld!
Send message to user4@email.tld!
Send message to user5@email.tld!

FO Roundup December 2019

2019-12-04T04:48:59Z

I’m a slow knitter. My ravelry.com account is nine years old today, and I’ve just posted my first projects (and design!)

Socks

I wanted to try something with some more shape than my usual hats and scarves. I didn’t follow any pattern, but I read about different ways to do heels and toes. I found the various “sock recipes” you can find online to be helpful (like Vickie Howell’s How to Knit Socks).

I ended up working cuff down: a few inches of ribbing with a 9" circumference, a heel flap, what I think is a French heel or similar, a gusset, the foot tube until it fit my feet, decrease for the toe, and then Kirchner stitch to finish the toe.

I used the magic loop method, and got a bit turned around after finishing the heel, but figured out a way to proceed. I’m sure there’s lots of ways to handle socks on a magic loop.

They are comfortable! I like the self-striping yarn. No one believes me, but I intentionally did not start the socks at the same place in the striping.

More details on my Ravelry Project: Learning Socks

Dad Cable Hat

After having made several very simple stockinette hats, I wanted to try something a bit fancier looking. So I tried this “Cabled Dad Hat” pattern by Alexis Winslow. Mine turned out with rather stiff peaks at the decreases, I think because of the yarn I used, but I like the pattern: the twists give it nice texture without looking too cable-heavy.

Ravelry project: Cabled Dad Hat

Ombre Hat

I also wanted to try one with a little bit of color work. Emily Dormier’s Quick Ombré Hat is a simple two-color pattern with a nice fade effect.

Ravelry project: Quick Ombré Hat

Hats for the Homeless and a Simple Crochet Cap Pattern

Years ago, when my Ravelry account was still young and blank, a friend taught me how to crochet a simple beanie as part of a "hats for the homeless" event she organized. I’ve written down that pattern along with some notes for the beginner: Simple Crochet Beanie Cap Pattern and Notes. I also re-discovered some of the hats we created at that event, added a few more, and (finally) donated them to a local charity that distributes them at its free health clinics and soup kitchens.

The Warm Up America! Foundation coordinates the collection of knit/crochet goods for similar charities throughout the country.

Crochet Your First Hat: Simple Beanie Cap Pattern and Notes

2019-12-03T22:32:05Z

A friend organized a project to crochet hats for the homeless (or other cold people) one winter. She gave us a simple hat pattern to learn and these notes are my attempt to make sense of it and explain to other beginning crocheters, including a schematic diagram. So this is not my original design (it’s so simple that it and similar designs have likely been independently made many times) — though I did make a small modification to remove the seam the original pattern left down the entire length of the hat.

This pattern is also available on Ravelry: Simple Crochet Beanie

Yarn, hook size, sizing

Use a medium/worsted weight yarn. Acrylic yarn is inexpensive and nonallergic, but it does not retain heat when it gets wet and it melts when exposed to open flame which could pose a safety concern. Wool stays warm even when it is wet and does not melt, but it is expensive and some people are allergic to it. All of the hats pictured in these pattern notes are made with 100% acrylic yarn.

As presented below this pattern is for an adult-sized cap of about 20" circumference. The exact hook size gauge is not critical, but aim for 14 hdc per 4". The size can be adjusted both by changing hook size and by changing the number of increase rows performed at the beginning of the pattern. Anything from size H to J (5.0-6.0mm) hooks should work well with worsted yarn.

Pattern

Here is how to make the basic hat, presented as a typically terse crochet pattern. It is explained in detail in the notes below.

Key

For an overview of reading crochet patterns (and other tips on getting started) see the Craft Yarn Council’s “How to Read a Crochet Pattern”.

Hdc	Half-double crochet stitch (called half-treble crochet in the UK) ^[1]. This is the stitch which is used throughout the entire pattern.
Sc	Single crochet stitch (called double crochet in the UK).
Join	Join rows with a slip stitch ^[2]
( ) repeat	repeat the instructions in the parenthesis the number of times specified.
(#)	Number in parenthesis at end of row denotes the total number of stitches you should have on the circumference of the hat after completing that row.

Row 0	Chain 1. This first loop will be the center of the hat.
Row 1	Chain 2 (so you now have 3 chains), make 8 hdc in third chain from hook. Join. (9)
Row 2	Chain 2, hdc in same stitch, 2 hdc in each remaining stitch. (18)
Row 3	Chain 2, hdc in same stitch, 1 hdc in next stitch, (2 hdc in next stitch, 1 hdc in next stitch) repeat to end of round. Join. (27)
Row 4	Chain 2, hdc in same stitch, 1 hdc in next two stitches, (2 hdc in next stitch, 1 hdc in next two stitches) repeat to end of round. Join. (36)
Rows 5-7	Continue increasing as in Row 4. Each row will have an additional hdc between every increase: chain 2, hdc in same stitch, 1 hdc in next Row#-2 stitches (that’s the row number minus two), (2 hdc in next stitch, 1 hdc in next Row#-2 stitches) repeat to end of round. Join. (72)
Row 8	Chain 2, hdc in same stitch, 1 hdc in next six stitches, (2 hdc in next stitch, 1 hdc in next six stitches) repeat to end of round. Do not join! (72)
Rows 9-end	Hdc in next stitch (instead of slip), continue around making one hdc in each stitch until hat is of desired length.
Finish	Make last two stitches as sc to reduce the offset caused by the spiral. Cut yarn and pull through last stitch to secure.

Pattern Schematic Diagram

See below for a detailed textual description of the pattern. But it can also be useful to look at a blueprint diagram to understand the structure of a crochet pattern.

Key

	Half-double crochet (hdc)
	Chain
	Slip stitch

Resources for reading crochet diagrams:

“How to Follow a Stitch Diagram in Crochet”: http://www.dummies.com/how-to/content/how-to-follow-a-stitch-diagram-in-crochet.html
“Crochet chart symbols”: http://www.craftyarncouncil.com/chart_crochet.html
“Annie’s Stitch Guide”: https://www.anniescatalog.com/crochet/content.html?content_id=708&type_id=S&scat_id=3

Figure 1. Schematic of Hat Pattern

(SVGversion)

The above image shows a graphic representation of the hat pattern. Each row is a different color to make it easier to follow. Read it like this:

The base chain 3 is the red chain in the center. Start there and then read counterclockwise (left-handed crocheters will read counterclockwise, but actually work clockwise).
Work around Row 1 (black), making 8 hdc through the first loop of the base chain.
When you get back around, make a slip stitch (the solid circle symbol) into the top loop of the base chain.
Move up to the next row (green): chain 2. Continue around to the left of that chain making 17 hdc (two into each of the hdc of the previous row), then joining to the starting chain with a slip stitch.
… and so on until you get to the last row shown in the schematic (bright green). In this row notice you only make one hdc in each stitch of the previous row. Repeat this row until the hat is the desired length.

The diagram only increases to 63 stitches for a smaller hat. Add one more row of increasing for a larger hat.

By looking at the schematic you can see:

How the turning chain 2 of each row acts like an hdc in the pattern
Where each increase is made
- Each increase is made on the first stitch of the increase directly below it
The seam formed by the slip stitch and turning chain of each row

Notes on Pattern

To the beginner

This is a beginner-friendly pattern (which assumes you know or can look up the basics of chaining, slip stitches, and crochet stitches) except for the first two rounds. It starts off by putting 8 stitches through a single loop which gets quite crowded and can be very difficult to see what’s going on. Having an experienced crocheter on hand to help you get the hat started can save lots of frustration. Using a lightweight and light-colored yarn, a larger hook, and having good lighting will make these first rows easier.

Row 0: Chain 1

The first step is to attach the yarn to the hook with a slipknot. Maybe leave the loop formed by the slipknot a little loose rather than cinching it close to the hook in order to make the first row easier (this loop is where you’ll make the first 8 stitches). Then make one chain stitch, which will be the center of the top of the hat. You’ll make the first 8 stitches through that loop which, when joined, will form a circle. The next rows then work around that circle increasing its diameter for the crown of the hat.

If the tail end of the yarn is getting in your way, you can cut it short.

Alternatives for center loop

The first few rows are the most difficult because it is hard to see what is happening and where the next stitch is. The first row is especially difficult since you can lose track of the center loop before finishing the 8 stitches. Here are two alternative methods of beginning which give a bigger first loop to make all 8 initial stitches into so it is easier to work with.

Chain Loop

First chain five or six. Then slip stitch into the first chain you made to join into a ring. Then continue the pattern from Row 1. The difference is that you will make all 8 stitches in Row 1 into the center of the ring of chains you made instead of trying to do them all through a single chain stitch.

Base Adjustable Ring ("Magic Ring")

Another way to begin with a bigger base ring for making the first 8 stitches in is to make a loop of yarn, make all 8 stitches into it, and then pull to close the loop. The advantage is that it is easier to stitch the 8 first stitches into a large ring, and you can then pull the ring closed so that hat won’t have a big hole at the top.

Good written instructions for the magic ring can be found in this tutorial by Vivid Kreations. Both of these alternative methods are also demonstrated in many YouTube videos, such as this one by B.Hooked Crochet & Knitting:

Row 1: Chain 2, make 8 hdc in third chain from hook. Join. (9)

You are going to make 8 hdc stitches into the first chain you made (the one furthest from the hook), which you will then join together into a circle.

The chain 2 you make at the beginning of every row counts as an hdc stitch. Two chains equals the height of one half-double crochet stitch, and you will always chain 2 at the beginning of every row while increasing. So when you complete Row 1 you’ll have 9 stitches on the circumference: 8 hdc + the chain. You should be able to count 9 V-shaped stitches which you will work into on the next row.

Figure 2. The first row of 8 hdc joined to the initial turning chain. This little circle will become the top of the hat.

Half-Double Crochet (HDC)

The entire hat is made out of half-double crochet stitches which creates a slightly more dense (and warm) fabric than double crochet, but builds up faster than using single crochet:

Wrap the yarn over the hook towards your body. This is called yarn over (often abbreviated to yo in patterns). You should now have 2 loops on the hook.
Insert hook through the next stitch to be worked. For Row 1 this means to insert the hook through the center loop for all 8 hdc. For other rows, insert beneath both strands that form the V shape of the top of each stitch. (You can instead insert through the two strands to only pick up one of them; this will result in a more flexible fabric.)
Yarn over hook.
Use the tip of the hook to pull the yarn up through stitch. You should now have 3 loops on the hook.
Yarn over hook. You should now have 4 loops on the hook.
Pull the loop closest to the tip of the hook through all 3 other loops on hook. That completes the half-double stitch (you should be left with one loop on the hook, and you can start again into the next stitch to be worked).

Joining rows

At the end of each of the first 8 rows, join to the beginning of the row by making a slip stitch into the top loop of the turning chain you started the row with:

Insert the hook through the stitch (the top turning chain loop).
Yarn over.
Pull the yarn up through both the stitch and the loop already on the crochet hook. You should be left with a single loop on the crochet hook ready to chain.

When inserting the hook into the chain stitch, don’t just insert it in the space beneath the chain. That will result in a more-visible seam on the hat. Instead insert it beneath the V of the top loop of the chain like you do every other stitch.

After joining a row, you will begin a new row by chaining 2. The purpose of joining and chaining is to bring the next row to the proper height for a hdc without stretching the stitch. However, the line of join and turning chains is often visible as a seam-like line in the finished work. For that reason, after the increases in the crown of the hat have been completed this pattern no longer calls for joining and chaining between rows. Instead make the first stitch of the new row directly on the first stitch of the previous row. The distortion of an hdc directly spanning rows is minimal, and this allows creating the main part of the hat with no visible join seam.

Row 2: Chain 2, hdc in same stitch, 2 hdc in each remaining stitch. (18)

In this row we make two hdc stitches in each of the 9 stitches from Row 1, which doubles the size of the circle.

Remember, the chain 2 you do at the start of each row counts as an hdc stitch, so only make one actual hdc stitch into the same stitch you chained from (that’s why the pattern reads: chain 2, hdc in ‘same’ stitch)

Don’t worry, it gets easier to see what you’re doing and where to make stitches after this row.

Figure 3. The circle after round 2

Rows 3-7 Chain 2, hdc in same stitch, 1 hdc in next Row#-2 stitches, (2 hdc in next stitch, 1 hdc in next Row#-2 stitches) repeat to end of round. Join.

These rows uniformly increase the size of the circle. Working two hdc into the same stitch is called an ‘increase’ and effectively adds one stitch to the circumference of the hat. On each of Rows 3-8 you’ll increase 9 times.

Each of Rows 3-8 begins with a chain 2, which counts as an hdc, followed by an hdc in that same stitch. So every row begins with an increase. The remaining 8 increases are spread evenly around the row. On Row 3 you make a single hdc in the next stitch after each increase. On Row 4, you make a single hdc in the next ‘two’ stitches after each increase. And so on. So the number of hdc you make in each stitch around the hat follows this pattern (remember the first 2 consists of the chain + the first hdc):

Row 3	2, 1, 2, 1… 2, 1
Row 4	2, 1, 1, 2, 1, 1… 2, 1, 1
Row 5	2, 1, 1, 1, 2, 1, 1, 1… 2, 1, 1, 1
Row 6	2, 1, 1, 1, 1, 2, 1, 1, 1, 1… 2, 1, 1, 1, 1
Row 7	… and so on

Notice every row ends in a single hdc. That is a good way to test if you counted correctly for that row.

How do you know where to make the next increase if you lose count? Every increase is made exactly above the stitch formed by the increase made in the previous row. It is possible to examine the previous rows to find where to make the next increase. You can also count the stitches you’ve already made.

What if you don’t make the increase in the correct spot? It doesn’t really matter. You may end up with a slightly less round circle, or without exactly 72 stitches on the circumference, but it will probably not be noticeable.

If, however, you consistently make too many or too few increases, you’ll end up with a hat that is too big or too small.

For a smaller hat, stop increasing after row 7 and go on to Row 9. This gives a circumference of 63 stitches instead of 72.

Figure 4. Ready to join after Round 6

Row 8: Chain 2, hdc in same stitch, 1 hdc in next six stitches, (2 hdc in next stitch, 1 hdc in next six stitches) repeat to end of round. Do not join! (72)

This is the last increase row. When you get to the end of the row you should have 72 stitches on the outside of your circle. Do not join with a slip stitch; instead you will begin the next row with a hdc

Figure 5. Row 8 is complete, and the first stitch of Row 9 (an hdc and not a chain) has been made

Rows 9-end: Chain 2, hdc in the next and every stitch around. (72)

Now you’re done increasing. Keep crocheting a single hdc in each stitch all the way around each row until the hat has the length that you want. Try it on every now and then to see how it fits.

Figure 6. Making progress

Finish: Make last two stitches as sc to reduce the offset caused by the spiral. Cut yarn and pull through last stitch to secure.

Once the hat is long enough (I like it to cover my ears), finish off with a couple single crochet stitches which will create a less pronounced step between the last and second-to-last rounds.

Cut the yarn leaving a few inches and pull the end through the last loop on the hook. Pull to secure. To make it more secure, weave the end under a few strands on the inside of the hat and then trim it off.

Figure 7. Completed hat

Variations and Next

Try using this basic pattern as a platform for experimentation. Do the whole hat in double crochet. Switch yarn colors every few rounds to make a striped hat. Add a single crochet ribbed brim to the hat. Try adding non-increasing rows between the initial increasing rows to give the hat a longer shape.

The Warm Up America Foundation collects donated hand knit and chrochet items to distribute to people who need them.

Figure 8. Hat with double crochet brim

Figure 9. Hat with multiple yarn colors

Figure 10. Striped hat with knit rib. Made with a 6mm hook, I changed between two balls of yarn every row (brown and a variegated pink/grey). I stopped the hat once it was about 6" long and picked up the stitches on 5mm 16" circular knitting needles to knit the k1p1 ribbed brim.

Similar Patterns

Basic Men’s Beanie Free Pattern Workshop by Deja Joy - basically the same pattern; designd for a bigger hook so works up even faster.
Easy Breezy Beginner’s Crochet Beanie by Bonnie Barker
Seamless Double-Crochet Hat with the Invisible Join Method

1. Half-double crochet instructions w/photos: https://web.archive.org/web/20120415065415/http://renee-blixt.suite101.com/the-half-double-crochet-stitch-a40770

2. http://crochet.about.com/od/learnbasics/qt/slst.htm