reuben364

Stupidly Malfunctioning At cRitical Times. Needs some workshopping.

Reminds me of Edward Kmett's talks on monoidal parsing in which he has Dyck languages as an example. I'm confused about the need for "linear types", unless you mean a monoid. I'm not sure of a use case where you would want a open fragment of html or a closed one other than to a have a hole, that is something like

    f : HtmlBody -> HtmlBody
    f x = someOpenFragment + x + someClosedFragment

I'm sure that holds for most people. However I'm not exactly attached to the idea of being alive. If I'm dead I naturally wouldn't have any thoughts on the matter. Dying however does scare me.

'can be considered "constitutional"' is a function of the persons interpretation. Is it not the case that whether a law passes is affected by the interpretations of 'can be considered "constitutional"' by the powers that can influence the outcome.

I think a slightly dark pattern of making a "Yes" more visible (or default on enter in a CLI like Y/n) is an acceptable compromise. Informed consent, but biased.

At most it's an error of 'a-b' not in scope. Unless you have dynamic scoping or somehow have a variable 'a-b' and also want to perform 'a - b'. I think the rule that binary operators must be separated by spaces is much easier to reason about then not having certain characters usable in identifiers.

As far as I recall Meta's Galactica has special tokens to mark working out which can include python code and can run the code during inference to get a result.

I wonder if AppleTV's atrocious single-line onscreen keyboard fits into this picture of making things less discoverable, or if it's just an extreme of form over function.

The transition from accountability to predictability was rather unmotivated. I guess accountability is a strategy of optimization. You want to identify when sufficient gains can be made by unilaterally adjusting the process of an individual or team or organizational unit, and reinforce that adjustment with reward/punishment ranging from feelings of usefulness to monetary reward to continued employment.

If you model your productivity as hierarchical composition of dynamical systems, then I guess predictability would be a rapid step response, unilaterally in each parameter, in each system. Losses in productivity could then be traced back each system and form a low-latency feedback loop.

This model is cold and calculating and probably wrong. I just want to try make it more concrete.

As a South African, I have a engineer friend working for a company that does solar for places like retail complexes. They have a lot of business.

Also there is a widely used app for load shedding timetables called "EskomSePush" which is a pun on "Eskom se poes" roughly translates to "Eskom's cunt" with poes being very vulgar and offensive.

For the StrategyWithSetup example, my FP oriented brain would create another function:

    withSetup :: IO c -> IO d -> (a -> IO b) -> a -> IO b
    withSetup mc md f = \ a -> do
      mc
      b <- f a
      md
      return b

Which is pretty identical except with a closure over functions in place of a class of abstract methods. Classes with abstract methods are effectively higher order functions, except differences in boilerplate.

Another thing worth mentioning are language features that can't be implemented unless you effectively implement a DSL like automatic differentiation, call-cc, algebraic effects.

Hooks in React are sort of like a poor man's algebraic effects. It can't affect the control flow so it relies on immutability and hooks to unconditionally run to operate.

EDIT: after a bit of thinking, I realize that the unconditional ordering of hooks is really a way to identify call sites at runtime, which I don't think is related to algebraic effects.

If that's the reasoning, then hiding add-ons not ratified for mobile behind a flag that normal users won't ever touch should be an acceptable solution.

Is this meant to be a reply to the above comment? My thoughts are as follows: If one can decompose one's subjective experience into an agent and the environment it interacts with, then there are several variations I can think of:

- The agents actions are entirely determined by its environment

- The agents actions form a probability distribution determined by it environment

- The agent actions from their environment are annotated in some way that we haven't or can't have thought of that represents what the agent is. In my opinion, something that we can't think of or experience and something that doesn't exist are indistinguishable and we shouldn't really separate them except for making this statement.

- There is no agent and subjective existence is merely one route down immutable decision tree that is our choices and their consequences.

None of these options really intuitively sound like free will to me. Ultimately thinking along these lines requires separating the agent from the environment.

EDIT: I see now the reply is to the YouTube link which I missed

But it's always unknowable. The only consciousness/suffering one truly knows is one's own. We just use heuristics like "this human/animal behaves like I do when suffering". Where we draw the line is completely arbitrary.

- Web interface is not supported on Firefox, last I tried.

I try and avoid installing native clients for occasional uses.

In the proof assistants I'm familiar with, such as Lean and Coq, you can write tactics which generate proofs for a goal and potentially produce more subgoals. However there isn't a "one size fits all" tactic for these gaps. One area that is being explored is ML for generating proofs, but training data is limited.

Single-argument doesn't capture the difference between functor and applicative.

  ex1 :: Functor f => f (Int, Int) -> f Int
  ex1 = map (uncurry (+))

Applies a multi-argument function within a functor. What applicative allows you do is take a product of contexts to a context of products, and lift a value to a context.

  pure :: a -> f a
  zip :: (Applicative f) => (f a, f b) -> f (a, b)

This can then be used to make ex1 into a multi-argument function of contexts, which is not the same as (uncurry (+)) being a multi-argument function

  ex2 :: (Functor f) => (f Int, f Int) -> f Int
  ex2 = ex1 . zip

There is also nix-straight, which is used in nix-doom-emacs, although it is fairly limited and takes ages to build when you make any changes.

I have a combination microwave/conventional oven with capacitive buttons as well as a dial for temperature. You can only use the buttons to adjust the timing for the microwave in 10-second increments, leaving the dial completely unused in that modality.

See: this ad from Gov Parson in response to a disclosure about a state website leaking social security numbers of teachers

https://m.youtube.com/watch?v=9IBPeRa7U8E

Now this comment can neither agree nor disagree. Barber shaving their own head and such. EDIT: now I realize not really since the above being false doesn't force me to agree.

The stylus I'm using operates independently from the capacitive touchscreen and is presented as a separate input device by libinput. The stylus needs external power and the input reports not just xy, but z coordinates. Physically I am not sure whats going on, and struggled to find anything authoritative on the subject.

I've had a few issues (NixOS, sway). Mainly screen capture. XWayland apps can record windows, but not my whole screen. Wayland apps can record my whole screen but not individual windows. I also don't know how to get XWayland to match my sway display resolution as it is only half the resolution.

Also libinput via sway doesn't have a way to disable the touchscreen if I'm using a stylus as far as I'm aware.

I'm sure there are solutions to some of these, but given I already spend a significant amount of time fiddling with my NixOS configuration I'm already quite an outlier with regards to the amount of effort I am willing to spend and even I'm exhausted.

I've managed to get the compiler to typecheck

  const x: Thing = exprA;
  const y: Thing = exprB;
  const z = [x, y];

but somehow not:

  const z: Thing[] = [exprA, exprB];

although exprA and exprB were pretty nasty typing wise.

As all types in Haskell are inhabited by undefined, any type can be made an instance of a typeclass. True type equality.

  {-# LANGUAGE GADTs, MultiParamTypeClasses, FlexibleInstances #-}
  data Eq a b = (a ~ b) => Eq
  
  class Revolution a b where
    eq :: Eq a b
  
  instance Revolution a b where
    eq = undefined

I understand envy to be more about what others have in relation to you, rather then what they have in relation to their past selves.

computerTemperatureWhenFire :: IO (Maybe Double)

A human being doesn't solve the halting problem either.

Anything using = for a relation that is not symmetric is cursed IMO. More generally, any relation using a symbol that is visually vertically symmetric should be symmetric.

But you are choosing to use the Turing test, which tests a form of intelligence, as a proxy to determine whether to believe the claim. A Turing test does not preclude philosophical zombies. It does not demonstrate anything about consciousness.

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