tlrobinson

I always assumed LLMs would be one component of “AGI”, but there would be “coprocessors” like logic engines or general purpose code interpreters that would be driven by code or data produced by LLMs just in time.

100%. I know I’m in the “get off my lawn” phase of my career when I see things like MCP and LangChain, but know I would have been excited about them earlier in my career.

Tailwind’s abuse of CSS classes as a DSL has always felt like a hack to me.

You shouldn’t need a special editor extension to get highlighting/autocomplete/etc, just use TypeScript and a CSS-in-TS solution.

Or not even imagery collection, but testing to see what our response is like. If we're scrambling and unable to explain/contain it, that's useful for an adversary to know a little about our current defensive capabilities.

This is all inevitable. At worst it's pulling the issues forward by a few months or years, and I don't think anyone will meaningfully address the problem until it's staring us in the face.

I believe the internet needs a distributed trust and reputation layer. I haven't fully thought through all the details, but:

- Some way to subscribe to fact checking providers of your choice.

- Some way to tie individuals' reputation to the things they post.

- Overlay those trust and reputation layers.

I want to see a score for every webpage, and be able to drill into what factored into that score, and any additional context people have provided (e.x. Community Notes).

There's a huge bootstrapping and incentive problem though. I think all the big players would need to work together to build this. Social media, legacy media companies, browsers, etc.

This also presupposes people actually care about the truth, which unfortunately doesn't always seem like the case.

not responsible for the technical successes

He's not doing the nitty gritty engineering day-to-day, but he understands enough to ask the right questions, give his teams permission to try ideas that seem crazy at first, and sometimes come up with those ideas himself (e.x. supposedly catching Starship with "chopsticks" was his idea).

Fixed in master: https://git.savannah.gnu.org/cgit/man-db.git/commit/?id=84bd...

Waiting for the bug report that the fix broke someone’s workflow. https://xkcd.com/1172/

Not quite the same, but EMT conduit is very popular for shade structures at Burning Man and similar events. You can get fittings that will hold up very well in windy conditions (if properly secured) https://formandreform.com/blackrock-hardware/

$50,000 income, 4 year product lifespan?

Obviously doesn’t apply to all engineers.

Who do you think writes those CAD and design tools that help “actual engineers” solve the same problems over and over?

I don’t think it’s at all unreasonable for an engineer using a device for 8+ hours every day to pay an additional, say, 0.5% of their income (assuming very conservatively $100,000 income after tax, $1,000 extra for a MacBook, 2 year product lifespan) for the best built laptop, best screen, and best OS.

LLMs are also often used in the search component of RAG, by generating embeddings that are then indexed and searched.

(I don’t know if that’s how Bing AI works)

I think in both cases some amount of interpretation was required:

- for Perl, OCR to a character set

- for Piet, manual “convert[ion] into a clean image file using close colours from the Piet palette”

A couple other potentially desirable properties you could incorporate:

- K-sortable: ensures good locality when used as an id in a database (e.x. https://github.com/jetify-com/typeid https://github.com/segmentio/ksuid )

- checksum: primarily useful when an id might be conveyed verbally (e.x. customer support) or transcribed (e.x. Bitcoin wallet backup, BIP-39)

(parent commenter is founder/CEO of Stability AI, Emad Mostaque, I assume)

https://digitalcommons.usu.edu/smallsat/2023/all2023/72/

Not sure why you obfuscated it but here's the code for anyone curious:

    function update() {
      if (!ticks) {
        player = { x: 40, vx: 1 };
        enemy = { x: 100, eyeVx: 0 };
        multiplier = 0;
        addDots();
        powerTicks = animTicks = 0;
      }
      animTicks += difficulty;
      color("black");
      text(`x${multiplier}`, 3, 9);
      if (input.isJustPressed) {
        player.vx *= -1;
      }
      player.x += player.vx * 0.5 * difficulty;
      if (player.x < -3) {
        player.x = 103;
      } else if (player.x > 103) {
        player.x = -3;
      }
      color("blue");
      rect(0, 23, 100, 1);
      rect(0, 25, 100, 1);
      rect(0, 34, 100, 1);
      rect(0, 36, 100, 1);
      color("green");
      const ai = floor(animTicks / 7) % 4;
      char(addWithCharCode("a", ai === 3 ? 1 : ai), player.x, 30, {
        // @ts-ignore
        mirror: { x: player.vx },
      });
      remove(dots, (d) => {
        color(
          d.isPower && floor(animTicks / 7) % 2 === 0 ? "transparent" : "yellow"
        );
        const c = char(d.isPower ? "g" : "f", d.x, 30).isColliding.char;
        if (c.a || c.b || c.c) {
          if (d.isPower) {
            play("jump");
            if (enemy.eyeVx === 0) {
              powerTicks = 120;
            }
          } else {
            play("hit");
          }
          addScore(multiplier);
          return true;
        }
      });
      const evx =
        enemy.eyeVx !== 0
          ? enemy.eyeVx
          : (player.x > enemy.x ? 1 : -1) * (powerTicks > 0 ? -1 : 1);
      enemy.x = clamp(
        enemy.x +
          evx *
            (powerTicks > 0 ? 0.25 : enemy.eyeVx !== 0 ? 0.75 : 0.55) *
            difficulty,
        0,
        100
      );
      if ((enemy.eyeVx < 0 && enemy.x < 1) || (enemy.eyeVx > 0 && enemy.x > 99)) {
        enemy.eyeVx = 0;
      }
      color(
        powerTicks > 0
          ? powerTicks < 30 && powerTicks % 10 < 5
            ? "black"
            : "blue"
          : enemy.eyeVx !== 0
          ? "black"
          : "red"
      );
      const c = char(
        enemy.eyeVx !== 0 ? "h" : addWithCharCode("d", floor(animTicks / 7) % 2),
        enemy.x,
        30,
        {
          // @ts-ignore
          mirror: { x: evx },
        }
      ).isColliding.char;
      if (enemy.eyeVx === 0 && (c.a || c.b || c.c)) {
        if (powerTicks > 0) {
          play("powerUp");
          addScore(10 * multiplier, enemy.x, 30);
          enemy.eyeVx = player.x > 50 ? -1 : 1;
          powerTicks = 0;
          multiplier++;
        } else {
          play("explosion");
        }
      }
      powerTicks -= difficulty;
      if (dots.length === 0) {
        play("coin");
        addDots();
      }
    }

Agreed, when Ruby became popular it was primarily competing against languages with verbose and rigid static type systems like Java. That is no longer the case, and the benefits of safety and developer experience provided by a good type system outweighs the cost.

Obviously Mini was using the encryption properly else it wouldn't have worked to begin with.

Just want to point out this isn’t inherently true. For example an insecurely generated session key would work fine but not be secure.

Of course, it's very unlikely Apple is doing that. Just putting the thought out there.

Apple is doing what? Not using encryption properly? What reason do you have to believe that?

- Styles colocated with markup/logic (I consider this an advantage with a component library like React, others may not)

- No global styles stomping on each other, styles scoped to a single module unless explicitly exported/imported

- Type safety, if using TypeScript

The main downside is often performance, though

Another new library (I haven’t used yet) that supports pseudo selectors is called CSS Hooks: https://css-hooks.com/

Shopify has a styling library for React Native called Restyle: https://github.com/Shopify/restyle

I like it a lot. It lets you define a theme with design tokens like spacing and colors, then enforces using only those via TypeScript (with an escape hatch via style prop), which also gives you editor autosuggest support without hacks like the Tailwind extension.

If you implement a feature like this, please, make it optional and obvious when it’s enabled. It’s maddening when tools try to be too smart and don’t get it perfect (I have been guilty of this too)

I don’t understand how these two statements are both possible:

"Several passengers recalled that after takeoff the aircraft cabin seemed noisier and colder than they were used to," investigators wrote

…

the plane had remained "pressurized normally," investigators wrote.

There’s even packet radio BBSs aroun. I connected to KE6JJJ’s in SF a few years ago https://www.reddit.com/r/amateurradio/s/wNUaNbGH6S

I think you can also still find pockets of similar communities among esoteric social/distributed networks.

In my experience these models are very bad at [...]

Given the progress across many AI applications in the past year I certainly wouldn't bet on this continuing to be true.

Ishkur's Guide V1 is classic internet lore.

I'm looking forward to AI models that can describe, classify, and recommend music. Obviously there's Shazam and things like Cyanite (https://cyanite.ai/) but hopefully there will be some good open source models too shortly.

You could imagine Ishkur's Guide V3 is constructed automatically by AI models, and places every track somewhere on the map, listing all the genres and influences, etc.

We don't know what "intelligence" means, but we know it isn't matrix multiplication

What makes you believe “intelligence” can’t emerge from lots of matrix multiplications? Unless you believe in some more mystical explanation, human intelligence is just electrochemical processes not that unlike computers.

The problem is also your fellow consumers, most of whom don’t actually care about the things us nerds care about.

“Unable”? How did this manifest?!

Given that it may very well be better to assume that anything untested doesn't work at all and to live within those restrictions.

There are an infinite number of untested cases though. Figuring out the important ones is the hard part, otherwise they likely would have been identified and fixed in development.