Programming Leftovers

posted by Roy Schestowitz on Nov 09, 2023

• Hackaday ☛ 50-Year-Old Program Gets Speed Boost

  At first glance, getting a computer program to run faster than the first electronic computers might seem trivial. After all, most of us carry enormously powerful processors in our pockets every day as if that’s normal. But [Mark] isn’t trying to beat computers like the ENIAC with a mobile ARM processor or other modern device. He’s now programming with the successor to the original Intel integrated circuit processor, the 4040, but beating the ENIAC is still little more complicated than you might think with a processor from 1974.

• Jonathan Dowland ☛ Jonathan Dowland: gitsigns (useful neovim plugins)

  gitsigns is a Neovim plugin which adds a wonderfully subtle colour annotation in the left-hand gutter to reflect changes in the buffer since the last git commit¹.

  My long-term habit with Vim and Git is to frequently background Vim (^Z) to invoke the git command directly and then foreground Vim again (fg). Over the last few years I've been trying more and more to call vim-fugitive from within Vim instead. (I still do rebases and most merges the old-fashioned way). For the most part Gitsigns is a nice passive addition to that, but it can also do a lot of useful things that Fugitive also does. Previewing changed hunks in a little floating window, in particular when resolving an awkward merge conflict, is very handy.

• Qt ☛ Qt Safe Renderer 2.1.0 Beta2 Released

  We have released Qt Safe Renderer 2.1.0 Beta2 for commercial license holders today. It provides snapshot of the following QSR 2.1.0 features:

• Idiomdrottning ☛ Local repo copies

  It’s just that if you don’t know that you can “clone” locally easily by just copying the folder, or get a fresh copy by recloning into another directory, you might be missing out, especially for new git users.

• Sumana Harihareswara ☛ Set Contributor Expectations To Reduce Ghosting

  And so a lot of open source contributors seem to react accordingly, especially if they're new to the project. The more days they have to wait, the greater the chance that they will assume rejection and mentally move on. Some data: the 2014 study "Measuring Engagement: Recommendations from Audit and Analytics" by David Eaves, Adam Lofting, Pierros Papadeas, Peter Loewen of Mozilla, particularly pp. 18, 20 and 26-29 of the slide deck. (Wayback machine capture of context from Mozilla's now-defunct wiki.) Their analysis: [...]

• Alexandru Nedelcu ☛ In Scala 3, Use 4 Spaces for Indentation

  Scala’s coding style advised to use 2 spaces of indentation, but that was before Scala 3’s optional braces, which introduces significant indentation. It’s time for an upgrade of the coding style.

• Yoshua Wuyts ☛ Iterator as an Alias

  This is another short post covering another short idea: I want to explain the mechanics required to make Iterator an alias for the Coroutine trait. Making that an alias is something Eric Holk brought up yesterday. We then talked it through and mutually decided it probably wasn't practical. But I thought about it some more today, and I might have just figured out a way we could make work? In this post I want to briefly sketch what that could look like.

  ⚠️ DISCLAIMER: I'm making up a ridiculous amount of syntax in this post. None of this is meant to be interpreted as a concrete proposal. This is just me riffing on an idea; which is a very different flavor from some of my multi-month research posts. Please treat this post for what it is: a way to share potentially interesting ideas in the open. ⚠️

• Bruce Schneier ☛ Decoupling for Security

  Here’s the gist. The less someone knows, the less they can put you and your data at risk. In security this is called Least Privilege. The decoupling principle applies that idea to cloud services by making sure systems know as little as possible while doing their jobs. It states that we gain security and privacy by separating private data that today is unnecessarily concentrated.

  To unpack that a bit, consider the three primary modes for working with our data as we use cloud services: data in motion, data at rest, and data in use. We should decouple them all.

• Bruce Schneier ☛ Decoupling for Security: Decoupling our identities from our data and actions could safeguard our secrets

  We’re all hoping that companies will keep us safe, but it’s increasingly clear that they don’t, can’t, and won’t. We should stop expecting them to.

  Our message is simple: it is possible to get the best of both worlds. We can and should get the benefits of the cloud while taking security back into our own hands. Here we outline a strategy for doing that.

• Rlang ☛ Grouped Sequences in dplyr Part 2

  I just wrote a post about grouped sequences in dplyr and following that, I’ve been made aware of another couple of solutions to this problem (credit John Mackintosh). The solution involves using the consecutive_id() function, available in dplyr since v1.1.0. In the help page for this function, it’s mentioned that it was inspired by rleid() function from the data.table package. These functions work similarly to the rle() function I used last time (in what I called ‘the complicated solution’) but provide neater outputs. I’ll try them both out here.

• Idiomdrottning ☛ Automatic commit message formatting

  For just jamming off tiny drive-by changes in a git repo, I often don’t bother whipping out magit and instead use a couple of shell scripts and they take a commit message right there on the command line.

  Today I finally modded them to also jam that commit message through

  sed 's/\. */\n\n/'|fmt -w 72

• Juha-Matti Santala ☛ Done is the engine of more

  I think “Done is the engine of more” is a more powerful version of the “perfect is the enemy of done”. You can always argue with the quality and where to draw the line but rephrasing it as a tool that allows you to create more is a brilliant way to say it.

  Essentially it comes down to a couple of reasons: [...]

• Yoshua Wuyts ☛ What is a team?

  This is going to be an ultra-short post to share an idea I've been mulling over in my head for a while. Yesterday I raised the question again about WG Async getting checkboxes for approval on decisions. For the past five or so years we've had a version of the async working group driving the design of async Rust. With the past three years being a lot more organized, with a steady roster, leadership, and mandate. WG Async getting the ability to set checkboxes for approval would mostly just be a formalization of the existing role we play in the project.