tlrobinson
You shouldn’t need a special editor extension to get highlighting/autocomplete/etc, just use TypeScript and a CSS-in-TS solution.
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.
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).
Waiting for the bug report that the fix broke someone’s workflow. https://xkcd.com/1172/
Obviously doesn’t apply to all engineers.
(I don’t know if that’s how Bing AI works)
- for Perl, OCR to a character set
- for Piet, manual “convert[ion] into a clean image file using close colours from the Piet palette”
- 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)
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();
}
}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?
- 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
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.
I think you can also still find pockets of similar communities among esoteric social/distributed networks.
Given the progress across many AI applications in the past year I certainly wouldn't bet on this continuing to be true.
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.
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.
> 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.