sheept

"like" has been documented to be a synonym of "such as."[0]

[0]: https://www.merriam-webster.com/dictionary/like preposition sense 4

Can’t LLMs make forks as needed?

I’ve been using Deno’s permission system as a sandboxed replacement for ‘python -c’ for my agents. Hopefully a better supported runtime (in any language) adds a similar permissions system in the near future.

I wonder if xyz.com is simply requesting TLDs based on domains their users enter, so cmo and con come from their users’ typos rather than malicious intent. It would be similar to how some registrars park domains when a user checks if a domain is available.

It is possible they can; it’s not yet proven that the listed packings for 83 and 87 are optimal.

I would think that a regular user of Hacker News would be visiting new websites every day (though it'd definitely still be below 140k)

Scratch is probably the most used programming language with hot reloading, allowed for by its persistent global state.

Web development supports hot reloading modules, but this is effectively just dynamic imports and relies on the app being written for a library/framework that encourages pure code; it doesn’t kill the old module.

I added a wrapper script around Deno to my agent’s allowlist to take advantage of its permissions system, and instructed it to use Deno instead of Python or bash commands. It’s worked pretty well.

All those years of captchas must've made Google's model bulletproof

Is that a contradiction? Adding list and arrays doesn't break backwards compatibility. In general, guaranteeing backwards compatibility doesn't prevent you from adding new features, and having both old quirks and new features is fairly common for any decently old software

Wikis don’t have as much vendor lock-in as other Github features since they’re just git repos,[0] so you can clone and push the wiki elsewhere.

[0]: https://docs.github.com/en/communities/documenting-your-proj...

It’s not a web page; it’s a git remote url

Yes, affine transformation matrices are essentially shears.[0] In the 2D case, shearing the plane z=1 in 3D space essentially translates it around.

[0]: Here’s a visual: https://gunn-gatm.github.io/textbook/gatm.pdf#page=28

For a native speaker in casual speech, it'll only be at most a bit slower than its expansion because English is stress-timed

Even though the never type has been experimental for a while, I've seen `!` used in the docs,[0] so at this point, Rust developers are probably already aware of what it means even if they haven't used it before.

[0]: Example: std::process::exit returns `!` https://doc.rust-lang.org/1.0.0/std/process/fn.exit.html

In addition to making the sidebar dismissable on small screens, it'd be nice to add touch-action: none to the canvas so rotating the object doesn't get interpreted as a scroll on touchscreens.

Right now, at least in Android Chrome, dragging to rotate only works briefly before it's interrupted.

That wouldn't be open source. OSI includes the clause "No Discrimination Against Fields of Endeavor"[0] for its definition of open source. Famously, the JSON license[1] has a clause "The Software shall be used for Good, not Evil," so the Free Software Foundation considers it nonfree.[2]

[0]: https://opensource.org/osd

[1]: https://www.json.org/license.html

[2]: https://www.gnu.org/licenses/license-list.en.html#JSON

It'd be neat if you could pan a slider through the year to see the sunrise sunset times change

Dragging the globe around isn't working on touch; it feels like it's missing touch-action: none

I use dontAsk mode[0] with read access to the entire file system, write access to files from the working directory[1], some git commands (git commit yes, git push no), and a script wrapping Deno with the same read/write permissions (safer substitute for `python -c`).

These are usually enough for most of my coding tasks. In my experience, Claude has been good enough that it can write code and fix bugs without needing anything else. It's far better than ever needing to approve permission requests.

[0]: https://code.claude.com/docs/en/permission-modes#available-m...

[1]: Note that this includes escaping the directory via symlinks

There's several web APIs for browser window positioning, like screenX/Y[0] (which is what OP uses), which allows for those classic pop-up based browser games from over a decade ago, like Browser Ball.[1]

[0]: demo: https://mdn.github.io/dom-examples/screenleft-screentop/

[1]: https://romanbaiocco.github.io/browser-ball-reloaded/

Video generation models generate videos of a predetermined duration, so if a character finishes a line but there's still seconds remaining, then the model still has to fill it in

In JavaScript, it's

    Math.PI.toString(2)

Who knows how optimized Python or JavaScript's implementations are, but I'd imagine printing the binary representation of floating point numbers is relatively easy to implement manually because you'd just take 1 followed by the bits of the mantissa, then move the decimal point based on the exponent.

HTML is case insensitive, so <Button> is the same as <button>, and custom element names must have a hyphen.

Your component regex represents a JSX limitation, but web components do not need React. Plus, if you capitalize the first letter, JSX would treat it as a React component rather than a web component (i.e. custom native HTML elements)

I guess that makes sense. Since most non-privacy-focused Android distributions don't let users turn off the internet permission, keeping the permission secure likely ceased to be a priority.

The full list of bypasses is likely much larger because it doesn't fall in the scope of bug bounties.

It's pretty interesting that while both languages still receive new features, Java seems to stay ahead of JavaScript:

- Java has long had a modern replacement for Date, while JavaScript's recently standardized Temporal API still isn't supported in Safari.

- Java has switch expressions, while JavaScript, despite its Scheme influence, does not.

- And now Java is getting value objects, while JavaScript's equivalent tuples & records proposal has been withdrawn.[0]

JavaScript was not developed as a fork of Java, but much of its basic syntax still resembles Java, so I think it's fair to compare them.

[0]: https://github.com/tc39/proposal-record-tuple

The main drawback with the page's unstyled design is that the page is not mobile friendly.

Publishing web pages by manually editing HTML files is still very common today; any GitHub Pages blog does this.

One of the strengths of TypeScript besides its expressiveness is that it's compatible with the massive npm ecosystem. Most packages only ship untyped JavaScript with type declarations defining the interface,[0] so realistically you'd still need a JavaScript engine if you use any packages.

But if you're starting from scratch and know you won't be using any npm packages, you might as well use AssemblyScript.[2]

[0]: Publishing packages in TypeScript is explicitly discouraged by Node[1]. TypeScript isn't backwards compatible even in minor releases, and its compiler settings aren't portable for packages.

[1]: https://github.com/nodejs/node/blob/main/doc/api/typescript....

[2]: https://www.assemblyscript.org/

It'd be nice if there was a live demo without needing to clone the repo. Though I suppose I could just try it out with a bookmarklet:

    javascript:import('https://esm.sh/writemark-editor').then(() => document.body.append(document.createElement('writemark-editor')))

I'm surprised it doesn't use proper HTML by default. I wasn't able to tab focus on the Administrator button on the login screen, and it turns out it's because the entire UI is div spam.