dasyatidprime

My point above was not about how to deal with it, but only to point in the direction of it being very very much not a “stretched hypothetical”, but a reality of a vast quantity of consumer software, including critical things that are difficult for people to replace. (My worldmodel doesn't judge your proposed counter very highly either, FWIW, but I don't feel up to arguing that part just now.)

They don't actually have to be in the same update, the security fix just has to come after the ad antifeature with no separate patches presented, only a linear series of versions. And that linear model is extremely common. Anything using the linear model that has both antifeature updates and security updates at unpredictable times is very likely to run into the “can't install the security update without accepting the antifeature” problem.

So, just out of curiosity: I know in ECMAScript this is probably mainly for the purpose of giving you a convenient way to lift either (α → β) or (α → Promise β) into (Promise α → Promise β) without static typing or having two "then" functions, by forcing β and Promise β to be disjoint. It also allows looser composition underneath, since you can choose which kind of return to provide at runtime without having to re-wrap the bare case manually. But are there any other reasons for Promise of Promise to be squashed away like that?

> Git + Github

You mean, you “own” copies of your data, but unless the person who controls the interface with that popular happy workflow that Everyone Already Knows How To Use lets you store it on their server, a lot of people who might otherwise be willing to collaborate with you will go “eh” and give up, and therefore, since so many marginal things require that to get anywhere, you can still just lose completely if you don't agree to the GitHub Terms of Service?

I imagine you didn't mean that part primarily, of course—but it's another thing to be aware of. There's a lot of potential for SaaSS interface lock-in—I think this is much worse for users with less technical inclination or less mental slack, but even in the realm of “people who are already developers who use Git”, this becomes a large friction source. And with more-social smaller-world flows, the coordination-control aspect has a stronger grip.

That said, it's also worth looking at how the “cloud” model is in a way reifying the folk model many users were already using. People thinking of their documents as being “in” (for instance) Word, and having no idea where they are in a filesystem or what that is in the first place, is already seared into the cultural memory of people who were family tech support in the 1990s. The default consumer cloud model is an easy extension and solidification of this: now it totally is “in” Google Docs rather than being a leakier folk-model weakening of accessing your your hard drive, and now Google Docs is accessible from anywhere. Everything is like you expect! No need to panic when your machine breaks, just get a new one and it's all still there!

And those upsides are real in their own way. But a number of downsides which are also real are less obvious and immediate.

As a big counterexample, Kikkoman is popular enough in the USA to carry in mainstream grocery stores, and is a legitimate soy sauce. I go to the Korean market here when I can for soy sauce (in which case I often get Sempio 501 or 701), but when I don't have time for a separate trip for some reason, I get Kikkoman from the big-box store and it's perfectly reasonable. The level of salt is still relevant, though.

If you start getting into different kinds of legit soy sauce then you'll find more subtle differences of course, and depending on what you're cooking, they may be relevant. I don't cook at home with enough precision for the difference between “primary” soy sauces to matter much, but if you start learning an actual cuisine, that's different.

(No affiliation.)

They are indeed the standard symbols for those planets, and they do also coincide with the gender symbols, presumably because of the way the associations played out in classical mythology.

Fun extra fact: in Western alchemy, the symbols for major solar system objects ("planets", even though not all of them are planets by the modern astronomical definition) were also used to represent metals. Except HN seems to delete the symbols when I try to post them, so you'll have to look them up yourself, I guess!

Landing a first job while holing up with an acquaintance after escaping my birth family, and then trying to move to live by myself without realizing just how screwed-up a lot of my subconscious and worldmodel was (and some of you will have noticed that possibility already after reading “escaping my birth family”). Access to the city and not wanting to be more of a burden on my host were legit motivations, but it turns out that that much stress at once combined with the wrong kinds of weakness in handling results in going near-catatonic (at least externally) a few months in and getting fired.

Whoops! Oh, and there's that multi-year non-compete agreement… in the only thing I have experience in…

Fifteen years and several retry cycles later, someone who graduated twelve years after me now has the three solid years of full-time experience that I never got (in significant part because once you have a Résumé of Nothing, it stays that way), and just landed a job making about twice as much as I'm potentially going to be able to start making a month or two from now if I drive my context-switching ability and energy output right up to the limit.

Did I mention that getting access to healthcare to fix relevant issues was almost impossible for almost the entire time? At least I have a potential path to it now—and there's only a decade of backlog…

Don't do what I did and waste your life. You need a fucking real job. Do whatever it takes to keep it for long enough. Otherwise you lose.

(In fact I am not entirely coherent in my opinions on the matter, though—and the rule of equal and opposite advice applies…)

I've had a lot of success with this for things like closing doors and taking medication, as my memory gradually wanders off into the misty lagoon. Especially the “as needed but at most once every 24 hours” kinds of medication that can't be handled with a pill organizer—with the timing information included in the call. Point to the bottle (or if out of range, hold the pill up, or otherwise physically emphasize the object), say “Taking a symptomstoppidine on Thursday morning” or such.

There's some complexifiers to this that seem worth recognizing, especially since the "financially drained" that was mentioned was pandemic-related and therefore is likely part of a broader cluster of problems:

1. $5 and tail risk. Even if your financial hardship isn't that bad, if it's still making things more unpredictable, that could be $5 plus a cascade of overdraft fees one day. If things are worse, of course, it could also be your last meal for the month, or your last chance to not go homeless. Better get rid of any expense you can.

2. $5 and executive function. The payment card you were using expired. Are you going to remember to update the info when you're in constant low-grade panic or depression?

3. Relatedly to (2), $5 if you can get to that point in the first place. Maybe you had your site hosted on something more expensive, for… whatever reason. Now you have to remember how to transfer all the files and hope everything still works, and so on.

4. Kind of like (3), $5 except for the more-expensive domain name that seemed like a good idea at the time. Oops. Where are you going to move to? Will anyone be able to find it afterwards anyway?

5. $5 and relationship overhead. Which of these five-dollar hosters are trustworthy? Will they stay that way?

There's probably more.

If we care about preserving the independent Web, these sorts of problems definitely present themselves over the long run. I'm theoretically an affluent-by-many-standards technologist, but I've had issues over time that resulted in my previous sites going splat and just… couldn't really pull together what it would take to revive them, and wasn't that motivated. Decentralization of maintenance-energy overall while having individual sites relying on one or a few people has real inefficiencies that way if permanency is valuable.

Ah, my mixed feelings over having gone with "dasyatidae" as a 2LD… there were some subsequent potential repicks but thus far they haven't stuck. (IIRC this was also before "stingray" got so associated in the popular consciousness with the police surveillance equipment.)

Lua is very Scheme-like in its compactness and cohesion, but with the table as the fundamental compound data type instead of pairs and vectors. It's also a statement/expression language like Python, rather than just an expression language like a Lisp would be.

Without going into too much detail, my mother¹ had a way of interfering in my attempts at projects both by trying to tie it into "getting a credentialed person on board"² for Proper Supervision and piling on… other abuse, often after I was a significant ways in.

Fifteen years after escaping, I still haven't published anything real, and I can see the pattern. I saw the pattern ten years ago, even, but deep conditioning is really hard to break. Only being able to finish things for other people is kind of a disaster, especially when you wind up in the “need experience to gain experience” trap.

¹ Who, again without too much detail, was Asian. ² Which never happened. She never put any actual energy into it, I had no framework for approaching it as a child, and I'm not sure the surrounding environment contained people who were willing to do that sort of thing anyway.

I was assuming that at minimum the forms would be fully macroexpanded first (though macrolet is its own problem there). I also have the sense this might be easier in some Scheme dialects, but I don't know any of them well enough to say (thus that's part of my question).

Tangential curiosity: S-expression languages with lexical binding seem like they still require context-sensitive codewalkers in order to reliably search for patterns that involve any literal symbol that isn't constrained out of that mechanism¹, don't they? What's your strategy for this, just ignore it and hope for the best, or punt to interactive handling for any cases that look slightly tricky? (Or is that still small enough to count as "few lines"?)

¹ For instance, I believe CL forbids lexically binding symbols from the CL package in ways that might conflict with the original definitions. But if you want to find uses of a particular library call from some other non-special package in a sound way, then you have to assume someone might flet that name, due to the way locals work. The underlying codewalker issue is roughly dual to the functioning of non-hygienic macros.

A lot of DOS programs using 32-bit CPUs would embed a "DOS extender" which would take care of the switch to 32-bit mode and needed translation of interrupts and device accesses, forming another layer of mini-OS on top of DOS while leaving the "launch application from DOS" flow unchanged to the user. Windows 3.1 also had Win32s which provided partial compatibility for 32-bit Windows applications, though that wasn't directly related.

Hah! Yes, okay. I should have said “… by opening”.

It shows up rarely in that form in "standard" English, but the related morpheme "-ponent" shows up more often: component (put+together), exponent (put+out), proponent (put+forth). And then the "-pose" variants come from the same Latin root but modified via French: compose, expose, propose.

To be more precise on one bit, you can't get fd=1026 without having had at least 1027 open at some point in the past. You can subsequently close a bunch of them in the middle.

A compatibility hack for some applications reliant on badly-done select() might be to set RLIMIT_NOFILE to FD_SETSIZE.

In "public access single-app" cases like this, the user is generally connected to a restricted shell or other program which (… supposedly—this is very easy to get wrong if you're running anything that isn't specifically built for it) does not allow arbitrary executable access.

If you mean geofft's comment, I don't believe they're talking about a replay attack. thaumasiotes wrote "It wouldn't prove it, because anyone could be presenting the public key", but geofft is saying that if the server claims to recognize the key and requests to continue authentication using it, then your client will potentially provide the proof—invisibly and automatically, if the private key is passwordless/agent-loaded. There is no second server; this is the original server being able to confirm that you are actually in possession of a supposedly-unrelated-to-anything key. (I have not verified whether the order of operations in the protocol actually works this way; I'm just interpreting what geofft is saying.)

I would say more specifically: if you have any SSH keys that are associated with non-career nyms (which is a perfectly reasonable thing to do) then keep them separate and only include them for known associated hosts, perhaps by using IdentityFile in Host blocks in .ssh/config.

You would want to offer a specific something else for the user's executive function to latch onto immediately, even if you continue to interpret anything other than the narrow confirmation pattern as "cancel", just so there isn't only one immediate, recent attractor for "think of something".

Aha! I was half-wrong, but it's also horrible…

  (defclass tracer () ((actual :initarg :actual)))
  (defun make-tracer (object)
    (make-instance 'tracer :actual object))

  ;; But please don't.
  (defmethod no-applicable-method :around (gf &rest args)
    (if (typep (car args) 'tracer)
        (let* ((tracer (car args))
               (args* (cdr args))
               (actual (slot-value tracer 'actual)))
          (format t "Calling ~S on ~S" gf (cons actual args*))
          (apply gf actual args*))
        (apply #'call-next-method gf args)))

You can't do this with a real specialization on no-applicable-method, incidentally, because the first arg isn't special enough, it's just folded into the &rest. And that, I'm pretty sure, means this doesn't coexist with other uses of no-applicable-method properly… and you still can't do on-the-fly method names that aren't attached to a generic, and so on, but this does sort of account for the object forwarder case (and in fact you could extend it to allow tracers on more of the arguments!). It does, I expect, remain extremely unidiomatic by comparison.

CLOS generics+methods style is actually quite a different model in some ways from the Smalltalk-like model Python runs on! Primarily, method dispatch has the generic function primary and the classes secondary: methods are separately-definable specializations of what would otherwise be functions, rather than “owned” by a receiver object via its class. There was a recent item on Python versus CL: https://news.ycombinator.com/item?id=27011942

I wouldn't call this “proactive” any more than trust busting in the 20th-century USA, nor for a more recent example the introduction of the GDPR. Abuses are occurring now, so society saying “actually we don't want that to happen” would be reactive regulation, in itself, even if the forward-looking side effects are debatable. To be clear, I'm not sure what I think about the possibility of dismantling network effects by legislation at the current tech level; it would depend a great deal on specifics, and I certainly think the idea in general has a lot of potential downsides—but not enough to make me immediately reject the whole thing, thus the speculation. I note especially that some of the aforementioned trust busting involved the abstractly similar case of the Bell System.

The bifurcation-chaos that intuitively seems to surround network effects makes for an interesting fork here, actually (assuming of course that my intuition is anywhere close to correct). Both sustained overreaction and sustained underreaction can get very bad. Looking at the earlier example, earlier communication grids' network effects were more dependent on physicality, and “everything is ephemeralized as software with effectively unstoppable automatic updates” is a huge lever in both speed and dimensionality of power. So maybe the meta problem of “legislation can't operate as a control system with enough bandwidth to keep up with technology businesses wiggling the cable to get what they want in the grapple for the ‘humanity's nervous system’ role” is more important here.

Or, perhaps, human societies decide that technology level exceeding value reach is so undesirable that the innovation explosion becomes a casualty of preserving humanity's nature, because the alternative of it eating into everything faster than it can respond (which I would say is what is happening now) is worse, and then we get Dune. Or perhaps we designate sub-areas of society as experimental zones, regulate the heck out of the stable zones, and get closer to dath ilan…

I'm not sure what you're pointing at there. I'm aware of method combinations and method qualifiers—are you referring to being able to add a general :before/:after/:around on a single generic? If so, that's not what I mean; what I mean is vaguely similar but on the first-arg dispatch axis. Here's a toy Python example. Given:

  class KnowItAll(object):
      def __getattr__(self, attr):
          return lambda: "yes, I know how to " + attr

We then have:

  >>> k = KnowItAll()
  >>> k.reveal()
  'yes, I know how to reveal'
  >>> k.transfigure()
  'yes, I know how to transfigure'
  >>> k.make_sandwiches()
  'yes, I know how to make_sandwiches'

Ruby does this with method_missing instead, which is where I'm most used to it happening (and I think it's used a lot more in Ruby than in Python owing to the language-culture's higher tolerance for magic). Smalltalk used doesNotUnderstand, IIRC. One of the key secondary results of this is that you can do things like https://paste.ee/p/tUaRP, which is a toy “Tracer” class which intercepts, prints, and forwards method calls and attribute accesses (ignoring some edge cases).

If we were in CLOS, and started with:

  ;;; widget.lisp
  (defclass widget () ((radius :initarg :radius)))
  (defmethod grow ((w widget)) (incf (slot-value w 'radius)))

What I would expect for the equivalent is that, given:

  ;;; tracer.lisp
  (declaim (ftype (function (t) t) make-tracer))
  (defun make-tracer (object) ...)
  ;; ... further code goes here ...

Somewhere else, we can do:

  ;;; fiddle-with-widgets.lisp
  (let* ((w (make-instance 'widget :radius 3))
         (w* (make-tracer w)))
    ;; ???
    (grow w*))

Can you add code to tracer.lisp, without specific reference to anything from widget.lisp, such that this has the effect of (grow w) but prints what it's doing? Note also that my use of slot-value above is very deliberately a ‘raw’ access. I'm here completely ignoring the “make up entirely new methods on the fly as needed” part that method_missing also gets used for, which is even more impossible in CLOS given that it would require intercepting, what, all symbol lookups…

In CLOS, the class doesn't ‘own’ the method, it provides a type for dispatching on, so there's no way to do “give me some control over every generic function so long as the first arg is of ‘my’ type”. Which is a reasonable model, but means you can't do the same thing. Indeed the flip side is that in the Smalltalk-like model, generics are not reified, and methods that are specializations of the ‘same’ thing have no ‘real’ identity to them, so you can't do a type-ignoring :around method for an ‘entire generic’. (Often there will be a superclass to attach to instead, but it's considered dangerous “monkey patching” to mess around with someone else's class hierarchy like that, and in the case of more abstract interfaces there's nothing.)

Does that make sense?

Expert witness on reasonable industry practices, perhaps? But the deck might be easy to stack. Hmm.

I suspect it's solvable if society has at least a slightly coherent idea of what's desired though.

And roll the dice on whether you would be able to tell the court with a straight face whether you had a business reason for making all those changes and it isn't just an end run around the interoperability law, perhaps comparing your behavior to competitors who don't do that, and…

There's a prior attempt in the form of Firefox OS, which tried to push the “Web technology as driver of local UI” thing. Some cursory looking around suggests that webOS may also have done this, but I'm not as sure (it would make sense from the name).

CLOS (as you presumably know) models method application as calls to generic functions, instead of the now-more-mainstream Smalltalk-like message-dispatch approach which Python uses. The latter allows for things like overriding __getattr__ to intercept ‘all’ method calls and property accesses, for which I don't think there's any equivalent in CLOS.

The way methods are ‘attached’ to classes gives you a natural form of type-directed name lookup. CL generics have the advantage that you can define your own methods on existing classes while naming the methods in your own package so they don't conflict, but also have a curse of inconvenience along the way where importing a class doesn't naturally pull in everything associated with it, and you wind up writing the class name again and again when dealing with fields of an object. with-slots et al. are poor substitutes. (In an experimental sublanguage at one point I actually had local variables with object type declarations implicitly look up the class using the MOP and symbol-macrolet every available var.slot combination within the scope as a brute hack around the most common desirable case.)

Python's short infix/prefix operators are naturally generic, since they're implemented as method calls. In CL there's the generic-cl extension, but I haven't seen it have that much uptake… in particular, any library code that isn't explicitly aware of it won't use it ‘naturally’ on foreign objects, which could be good or bad.

That shades into the very-concrete type system that CL starts out with, where any attempt at ad-hoc polymorphic interop is a disaster unless everyone already agrees on what methods to use. I can't make a thing that acts like a hash table but uses a different implementation underneath, then pass it to something that expects to be able to gethash on it. I especially seem to get bitten by this in cases where alists are the expected way of representing key-value maps: there's no way to extricate yourself from the linear search without rewriting every piece of code that touches it, there's often an implicit contract that you don't want duplicate keys but it's easy to violate by accident and create bad behavior down the line, and so on. By comparison, Java collections in particular got this very right in terms of decoupling intention from implementation, and Python does basically the same thing but with a looser set of ‘expected’ methods.

By default, Python objects have a ‘purely’ dynamic set of properties, rather than the fixed slots CLOS imputes on an object via its class. Indeed the class-level property one can set in Python to constrain this for possible performance gains is called __slots__.