Threads for e12e

  1. 14

    A lot of the fun of wordle for me is picking a different start word everyday.

    1. 3

      Someone I know picks her name as the start every day.

      Paid off this week.

      1. 2

        Her name, not her outlook on life?

        1. 3

          Her name. Outlook on life was today :)

      2. 1

        I mostly try to do have my first word be new(ish) each day, have chance to be correct (so far i have only twice got it on second try, never on first), lock in correct letters (I play in hard mode).

        I end up re-using a few words: PANIC if I’m tired, RAISE, MANIC or AMBER - or something else…

        As there’s no text version of TFA - I’m not sure what the bug is, or what is optimized for - but I guess it’s trying for best opener wrt fewest guesses - ie: excluding as many words from possible solutions at each step?

      1. 1

        Spinning up a arch, centos or nix VM with a single command is very appealing. Automatic hostname even!

        1. 1

          well, works nicely with vagrant, though.

          1. 3

            Vagrant is a valid way to do this, however I admit my needs are a bit self-inflicted. I don’t like Ruby (the package manager is a pain) and wanted to have it be a single command to choose distribution/version, CPU core count, disk size, memory that the VM has and what machine to run it on. I also wanted to be able to run waifuctl on a machine that is NOT the one that runs the VM. Basically I want waifud to be instrumental to making my private cloud run. Ideally I’d like it to be like having my own private EC2 that I can also let friends use.

            My homelab setup is a bit weird (4 kinda powerful machines that run libvirtd instead of 1 really powerful machine to rule them all), so this software reflects that weirdness. I’d love to use Vagrant, however most Vagrant boxes do not support libvirtd, so my options are limited at best. My current biggest limiting factor in waifud’s implementation is the fact that I have to sling around base images, this will probably be done better in the future (NFS? 9P? Samba?), but for now it works enough.

            1. 4

              I had the same issues with Vagrant and similar design goals as what you mention:

              • Multiple physical hosts (in different providers or at home)
              • Single standard way to provision VMs from an underpowered laptop
              • Version controlled config files
              • Standard images format

              I ended up using terraform + libvirtd to achieve the above goals. Three years later and it still works fine for provisioning VMs and networks in my laptop, desktop and various physical hosts in datacenters.

              However as you noted, I have the same issue with moving images around, which is somewhat alleviated by creating images in each host locally using packer.

              1. 2

                no worries, i like the approach. Have you had a look at the generic/* images from the roboxes.org project? Theyre all available for libvirt, using the vagrant-libvirt plugin, too.

                I dont like ruby, too, but with the generic/* boxes and an centralized dhcp service its also possible to easily spin up machines on multiple hosts, if required, which comes more closely to your approach (vms must run qemu agent within them for vagrant to be able to find out about the assigned ip address, and vagrant must be configured to run a remote connection to the libvirtd host)

                1. 3

                  I have had a look at them just now, but I am deep enough into making waifud a thing that it may be too late for me now :)

                2. 2

                  At the risk of being unduly opinionated, I’d advise that you don’t use NFS. Sling the images around in userspace. In the medium to long run the bugs you get that way will be less nasty.

                  1. 1

                    Why not Ubuntu MaaS (metal as a service) / lxd? (I can think of a few reasons, just wondering)

                    1. 3

                      My homelab runs NixOS. I didn’t want to try and get MaaS working on there. I also remembered that exists today.

              1. 3

                This is great. I’d love to see a part two dealing more with dynamic / run-time strings i/o - eg: classic beginner program prompting “what is your name.”, responding with “Hello, {name}”, and/or reading from arguments etc.

                I feel it’s a bit underseved by current zig documentation.

                Come to think of it, maybe some of the examples from k&r “The C programming language” would be useful in idiomatic Zig? (Also is there an equivalent for modern idiomatic C?).

                1. 6

                  What would an ideal JavaScript dependency management system look like?

                  1. 6

                    It’s a good question. I’m not sure that npm is all that different from most other dependency managers. My feeling is that it’s more cultural than anything – why do JS developers like to create such small packages, and why do they use so many of them? The install script problem is exacerbated because of this, but really the same issue applies to RubyGems, PyPI, etc.

                    There are some interesting statistics in Veracode’s State of Software Security - Open Source Edition report (PDF link). Especially the chart on page 15!

                    Deno’s use of permissions looks very interesting too, but I haven’t tried it myself.

                    1. 9

                      I’m not sure that npm is all that different from most other dependency managers. My feeling is that it’s more cultural than anything – why do JS developers like to create such small packages, and why do they use so many of them?

                      I thought this was fairly-well understood, certainly it’s been discussed plenty: JS has no standard library, and so it has been filled-in over many years by various people. Some of these libraries are really quite tiny, because someone was scratching their own itch and published the thing to npm to help others. Sometimes there are multiple packages doing essentially the same thing, because people had different opinions about how to do it, and no canonical std lib to refer to. Sometimes it’s just the original maintainers gave up, or evolved their package in a way that people didn’t like, and other packages moved in to fill the void.

                      I’m also pretty sure most people developing applications rather than libraries aren’t directly using massive numbers of dependencies, and the ones they pulling in aren’t “small”. Looking around at some projects I’m involved with, the common themes are libraries like react, lodash, typescript, tailwind, material-ui, ORMs, testing libraries like Cypress, or enzyme, client libraries eg for Elasticsearch or AWS, etc… The same stuff you find in any language.

                      1. 4

                        It’s more than just library maintainers wanting to “scratch their own itch.” Users must download the js code over the wire everytime they navigate to a website. Small bundle sizes is a unique problem that only JS and embedded systems need to worry about. Large utility libraries like lodash are not preferred without treeshaking — which is easy to mess up and non-trivial.

                        People writing python code don’t have to worry about numpy being 30MB, they just install it an move on with their lives. Can you imagine if a website required 30MB for a single library? There would be riots.

                        I wrote more about it in blog article:

                        https://erock.io/2021/03/27/my-love-letter-to-front-end-web-development.html

                        1. 1

                          Sure, but that’s just the way it is? There is no standard library available in the browser, so you have to download all the stuff. It’s not the fault of JS devs, and it’s not a cultural thing. At first people tried to solve it with common CDNs and caching. Now people use tree-shaking, minification, compression etc, and many try pretty hard to reduce their bundle size.

                      2. 3

                        I was thinking about Deno as well. The permission model is great. I’m less sure about URL-based dependencies. They’ve been intentionally avoiding package management altogether.

                      3. 2

                        It’s at least interesting to consider that with deno, a package might opt to require limited access - and the installer/user might opt to invoke (a hypothetical js/deno powered dependency resolver/build system) with limited permissions. It won’t fix everything, but might at least make it easier for a package to avoid permissions it does not need?

                        1. 0

                          hideous, I assume

                          1. 1

                            What would an ideal JavaScript dependency management system look like?

                            apt

                            1. 4

                              apt also has install scripts

                              1. 1

                                with restrictions to ensure they are from a trusted source

                                1. 4

                                  You mean policy restrictions? Because that only applies if you don’t add any repos or install random downloaded Debs, both of which many routinely do

                                  1. 1

                                    yeah

                                2. 1

                                  Yes, but when you use Debian you know packages go through some sort of review process.

                            1. 2

                              That is a very nice effort, and a useful tool I might add to my command-line toolbox.

                              I just pity it hasn’t reused Troff’s GRAP’s language, which is very readable, clear, English-like and follow the UNIX philosophy, besides being a well-thought product of Brian Kernighan; instead, they chose a JSON-based one, which seems very polluted to my eyes.

                              1. 2

                                IIRC Gnuplot takes after GRAP. I’ve been doing a lot of Gnuplot lately and clip’s language looks cleaner to me.

                                1. 1

                                  Would you mind expanding your comparison?

                                  What do you think it is cleaner in clip’s compared to Gnuplot’s syntax?

                                  And how do you compare GRAP’s and Gnuplot’s syntax, except both use (most of time, for Gnuplot) proper English tokens as their command set?

                                  I looked at your repository, and I could mostly understand the Gnuplot files, even though I am not used with the syntax.

                                  On the other hand, I struggled to “plot the graph in my mind” looking at clip’s examples.

                                  I suspect that our divergence my be only on taste grounds, and I guess it is difficult to make a proper comparison without getting a big graph and plotting it in the three applications.

                                  Personally, the initial example of GRAP seems way easier to plot using that tool than clip, based on their “Getting Started” document. However, I suspect clip is easier at some kind of plots (e.g., their charts-scientific/streamgraph) than GRAP, but I cannot say so (for lack of knowledge) about Gnuplot.

                                2. 1

                                  they chose a JSON-based one

                                  I’m not sure how you mean this is “json based”? Looks like it avoids most of the pitfalls of json, and is rather golang/c-like?

                                  https://clip-lang.org/examples/charts-scientific/vectorfield/

                                  I see no quotes around keys; possibly? support for comments; what appears to be number support, but I suppose it might be brain-dead floats like json; semicolon as line/statement separator?

                                  1. 2

                                    Your comment made me evaluate it better, and see it is neither based on JSON nor C-like as you suggest, but it seems based on CSS.

                                    The similarity with CSS can be better seen in the charts-scientific/streamgraph:

                                    • keys and values are not enclosed by quotes, except if text (e.g., path);
                                    • keys and values are separated by colon;
                                    • property’s (i.e., key-values) declaration finishes with semicolon;
                                    • multiple values are separated by spaces;
                                    • some values are defined by “function calls”, such as rgba();
                                    • named blocks, delimited by curly-braces, agglomerate properties.

                                    While I see good value in the influence of CSS and the analogy between language for graphical design and language for plot design, I am in conflict with that choice for a command-line tool: I would have expected the “line experience” seen pervasively in the *NIX world—and, with that, a lower cognitive load for those I believe is the tool’s most potential users—instead of a “language of the web”.

                                    Also, I feel that the art of creating (domain-specific, but also programming) languages with tokens as English words, and making their represented code read like natural language, seems to be dying. GRAP had that, in my opinion.

                                    But setting my sentiment and bias aside, I re-state there is a value in basing its language on CSS, and it might be it will reach more people than if it had followed “the UNIX tradition”: I guess there are more people, nowadays, who know CSS than people who grok grep.

                                1. 1

                                  Bounced after the second time the page stole my focus away from the text. I barely got past reading the title.

                                  1. 3
                                    1. 1

                                      Indeed, there are a couple of annoying pop-ups - but the content was interesting IMNHO.

                                    1. 1

                                      I feel the point about “not libraries or frameworks” needs to be more clearly adressed (already brought up in a sibling comment) - most practical, current OOP programs are likely to be in a class-oriented language: ruby, python, smalltalk, objective-c, Java, c++ and c# all fall into that group AFAIK. Possibly there’s some OOP in common lisp that does not? (and potentially in Javascript, I suppose; using prototypes, not the new classes).

                                      In any project one would generally find useful abstractions that fit the problem domain, then use these to solve the problem. Ideally the main program is a trivial combination of appropriate abstractions.

                                      For OOP languages, that would typically be a set of classes and interfaces in the form of a library or framework?

                                      So that would be the interesting part?

                                      Maybe the author can give an example of “good” structured/procedural/functional code?

                                      1. 11

                                        Switching to using Lua for Neovim seems like it’ll be really powerful. I’m just a little scared to make that final jump, because there’s way to really go back to Vim after doing this. I’ve already leveraged a bunch of Neovim-only stuff, but this is a lot more extreme.

                                        1. 7

                                          The Lua support in Neovim is one of the things making me eager to look at it. Lua is a fantastic little language and there’s no reason to be stuck with something like vimscript in 2021.

                                          1. 5

                                            I looked a bit at lua, and a lot of stuff seemed much more verbose/awkward to me.

                                            I kinda of like VimScript 😅 There are a few annoying parts (line continuations, ugh, and I still forget that stupid a: sometimes), but overall I find it works fairly well, especially since lambdas (already some time ago) and the method syntax (also some time ago, but never ported to Neovim) were added. It’s a fairly small language that fits its purpose reasonably well.

                                            It’s perhaps a bit of an acquired taste though.

                                            1. 4

                                              Neovim is claiming that lua is much faster than VimScript. I’ve seen VimScript chug on files with just a few hundred lines, so I’m hoping I can convert my heavier functions to lua and get a speed boost.

                                              1. 2

                                                I can’t say I ever ran in to issues with this myself; most of the times I ran in to performance issues it’s because you do something like :%s/<something rather complex on a large file>/, but I’m not sure if Lua will really help with that? From what I can tell, most of the performance issues is when people implement stuff like fuzzy matching in VimScript and similar computation-heavy stuff.

                                                The new VimScript9 is quite a bit faster (but still slower than LuaJIT), but I haven’t really looked at it.

                                              2. 1

                                                I kinda of like VimScript

                                                Wow, this is the first time in twenty years I’ve heard anyone express an emotion about vimscript other than disgust.

                                            2. 7

                                              if you keep your dotfiles in source control (which I recommend if you aren’t already), you have nothing to lose. If you make the switch and decide later that it’s not for you, just revert back to the previous version of your config that uses vimscript.

                                              1. 3

                                                That only works until you customize further in lua.

                                                1. 2

                                                  I’m not sure what you mean. Sure, you lose some further custom lua config (until you port it to vimscript), but you won’t end up worse off than you were before you switched if you have your config in source control.

                                              2. 4

                                                I have recently switched not only to Lua, but to Fennel as well and I am pretty happy with result. Now I need to port rest of my config from VimL to Fennel.

                                                1. 2

                                                  Wow, that’s amazing! Did not know Fennel could be used like this.

                                                  1. 2

                                                    do you notice any delay from having to compile the fennel files to lua on every startup?

                                                    1. 4

                                                      Slight, but nothing annoying me. In the past I was trying to cut load time as much as possible, but now I stopped giving a damn. I haven’t tried precompilation though.

                                                    2. 1

                                                      If you’re using a lisp for your editor scripting.. At what point does evil/emacs becometthe saner choice, though?

                                                      1. 3

                                                        As soon as Evil will learn into all my favourite quirks of Vim. I have tested Emacs in the past and there was always some small nitpick that was missing and was irritating me. Now I get the best of two worlds.

                                                    3. 2

                                                      Is there a reason that’s a problem? Neovim is a fork of the vim codebase and migrating to it doesn’t seem all that different from upgrading vim and then using plugins that require the new version as their minimum version. Neovim is basically just vim that is making faster progress on cool new features than mainline vim is.

                                                      1. 5

                                                        Neovim 0.5 lets you write your vimrc as a lua script, which Vim8 can’t parse.

                                                        1. 2

                                                          The big gotcha I hit with Neovim was that it uses a different format for undo files. I have this in my vimrc:

                                                          set undodir=${XDG_CACHE_HOME}/vim/undo//
                                                          set dir=${XDG_CACHE_HOME}/vim/swap//
                                                          set backupdir=${XDG_CACHE_HOME}/vim/backup//
                                                          set undofile
                                                          set undolevels=1000
                                                          set undoreload=10000
                                                          

                                                          This avoids cluttering my working directories with undo / backup / swap files and gives me effectively unlimited persistent undo, my favourite feature of vim. If I run neovim on a file that I’ve edited with vim, it complains. Similarly, if I edit with nvim and then vim, vim can’t read the undo file. I wish they’d change the name of files if they were going to have things for the same purpose as vim but with incompatible formats.

                                                          1. 3

                                                            I wish they’d change the name of files if they were going to have things for the same purpose as vim but with incompatible formats

                                                            This can be achieved with something like

                                                            if has('nvim')
                                                              set undodir=${XDG_CACHE_HOME}/nvim/undo//
                                                              ...
                                                            else
                                                              set undodir=${XDG_CACHE_HOME}/vim/undo//
                                                              ...
                                                            endif
                                                            

                                                            I believe the undofile format became incompatible only very recently, when more information was added to undofiles.

                                                            1. 1

                                                              That’s what I did, but it’s annoying that I have to.

                                                              I was also quite excited by the built-in LSP support, but all of the tutorials I found required incredibly complex configs and didn’t explain how to configure the LSP integration for something like clangd for C/C++.

                                                        2. 1

                                                          There are heaps of incompatibilities between Vim and Neovim, and have been for years.

                                                          https://news.ycombinator.com/item?id=27719968

                                                        3. 1

                                                          What are some neovim features that you’ve really liked? I generally see the same things trotted out by fans, like treesitter and in-build LSP, but these aren’t things I’ve felt like I was missing in Vim (I do use LSP, plugins work well for this). I’d love to hear what benefits you have found, as an experienced Vim user?

                                                          1. 6

                                                            It’s a bit of a moving target, because a lot of neovim innovations are eventually implemented in vim. That’s what happened with floating windows, async jobs, and terminal emulation. So I guess the feature I really like is being a couple years ahead of everyone else :)

                                                            There’s also a few smaller things: I really like inccommand, which I don’t think has been ported over yet. And I just found out I can use the lua bindings to do this:

                                                            local nav_keys = {'h', 'j', 'k', 'l'}
                                                            for _, key in ipairs(nav_keys) do
                                                              local c_key = '<c-'..key..'>'
                                                              vim.api.nvim_set_keymap('n', c_key, '<c-w>'..key, opts)
                                                              vim.api.nvim_set_keymap('t', c_key, [[<c-\><c-n><c-w>]]..key, opts)
                                                            end
                                                            

                                                            I expect that as I get more comfortable with lua and the neovim API I’ll have more say. I write a lot of custom functions and vimL is one of the worst languages I’ve ever used.

                                                            EDIT ooh something I just realized I can do:

                                                            local set_all = function(list)
                                                            for _, item in pairs(list) do
                                                              vim.o[item] = true
                                                            end
                                                            end
                                                            
                                                            set_all {"termguicolors", "hidden", "splitright"}
                                                            set_all {"number", "relativenumber"}
                                                            

                                                            That’ll make it easy to create setting groups.

                                                            1. 2

                                                              No, no inccommand in Vim still. I was quite keen on this for a while until I discovered traces.vim which is a lot more powerful.

                                                              Yeah vimL has its quirks. The actual examples you’ve shown would look pretty similar in vimscript though … although they would use :execute, e.g. exe 'nnoremap' c_key '<c-w>..key. I’ve come to quite like vimL but I realise that puts me pretty firmly in the minority. I hate the line continuations but those are going away in vim9script.

                                                              It does look like configs will diverge now, to the lua neovim scripts and the Vim vim9script scripts. Which I suppose is good, trying to support 2 diverging editors with a single code-base is annoying, as each add different features.

                                                              1. 1

                                                                You can map stuff in loops in regular VimScript:

                                                                for k in ['h', 'j', 'k', 'l']
                                                                    exe printf('nnoremap <C-%s> <C-w>%s', k, k)
                                                                    exe printf('tnoremap <C-%s> <Cmd>wincmd %s<CR>', k, k)
                                                                endfor
                                                                

                                                                For a somewhat creative use of this you can see this ;-)

                                                                I guess the issue is that a lot of people just can’t be bothered to invest in learning VimScript, which is fair enough. But pretty much anything you can do in Lua you can do in VimScript, and vice versa.

                                                                1. 1

                                                                  I guess the issue is that a lot of people just can’t be bothered to invest in learning VimScript, which is fair enough. But pretty much anything you can do in Lua you can do in VimScript, and vice versa.

                                                                  Also, there’s more third party Lua libraries. A while back I needed to fill an autocomplete based on information in a YAML file, but couldn’t figure out how to parse YAML in VimScript. I ended up writing a python script to first convert the file to JSON, then use json_decode. It worked in that case but would have been nicer to just import a library and read the YAML directly.

                                                                  1. 2

                                                                    I think this - the availability of the Lua library ecosystem - is probably a “bigger deal”, looking forward, than the performance/tooling/ergonomics benefits Lua brings over VimScript. I haven’t seen too much adoption of Luarocks packages in plugins yet (though there are some examples, e.g. https://github.com/camspiers/snap), but I expect this to change now that 0.5 is stable.

                                                                    I will also say that, while anything* you can do in Lua you can do in VimScript, I personally find it much easier to do most things in Lua - partially due to familiarity, but also due to the simplicity of the language and the relative lack of footguns, compared to VimScript.

                                                                    *In Neovim specifically, Lua provides access to luv, which I’m not sure you can access from VimScript. In my experience, having the libuv event loop and utility functions readily at hand makes it possible to write functionality which would be at least substantially more painful without these tools.

                                                                    1. 2

                                                                      I haven’t seen too much adoption of Luarocks packages in plugins yet, but I expect this to change now that 0.5 is stable.

                                                                      Why do you expect this to change with 0.5? It’s been possible to write Lua plugins since 0.3, with luv becoming available in 0.4. I don’t see anything (besides the hype, maybe? :^) ) in 0.5 that would change the attitude of plugin authors towards Luarocks.

                                                                      1. 1

                                                                        It’s true that we’ve had the ability to write Lua plugins for a while now, but there’s been a huge increase in the use of Lua during the later part of the 0.5 development cycle (the past year or so). This, to me, indicates that we may have passed an inflection point in the ease of using Lua for plugin development that will contribute to more people writing Lua plugins, and (potentially) more people using functionality from Luarocks libraries for those plugins (though I admit this also assumes that people need and know about the libraries available through Luarocks).

                                                                        The hype is another factor, at least at first. And - noting that this runs dangerously close to self-promotion - I think that tools like packer.nvim‘s Luarocks integration (which you can use even if you don’t use packer for plugin management) significantly lower the complexity cost of using Luarocks packages, while also requiring features from 0.5.

                                                                        1. 2

                                                                          I see. In my opinion there’s a fundamental issue with the with dependencies where as a plugin author you don’t want to rely on external dependencies (otherwise you’re inevitably going to end up with people opening issues after misconfiguring the dependencies for your plugin…) but vendoring is fairly unattractive too (messes up version control history, you have to manually update everything…). This issue was already there with Vimscript and I don’t think it can be solved by anything else than Vim/Neovim implementing a full-featured plugin manager (which I don’t think it should do).

                                                                          1. 1

                                                                            Yeah, that’s definitely true too. I think this is easier with Luarocks because it already supports some basic versioning specification, so you can control what versions of dependencies your users get without needing to vendor. I definitely agree that there shouldn’t be a full-featured plugin manager baked into Vim/Neovim, though - people’s preferences and needs around plugin management are too disparate for there to be a good “one size fits all” option, in my opinion.

                                                                            1. 2

                                                                              I think this is easier with Luarocks because it already supports some basic versioning specification

                                                                              My point was that the package manager that downloads from luarocks itself becomes a dependency, which you want to avoid. So luarocks doesn’t really make things easier there :)

                                                                    2. 1

                                                                      One way would be to use Python:

                                                                      :pyx import yaml, vim; vim.vars['x'] = yaml.safe_load('{"hello": [1, 2]}')
                                                                      

                                                                      Or Ruby, Racket, Lua, Tcl, Perl, or even Visual Basic. It’s nice that Vim can interface with all that, but the big problem with that is that a lot of people don’t have the scripting support, and if you want things to work on Linux (all distros), macOS, and Windows is nigh-impossible. In reality It’s all pretty useless if as can never use it and have it work for everyone (the reason I didn’t try :lua is because my Vim isn’t compiled with it, and also, because I don’t really know Lua).

                                                                      Generally Vim tries to minimize required dependencies, which isn’t a bad thing. The Lua interpreter is pretty small so it could be integrated like libvterm or xdiff instead of linking toliblua. But I guess it’s too late for that now :-/

                                                            1. 3

                                                              Basically this is a guide to setting up Mailu: https://mailu.io/1.7/

                                                              Mailu looks interesting but I’m running all of the same major pieces myself on a $5 VPS. (Plus some other services.) It only has 1G of memory so I can’t really afford the overhead of docker. But I’ll definitely give it some serious thought when it’s time to rearrange the deck chairs.

                                                              I assume the author’s definition of self-hosted is “running everything off a raspberry pi hanging off residential cable internet” because any reasonable VPS provider is going to have clean IP blocks and will help you if their IPs are blacklisted anywhere. Thus negating the need to rely on a third-party outgoing relay.

                                                              A good chunk of the article is spent configuring a backup SMTP server and syncing IMAP… I feel like the author didn’t know that SMTP is already a store-and-forward system… Yes, you can have multiple incoming SMTP servers for high-availability but unless you’re a big company or an ISP you probably don’t need them. If your mail server is down, any RFC-compatible system will queue and retry delivery, usually for up to 24 hours.

                                                              Also fetching mail from the backup server via IMAP seems bonkers to me… again, SMTP is store-and-forward, the backup server can simply be a relay that delivers to your main server and just holds it in a queue when the main server can’t be reached.

                                                              1. 5

                                                                Mailu looks interesting but I’m running all of the same major pieces myself on a $5 VPS. (Plus some other services.) It only has 1G of memory so I can’t really afford the overhead of docker.

                                                                What overhead? It’s just a glorified fork with chroot?

                                                                1. 4

                                                                  I feel like the author didn’t know that SMTP is already a store-and-forward system

                                                                  I did in fact know this 🙂 But it’s not enough for my scenario. To expand, my personal self-hosted setup runs off of a machine in my house. It’s possible that if I were outside of the country and something catastrophic happened, it could be offline for an indeterminate amount of time. Possibly weeks. MTAs will stop retrying after some time and bounce the mail. So for my scenario, having a reliable backup MX is crucial.

                                                                  I had an interesting discussion on Reddit about exactly this, with some anecdotes about how common MTAs handle downed MX servers: https://reddit.com/r/selfhosted/comments/ogdheh/setting_up_reliable_deliverable_selfhosted_email/h4itjr5

                                                                  the backup server can simply be a relay that delivers to your main server and just holds it in a queue when the main server can’t be reached.

                                                                  An SMTP relay with a infinite retention time would be a good way to achieve this as well. Though, with Google Workspaces already set up on all my domains, I didn’t want to spend additional effort reconfiguring all my MX records to point to a separate SMTP server, let alone paying for/setting up such a service. So this bonkers IMAP setup was the way for me!

                                                                  1. 1

                                                                    Historically, spammers would target lower priority MX because they would often not have the anti spam measures configured. It looks like in your scenario you won’t get your own anti spam measures applied, but you will get Google’s, whether you want it or not.

                                                                  2. 2

                                                                    It only has 1G of memory so I can’t really afford the overhead of docker.

                                                                    I’ve forgotten how much memory my VPS has but it’s not likely more than 2G and I think we are running a couple of Docker containers. Is the daemon really RAM hungry?

                                                                    1. 3

                                                                      I checked on one of my VPSs and it uses 50MB. I don’t think that that is too bad. Could be less, sure, but not the end of the world.

                                                                    2. 1

                                                                      It only has 1G of memory so I can’t really afford the overhead of docker.

                                                                      I’ve run multiple docker containers on a host with 1G of memory. Other than the daemon itself, each container is just a wrapper for cgroups.

                                                                    1. 1

                                                                      It’ll be interesting to see where this goes. I wonder if a database is coming?

                                                                      Strange that they don’t mention the suffix list in the announcement - but at least they’re on it:

                                                                      https://publicsuffix.org/list/public_suffix_list.dat

                                                                      1. 2

                                                                        Their docs have examples on using three existing databases, so I doubt they’d make up a new one…

                                                                        1. 1

                                                                          I was wondering more about actual databases, rather than rest/web services that persist data - but I guess it makes perfects ense for deno to use/showcase services that work similar from browsers, rather than try to integrate directly with something like postgresql.

                                                                      1. 1

                                                                        Congratulations on launching, and thank you for releasing the code under MIT (I admit the more I read, the more I feared it was closed source, until I got to the relevant paragraph…).

                                                                        The actual doc sites, seem good -but the splash/home page could use some love on mobile.

                                                                        That is, I like the look of:

                                                                        https://little.webby.press/documentation/en/getting-started/book/getting-started.html

                                                                        (the important part - I take it this is how the website part of the output looks?)

                                                                        But this could look better on a phone:

                                                                        https://little.webby.press/#documentation

                                                                        I just had a look at the epub, and it looks OK - but it doesn’t play so well with dark mode in FBReader (quite common for epubs that uses images with backgrounds filled in etc). I’m not sure what the current state of theme/css is for epub - if some thing like this would/should work (with proper rules for shifting to “dark” images/illustration)? :

                                                                        https://css-tricks.com/dark-modes-with-css/

                                                                        1. 2

                                                                          Thanks for the kind words and feedback, I really appreciate it.

                                                                          The webapp has not been designed with mobile in mind because originally all the workflow was drag and drop based and that does not play well with mobile anyway. An important thing to notice, is that the webapp is used usually on the same machine that you write your content on, which is usually not a smartphone. The current layout works on desktop and on tablets. Still, there is no harm whatsoever in being a good citizen on smartphones. I’ll fix that.

                                                                          As for dark mode on epubs, I suspect the CSS support in eReaders is not yet up to those standards. In a quick glance in the EPUB spec, I can only find references to DOM Level 2 style. I know that iBooks support lots of nifty features including JS, but usual eReaders like Kindles and Kobos don’t have such advanced features. It is also important to notice that many eReaders will simply override styling and fonts with their own. You have less control over styling than on web. I suspect that many of those “inverted modes” on eReaders are done with overrides that force a specific colorscheme. I’m not sure. I’ll look into it.

                                                                          (the important part - I take it this is how the website part of the output looks?)

                                                                          And you’re right, that is how it looks. There is a landing site and a reading experience. For the documentation, I have only enabled the reading experience. The landing site should render well on mobile too. You can create your own templates as well, so if you want to play with the CSS, there is a way to do it which I still need to document.

                                                                          Don’t know if you’ve watched the embedded video but, in it I go over the app and show how to use it. You might like it.

                                                                          1. 1

                                                                            As for dark mode on epubs, I suspect the CSS support in eReaders is not yet up to those standards. In a quick glance in the EPUB spec, I can only find references to DOM Level 2 style. I know that iBooks support lots of nifty features including JS, but usual eReaders like Kindles and Kobos don’t have such advanced features.

                                                                            For me and my use-case, I only care about dark mode on a phone/oled screen (much prefer light gray on black text, I the Kindle app or FBReader app) - while on an e-ink screen, like a Kindle device - I don’t dark mode makes much sense.

                                                                        1. 2

                                                                          Datastation looks really interesting too… By the way. How does sql connectivity work - does the online version allow direct connection from browser to postgresql? That can’t work, without a (protocol) proxy, can it?

                                                                          1. 2

                                                                            Thanks! Here are the deets on the online environment: https://datastation.multiprocess.io/#online-environment.

                                                                            tldr; it has a limited set of functionality (including being restricted to in-memory SQL) so that you can try it out and get the feel for it before you download. These restrictions (the whole app being in-memory) means I can offer it for free to anyone to try it out forever. You can even use it on your work laptop since the data stays on your machine. (Well that applies to both the desktop version and the online version.)

                                                                            1. 2

                                                                              OK, thanks. I guess I’ll have to try the desktop version, as I’d be most interested in accessing postgresql bases.

                                                                              1. 2

                                                                                Makes sense! The desktop version is fully featured.

                                                                          1. 1

                                                                            Nice. Small typo, the last “body.js” should be “app.js”, I believe.

                                                                            1. 2

                                                                              Good catch! index.jsx (and they were all supposed to be .jsx to make esbuild happy without further config).

                                                                              1. 1

                                                                                Really appreciate this as I’m trying to wrap my head around modern front-end - and get frustrated with tutorials that have a gig of dependencies just to get off the ground… Only problem is no typescript support in browsers (yet) -maybe deno will blaze way…

                                                                                Btw, I would probably prefer a “js” (or static binary) webserver to python -as the rest of the article has no extra dependencies (eg: a windows (js/ts) developer might not have python).

                                                                                So either:

                                                                                npx http-server . -p 8080
                                                                                

                                                                                https://github.com/http-party/http-server

                                                                                Or:

                                                                                caddy file-server
                                                                                

                                                                                https://caddyserver.com/

                                                                                Or, for those that are deno-curious: https://deno.land/manual/examples/file_server

                                                                                (nothing against python - but if node is already available…)

                                                                                1. 3

                                                                                  Ah I figured even Windows has Python by default now but they only have an alias that leads you to the app store: https://devblogs.microsoft.com/python/python-in-the-windows-10-may-2019-update/.

                                                                                  In any case, whatever web server you’d like to use is totally fine!

                                                                            1. 6

                                                                              Okay, that’s a few less keystrokes, but a harder mental load. I’d rather press F3 to go to the next result (or even, re-hit ctrl+f and enter) than remember if I’m in the “search” mode and hit some random button that has a different meaning in a different context.

                                                                              When programming, you already have to juggle so many different things in your mind - why complicate it further? I feel like all those vim/emacs articles are just written to justify the time spent learning all those keystrokes and quirks, and all the time setting up the plugins.

                                                                              1. 10

                                                                                I get that concern, but the truth is that after a couple weeks of using vim all the commands and things you use daily become second nature. I’ve had times where I couldn’t tell someone how to do something in vim without having my fingers on the keys so I see what my movements were. It’s pretty amazing how many shortcuts you can keep in your head.

                                                                                1. 2

                                                                                  I’m able to mostly do that by playing the air-qwerty- keyboard. Definitely keeping most of my vim knowledge in my muscles, leaving my brain free for how I want the text to change.

                                                                                2. 6

                                                                                  You’re actually looking at it the wrong way around. F3 is the random key here. Nobody would ever figure out that key without help. On the other hand, in VI most keys are part of a logical pattern, even though some of those are historical. For example: n is the key you’d press to get to the next search result.

                                                                                  So while most shortcuts in modern day GUI have to be memorized without much context to help*, Vim commands are a language built out of related patterns.

                                                                                  *) That’s of course not the full story. All those shortcuts have a history as well and some are an abbreviation for the action as in ctrl+f(ind) or ctrl+c(opy). But there’s no “copy a word and paste it to the next line” or anything similar one could express with those.

                                                                                  1. 5

                                                                                    People figure out the F3 key by seeing it in the IDE’s menus - which vim doesn’t have. With vim, you have to put in the effort and actively learn the shortcuts. But even then, I said you can just hit Ctrl+F and enter again to get the same behavior, which is obvious because most software has the same shortcuts, and work the same way.

                                                                                    But there’s no “copy a word and paste it to the next line” or anything similar one could express with those.

                                                                                    Ctrl+Shift+Right to select the word, then Ctrl+C, Down arrow, Ctrl+V, am I missing something?

                                                                                    1. 2

                                                                                      Yes, if you use GVim you get those little helpers in menus as well. That’s a different interface. But the topic should be about concepts. VIM commands are a concept, a language, rather than a list of unrelated commands.

                                                                                      Of course you can do everything that you can do in VIM in any other editor as well. I’m referring to concepts and I might not be very good in conveying that. Sorry.

                                                                                      1. 1

                                                                                        In the end you can express pretty much anything in any editor with enough keystrokes: the arrow keys exist, after all.

                                                                                        Modal editing tends to be a lot more efficient than non-modal though, and the keystrokes don’t require you to move your hands much e.g. to the arrow keys (way off the home row) or to use modifiers like Ctrl that require stretching your hands. Modal editors allow you to use the keys that are the easiest to reach: the letter keys, since the modal editor knows whether you’re intending to write vs intending to issue commands. These days I mostly use VSCode, rather than Vim, but I always have Vim emulation turned on because it’s much faster than non-modal editing once you’re familiar with it. Vim is particularly nice because it has a mini language for expressing edits; for example, w means “word,” and can be combined with deletion to delete a word (dw), selection to select a word (vw), “yank” to copy a word (yw), etc — or it can be used alone without a prefacing action, in which case it simply jumps to the next word after the cursor position. And there are many other “motion” nouns like w, and those can also be combined with the action verbs in the same manner — to copy letters, paragraphs, etc, or even more complex ideas such as letter search terms. Command sequences are first-class and your last command can be replayed with a single keystroke, and there’s even a built-in macro definition verb q, which stores up indexable lists of command sequences you issue and can replay the entire lists for executing complex but tedious refactors.

                                                                                        Sure — the bottleneck in programming is typically not between your hands and the keyboard; it’s typically thought. But once you know what you want to express, it’s a very pleasant experience to be able to do it with such efficiency of motion. And since we do ultimately spend quite a while typing, it’s not irrational to spend some time learning a new system to have that time feel nicer.

                                                                                        1. 2

                                                                                          Modal editing tends to be a lot more efficient than non-modal though, and the keystrokes don’t require you to move your hands much

                                                                                          Real gain is in reduced load on one’s muscles and tendons. Moving to vim bindings has helped me overcome pain in my wrists.

                                                                                          1. 2

                                                                                            I don’t see it as much for programming, but for writing prose a modal editor is great for forcing me to separate writing from editing. When I write an article / book chapter in vim, I try to write the first draft and then go back end edit. At worst, I try to write entire paragraphs or sections and then edit. I find this produces much better output than if I use an editor that makes it easy to edit while I’m writing.

                                                                                    2. 5

                                                                                      This is something that the article comes close to saying, but doesn’t actually say: Vim doesn’t just provide a bunch of shortcuts and keybindings for arbitrary operations, instead it provides a fairly well thought out programming language for dealing with text, that happens to also be bound to convenient keys. Crucially, operations in this language can be composed such as in the examples that the article gives, so you can build up your own vocabulary of operations even if the developers didn’t account for them. Does this take longer to learn than looking up the? Yes, probably. But I suspect that for most vim fans, there comes a “aha moment” where the power of this approach becomes apparent, and once you get used to it, you can’t live with it.

                                                                                      1. 2

                                                                                        I’m not sure “n” for next is “some random key”? And “N” (shift-n[ext]) for previous.

                                                                                        And slash/question mark for search might be a bit arbitrary, but slash sorta-kinda “means” pattern/regex (as in /^something/).

                                                                                        Ed: ok, I’m not sure why op is exited about “find” - I generally “search”.. . Or move by word (w) beginning/end of line (| and $). See also: https://stackoverflow.com/questions/12495442/what-do-the-f-and-t-commands-do-in-vim#12495564

                                                                                        1. 1

                                                                                          Move by word - hold ctrl, works in any textarea in any operating system.

                                                                                          Move to beginning/end of line - press “home” or “end” keys, works in any textarea in any operating system.

                                                                                          n is “some random key” on every other software with a text box on your computer. Vim is inferior in that aspect, not superior.

                                                                                          1. 1

                                                                                            ) moves by sentence and } moves by paragraph. I miss that all the time while writing prose outside of vim.

                                                                                            Since they’re motions, you can combine them with delete/yank/replace/whatever. So di) deletes the whole sentence.

                                                                                            1. 1

                                                                                              Option up/down moves by paragraph.

                                                                                              1. 1

                                                                                                I’m on Windows

                                                                                        2. 2

                                                                                          The mental load goes away after a while and it just becomes muscle memory. Each saving by itself is small, but they all add up over time. One I used recently was %g/^State \d/norm! f:lD: “On every line that starts with State followed by a number, delete everything after the first colon. Would have taken several minutes without that, with it it’s just a couple of seconds. When I’m constantly getting savings like that, it’s worth it.

                                                                                        1. 1

                                                                                          At work, I generally use the o365 web client (on Linux). I’ve dabbled with outlook in my w10 vm, but it doesn’t seem worth it. And few people seem email literate anyway (probably in part because they’re stuck with awful tools, like Gmail and o365).

                                                                                          I made half an effort to see if I could get some sensible calendar/contact sync - perhaps via evolution - but I never got close to what I wanted (ie: online feedback on when people and rooms are available; ability to accept invitations and see other people accepting/declining). I’d be happy to hear of any success stories.

                                                                                          When I read more mail (a couple of lists, hundreds of support-related mails a day)- I used pine - and I’ve been ttoying with alpine more recently: https://alpine.x10host.com/

                                                                                          I’m in the (slow) process of building up email for my own domains again, and hoping to maybe use postgresql/dbmail for the mailbox/search - with the ambition of maybe exposing it via a graphql layer rather than IMAP.

                                                                                          Idea being that dbmail have LMTP sorted, as well as battle tested schema for mail storage and retrieval.

                                                                                          https://www.dbmail.org/

                                                                                          Ed: i also think that with dbmail handling inserting mail, it might be possible to extend the schema with a few pg fulltext indices, and enable search via pg fulltext search.

                                                                                          1. 2

                                                                                            In my e-mail golden days when I was able to keyboard-warrior through half a dozen W3C mailing lists, I’ve used Opera Mail. It was fantastic.

                                                                                            When Opera died I defaulted to Apple Mail, and it’s been a slow death of e-mail for me. It’s sooo primitive. How can people use e-mail clients with flattened barely-working threads, and binary “read” flag that automatically disappears after two seconds and you never find the message ever again?

                                                                                            Now there’s a revived Vivaldi Mail, so I’m giving it a try.

                                                                                            1. 4

                                                                                              Ah, Opera mail. What a shame it got sold rather than open sourced.

                                                                                            1. 3

                                                                                              One of the best feelings in the world is when you realize what makes lisp “LISP” rather than just a programming language is code as data, data as code. Because then you’ll see it everywhere, and suddenly you realize everything is a lisp, and all it’s like no one learned the lesson of the turing machine.

                                                                                              1. 3

                                                                                                Concatenative languages aren’t a LISP. They’re based on function concatenation, not function application, which is slightly but importantly different than lambda calculus. There’s a good explanation here: http://evincarofautumn.blogspot.com/2012/02/why-concatenative-programming-matters.html

                                                                                                “Everything is Turing complete” is not the same as “everything is a LISP”.

                                                                                                1. 2

                                                                                                  (…) what makes lisp “LISP” rather than just a programming language is code as data, data as code. (…) it’s like no one learned the lesson of the turing machine.

                                                                                                  “Everything is Turing complete” is not the same as “everything is a LISP”.

                                                                                                  The reference was to a single tape, holding data and instructions - not to the idea of Turing completeness.

                                                                                                2. 1

                                                                                                  If everything is a lisp, then lisp is just another programming language. You can’t have both uniqueness and ubiquity.

                                                                                                  1. 1

                                                                                                    This is the exact conflict that I enjoy experiencing :)

                                                                                                1. 1

                                                                                                  I hope winget will continue to improve, but for now it seems quite limited - even compared to https://scoop.sh and chocolately?

                                                                                                  And apparently you can’t winget iis or sql server? (but on Linux you can docker run sql server.. What à time to be alive…).

                                                                                                  Both python and ruby have long had rather good cross platform support -but the real test is compiling and linking against c extensions, and uploading wheels etc. Still seems there’s a bit of effort in getting a native compiler tool chain set up on windows? (but there’s been a lot of improved support for using msvc). And is there support for cross-compiling wheels?

                                                                                                  1. 2

                                                                                                    Please note that my post was very narrowly focused on Windows being used as a desktop environment for Python developers.

                                                                                                    All I want from winget is “Install the stuff I want from the command line” and the ability to create a JSON file I can make it execute against to get all the things I need on a new machine is awesome.

                                                                                                    1. 4

                                                                                                      Love to see it. I use Elixir everyday at work, and am a big fan of static types, so in principle I’m the target audience. However, I’m reluctant to give up the Elixir ecosystem I love do much. E.g. I’m really excited LiveView, Livebook, Nx, etc.

                                                                                                      What are the benefits / necessity of a whole new language as opposed to an improved dialyzer, or maybe a TypeScript style Elixir superset with inline type annotations?

                                                                                                      1. 11

                                                                                                        One issue is that existing Elixir code will be hard to adapt to a sound type system, more specifically in how pattern matching is used. For example, consider this common idiom:

                                                                                                        {:ok, any} = my_function()
                                                                                                        

                                                                                                        (where my_function may return {:ok, any} or {:error, error} depending on whether the function succeeded)

                                                                                                        Implicitly, this means “crash, via a badmatch error, if we didn’t get the expected result”. However this is basically incompatible with a sound type system as the left-hand side of the assignment has the type {:ok, T} and the function has the return type {:ok, T} | {:error, Error}.

                                                                                                        Of course we could add some kind of annotation that says “I mismatched the types on purpose”, but then we’d have to sprinkle these all over existing code.

                                                                                                        This is also the reason why Dialyzer is based on success typing rather than more “traditional” type checking. A consequence of this is that Dialyzer, by design, doesn’t catch all potential type errors; as long as one code path can be shown to be successful Dialyzer is happy, which reflects how Erlang / Elixir code is written.

                                                                                                        1. 5

                                                                                                          Of course we could add some kind of annotation that says “I mismatched the types on purpose”, but then we’d have to sprinkle these all over existing code.

                                                                                                          This is what Gleam does. Pattern matching is to be total unless the assert keyword is used instead of let.

                                                                                                          assert Ok(result) = do_something()
                                                                                                          

                                                                                                          It’s considered best practice to use assert only in tests and in prototypes

                                                                                                          1. 1

                                                                                                            What do you do when the use case is “no, really, I don’t care, have the supervisor retry because I can’t be bothered to handle the error and selectively reconcile all of this state I’ve built up, I’d rather just refetch it”?

                                                                                                            1. 1

                                                                                                              Maybe we need another keyword:

                                                                                                              assume Ok(result) = do_something()
                                                                                                              
                                                                                                              1. 1

                                                                                                                That is what assert is for.

                                                                                                              2. 1

                                                                                                                That’s what assert is. If the pattern doesn’t match then it crashes the process.

                                                                                                                1. 1

                                                                                                                  So why not use it in production?

                                                                                                                  1. 2

                                                                                                                    You can for sure. I was a bit too simple there. I should have said “It is best to only use assert with expected non-exceptional errors in prototypes`. There’s place for Erlang style supervision in Gleam in production.

                                                                                                            2. 3

                                                                                                              Great, succinct explanation!

                                                                                                              1. 2

                                                                                                                This is an interesting example. I’m still not sure I understand how it’s “basically incompatible”, though. Is it not possible to annotate the function with the possibility that it raises the MatchError? It feels kind of like Java’s unchecked exceptions a bit. Java doesn’t have the greatest type system, but it has a type system. I would think you could kind of have a type system here that works with Elixir’s semantics by bubbling certain kinds of errors.

                                                                                                                Are you assuming Hindley Milner type inference or something? Like, what if the system were rust-style and required type specifications at the function level. This is how Elixir developers tend to operate already, anyway, with dialyzer.

                                                                                                                1. 1

                                                                                                                  I don’t see how that’s a problem offhand. I’m not sure how gleam does it, but you can show that the pattern accommodates a subtype of the union and fail when it doesn’t match the :ok.

                                                                                                                  1. 4

                                                                                                                    The problem is the distinction between failing (type checking) and crashing (at runtime). The erlang pattern described here is designed to crash if it encounters an error, which would require that type checking passes. But type checking would never pass since my_function() has other return cases and the pattern match is (intentionally) not exhaustive.

                                                                                                                    1. 1

                                                                                                                      Ah, exhaustive pattern matching makes more sense. But also feels a little odd in Erlang. I’ll have to play with Gleam some and get an understanding of how it works out.

                                                                                                                2. 4

                                                                                                                  One thing is that TypeScript is currently bursting at the seams as developers aspirationally use it as a pure functional statically-typed dependently-typed language. The TypeScript developers are bound by their promise not to change JavaScript semantics, even in seemingly minor ways (and I understand why this is so), but it really holds back TS from becoming what many users hope for it to be. There’s clearly demand for something more, and eventually a language like PureScript / Grain / etc will carve out a sizable niche.

                                                                                                                  So, I think starting over from scratch with a new language can be advantageous, as long as you have sufficient interoperability with the existing ecosystem.

                                                                                                                  1. 2

                                                                                                                    I won’t go too much into Dialyzer as I’ve never found it reliable or fast enough to be useful in development, so I don’t think I’m in a great place to make comparisons. For me a type system is a writing assistant tool first and foremost, so developer UX is the name of the game.

                                                                                                                    I think the TypeScript question is a really good one! There’s a few aspects to this.

                                                                                                                    Gradual typing (TypeScript style) offers different guarentees to the HM typing of Gleam. Gleam’s type system is sound by default, while with gradual typing you opt-in to safety by providing annotations which the checker can then verify. In practice this ends up being quite a different developer experience, the gradual typer requires more programmer input and the will to resist temptation not to leave sections of the codebase untyped. The benefit here is that it is easier to apply gradual types to an already existing codebase, but that’s not any advantage to me- I want the fresh developer experience that is more to my tastes and easier for me to work with.

                                                                                                                    Another aspect is just that it’s incredibly hard to do gradual typing well. TypeScript is a marvel, but I can think of many similar projects that have failed. In the BEAM world alone I can think of 4 attempts to add a type checker to the existing Elixir or Erlang languages, and all have failed. Two of these projects were from Facebook and from the Elixir core team, so it’s not like they were short on expertise either.

                                                                                                                    Lastly, a new language is an oppotunity to try and improve on Elixir and Erlang. There’s lots of little things in Gleam that I personally am very fond of which are not possible in them.

                                                                                                                    One silly small example is that we don’t need a special .() to call an anonymous function like Elixir does.

                                                                                                                    let f = fn() { 1 }
                                                                                                                    f()
                                                                                                                    

                                                                                                                    And we can pipe into any position

                                                                                                                    1
                                                                                                                    |> first_position(2)
                                                                                                                    |> second_position(1, _)
                                                                                                                    |> curried_last_position
                                                                                                                    

                                                                                                                    And we have type safe labelled arguments, without any runtime cost. No keyword lists here

                                                                                                                    replace(each: ",", with: " ", in: "A,B,C")
                                                                                                                    

                                                                                                                    Thanks for the questions

                                                                                                                    edit: Oh! And RE the existing ecosystem, you can use Gleam and Elixir or Erlang together! That’s certainly something Gleam has been built around.

                                                                                                                    1. 1

                                                                                                                      Two of these projects were from Facebook and from the Elixir core team, so it’s not like they were short on expertise either.

                                                                                                                      Oh, wow, I don’t think I’ve heard of these! Do you have any more info? And why was Facebook writing a typechecker for Elixir? Are you talking about Flow?

                                                                                                                      1. 1

                                                                                                                        Facebook were writing a type checker for Erlang for use in WhatsApp. It’s not flow, but it is inspired by it. I’m afraid I don’t think much info is public about it.