Threads for gpanders

  1. 4

    I tried to do something like this but I eventually caved and paid the Apple Tax.

    1. 2

      Same. And thus far I am very happy with the arrangement.

      $3/mo for 200 GB of storage that I can share with my family. Even taking ludicrous amounts of pictures of our kids, we have not come even close to hitting that limit.

      I don’t have to worry about creating, managing, or maintaining backups. And every photo I take is immediately and transparently backed up and synced to all my devices.

      Forgive me for sounding like a fanboy, but my experience with iCloud storage has been very positive.

      1. 3

        We’re already at the 200GB limit and I don’t think it would take long to hit the 2TB limit if we upgraded. I really just wish they would let me bring my own storage because otherwise my experiences with iCloud have been very positive.

    1. 4

      Fantastic work! Although I’m rather disappointed by the changes to make a _ = unused_var a compile-time error in the name of clarity (this is on top of making unused variables a fatal error in Zig 0.8), I’m excited to see the development of the stage2 compiler and look forward to the completion of async, when I’ll be able to migrate a few of my projects over. I’m especially licking my lips over the planned for (0..100) {} range syntax, which will make iterating over matrices and such much more ergonomic.

      Which is why I’m curious when Zig 0.10.1 will be released. I’m assuming it’ll be at the end of the next 6-month period in April, give or take a few weeks; is this correct?

      1. 7

        Although I’m rather disappointed by the changes to make a _ = unused_var a compile-time error in the name of clarity

        This is apparently a controversial subject (as anyone who follows Zig development knows), but I feel the exact opposite: with this change, as a reader of Zig code, when I see _ = unused_var; I know that unused_var is actually unused, and I no longer need to mentally keep track of that variable as I read through the code.

        1. 2

          Generally bugfix releases such as 0.10.1 are released as soon as all the issues in the milestone are completed: https://github.com/ziglang/zig/milestone/18

        1. 13

          I love Ned, but he’s an American, and it shows.

          He finds not tipping horrifying, but doesn’t seem acknowledge the horror of a system that allows waiters to be paid misery wages and starve without tips [^1].

          He finds regrettable that companies enjoy the benefits of opensource and free software often without giving anything back, but can’t seem to imagine any other way of fixing this than maybe shaming corporations into niceness.

          Keeping to the analogy, even with wider societal pressure to tip, waiters are still getting a bad deal: abuse from clients and from bosses, uncertain income, ungodly shifts, often no rights or benefits. I see absolutely no reason to think that it would be any different if the same model was applied to opensource. In fact, some of it already happens, with maintainers often burning out from the unreasonable expections put on them.

          The truth is that any solution to a problem that essentially amounts to the tragedy of the commons necessarily requires something that is anathema for a lot of people, and, in my granted, limited, experience, specially Americans: more government regulation and socialist principles, less free market and capitalism [^2].

          [^1]: to be fair, he might acknowledge this as a matter of personal view, but that’s not what he showed in the article.

          [^2]: yes, there are examples of people self-organizing to overcome this without government regulations, but not on a scale like opensource.

          1. 2

            He finds not tipping horrifying, but doesn’t seem acknowledge the horror of a system that allows waiters to be paid misery wages and starve without tips

            I cannot speak for the author, but I can tell you that many Americans do recognize and acknowledge that it’s an unfair system, but there’s little to be done about it without legislation that forces restaurants to pay their servers a real wage. If you take a “principled” stance and refuse to tip, you are only hurting the (already underpaid) server.

            It’s unfortunate that the practice of tipping seems to be becoming more commonplace, not less. I am asked to tip on almost every food-related transaction, even if I am just buying a cup of coffee or picking up a take out order. But again, being “principled” just ends up hurting someone who makes less money than me. It’s a bad situation with no clear solution in sight.

            1. 4

              Don’t get me wrong, I am in no way advocating for not tipping. The vast majority of us (as in, people in this site) are probably way closer to waiters than to the rich, so we should be solidary.

              But I feel that this is one of those things that has to be brought often, annoyingly often, if need be, or it will never change.

              Update: also, there’s a very clear solution, and you mentioned it yourself: legislation. It’s a shame that it is so fucking hard to pass it in the US, apparently, but the answer is there. But at the end of the day, it’s the people that make the rules, the whole country was supposed founded on that principle.

              1. 1

                I’m not convinced that is such a clear solution. First there’s the obvious difficulty of actually passing it, as you mention. But even beyond that, what is the right legislation? There are some obvious low-hanging fruit like repealing tip credit laws, but that would still just mitigate some of the worst parts of the system, not actually eliminate it.

                My sticking point on this is the question, “Where’s the example of a similar industry that has done better?” I struggle to think of one that doesn’t suffer some or all of: offering fewer jobs, fewer locations, higher barriers to entry, greater physical demands/dangers, inflexible working hours,or paying no more than minimum wage. We could certainly choose to eliminate tipping by legislative decree, but until you answer that question, I think it’s disingenuous to not also be clear that realistically that also means reducing the pay of a great many people who are already not making a huge amount of money. Are they the ones who should be made to sacrifice for the greater good of a “better” system?

                1. 5

                  The solution is to have a minimum wage that does not vary by industry and is high enough to not starve.

                  Or any min wage alternative like UBI, take your pick.

                  1. 2

                    I don’t disagree, but why are we fixating on tipping as the issue, then?

                    Without those changes any effort to eliminate tipping is likely to do more harm than good, and once you have achieved those, many of the ills of tipping go away or are greatly alleviated anyway… yet people would rather fight over tipping rather than fix the underlying problem.

                    Also, to my knowledge there aren’t variances to minimum wage by industry – by location, by age, yes, but I think what you’re thinking of is tip credit laws, which aren’t a different minimum wage, only the option to allocate how it’s funded.

                    1. 2

                      Where I am they have “server’s minimum wage” which is lower that regular minimum wage on the assumption that they will get tips.

                      If they got paid regular minimum wage it wouldn’t be much of an issue (though I know some places also have regular minimums set too low).

                      1. 2

                        Again, I’m not convinced that’s actually what’s happening… what is commonly referred to in shorthand terms like “server’s minimum wage” is actually more accurately described as the minimum mandatory employer contribution after tip credit.

                        I don’t know every state’s laws, but every tip credit state I do know works largely the same way: If the minimum wage is $10 and the minimum employer contribution (sometimes called the “servers minimum” or “tipped minimum”) is $2, then an employee will still always earn at least $10 total, but up to the first $8 of their tips can be credited towards meeting that minimum wage, so the employer may contribute less than the full amount (but no less than the minimum employer contribution.) However they can’t just “assume” those tips, there’s typically accounting and documentation necessary to track that, and in any cases where an employee does not make enough tips to cover the minimum wage then there is no money to credit and the employer is still legally required to make up the difference.

                        These are state laws, and do differ from one state to the next (and the better states don’t allow tip credit at all) so I can’t swear your local laws follow that exact model… But there is a common misconception about how tip credit works, and my understanding is that any attempt by a state to actually lower minimum wage would be unenforceable as it would counter the federally mandated higher wage.

                        Also, essentially no one thinks tip credit is a good idea… the whole idea is somewhat questionable, and they are prone to and rife with abuse. They’re merely a special interest carve-out that the restaurant industry lobbyists were able to get enshrined in law, and as I said above would be a prime candidate for relatively “easy” improvements to the law.

                        1. 2

                          However they can’t just “assume” those tips, there’s typically accounting and documentation necessary to track that, and in any cases where an employee does not make enough tips to cover the minimum wage then there is no money to credit and the employer is still legally required to make up the difference.

                          This is an accurate description of what the law says, but I don’t really think it represents actual practice. When I waited tables (many years ago), my employer had no idea what my tips were. If there was required documentation for tip credits, I assume they fabricated it to meet their own needs.

                          1. 1

                            Yeah, it’s common that what they record may not be terribly accurate, but they’re likely recording something.

                            Technically you are supposed to be reporting all those tips to the employer (if you receive direct cash tips, they have no way of tracking it otherwise), and they’re legally required to give you a way to do so… but there is no requirement that they make it easy, obvious, or well enforced. From what I saw doing payroll for servers, the majority did not ever do this (some intentionally, because they thought it helped them evade taxes on the cash), and hardly any indirectly tipped employees did. Common practice was to impute some “standard rate” of cash tips based on hours and/or sales and record that in instances where servers failed to report themselves. So, yeah, that happens, but the employee can choose to do it the “right” way if they want, and potentially gain the benefit of correct employer contributions that way.

                            1. 2

                              Ah, that’s right, thanks for reminding me. 8% of our sales were entered as tips. No one wanted to report the full amount of their cash tips.

          1. 16

            This is a good overview, but I wish it talked about potential solutions or directions too. Let me scribble some quick notes on that:

            • Virtual memory: With 64 bits all processes can share the same address space, so there’s really no need to remap addresses between processes; only permissions need to change.
            • Memory protection: less of an issue with “managed” runtimes (JS, Java…) that allow only safe accesses, and with compiled languages like Go and Rust that statically ensure safety (aside from “unsafe” calls of course.)
            • Filesystems: Nonvolatile memory is going to take over some of the filesystem’s use cases, like saving state, and maybe some databases. And I’m a big fan of replacing the filesystem abstraction with something more like a “soup” of persistent objects, or with systems that rely more on tagging than on directories.
            • Concurrency, IPC, networking: Lots of momentum these days for CSP and Actor -like mechanisms, I.e. lightweight threads that communicate by message passing not shared memory. And Capabilities are a really powerful way to add authorization to this type of messaging

            Another area the authors didn’t address is the difficulty of the POSIX APIs, especially in the area of networking. Writing a solid, performant TCP-based client or server on those APIs is quite hard, with all sorts of gotchas; just look at doorstop books like Unix Network Programming. I’ve done it but I never want to do it again! This s a side effect of how the APIs grew over time and as more capabilities were added — for example, signals predate threads, so the two don’t work well together.

            1. 10

              Nonvolatile memory is going to take over some of the filesystem’s use cases, like saving state, and maybe some databases. And I’m a big fan of replacing the filesystem abstraction with something more like a “soup” of persistent objects, or with systems that rely more on tagging than on directories.

              Early 90s Apple employee detected - who else would call single-level storage/persistent memory soup?

              1. 9

                Guilty as charged, but there’s been some definite interest recently in the Newton architecture — what I know of it comes mostly from reading old Apple manuals that were linked here in the last year or two.

                1. 3

                  Much has been lost.

                2. 3
                  • Virtual memory: With 64 bits all processes can share the same address space, so there’s really no need to remap addresses between processes; only permissions need to change.
                  • Memory protection: less of an issue with “managed” runtimes (JS, Java…) that allow only safe accesses, and with compiled languages like Go and Rust that statically ensure safety (aside from “unsafe” calls of course.)

                  One of the current CHERI projects involves flat address spaces with POSIX. This augments vfork with a coexecve system call, which is like execve but launches the new process in the same address space as the caller (but with a disjoint set of capabilities).

                  Filesystems: Nonvolatile memory is going to take over some of the filesystem’s use cases, like saving state, and maybe some databases. And I’m a big fan of replacing the filesystem abstraction with something more like a “soup” of persistent objects, or with systems that rely more on tagging than on directories.

                  One of the HP engineers on the The Machine put this best: the problem with persistent single-level stores is that your memory safety errors last forever. CHERI helps here, now only your type-safety bugs last forever.

                  There’s a much bigger problem with using NVM as memory though: you have two kinds of consistency and both matter. You have consistency that arises from cache coherency (things like the C++11 memory model), which defines the order in which other cores can observe writes to shared memory. You also have the consistency that arises from writes to persistent memory, which defines the order in which stores become visible after a crash. Providing a model that is consistent across both is incredibly hard (well, it’s easy, unless you want performance to be better than totally awful).

                  There’s also the locality issue with filesystems. Increasingly, applications store data in cloud services with local caches. All of the problems that CODA tried to solve are still there but, for security, the shared-namespace aspects of a filesystem are less important.

                  This is also interesting for server-side applications, where the storage is often provided by a different VM or other service and so the ‘local’ OS needs to expose only a low-latency network interface.

                  Concurrency, IPC, networking: Lots of momentum these days for CSP and Actor -like mechanisms, I.e. lightweight threads that communicate by message passing not shared memory. And Capabilities are a really powerful way to add authorization to this type of messaging

                  Completely agreed.

                  1. 1

                    One of the HP engineers on the The Machine put this best: the problem with persistent single-level stores is that your memory safety errors last forever. CHERI helps here, now only your type-safety bugs last forever.

                    I don’t envision NVM being used just like a regular heap only it lasts forever. I see it more like a memory-mapped database without the paging. That is, ideally you can use the persistent data as regular runtime data structures (including pointers!) but there’s more ceremony involved in writes to ensure ACID-type guarantees. That way, anything that might affect memory/type safety is going through some code that’s hopefully as well-debugged as SQLite.

                    That might mean it isn’t single-level storage, but that’s OK; it’s not too hard to make it look that way to the application, and it will probably be lighter-weight than an ORM.

                    1. 1

                      That still requires you to hide behind fairly complex proxy objects because direct mutation is unsafe. You need explicit cache writebacks to guarantee that data is committed to persistent memory but you need barriers to ensure that it is visible to other threads. It’s hard to unify these because barriers typically cost tens of cycles or less, writebacks cost thousands. Concurrent mutation of data structures in NVM is an active research area and is hard.

                  2. 3

                    Virtual memory: With 64 bits all processes can share the same address space, so there’s really no need to remap addresses between processes; only permissions need to change.

                    Security, security, security.

                    Memory protection: less of an issue with “managed” runtimes (JS, Java…) that allow only safe accesses, and with compiled languages like Go and Rust that statically ensure safety (aside from “unsafe” calls of course.)

                    And more security. Most runtimes that “allow only safe accesses” run in user space, which means they protect the machine from bad code handed to the runtime. But, they do nothing to protect against bad actors and bugs in these runtimes.

                    1. 8

                      There are OSes that handle single-address space and static safety with managed languages fine - IBM i is the most commercially successful example.

                    2. 1

                      With 64 bits all processes can share the same address space, so there’s really no need to remap addresses between processes; only permissions need to change.

                      What does this buy you though, except for perhaps saving a little bit of memory from page tables? You cannot know how much memory each process will need a priori, so how much of the address space do you partition for each process? I suspect you would quickly run into fragmentation problems which is precisely one of the issues page-based virtual memory was intended to solve.

                      1. 2

                        I am not a kernel expert, but I hear it’s a performance win not having to remap memory during system calls and context switches.

                        I don’t see why fragmentation would be a problem. The space available is on the order of 10 billion gigabytes. To fragment that, a pretty sizeable fraction of it would need to be allocated, and processes would have to be making some huge individual allocation requests.

                    1. 3

                      I tried using Nix on macOS for a little while. The experience was pretty unpleasant. A lot of software was broken and failed to build (off the top of my head, Julia installation was broken on my Intel Mac. On my M1 Mac there were a lot more things that wouldn’t install). The user interface of Nix is notoriously obtuse and poorly documented. Integrating with build systems or projects that don’t use Nix and thus assume pkg-config or cmake or whatever is on your PATH becomes more painful and requires you to create a shell.nix file (often with some other poorly documented variables you must set to get things working). The “flakes” model was yet another layer and interface that was different from and incompatible with the old interface. Basic command line utilities like searching the package index were either slow or would suddenly break when Nix updated (searching is now considered an experimental feature apparently?) Simple things like “which package provides a given file or command” or “what packages depend on X?” are difficult or impossible. I ended up needing to understand yet another build system. And all of this for what? Whatever problems Nix intends to solve I have never personally experienced using traditional package managers. I switched back to Homebrew and have been much happier.

                      1. 5

                        And all of this for what? Whatever problems Nix intends to solve I have never personally experienced using traditional package managers. I switched back to Homebrew and have been much happier.

                        I think you made the right call switching back to Homebrew. I’m a little cautious about who I recommend Nix to for roughly this reason. It’s a very powerful lever, but it’s a lot of work to learn if you don’t need the lever.

                        All of these are pretty fair, but I want to add a little context to 2 of them:

                        A lot of software was broken and failed to build (off the top of my head, Julia installation was broken on my Intel Mac. On my M1 Mac there were a lot more things that wouldn’t install).

                        I wouldn’t say “a lot” (but of course that distinction is meaningless when it’s a lot of the software you need.)

                        Making software build on macOS tends to be work that takes hands and requires access to running macOS systems (which is rarer than access to general Linux systems, among the community of maintainers).

                        Apple’s also made a few decisions in the past few years that have all been independently pretty disruptive, and working them has soaked a lot of macOS energy/effort (both causing some package breaks, reducing the free time people are able to allocate to fixes, and blocking some things that people would fix until some trickier ~foundational work is done. The main ones I’d cite are:

                        • The change to a read-only root directory. This didn’t strictly hit whether individual packages work too much, but it ate up a lot of work to get fixed and caused a long rocky period that created a lot of uncertainty, squandered momentum on macOS, made it much harder to onboard new macOS users (and thus potentially a few new maintainers) for nearly a year, etc.
                        • macOS has made some architectural changes, like no longer has dynamic libraries on the filesystem (can see an HN thread in https://news.ycombinator.com/item?id=23612772) that’ve entailed work to catch up with before newer SDKs have clean support. Some higher-level background on this and more in https://discourse.nixos.org/t/nix-macos-monthly/12330/11
                        • M1/aarch64. (This obviously takes work to support, and also fractures the macOS maintainers a bit, since now a significant fraction of maintainers who have access to a macOS device will only have either an Intel or Apple Silicon system.

                        would suddenly break when Nix updated (searching is now considered an experimental feature apparently?)

                        This was a few mistakes that snowballed into a big butt fumble. Mainly:

                        1. It was a mistake to release the early “new” Nix CLI without guarding it behind the experimental flag.
                        2. The nix 2.3 series, which made this mistake, lasted way too long (years) before the project bit the bullet last fall and moved to releasing every 6 weeks.
                        3. Uses of the new CLI turned up in the official manuals.
                        4. A lot of unofficial community sources, which are important because of the well-trod documentation problems, were eagerly using the new CLI without putting up warning signs.
                        1. 2

                          Also there’s an issue where updating to a new version of Apple sdk is just harder than it should be. We’re close to 2 years now (https://github.com/NixOS/nixpkgs/issues/101229) and already ran out of time. Macos is really hostile to nix - not actively, it’s just not a consideration at all.

                          1. 1

                            I’d say that’s roughly all under the umbrella of what I mean by citing https://discourse.nixos.org/t/nix-macos-monthly/12330/11.

                            The community was technically put in touch with an Apple devrel back during the read-only-root period, but the go-between hasn’t had time to serve that role. I’m not sure it’ll help, but I’ve been trying to (as often as I remember and can bear being annoying) squeak enough to get toonn or I in touch with the devrel.

                        2. 1

                          Agreed regarding homebrew since I’ve fallen in love with simple Brewfiles and such for easy onboarding of development staff to a team.

                        1. 10

                          That was a joy to read. I don’t have much interest in running Asahi on my M1 Air anytime soon, but the depth of this update was extremely educational on how some slices of Mac hardware works at the foundation. I’ll be following along in coming months!

                          1. 9

                            They are all like this. If you are at all interested in low-level systems/computer engineering, these updates are some of the best material around. If you enjoyed it, it might be worth going back and reading some of the older updates too.

                          1. 5

                            I am a happy user of https://healthchecks.io at the free tier.

                            1. 5

                              Seconded. I use healthchecks.io for my automated backups. When the backup completes, it simply makes a curl request to a certain endpoint. healthchecks.io “knows” approximately what time that request should be arriving, and if it doesn’t arrive within a specified window around that time (say, an hour) then it sends me an email that something failed. It’s been working beautifully with zero maintenance for years

                              1. 1

                                You can also track how long a command takes. My backup script looks like this:

                                curl -fsS -m 10 --retry 5 -o /dev/null https://hc-ping.com/$ID/start
                                nice /usr/bin/tarsnap $ARGS
                                curl -fsS -m 10 --retry 5 -o /dev/null https://hc-ping.com/$ID/$?
                                

                                (where $ID is my healthcheck identifier and $ARGS are my tarsnap arguments, and $? is the status from the command). Now if the job doesn’t complete within the grace time, I get an alert, and I can see how long the jobs took on the status page.

                                1. 1

                                  Great idea. Does that request need to arrive at the exact time? Does healthchecks.io allow a window of time?

                                  1. 1

                                    Healthchecks expects the request at a specific time, but it has a configurable “grace time” parameter – the time to wait for a request that is late, before sending out alerts.

                              1. 2

                                I have heard great things about rr, but unfortunately I’ve never been able to try it: it doesn’t work on macOS and it doesn’t work in a VM (at least, it didn’t when I tried). So if you have Apple hardware at all it looks like you’re out of luck.

                                1. 2

                                  It doesn’t work on MacOS, but it will work on Apple hardware if you dual boot (also M1 iirc: https://github.com/rr-debugger/rr/pull/3144)

                                1. 5

                                  I’m going to finally take the plunge: I’m going to work on converting my vim configuration and some small vimscript plugins to Lua for neovim.

                                  And as a treat, we’re making La Viña style cheesecake. If you’ve never tried it (and you like cheesecake), check out that video. The owner of the place that made it famous walks through their recipe, and it’s surprisingly easy to make. (The toughest part is that you need to let is cool for hours. We usually leave the house for the afternoon after it comes out of the oven. Otherwise, it’s really hard to wait…)

                                  1. 3

                                    Good luck!

                                    I’ve started making the switch to neovim, mainly for rust-analyzer LSP integration.

                                    Some initial annoyances:

                                    I hate the shifting of the text over by two columns when I’ve made an edit to the code and it detects an error. I think I’d rather just give up the two columns all the time, the shifting back and forth really bothers me.

                                    Error messages found in my Rust code nearly always extend beyond the end of the line on my already very wide terminal window. Making them nearly useless. There may be a key binding or something that pops up the entire error messages, but I think I’d prefer a split, and have the error displayed in full below. I’ll need to dive further into the configuration files.

                                    The configuration files! Switching between:

                                    • ~/.config/nvim/init.vim
                                    • ~/.config/nvim/lua/plugins.lua
                                    • ~/.local/share/nvim and all the stuff under there

                                    That may be because I ended up using packer as the plugin manager, not sure. I’m not sure what the justification is for having stuff in two different directories.

                                    I also don’t like having the checker run on every edit. I really don’t need stuff popping up all the time as I’m trying to think and make a series of edits. There is probably a setting for this. I hope there is a setting for this…

                                    1. 3

                                      I agree with all of your annoyances already! I really dislike the way that LSP features work and feel. Whatever the opposite of Vim is, that’s how those features feel. They completely break my flow.

                                      With all that in mind, my goal is to take my (more traditional) vimscript modifications and rewrite them in Lua. I want to do this mostly because I enjoy writing Lua, and I really don’t enjoy writing (or reading) vimscript. My second reason is that the more I look at things, the more I think that neovim is the future of vim. I’m not excited about vimscript9, and that may lead neovim and vim to drift further and further apart.

                                      I also don’t like having the checker run on every edit. I really don’t need stuff popping up all the time as I’m trying to think and make a series of edits. There is probably a setting for this. I hope there is a setting for this…

                                      I’m 99% sure that there is. I don’t work with Rust, but the go plugins all come with global configuration variables that can turn off “lint on write” behavior. Check the docs for configuration options and good luck.

                                      1. 3

                                        I only use LSP for symbol navigation and code diagnostics, neither of which feel non-Vim like to me (think of it as a souped up version of tags navigation or the quickfix list).

                                        There is a sizable population of Neovim users who try and turn it into “VSCode in the terminal”, and this sometimes gives the impression to others that this is the only way to use Neovim. But I am with you, I use Neovim basically the same as I used Vim. The big draw for me is indeed the Lua API (and the community).

                                        1. 2

                                          I only use LSP for symbol navigation and code diagnostics, neither of which feel non-Vim like to me (think of it as a souped up version of tags navigation or the quickfix list).

                                          Fair enough. Once I have everything settled in Lua, I’ll probably take a look at ways that LSP can help me without making Neovim feel like VSCode.

                                          There is a sizable population of Neovim users who try and turn it into “VSCode in the terminal”, and this sometimes gives the impression to others that this is the only way to use Neovim.

                                          A fair point: thanks for helping me see it.

                                      2. 3

                                        rust-analyzer has a known bug which makes the sign column shifting much worse than other LSP servers. The LSP server sends diagnostics to the editor and Neovim updates the display based on these diagnostics, but RA erroneously sends 2 diagnostic messages each time: the first is an empty message, the second contains the actual diagnostics. This causes Neovim to clear the existing diagnostics before redrawing them every time, which causes noticeable (and annoying) visual UI flicker.

                                        The configuration files don’t need to be complicated and can, in most cases, mirror what you’re used to in Vim.

                                        If you have any questions feel free to make a post on the Neovim Discourse and tag me personally (I am a Neovim maintainer).

                                        1. 1

                                          Thank you. If there ends up being things I can’t figure out, I’ll be sure to ask.

                                          I am very much in the RTFM category, and I know I haven’t exhausted the resources there yet.

                                          I’m actually much more familiar with Lua than Vimscript, so my initial confusion was more about the layout of the files more than what was in them.