1. 15

    Other TL;DR: Just pay for the thing if you’re a big company.

    1. 9

      It’s kind of easy to say, and likely doable in the smaller end of the “big company”. But at some level of corporate, you also have to fight with “the process”. In other words, if I get a choice to spend a week migrating to podman or to deal with expense approval chains, legal, it, management, etc. then there’s a really good chance I’m going with podman. (If no critical features are missing)

      1. 6

        Wouldn’t you also have to get legal and IT approval to introduce Podman in places where you were previously using Docker?

        1. 4

          Depends on the project. In some cases yes, in others, if it already comes with an approved distro then no.

          1. 1

            No doubt these places exist, but the theoretical company you describe sounds like a really miserable place to work

          2. 4

            There’s also an argument that we should try to support good open source projects when they offer paid products that we actually also use.

        1. 3

          Battle hardened and somewhat cynical opinion. Keep a virtual machine, set it up once, keep track of every click and command, then you have a run list.

          It’s up to you if it’s worth it to lift that to a higher level of abstraction. Your test is just bash bats tests from a clean virtual machine + setup script. Keep a Brewfile if you want to define a version set that way.

          Because it’s a domain that is not as well developed when it comes to tooling, I think the sober advice of just be disciplined about your recipe and roll a VM til it’s right is probably less time consuming than googling what’s wrong with some unpolished / sharp edges tool.

          1. 2

            Anyone have a primer for the kind of language used in these distill projects? The jargon is dense, but the outputs are awesome.

            1. 1

              If the author reads this, thanks. These are great.

              1. 1

                I might be curmudgeon here, but I don’t think this project will live for long. The power of emacs comes from the ability to modify everything using a simple language - lisp. Adding javascript just increases complexity (ok, performance might be better) and adds an inconsistent language to the mix.

                1. 4

                  I’ll be very interested to see how far it goes. If there is one language that could be used in a project like this and survive, Javascript would be it.

                  1. 3

                    Legitimately curious what would prevent a lisp to underlying typescript / javascript interpreter to interop with existing elisp.

                    1. 3

                      I tried writing a simple elisp-to-js transpiler some time ago, it’s doable and mostly straightforward (macros are tricky, but doable). I lost interest after I’d gotten the basics working (functions, variables, simple data types, macros). Maybe I should go back to that little project, it was fun.

                      1. 1

                        Sounds fun and like it could have practical/research benefit to this project!

                      2. 1

                        Same, it’s something I’ve been wondering for a long time. I genuinely don’t understand why, as an example, why can’t I use python’s regex functions (which I already know) to manipulate strings. Apart from performance concerns, of course, but often there aren’t any.

                        For me, the power of emacs usually comes from

                        • advice system
                        • scoping rules: sucks that lexical scope isn’t the default, but it’s nice when you can easily override any global variable over the course of a single function call
                        • integration with the runtime, e.g. REPL, evaluating arbitrary form in the file, being able to jump to any function source, etc.

                        I don’t see why this all can’t be achieved in other languages (but I’m happy to be convinced!).

                    1. 7

                      I’ve used emacs for years and I still managed to learn some tricks from the first section. The rest is insightful. Upvoting both for the effort put into this and the actual content.

                      1. 8

                        One of the better histories I’ve read in some time. Thanks.

                        1. 4

                          Clickbait, and I didn’t come away from it with any real positive takeaway. This entire thing boils down to the Overton window. I’ll let the link speak for itself rather than editorializing.

                          https://en.wikipedia.org/wiki/Overton_window

                          1. 2

                            There’s also -fstack-protector-all. And note that both clang and gcc support -fstack-protector* It’s important to keep in mind that stack cookies are generally not effective against today’s exploitation techniques. Use of the combination of ASLR, strong W^X (applying W^X both to memory map creation and memory protection attribute changes post-creation), and both forward-edge and backword-edge cross-DSO CFI provide much better exploit mitigation coverage than simple stack cookies.

                            1. 1

                              Is there a good overview of these that you can point to?

                              1. 3

                                The HardenedBSD wiki is a good starting point: https://git-01.md.hardenedbsd.org/HardenedBSD/hardenedbsd/wiki

                                Caveat for what I said above: it’s still worth it to apply stack cookies, since there’s not much of a perf hit. But, newer and stronger exploit mitigation techniques have joined the playing field and can complement stack cookies.

                                1. 3

                                  This is great context. Just a thank you

                            1. 5

                              My technological dream: laws are written in a restricted, runnable language (let us say, Prolog) and validated whether they conflict with other laws before they get ratified.

                              And looking to the predicates in the predicate.pl file, it seems a (minimalist) vocabulary of validations (well, predicates…) was developed, which is a great effort per se, in my opinion. :)

                              1. 4

                                Assuming laws will never be written in anything but words with their own legal formalities I think it’s more plausible that there will be nlp “burden detection” on entities that are extracted from existing law, then reviewed and tagged by humans. As I understand it existing work in this area bumps up against the fact that there is a lot of manual work reviewing the output of a tagged legal document for determining accuracy of what is binding upon which people in which situations.

                                However, once past a critical mass of tagged and reviewed documents I can see how things like “validated” and “in conflict” can be done in a more automated fashion. American law ends up being that which is passed, then of course the text of the judicial rulings and precedent. If only the full text of constitution to the first bill passed by congress, all the way through to today’s explosion of daily judicial decisions were all available in a single place for that sort of nlp to work against.

                                Neat links, thought about this too much. Of course the tools lawyers use probably already have approximations of what I’m describing but they’re not at all free. :)

                                https://en.wikipedia.org/wiki/An_act_to_regulate_the_time_and_manner_of_administering_certain_oaths

                                ^^ first act passed by congress

                                https://www.thestrangeloop.com/2019/improving-law-interpretability-using-nlp.html

                                ^^ really good presentation on this subject

                                1. 3

                                  Someone did codify French tax law to find discontinuities. We should do this sort of thing as a matter of course for mathematical laws like those for taxes.

                                  https://blog.merigoux.fr/en/2019/12/20/taxes-formal-proofs.html

                                1. 2

                                  I gotta say, the end of this when he talks about retirement drove me out of lurking to comment.

                                  In the middle of a successful career I look forward to probably one of the fastest moving fields when it comes to ‘new words’. Just separating the noise from the signal as new improvements on older tech come out is real work, elbow grease, and a matter of keeping abreast enough of the progression of tools.

                                  Places like this are gems in the rough where in you all help each other surface good links for perusal. Gonna come in handy, thanks.

                                  1. 15

                                    Haskell is a fascinating language that will give you a better understanding of functional programming concepts than other languages. Learn you a Haskell for Great Good is a great resource for beginners:

                                    http://learnyouahaskell.com/chapters

                                    1. 3

                                      Worked at a Scala shop, been into functional programming for years. I’ll safely say that The Haskell Book is when a lot of the more esoteric words of FP “click” into place for me.

                                      https://haskellbook.com/

                                      1. 2

                                        If you like concise writing, however, I recommend Hutton’s and Bird’s books for learning Haskell.

                                      2. 2

                                        I worked through LYAH and really enjoyed it. However, I’m feeling a bit stuck. The code I see online has difficult to grok language extensions, like existential quantification. Or complicated type based approaches like Servant. I even struggle to understand how the json library Aeson works.

                                        What’s a good next step if I’d like to become proficient?

                                        1. 3

                                          Shameless plug for the Applied FP Course :) (disclaimer: I wrote it) Staged levels designed for the gap between intro material and building things that squeak and move. There’s lots of helpful peoples that lurk in the #qfpl #haskell-beginners channesl on IRC, or one of the no-doubt several FP discords. :)

                                          1. 2

                                            What’s a good next step if I’d like to become proficient?

                                            In my experience? Start writing real projects in Haskell, work with other Haskellers. You can also use these resources.

                                        1. 1

                                          I like this abstract, printed it out to read. Anyone have other papers in this realm that they think are cool?

                                          1. 2

                                            I like “Compiling to Categories” by Conal Eliott. His original goal was to compile Haskell functions to hardware, like FPGAs. But instead of creating a whole separate compiler, he added a feature to GHC that lets you “Overload lambda”. That means you can take an ordinary lambda expression like (\a b -> square a + square b) and interpret it as a combinational circuit, or a GPU shader, or an SVG of the dataflow… One of the many applications is automatic differentiation.

                                            I also like “Dex: array programming with typed indices”:

                                            The Matlab/NumPy model of array programming avoids explicit loops and indexing and it can be impressively concise. But it can also feel obfuscated. […]

                                            The traditional scalar loops of Fortran and C are more explicit, but much heavier. […]

                                            Can we have the best of both? The clarity of indexing explicitly and the succinctness of looping implicitly? Perhaps!

                                            When I used Matlab for a class, I found it really hard to keep track of the implicit array indexing. It’s nice to know I’m not the only one, and their solution looks really slick!

                                          1. 6

                                            A variety of threads have led me to wonder how to build ergonomic typesafe state machines.

                                            I made a reasonably complex one last night in Rust that follows this pattern [1]. While I think I could do more with it, the macro system made the final product look pretty clean. Stepping through state transitions with the guarantees that setup gives I’m sure will come in handy.

                                            [1] https://hoverbear.org/blog/rust-state-machine-pattern/

                                            1. 9

                                              Finally made an account to post this. I’ve certainly been on team linux moreso than windows since the late 90s but in the past month I’ve gotten a very nice, very modern setup on the latest insider builds of windows 10. All of the “crap” can be disabled, and didn’t take a very long time in the new builds. Turn off cortana and whatever else starts on bootup and Windows is just absolutely no longer annoying. Specifically the start menu improvements. Just install stuff with chocolatey.

                                              The microsoft terminal is exactly what you’d want it to be though and paired with WSL2 specifically I find it reasonably uncompromising and fast. I have docker working within it perfectly atop both Alpine and Ubuntu-18.04.

                                              The docs here and at the “command line” blog are basically all I followed. https://devblogs.microsoft.com/commandline/ https://docs.microsoft.com/en-us/windows/wsl/about https://www.windowscentral.com/how-join-windows-insider-program

                                              Protips: you can pipe between windows and linux applications back and forth and it “just works”. Visual Studio Code has interop w/ the WSL that also “just works”, as does the “localhost” development story for things that open ports on the thin wsl2 sidecar hyper-v thing that runs a full linux kernel. You can browse your linux filesystem with explorer.exe and it’s fast. There are a few X servers for windows, but the paid X410 is the one that works the best and makes it so i can’t tell the difference between which windows are linux and which are classic windows programs.

                                              In general I never thought I’d be on team Microsoft in this respect. I pretty much think with these strides it’s likely the death of Windows a second class citizen in many respects.

                                              1. 1

                                                Thanks for the reference to X410. I’ve been dabbling more with WSL2 in an attempt to avoid macOS lock in, however VcXsrv was too quirky with Intellij for me.

                                                While I can still tell the difference between Intellij running natively on Windows compared to X410, particularly my intolerance for font rendering on Linux, it’s feeling acceptable enough to continue down the WSL2 path (still hoping for Intellij to support WSL2 directly ala VS Code Remote!).

                                                I’ll say that the new windows terminal app is promising too, but lacks a lot of the polish that I’ve grown accustomed to from iTerm2… primarily around searching output and generating clickable hyperlinks.