I make things: electronics and software and music and stories and all sorts of other things.

  • 0 Posts
  • 16 Comments
Joined 3 years ago
cake
Cake day: June 14th, 2023

help-circle


  • It’s not really 130-150 words per min though bc mostly the words we say are nonsense, “uhms” and saying the wrong thing and starting over and pausing and such.

    Not to mention, when we speak to a computer, it’s not like to a person, as others have pointed out. The 130-150 wpm number comes from in context speaking where we already know what we’re going to say. That isn’t the case when doing things on a computer such as responding to a comment, anything requiring thinking, coding, etc.

    Also, speech-to-text systems do not immediately recognize the speech we say, adding further delay.

    So it’s not actually 130-150 words a minute.

    In terms of meaningful day-to-day use, I maintain that it’s far slower and less precise than a keyboard, especially if you’re a proficient typer.

    And this makes sense as everyone I’ve ever met who likes to use speech-to-text (excluding those who MUST use it for disability reasons) are simply those who are bad at typing. Cope harder. slow-mo. This comment was written using a keyboard

    EDIT:

    so what they’re saying is true for that one use case

    This doesn’t follow. Both of us are talking about inputing in english. Vibe-coding with a keyboard is also superior there





  • Are they using any original GNU coreutils code as reference? My understanding is nothing is 1:1. They’re trying to build, from the ground up, a totally new codebase that has the same user-facing functionality but under the hood is idomatic Rust code (so nothing like the GNU C code)

    They are recreating something that matches behavior not using licensed GPL code. Which is the same way the GNU coreutils were a recreation of the proprietary Unix tools in an effort to provide open source alternatives.

    Like you wouldn’t say “An appropriate amount of work to slap a GPL license on somebody else’s work” in reference to GNU recreating the Unix tools, so why say it here?





  • I have this idea. It’s taken from the Android world. In Android, apps all get their own user, and can only access their own filesystem. They are then added to groups like Sound or Files or whatever to gain access to other things. This is simplifying but gave me an idea.

    So my idea is two parts:

    1. We add more groups to our Unix and Unix-like codebases. Piecemeal access to different folders like a fs-docs group for access to /home/<whoever>/Documents
    2. Each app, when installed, gets a user and a folder (maybe /opt/<pkgname> or /apps/<pkgname> and a group called app-<pkgname>). It requests during install (or maybe runtime via a permissions management application) access to specific groups for its user. Launching an app then becomes sudo -u app-<name> /opt/<pkgname>/<binname>.

    You login as a user with access to limited permissions and then run the application. Thus you run it sandboxed but without special software like Flatpak or AppImage - just standard Unix groups.

    Claude code I believe has its own sandboxing system, but with this system it would be the system itself restricting claude, not the claude code app, truly limiting accidental outreach.

    I built a demo package manager using this concept a while back called ‘bokspm,’ though I kept it private (and now, my current job will not let me open source it)






  • As others said, it means nullable, but to put it in more intuitive, less-jargony way - it’s a question mark bc you don’t know if the value is actually there or not. It could be a Singleton, but it isn’t until you check if there is a value. Whereas if you have, idk, int a no question mark, then you’re saying you actually have data.

    Essentially with C# 8, they “removed” null and reused the idea of null references in creating what is essentially an Option like in other languages. You either have some data of some type, or none (a null reference, in this case). By default, everything has to be there. Then when you need null, e.g. you may not have something initialized or an operation could fail, you explicitly grab for it. Thus it reduces null pointer bugs. If you don’t need nullability, you can ensure that you don’t accidentally write in an issue. It safety checks statements and parameters.