1. 2

    Or… don’t perform a generative stabilization loop in your destructor. This action is sufficiently meaningful to deserve its own method.

    1. 6

      [[tangential]] what’s with all the swearing nowadays? Has it become impossible to drive a technical point without swearing? I’m maybe becoming one hell of a grizzli bear but I find that to be a major turn-off.

      1. 6

        There’s no swearing here by typical standards. There is a Bowdlerized expletive in the title, but that word has explicitly been neutered. The author committed a crime against words in order to avoid swearing in front of you.

        1. 3

          If you declare yourself a fan of hobos, swearing is de rigueur.

        1. 6

          If someone comes to you and ask you to make things sloppier, your answer should be no.

          Words to live by.

          1. 5

            I am recurrently trying to build a minimalist LISP. I use it as a platform to try a few things like continuation-passing style, GC vs ARC, async vs MT, etc. It’s also a place of my own where I can be as anal about the code as I want to, some kind of engineering-oriented mental bachelor pad.

            1. 12

              Discussing the future of operating systems is fine, but not while ignoring the past. There had been at least 20 years of OS research before linux with a lot of interesting ideas wildly different from the “everything is a file” world view.

              For instance, z/OS. It has been powering large mainframes for 40 years. Every user run in its own VM (z/VM) where he has access to a full OS. Everything is not a file but a database. It’s the grand-daddy of cloud OSes.

              Symbolic operating systems, like those on Lisp machines, also are a lot of fun to read about.

              1. 4

                That’s VM/CMS (CMS, Conversational Monitor System, being the per-user VM). z/OS is a batch processing system historically, still used for that role.

                1. 1

                  I read somewhere that VM/CMS was one of the few hotbeds of “hacker culture” outside of UNIX.

              1. 4

                Server-side I would bet that in this day and age the POWER fleet is probably the largest after x86/arm. Z might not be weighing much in terms of raw population count but it’s powering a lot of large, critical systems. In the deep-embedded world STM chips are pretty widespread.

                1. 1

                  deep-embedded world STM chips

                  This is ARM (Cortex-M) though.

                  1. 1

                    The larger STM32, yes. Not the 8-bit/16-bit micro-controllers. That being said, the generations I was used to are now marked “legacy” (ST7/ST10), so I might very well be wrong.

                    1. 4

                      I get the impression new designs aren’t using the 8 or especially 16-bit MCUs anymore. Cortex-M0 (and soon RISC-V) ate their lunch. Of course, they’ll be around forever, as embedded designs tend to be.

                1. 2

                  Racket:

                  (for/fold ([p #f]
                             [cnt 0]
                             [counts null]
                             #:result (cdr (reverse (cons `(,p ,cnt) counts))))
                            ([c (in-string "aaaabbbcca")])
                    (if (equal? p c)
                        (values c (add1 cnt) counts)
                        (values c 1 (cons `(,p ,cnt) counts))))
                  
                  1. 1

                    Also using fold, with mnm.l :

                    (def challenge (IN)
                        (foldr (\ (C ACC)
                                 (let ((((V . N) . TL) . ACC))
                                   (if (= C V)
                                     (cons (cons C (+ N 1)) TL)
                                     (cons (cons C 1) ACC))))
                          IN NIL))
                    
                    1. 1

                      Racket’s group-by is wonderful but I usually want to group consecutive equal items into clumps as they arise rather than a single monolithic group.

                      (define (group xs)
                        (match xs
                          [(cons x _)
                           (define-values (ys zs) (splitf-at xs (curry equal? x)))
                           (cons ys (group zs))]
                          [_ null]))
                      
                      (define (encode xs)
                        (for/list ([x xs])
                          (list (first x) (length x))))
                      
                      (encode (group (string->list "aaaabbbcca")))
                      
                    1. 1

                      I never understood the value proposition of ReasonML. Was it really to make ML more palatable to a corpus of engineers broken to imperative-style languages (and more specifically JS)?

                      1. 3

                        The slogan I heard was “React as a language”, which makes sense.

                        React is a framework that encourages use of a functional style for your apps. And React is often written in dynamically typed JS. So it makes sense to write React-style apps in a statically typed functional programming language.

                        1. 1

                          I see, thanks. The fact that the two were intertwined was lost on me.

                      1. 9

                        OCaml is arguably small (it’s definitely not easy to find a job for it), but I’ve been using it for web development, hardware development, and even to play around some graph algebra. I love ML in general, but I am particularly fond of OCaml for the above-average quality of the ecosystem (and PPX extensions!).

                        1. 8

                          At 10 years in, I find myself agreeing with everything. It’s sufficiently rare an occasion to warrant this shamelessly me-too-ing comment.

                          1. 3

                            There is no point in using std::vector if the size remains contant. There is std::array for that, which has a (mostly) compile-time interface that is comparable to primitive C arrays.

                            1. 1

                              Two things to note though are that you have to know the size at compile time, and std::array has automatic storage duration, so depending on size and environment that may be prohibitive.

                              I think the problem is the intersection between needing a large fixed size array and not being able to pay the overhead of storing the one extra pointer in a std::vector is fairly small.

                            1. 3

                              The year of the mainframe, as a computing model if not as a technology: modern personal computers as dumb terminals, large batched jobs, large data sets stored remotely.

                              1. 7

                                It’s the same architecture as the Infiniband verbs (WR+CQ, a primer), one of the (if not the) best asynchronous I/O interface I’ve ever used. It definitely looks like a promising piece of work.

                                1. 1

                                  Notable details from the doc:

                                  Gatekeeper performs online checks to verify if an app contains known malware and whether the developer’s signing certificate is revoked. We have never combined data from these checks with information about Apple users or their devices. We do not use data from these checks to learn what individual users are launching or running on their devices.

                                  Notarization checks if the app contains known malware using an encrypted connection that is resilient to server failures.

                                  These security checks have never included the user’s Apple ID or the identity of their device. To further protect privacy, we have stopped logging IP addresses associated with Developer ID certificate checks, and we will ensure that any collected IP addresses are removed from logs.

                                  In addition, over the the next year we will introduce several changes to our security checks:

                                  • A new encrypted protocol for Developer ID certificate revocation checks
                                  • Strong protections against server failure
                                  • A new preference for users to opt out of these security protections
                                  1. 2

                                    We have never combined data from these checks with information about Apple users or their devices. We do not use data from these checks to learn what individual users are launching or running on their devices

                                    It’s nice to hear them state that explicitly, I wonder if people believe it when it comes from Apple.

                                    1. 1

                                      I might have misunderstood but I thought people where mostly worried about data collection and MITM attacks given that the ocsp.apple.com requests are made in clear. I don’t believe Apple’s doc actually address those concerns.

                                      1. 3

                                        The responses are signed, even in the current version, so a MITM can’t fake them. They can DoS the user, though.

                                        1. 4

                                          They might be signed, so they can’t be MITM, but the issue is that all that tracking data is being sent in cleartext.

                                        2. 1

                                          A new encrypted protocol for Developer ID certificate revocation checks

                                          Doesn’t this address it? Or is this about something else?

                                          1. 2

                                            Ah, you are right, it does address it… but as a future feature. That means the current implementation is indeed open to the winds.

                                    1. 3

                                      I wish the OP good luck with finding their next language.

                                      The one argument that rings true is the overall quality of the documentation. Not the core language, mind (that one is usually quite excellent), but for most libraries in the ecosystem. It’s not that it’s bad in the sense of lacking or half-backed, but I feel like library authors expect a very high level of fluency in the language and the concepts from their users. Lwt is indeed a good example of a critical piece of software in the OCaml ecosystem that could deserve a bit of documentation TLC.

                                      For the other points, YMMV:

                                      • I have never needed multicore OCaml and Lwt has always been more than enough for my use cases.
                                      • I have always found OCaml tooling to be first class (the compiler itself has gotten a lot better with error reporting over the years, merlin and ocaml-lsp are top shelf).
                                      • IDE integration has always been premium within vim. The OP issues could be because of ReasonML.
                                      • The only tool you really need is opam. The dune build tool is certainly an improvement over the dark days of oasis and ocamlbuild but it is not required to get started. I have never heard of esy and never ever used it.
                                      • “Real World OCaml” is excellent for any beginner wanting to get into the language.

                                      If support for some API or service is missing I usually end up writing the necessary libraries. I always found that fairly straightforward especially given the very high quality of some core libraries like opium, cohttp, or conduit, to mention only a few. But I understand how that could be seen as an impediment when the focus is to deliver a PoC or a MVP.

                                      1. 2

                                        The only tool you really need is opam. The dune build tool is certainly an improvement over the dark days of oasis and ocamlbuild but it is not required to get started. I have never heard of esy and never ever used it.

                                        This may be true, but when I was learning OCaml there was no way for me to find it out. There was no high-level description of how the tools fit together; all the docs that mentioned ocaml, dune, and ocamlbuild just assumed you were already familiar with what they were for. As someone new to the language, it just made my head spin trying to figure out how the pieces fit together.

                                      1. 6

                                        I would pay pretty money for an upscaled version of DS9. Not that I need an excuse to watch it again for an umpteenth time.

                                        1. 4

                                          Over the years I found that promotions and raises are disconnected from your worth as a professional and are the results of political scheming.

                                          Certifications and degrees are means to achieve personal growth but not a measure of career growth.

                                          I added the following dimensions to evaluate my career growth:

                                          • How much freedom I have to explore new/innovative technologies and use them in a production settings.
                                          • How much freedom I am given to manage my own time and to work from a place of my choosing.

                                          Time and intellectual freedom is the ultimate currency because it is absolutely finite and is based on professional trust.

                                          1. 10

                                            I overall agree with the post except for the following:

                                            Claiming there isn’t enough is a great way to look like you’re trying to help but not have to do anything.

                                            Unsubstantiated bug reports also encourage buck-passing behavior between departments. I wasted enough time in my career digging down root causes of bug reports passed along to me by other team members to finally discover that the issue was within components under their purview.

                                            Now I consider common courtesy to provide developers with a minimal scenario that reproduces the bug or, when not possible, sufficiently detailed information surrounding the failure so as not to waste the developer’s time.

                                            The fact that most large OSS projects request the same courtesy from their bug reporters (GCC comes to mind) comforts me in my decision.

                                            1. 4

                                              Sometimes the end-user is not-so technical, and mostly unable to grok the indications to reproduce the problem:

                                              Dev: can you provide me the .log files?

                                              User: what are logs? where are they? how to open .log files? what? no! I won’t ship you my device (was that what you were asking?).

                                              Issue: (after 3 weeks) “pending information from client” -> “cannot reproduce”

                                              1. 5

                                                In that case the dev should work with the user to repro the issue. Break down the communication wall!

                                                1. 3

                                                  I like this way to do it. That leads to a bugfix. While it is good to avoid bothering the non-tech user with technobabble, sometimes there is simply insufficient data for meaningful answer…

                                                  1. 3

                                                    Yeah, part of the dev’s job is to extract info from the user but not spout babble at them. Explaining things simply is always a good skill to have.

                                                    1. 3

                                                      Also a really damn hard one. It tends to pay dividends though.

                                            1. 11

                                              Thanks for posting! I wrote this with the help of some wonderful contributors. I’d be happy to work on any feature requests or answer any questions.

                                              1. 13

                                                Indeed, I’m excited and impressed at the the contributions to neovide. This is a case where Nvim’s decoupled architecture seems to bear fruit (which isn’t always totally obvious :)–people can fully embrace new ecosystems like rust without being blocked by Nvim’s tech stack.

                                                Recently https://github.com/equalsraf/neovim-qt/ (c++) has been picking up steam as well thanks to some talented contributors.

                                                For more on Nvim arch see also: https://lobste.rs/s/gchgjr/switch_sway#c_df7js3

                                                1. 8

                                                  I can not say enough good about neovim’s design. By taking care of the text editing part, I can focus on the front end concerns such as font selection, glyph calculations, and text rendering. Zero to functioning text editor was really fast as well so it was easy to get started

                                                  I highly recommend making a neovim gui as it gives you a better understanding of how things work in the text editor. @jmk and company have been doing amazing work

                                                2. 1

                                                  I immediately gave it a shot as I am avidly looking for a nvim GUI interface with good performance and ligature support, but was greeted with a SIGSEGV on OS X 10.15.3. It looks like a know issue, so I’ll keep my eyes peeled.

                                                  1. 1

                                                    Wanna help debug? I don’t have access to a mac and so am kind of at a loss for how to fix this. I think it has something to do with font-kit, but I don’t have any way to know beyond that

                                                1. 5

                                                  It’s rare that I find myself less in disagreement with an “… about software engineering” laundry list.

                                                  Most measures of success are almost entirely uncorrelated with merit

                                                  This one I think is a nugget which only become obvious after years of experience in the business. Understanding this is also, IMHO, the first step to reach a better appreciation of self-worth and work-related accomplishments.