Happy Friday {rmdocs} now handles namespaced::symbols #rstats
If you run the addin with the cursor on withr::with_options you’ll get served some delicious Rmd help for that function, even if you had rlang::with_options masking it via library(rlang).
This week I cracked a problem that I’d been stewing on for a while: Fast generation of renv.lock files.
For those not in the know: These fully describe an R project’s package dependencies and can be used to create a “known good” package environment for the project to run in. You should definitely be using these! Typically these are created with {renv}.
I set myself a budget of 3 seconds to:
{renv}My thinking was that this amount of time is short enough to facilitate new workflows involving always-on automated lockfile generation. So instead of lockfile creation being a kind of manual discipline that is done interactively, it can become something that just automatically happens everytime you build a pipeline with {targets} or render a document with {rmarkdown}.
And that means people won’t forget to do it before they go on holiday, Murhpy’s law etc etc.
The generation time has to be really short because during the iteration cycle of an analysis you’re typically building a pipeline many many times in a single day. You may be adding or removing dependencies each time. Time spent waiting for things to build can rapidly become annoying, and that annoyance inspires hacks that undermine everything.
Anyway I’m happy to report success. capsule::capshot() can tick all the items I listed off in 1.5 - 2 seconds on my current project which is quite mature and laden with dependencies (~ 200 recursive deps). You give it paths to files containing your dependencies (typically a single file for me), and you get back a lockfile, built against the current .libPaths().
So you’ve likely never heard of {capsule} (although it does have its fans). It’s a kind of reimagining of the {renv} workflow for my team. It actually uses {renv} under the hood. The main point of difference is that it’s a lazy workflow. You don’t typically work out of a local library. You do that only when picking something up that’s been on the shelf for a long time, or putting something “into production” - i.e. running unsupervised somewhere.
The laziness has several advantages: You get no interaction with personal dev setups. RStudio, VSCode, Emacs, Addin packages etc… none of that needs to go anywhere near the lockfile. It’s also an easy sell. There’s 2 commands you absolutely need to know and they have obvious names: capsule::create() and capsule::run().
Some cool opportunities get opened up by the always-make-a-lockfile workflow. If we’re doing that, hopefully, we’re always committing it, and so it can become a mechanism to help nudge team-mates to keep their R libraries moving forward in step.
For example, your lockfile target could pass on building a new lockfile that would contain versions behind the current one, and send a warning to update pacakges. There’s actually machinery already in {capsule} for that, although I am still settling on the best design. I am excited to get a feel for the best practice for this kind of stuff over the next few weeks!
Due to one of my current projects, R developers have been sharing their frustrations with CRAN with me. There are many distrubing aspects to these stories, but one that is on loop in my brain at the moment is the systemic degradation CRAN policies are creating.
I think this degradation is slow and doesn’t impact too much on functionality, so it will be hard to spot at first. If there is a trend though, over time its corrosive nature will become sorely apparent. This is because developers have confessed to:
\donttest.It’s kind of sad to imagine what the cumulative effect looks like of developers being nudged away from creating thoroughly tested works with rich interconnected explanatory documentation. To me, it’s just an odd situation to be in: where R itself contains excellent tools for this, but our package infrastructure is having a potentially out-sized influence on the utilisation of those tools.
l33t Data scientists can write #julialang to write R. They can write #haskell to write R. They can write #clojure to write R. For a long time many have been writing a half-baked version of #rstats ported to #python. Life’s a bit simpler if you Just. Write. R. Though?
Just say no to !important
Subtweeting an out of control hairy yak that has raised 2 gh issues, 1 stack overflow question, and 1 package update, and eaten most of my day.
Becasuse of GitHub I am not that used to thinking of git as a peer to peer decentralised version control system - despite the fact I know this theoretically. An upshot of this property that any folder that you have access to can act as a remote.
This came in handy today, rigging up a way to deploy code to a server that has very limited connectivity to the outside world.
First I copied my local copy over to the server.
Then on my workstation I added the folder as a remote:
git remote add prod \\analytics\blah\project_name
Then I can fetch that remote to get the branch metadata:
git fetch prod
after which I can push to it
git push prod
Well sort of. Initally I got this error:
git push prod
Enumerating objects: 18, done.
Counting objects: 100% (18/18), done.
Delta compression using up to 8 threads
Compressing objects: 100% (10/10), done.
Writing objects: 100% (11/11), 1.37 KiB | 467.00 KiB/s, done.
Total 11 (delta 6), reused 0 (delta 0), pack-reused 0
remote: Checking connectivity: 11, done.
remote: error: refusing to update checked out branch: refs/heads/main
remote: error: By default, updating the current branch in a non-bare repository
remote: is denied, because it will make the index and work tree inconsistent
remote: with what you pushed, and will require 'git reset --hard' to match
remote: the work tree to HEAD.
remote:
remote: You can set the 'receive.denyCurrentBranch' configuration variable
remote: to 'ignore' or 'warn' in the remote repository to allow pushing into
remote: its current branch; however, this is not recommended unless you
remote: arranged to update its work tree to match what you pushed in some
remote: other way.
remote:
remote: To squelch this message and still keep the default behaviour, set
remote: 'receive.denyCurrentBranch' configuration variable to 'refuse'.
To \\analytics\blah\project_name
! [remote rejected] main -> main (branch is currently checked out)
error: failed to push some refs to '\\analytics\blah\project_name
Git refused to accept my commits. The issue it is warning me about is that if I did push commits onto the main branch, the HEAD pointer in the copy on the server is not updated. So it would need to be updated by running git reset in the server’s copy.
This can be fixed by running this command on my local machine:
git config --global receive.denyCurrentBranch "updateInstead"
So now when I try to push commits onto the current branch in the server’s copy it will automatically update the HEAD, provided there is no other uncommited changes hanging out in the working tree. RAD.
So when @github Copilot drops a line of code into my project it’s also going to drop in 200 million LICENSE files and attributions right? RIGHT?
We have access to Pfizer vaccine at my work. I reckon you could draw a line through the department separating who’s vaxxed and who’s ‘gonna do it soon’ by asking ‘Can you describe an expontential function?’.
My review of the ZSA Moonlander Ergonomic Keyboard: www.milesmcbain.com/posts/zsa…
Another riff on the placeholder idea with |>:
library(dplyr)
#>
#> Attaching package: 'dplyr'
#> The following objects are masked from 'package:stats':
#>
#> filter, lag
#> The following objects are masked from 'package:base':
#>
#> intersect, setdiff, setequal, union
. <- function(.dat, template){
template_code <- deparse(substitute(template))
arg <- deparse(substitute(.dat))
interpolated_code <- gsub("(?<=[(, ])?[.](?=[), \\[])", arg, template_code, perl = TRUE)
eval(parse( text = interpolated_code))
}
"a" |>
.(c(., "b")) |>
.(setNames(., .))
#> a b
#> "a" "b"
mtcars |>
transform(kmL = mpg / 2.35) |>
.(lm(kmL ~ hp, data = .))
#>
#> Call:
#> lm(formula = kmL ~ hp, data = transform(mtcars, kmL = mpg/2.35))
#>
#> Coefficients:
#> (Intercept) hp
#> 12.80803 -0.02903
"col_name" |>
.(mutate(mtcars, . = "cool")) |>
.(bind_cols(., .)) |>
.(.[1, ])
#> New names:
#> * mpg -> mpg...1
#> * cyl -> cyl...2
#> * disp -> disp...3
#> * hp -> hp...4
#> * drat -> drat...5
#> * ...
#> mpg...1 cyl...2 disp...3 hp...4 drat...5 wt...6 qsec...7 vs...8
#> Mazda RX4 21 6 160 110 3.9 2.62 16.46 0
#> am...9 gear...10 carb...11 col_name...12 mpg...13 cyl...14 disp...15
#> Mazda RX4 1 4 4 cool 21 6 160
#> hp...16 drat...17 wt...18 qsec...19 vs...20 am...21 gear...22
#> Mazda RX4 110 3.9 2.62 16.46 0 1 4
#> carb...23 col_name...24
#> Mazda RX4 4 cool
Created on 2021-06-24 by the reprex package (v2.0.0)
I call . the ‘neutering’ function.
The dog’s balls pattern is a thing. I didn’t name it.
This is the pattern:
mtcars |>
transform(kmL = mpg / 2.35) |>
( \(df)
lm(kmL ~ hp, data = df)
)()
Copy pasta from this tweet.
Noisy syntax involving parentheses, including a werid empty pair hanging out in the breeze at the end. The easiest thing for beginners anyone to forget or accidentally unbalance.
So rather than reinvent the wheel, let’s take a quick look at how other programming languages with pipes have solved this issue.
Well there’s the Hack pipe and it uses a $$ placeholder to allow the user to set the position without making a lambda:
$x = vec[2,1,3]
|> Vec\map($$, $a ==> $a * $a)
|> Vec\sort($$);
But Hack? That’s a bit obscure.
What about Julia? Something more data sciencey and close to home. Well Julia uses a @pipe macro to, you guessed it, let the user deploy a placeholder to the arg position to be piped to:
@pipe a |> addX(_,6) + divY(4,_) |> println # 10.0
This macro theme is repeated in other languages. Checkout Clojure, it has so many pipes: -> pipe to first, ->> pipe to last, and ofcourse, as-> pipe to placeholder.
Okay so I am just cherry-picking examples. But the placeholder or placeholder/macro combination is a solution with precedent to the problem of how to pipe into an argument other than the first.
So let’s think now about R. We don’t have macros. Game over? No. R’s famed syntax malleability via lazy evaluation and syntax tree operations is how we get that kind of stuff done.
To fix Dog’s balls we’d be looking at some kind of function that manipulates the syntax tree. That is to say, it can turn:
a |> b(x, _) into a |> b(x, a)
Clearly, it needs to know about the symbols a and b(x, _) so it has to be an infix operator. Something like:
a %|>% b(x, _)
Where the %|>% function’s job is to rewrite the syntax tree by replacing any _ in the tree on its right-hand side, with the thing on its left-hand side. Easy done? Well, there is a recursion issue. It needs to rewrite:
a %|>% b(x, _) %|>% c(y, _) into c(y, b(x, a)) but details details.
I do think we can probably shave down some characters…. maybe drop the |? Still keeps the forward idea going.
And how do we feel about _… a bit Pearl-ish… maybe ? hmmm no that doesn’t inspire confidence… . ahhhh brief but firm - I like it. Putting it all together we have our new pipe:
a %>% b(x, .)
Now, I already know what you’re going to say, “This is not a pipe”.
With VSCode you can configure a keybinding to run artibrary #rstats code, including {rstudioapi} calls in just a matter of seconds. That code can refer to things like the current selection, cursor location, or the current file.
For example here’s me making myself a knit button, where the placeholder $$ refers to the current file:
{
"description": "knit to html",
"key": "ctrl+i",
"command": "r.runCommandWithEditorPath",
"when": "editorTextFocus",
"args": "rmarkdown::render(\"$$\", output_format = rmarkdown::html_document(), output_dir = \".\", clean = TRUE)"
}
And here’s a shortcut that opens a window to interactively edit the spatial object the user has the cursor on or has selected. In this case $$ refers to that object:
{
"key": "e",
"name": "mapedit object",
"type": "command",
"command": "r.runCommandWithSelectionOrWord",
"args": "mapedit::editMap(mapview::mapview($$))"
}
Snippets are also easy. There’s about 3 different ways to achieve inserting text, all in the same simple json config style:
{
"key": "ctrl+shift+m",
"command": "type",
"when": "editorLangId == r || editorLangId == rmd && editorTextFocus",
"args": { "text": " %>% " }
}
Although RStudio addins are supported in VSCode, many things popular addins do can be done with a few lines of config. It’s a keyboard shortcut lover’s dream - I’d argue even more so than ESS. RStudio users should campaign for this!
Here’s a little thing I was noodling with today. A drop in replacement for help() that pulls up the help file as an RMardkown document in your editor pane, not some weird special web browser window off to one side.
It’s reminiscent of the way help works in ESS/Emacs:
https://github.com/MilesMcBain/rmdocs
rmdocs
The advantages are:
On the downside:
It would be possible to bring it on par with ESS, but it would take a bit of work on the VSCode side, and then the VSCode-R extension would have 2 modes to view help in. Is this a good thing? I am not sure. I think this is probably good enough to fill the aching void in my setup.
With just little more work it could be used as a keyboard shortcut in RStudio as well.
For the benefit of my future self and other lovers of #rstats debugging:
Kevin Ushey just shared an incredible little trick with me that I am still reeling from in this issue thread.
You can use it to get a stack trace for code that is getting stuck in infinite loops or just generally taking a really long time. You can use that stack trace to see where in the code execution flow is getting bogged down.
I was there hacking in timing code and print statements (aka banging rocks together) when Kevin dropped this construct:
withCallingHandlers({
..YOUR SLOW CODE HERE..
}, interrupt = function(e) browser())
Here’s an example of it working:
[ins] r$> my_bad <- function() {
while(TRUE) {
lapply(letters, I)
}
}
withCallingHandlers({
my_bad()
}, interrupt = function(e) browser())
Called from: (function(e) browser())(list())
[ins] Browse[1]> traceback()
7: unique.default(c("AsIs", oldClass(x)))
6: unique(c("AsIs", oldClass(x)))
5: structure(x, class = unique(c("AsIs", oldClass(x))))
4: FUN(X[[i]], ...)
3: lapply(letters, I) at #3
2: my_bad() at #2
1: withCallingHandlers({
my_bad()
}, interrupt = function(e) browser())
So when I interrupted the code running in the console with CTRL+C, I was kicked into browse mode, and from there I could call traceback()!
I am still trying to figure out how to wield this new power. It seems that depending on where you interrupt it, you may or may not have traceback available. But if the stack trace is available are the environment frames?!
Noodling around with the idea I came up with this, which seemed to work consistently:
withCallingHandlers({
my_bad()
}, interrupt = function(e) traceback())
Sweeet!
There’s also a more powerful version that Kevin shared down the thread that allows resuming. That trapped me in a bit of a loop of my own, but that’s what you get when you play with MAGIC.
Luke Tierney (Gandalf level wizard), chimed in with some info that this trick can be pulled off with:
options(interrupt = browser)
Wow!
But then that lead me to try:
options(interrupt = recover)
Which is epic!
In case you don’t know about recover you REALLY should have a go with it. It’s pretty special. So special I made a video about it: https://youtu.be/M5n_2jmdJ_8 .
A mature debate was had about whether #rstats’ new |> requires the use of “dog’s balls”, ()(), for lambdas with \(). Sadly it does. But it’s still kind of cool, and if you want to feel extra thankful for our benevolent overlords you could take a walk through the smouldering ashes of the JS native pipe train wreck: github.com/tc39/prop…
Last week I hit a spot of bother trying to test against R-devel using Rhub. The issue is now fixed but it was blocking all builds against R-devel for a few days.
While that was being resolved I decided to try using VSCode’s docker integration to test against the Rocker R-devel container locally. This turned out to be quite easy! So here’s how you can test locally against any R version that has a tagged Rocker Docker container version!
To pull this off you’ll need:
Click the little stylised >< icon in the bottom left corner. It’s bright purple in my screenshots. It will open the remote development menu. Choose Remote Containers: Reopen in container:
From the next menu you will be offered some default containers for Linux distributions. If you choose Show all definitions…, You will be offered R (community) - choose it!
This starts the process of reopening your project in the container. You will have to wait for the container to download. This took a few minutes for me.
Your project should have opened in the rocker/r-ver:latest container. If you open an R terminal you should be able to confirm that R is the latest release version. This is pretty sweet, but what we want is to be running against rocker/r-ver:devel.
To configure this we have to alter some files VSCode has placed in your project directory. You will have a new folder called .devcontainer under the project root:
.
├── .Rbuildignore
├── .devcontainer
│ ├── Dockerfile
│ ├── devcontainer.json
│ └── library-scripts
│ └── common-debian.sh
We need to make a small change to Dockerfile and devcontainer.json.
In Dockerfile, change the line right at the start that has:
ARG VARIANT="latest"
to
ARG VARIANT
The hardcoding of “latest” stops us being able to set it in the devcontainer.json.
Now in devcontainer.json, change this bit of JSON that has:
{
"name": "R (Community)",
"build": {
"dockerfile": "Dockerfile",
// Update VARIANT to pick a specific R version: latest, ... ,4.0.1 , 4.0.0
"args": { "VARIANT": "latest" }
}
to
{
"name": "R (Community)",
"build": {
"dockerfile": "Dockerfile",
// Update VARIANT to pick a specific R version: latest, ... ,4.0.1 , 4.0.0
"args": { "VARIANT": "devel" }
}
Make sure both of those are saved.
Using the stylised >< icon in the bottom left corner access the remote development menu and choose: Remote Containers: Rebuild container
The container will now rebuild via much the same process as step 3.
Now when the project opens you can open an R terminal and run version to confirm you’re running against devel:
And that’s it. Now you can run devtools::test() and check() againt R-devel.
We could also go back to previous releases with this method by setting other tags in the devcontainer.json see available tags on the r-ver container here - they go back to around 3.2!
Using the remote development menu (><) we can flip back to our local R environment by choosing Remote Containers: Reopen Locally.
After the container versions have been downloaded the first time, flipping back and forth between local and container environments via >< takes just a couple of seconds!
#rstats tip: Use R-universe to harden yourself against CRAN irrationality. Here’s me installing {targets}, which is currently archived for nonsensical reasons.
Hey friends I’ve been off Twitter now for 34 days. I feel great. More focussed, greater attention span, happier.
These are syndicated posts coming from my micro.blog account.
I am tracking some #rstats Twitter stuff via RSS. But I’m not checking DMs. I’m open to chat via email or Slack spaces we share.
I spent the last few nights polishing up a new submission for CRAN. I had planned to submit today. However I learned someone I greatly respect, whom I know to be almost certainly the most responsive and generous package maintainer in the #rstats community, has become the latest victim of CRAN irrationality and toxicity. I am sure he didn’t deserve to have his weekend ruined because one seemingly rogue administrator can elect to punish people without any accountabilty.
And what about the bystanders who are going to attend work tomorrow and find their builds are no longer reproducible, because a keystone package was archived? Do they deserve that punishment too?
I am withholding my submission for now. I am not sure what to do. I don’t want to enable this behaviour, but I also want to make a tool I am enjoying as accessible as possible. A lot of thoughts are swirling about this. There’s more to write with a cooler head.
Recently I mapped out our #rstats centric public service data science stack for runapp. Here’s some words on the collaboration blob: www.milesmcbain.com/posts/the…
the_stack.png
Talking about this to my R-nerd friends in the R Users Network: Australian Public Policy (Runapp) this week. runapp-aus.github.io
#rstats work project dependency usage over the last 2 and a bit years
Unsung dev heroes miss out like: styler, mapview, lintr, languageserver, mapedit et. al.
This moment had me reflecting on the etymology of the word “parking’.
This $3k rig is standing in for a second car for us. Day care and shopping runs are no sweat. And the kids love it!
#Brisbane PSA: the best day to hit your local supermarket is the day after lockdown, once all the preppers have stopped thronging in the aisles.