1. 10

What are you doing this week? Feel free to share!

Keep in mind it’s OK to do nothing at all, too.

  1. 7

    Staring into the gaping void of an empty “New Post” form for my blog until it stares back or I pass out from exhaustion.

    1. 2

      If you need inspiration: I’d love to read something from you about how to safely use the Argon2 family to derive a range of keys for different uses from a password. Reading some of the docs, it’s difficult to tell if it’s fine to just use a different salt, if the salt needs to be non-guessable, or if I should generate a single key and then use a KDF for deriving separate keys (and, if so, are there any other things that I should worry about when using a KDF with the output from a password hash function).

      1. 2

        The okta hack might be a nice topic for inspiration ;)

        1. 1

          Hope it stares back with intent! Love reading your stuff.

        2. 3

          Finishing up work where I’m currently employed, preparing for my new place of employment. That’s gonna be most of it, really. Not-work-wise, snow’s been melting a lot, so probably a good deal of cleaning up on the yard.

          1. 2

            Not langdev. Think I’m rather burned out. I heckin’ hate type checking so much. Anyone want to write a pragmatic and functional type checker for me, including generics, and let me get on with life to the actually interesting part of the project?

            Maybe I’ll play with my OS project instead. It’ll never be useful and involves exactly zero theoretical math, which sounds exactly like what I need.

            1. 1

              Naive question: why is writing a type checking algorithm so difficult?

              1. 2

                It’s not. In theory. But nobody tells you how to do it. The only tutorials, examples, books etc come in one of three forms:

                • Too concrete (no generics, no subtyping, basically just integers and bools and maybe strings)
                • Too abstract (“here is how you implement simply typed lambda calculus, ok up to you to go from here”)
                • Demonic math

                I’m really sick of trying to deal with any/all of them, synthesize them into something small but sane and functional, and generally banging my head against a wall over and over.

                1. 1

                  As a casual consumer of adjacent literature this rings true to me. Especially the demonic math. I feel somehow deficient that I can’t decipher the mad scribblings that I see in a lambda cube article. I get the impression that this would be very clear and really just self evident if I had the proper education, except I don’t know what that education is, where to get it (without paying 5 or 6 figures) or how long it would take to get. What’s more, some arrogant part of me feels like I should be able to create some amazing programming language because really I’m so smart (you know except the whole not knowing how thing).

                  Your language also has a linear component too, right? I imagine that only compounds the wonderfully under specified nature of the whole ordeal.

                  1. 2

                    You might be interested in my book, A Programmer’s Introduction to Mathematics (pimbook.org, ebook is free), which doesn’t focus specifically on type checking systems, but does cover math, notation, and proofs more generally. That said, I do sense that languages folks (type systems, functional programming, etc.) go a bit haywire on the notation as compared to a typical mathematician.

                    1. 2

                      …except I don’t know what that education is, where to get it (without paying 5 or 6 figures) or how long it would take to get…

                      It’s doable. You just start reading and talking to people about it. There are plenty of people on the r/ProgrammingLanguages discord server that will happily tell you way more than you ever wanted to know about any of it, and a couple guides that are widely cited such as http://siek.blogspot.com/2012/07/crash-course-on-notation-in-programming.html and https://blog.acolyer.org/2018/01/26/a-practitioners-guide-to-reading-programming-languages-papers/. As for “how long it would take to get”, well, same as learning to program itself I expect. You can get functionally familiar with it in a few months, and getting good enough to really understand all the nuances will take a lifetime. But unless you’re doing fancy research you probably don’t need all the nuances, just the ability to follow others’ nuances.

                      Of course, I haven’t done this. As you said, “some arrogant part of me feels like I should be able to create…” I keep thinking I know enough already and trying to take short cuts.

                      Your language also has a linear component too, right?

                      If you’re referring to my effect-system-ish ideas, I’m not even that far yet, and I don’t want it to be that complicated. All I really want out of it is to be able to annotate functions with useful constraints (“does not panic”, “does not allocate”, etc) and have the compiler able to check/enforce them for me. That seems like it should be pretty straightforward, since I don’t really intend much composition or metaprogramming or such. Then either that will be good enough for what I want, or I will need to learn more and elaborate it. Either way, not my main concern right now.

              2. 2

                Work: Third week of the new job. Still getting up to speed with the domain knowledge, but it’s good to be contributing code.

                Fun: On Thursday I switched over from Pi-hole to a caching & recursive resolving DNS server I wrote myself. Other than a bug where it couldn’t resolve hostnames where Cloudflare is the authoritative nameserver (turns out Cloudflare just ignores queries where the RA flag is set - doesn’t even return an error response), it’s working pretty well! So I’ll gradually be working through more RFCs, getting something more fully-featured - though I could just stop now and this would already be more than good enough.

                1. 2

                  Drafting a new blogpost about chosing a platform to deploy static websites. Been thinking about it a lot lately, should I use simple git-hooks, GitHub Actions, GitLab Pipelines, simple scp/rsync routines.

                  1. 1

                    If it’s completely static, GitHub pages make this very easy. You can either use their hosted Jekyll install and just push, or you can set up a GitHub action that pushes the output of merges to the main branch to a specific branch that contains the web site.

                    1. 1

                      I vote scp/rsync.

                    2. 1


                      We’re involving a lot of different subteams to help us figure out how new features should arrive at the frontpage of our newspaper. A lot of coordination.


                      I just implemented Derw -> English generation. I was thinking about how other MLs have failed to pick up mainstream adoption. Part of the reason, I think, is the syntax and data structures being so wildly different from mainstream languages like JS. Types on a different lines from the argument names, we work with list manipulation, etc. So the idea is that you could take any function, generate the English version, and see what the compiler thinks the code is trying to do, in English.

                      Now I’m working on the language-server

                      1. 2

                        The concept of a language strangeness budget might be useful to you, if you’re not familiar with it already.

                        otoh, that language works perfectly fine to me. Considering the popularity of Elm I don’t think there’s anything fundamental wrong with ML-y languages, it’s a matter of tooling and use case. AFAICT Elm itself is a good example of how the meta-features around the language (stability and FFI support, in its case) can make or break it.

                      2. 1

                        So far:

                        For $CLIENT1:

                        • 90% of a feature request for $CLIENT1

                        For $CLIENT2:

                        • Recreating an entire zone file because someone in a marketing department decided on a whim to change the NS records for a domain, and Cloudflare auto-purges domains that aren’t “active”.

                        The rest of the week:

                        For $CLIENT1:

                        • The final 10% of the feature
                        • Adding another payment gateway

                        For $COMPANY:

                        • Yet more work on the deployment tool

                        For $HOME:

                        • Hopefully getting the first exterior wall of the new kitchen mostly sealed and painted.
                        1. 1

                          Well, at work we are approaching the soft launch of our product. So… speeding to get certain features done, clean some things up in our Terraform code and really trying to focus on those breathing exercises lol. So it goes.

                          1. 1

                            Work: This week I’m learning about toolchains that compile to wasm, and writing a blog post, but currently got a mental block on the blog post.

                            Fun: Lately I’ve been learning zig. The last thing I wrote for a little project was a generic iterator for reverse iterating a slice, to simplify stepping through a slice to visit every second element, which I found somewhat tedious to code without an iterator using a while loop with unsigned integers being the norm for array size and indexing. I think I finally have a better understanding of how to write generic types, and how arrays, slices, and pointers interact and coerce.