Newest Comments


    Nonguix exists and has substitute servers that include the mainline kernel and other popular software like steam and Firefox. So what you want in this case is available given a little research and setup.


      I wonder how much effort it would require to build a similar system on top of a R7RS compatible scheme, with minimal amount of extensions. We can’t divorce Guix with GNU. The Nix language is honestly the worst thing about Nix package manager.


        How does this compare to algebraic effects? I’m not super familiar with each but what I grasp is that they are a generalized version of try/catch & with the ability to resume after the throw.

        Is that correct & is this the same?


          Ah, I didn’t realize you needed to own the function to call it.

          I incorrectly thought changing Option<F> to F would allow writing self.0().


            I don’t know what this means. I’m neither a games dev nor a failed games dev. So… am I not a programmer?


              Company: ThousandEyes (part of Cisco)

              Company site:

              Position(s): pretty much everything but I’m looking for SREs.

              Location: US, UK, Portugal (remote or on-site)

              Description: ThousandEyes is a digital experience monitoring tool used by many to monitor their online services’ performance. We’re looking for SREs on all our teams. This is by far the best place I’ve ever worked in. The culture is just awesome.

              Tech stack: AWS, Kubernetes, Terraform, Puppet, Prometheus, Grafana, Kibana…

              Compensation: pretty competitive I’d say.

              Contact: or my email.


                For Drop. MaybeUninit<F> would’ve worked as well, but that needs unsafe.


                  When I dismissed it, Twitter redirected me to their homepage. When I clicked the link again it did the same thing. Safari on a patched up Mac.


                    Oh, and one of the comments in the article talks about longjmping out of a signal handler. Never do this. setjmp stores only the callee-save register state: it is a function call and so the caller is responsible for saving any caller-save state. Signals are delivered at arbitrary points, not just at call points, and so you will corrupt some subset of your register state if you do this.

                    I think you’re wrong here.

                    The POSIX standard says this about invoking longjmp() from a signal handler:

                    The behavior of async-signal-safe functions, as defined by this section, is as specified by POSIX.1, regardless of invocation from a signal-catching function. This is the only intended meaning of the statement that async-signal-safe functions may be used in signal-catching functions without restriction. … Note that although longjmp() and siglongjmp() are in the list of async-signal-safe functions, there are restrictions on subsequent behavior after the function is called from a signal-catching function. This is because the code executing after longjmp() or siglongjmp() can call any unsafe functions with the same danger as calling those unsafe functions directly from the signal handler. Applications that use longjmp() or siglongjmp() out of signal handlers require rigorous protection in order to be portable.

                    It also says this:

                    Although longjmp() is an async-signal-safe function, if it is invoked from a signal handler which interrupted a non-async-signal-safe function or equivalent (such as the processing equivalent to exit() performed after a return from the initial call to main()), the behavior of any subsequent call to a non-async-signal-safe function or equivalent is undefined.

                    So it seems the extra restriction mentioned before is that longjmp() and siglongjmp() cannot be used from a signal handler that interrupted a non-async-signal-safe function.

                    There are other restrictions. The standard says this about them:

                    If the most recent invocation of setjmp() with the corresponding jmp_buf occurred in another thread, or if there is no such invocation, or if the function containing the invocation of setjmp() has terminated execution in the interim, or if the invocation of setjmp() was within the scope of an identifier with variably modified type and execution has left that scope in the interim, the behavior is undefined.

                    So the function with the setjmp() invocation must be in the same thread and still on the stack (i.e., the invoking function has not returned), and it also has to be in scope (i.e., execution must be in the same C scope as the setjmp() invocation).

                    In addition:

                    All accessible objects have values, and all other components of the abstract machine have state (for example, floating-point status flags and open files), as of the time longjmp() was called, except that the values of objects of automatic storage duration are unspecified if they meet all the following conditions:

                    • They are local to the function containing the corresponding setjmp() invocation.

                    • They do not have volatile-qualified type.

                    • They are changed between the setjmp() invocation and longjmp() call.

                    All three of those conditions have to exist for the value of local variables to be unspecified. If you have a pointer to something in the stack, but in a function above, you’re fine; the pointer doesn’t change, and the contents at the pointer are specified. If you have a pointer to a heap allocation, the contents of the heap allocation are specified. And so on.

                    All of this is to say that you are broadly right, that code should usually not longjmp() out of signal handlers. But to say never seems a bit much, if you do everything right. Of course, like crypto, you should only do it if you know what you’re doing.

                    Also, I believe that the quotes above mean that if an implementation does not save caller-save registers, it is wrong. The reason is that the compiler could have lifted one local into a caller-save register. If that local does not change between the initial setjmp() and the longjmp() back to it, that caller-save register should have the same value, and if it doesn’t, I argue that the implementation does not follow the standard, that the implementation is wrong, not the application, especially since it is legal for an implementation to use a macro. In fact, the standard has several restrictions on how setjmp() can be invoked to make it easier to implement as a macro:

                    An application shall ensure that an invocation of setjmp() appears in one of the following contexts only:

                    • The entire controlling expression of a selection or iteration statement

                    • One operand of a relational or equality operator with the other operand an integral constant expression, with the resulting expression being the entire controlling expression of a selection or iteration statement

                    • The operand of a unary ‘!’ operator with the resulting expression being the entire controlling expression of a selection or iteration

                    • The entire expression of an expression statement (possibly cast to void)

                    If the invocation appears in any other context, the behavior is undefined.

                    Source: I implemented a longjmp() out of a signal handler in my bc and followed all of the relevant standard restrictions I quoted above. It was hard, yes, and I had to have signal “locks” for the signal handler to tell if execution was in a non-async-signal-safe function (in which case, it sets a flag, and returns normally, and when the signal lock is removed, the jump happens then).


                      See also the issue where they were removed – that issue & the see also links show why it didn’t work for Rust:



                        Company: Systems and Technology Research

                        Company site:

                        Position(s): Programming Languages Researcher, Software Reverse Engineer, Vulnerability Researcher, and more on the site

                        Location: Arlington, VA or Boston, MA. Most roles offer flexibility in WFH vs in-office, but some projects necessitate being in the office more.

                        Description: we do applied R&D for our clients, who bring us some pretty thorny problems. We’re not afraid of using whatever might give us an edge, however. In the two years I’ve been here, I’ve worked with static analysis, dynamic analysis via binary instrumentation, genetic optimization, grammar-based fuzzing, building LLVM compiler passes, and other fun tech. While the roles I mentioned above are rather specific, we’re very interested in strong generalists who have a deep understanding of computers and want to apply that daily.

                        Tech stack: highly project-dependent. I’m currently writing Haskell, and previously I’ve written code in assembly, C++, Python, and Rust on other projects.

                        Compensation: competitive salary and benefits

                        Contact: please contact me at $ if any of this sounds intriguing.


                          I tried opening the original Twitter link in a non-logged-in window and was able to read it with no difficulty.

                          Twitter’s log-in modal is optional and you can simply dismiss it and keep reading.


                            Company: Mission Lane

                            Company Site:

                            Position(s): Many open roles, but I have 2 openings on my team specifically for backend software engineers

                            Location: Remote (we have offices in Richmond VA and San Francisco if you’re interested in them though)

                            Description: Because there are so many open roles, it’s hard to pinpoint one description here. I can tell you that we have multiple products, including credit cards, debit cards, and a gigs app to help people find/track their gig income and make informed decisions about how they earn money. (Mission Lane, Mission Money, and Earn by Mission Lane in the app stores)

                            Regardless which team you work on, you will own your team’s domains and services from start to finish. You’ll build your app, deploy it, and monitor/maintain it. We work closely with our product owners (who are part of the team, not separate and distinct) to put out the most impactful features we can. You will be responsible for writing code, reading code, reviewing PRs, mentoring others, and rotating on-call for your own apps (you won’t be on-call for things you don’t own). While we’re at work, we work! But we take time off and encourage you to maintain your personal life. You will not be expected to work overtime or weird hours. Your time is your own outside of work. There is unlimited PTO, but we truly do encourage people to take it off and not burn out.

                            Tech Stack:

                            • Credit: Kotlin, GCP, kibana, k8s, JavaScript/TypeScript/React/React-Native, GraphQL
                            • Debit: NodeJS, TypeScript, GCP, k8s, kibana
                            • Gigs: Java/Kotlin, TypeScript/React-Native

                            Compensation: Depends on the pay band, but we pay based on national rates, not local (no matter where you are). Unlimited PTO (that we actually encourage you to take), 401k - 100% on the first 3%, 50% on the next 3% up to 6% for a total company match of 4.5%

                            Contact: – or if you really want you can message me and ask questions. I’ve worked here for about 3 years as both a tech lead and (now) an engineering manager. Happy to give you straight facts on the company / how it is working here.


                              Looks like I can no longer edit my post. The Git Systems role has been posted.


                                Sorry, I didn’t check that the article was up-to-date! I just remembered that I used to have exactly the problem that you described and that setting fixed it.


                                  I personally am not a fan of linguistic prescriptivism. Rendering is the term for a lot of things. For example, melting down fat, or to return something. Render, according to Merriam-Webster, also means to cause to be or become, which is apt description of what these servers are doing.


                                    Preferring to read minified code seems difficult regardless of display.

                                    I did it for years.

                                    Minified code is not the same as code that doesn’t use whitespace to indicate structure.

                                    Paren / delimiter matching in editors is a big help too.

                                    How would code be laid out if there be a preference to not use indentation at all? The joke has always been that the semicolon-loving languages break and indent the same way whitespace-sensitive languages

                                    And what of the Lisps? There was a time when I would write Lisp breaking all of the sighted-Lisper formatting conventions, like, keeping parens on their own lines and uncuddled, to make it easier to navigate. That’s a form of using space to indicate structure, but it’s vertical not horizontal, and not dependent on the indentation level.

                                    There are conventions some blind Python programmers use to make their code easier to navigate, like “# endif blah” markers at the end of compound statements.


                                      Why Option<F> instead of just F?


                                          This is a little behind the current ecosystem. For folks stumbling across this now, at work we use Rel8, which is a wrapper over Opaleye. Absolutely excellent - a lot of the Opaleye composability benefits with great ergonomics for common use cases.