I feel like the comments are taking away the wrong message from this. He used it to do the part of the project that he has poor knowledge/experience/capacity for. He needs a visualization but the project isn't about visualization. He's spent a lifetime coding in C, not writing python-based visualizations.
There's a big difference between vibe-coding an entire project and having an AI build a component that you lack competency for. That is what is happening here.
It's the same principle as a startup that builds it core functionality itself in-house and then uses off-the-shelf libraries for all the other uninteresting details.
"if something isn’t worth consuming at 1x, it’s not worth consuming at all"
Depends A LOT on what kind of content you're watching.
I've been studying physics lately and a lecturer talks slowly so 2x makes a lot of sense. Maybe even I know the subject somewhat but I believe the lecturer has a few insights or connections to point out that I haven't seen. But perhaps it's burried in the middle of the lecture. It really doesn't make sense to listen to the whole lecture at 1x speed. Much better to 2x to the "unfamiliar part" and then rewatch and carefully consider that part at 1x speed.
Also, some very intelligent people just speak/think slowly. They have interesting things to say but slowly.
On the other hand, if you're watching a highly-produced video (such as a movie), I think it's quite ridiculous to watch it at any speed other than 1x. It was paced that way for a reason (if it's worth watching).
I don't really understand why folks have to be so "binary" about playback speed.
Same. And I'd advise anyone to attempt it. You'll learn a lot about yourself and your society by quitting alcohol, even if for a brief moment. The benefits are immense.
Many people questioned why I'd given it up or said I was alcoholic. Some even said to me "never trust a man who doesn't drink".
Giving up alcohol has made me feel a lot better. It hasn't cured all my problems but it has made life easier. Heavy drinking put me in situations that were dangerous and I don't miss that at all.
I'm amused at how circular this is. Unix v4 is first OS written in C, now running on top of an unbelievable amount of C (and C++). Classic circular computer science delight.
Hobbies. Social hobbies. It kind of doesn't matter which, just pick one. Show up religiously. Try your best to talk to people. Having a shared hobby/interest makes for easy conversation and ice breakers. Don't expect to make friends immediately but if you stick with it, show some vulnerability, avoid ego, etc it will happen. Good people are attracted to good people.
I'm personally into rock climbing and the social scene at a good climbing gym is really fantastic. Climbers need climber friends (if only for the selfish need of a belayer). Its great to share notes on a climb, or chat about gear, or dream/plan good outdoors trips.
Not suggesting you take up climbing. I'm using it as an example. But you want some hobby you're gonna take seriously that has a social component.
And, stop being so hard on yourself. Making friends is hard actually (especially making really good ones). Give yourself some grace.
> Try your best to talk to people. Having a shared hobby/interest makes for easy conversation and ice breakers.
Unfortunately for OP, they have a distaste for small talk, and yet small talk is the launchpad for any potential conversation partner.
Small talk is the lubricant for all social interactions and provides a safe, shallow harbor where people can get to know each other before heading out to deeper waters that require more earned trust. People actively reject small talk come across as socially awkward, uninterested, or both.
Strong agree. I switched back to RSS after trying social media. Much more boring. And that has been a very good thing. It's also been much more substantive. It's like eating your veggies vs eating sugar candy.
Why should we believe that "being entertained" is a valuable thing? I suppose it serves an evolutionary purpose as "steering focus", e.g. noticing the unusual/novel/scary/etc. But, it's not the end goal. And overloaded attention mechanisms sounds like an obvious misfeature.
Indeed. I'd suggest Susskind's Theoretical Minimum: Classical Mechanics if someone wants an introduction. He doesn't explicitly prove Noether but he demonstrates the connection between symmetry and conservation laws building the intuition to properly appreciate Noether.
I've also written a series on Abstract Algebra for computer programmers if you're serious about learning it:
"Memory Safe
No garbage collector, no manual memory management. A work in progress, though."
I wish them the best, but until they have a better story here I'm not particularly interested.
Much of the complexity in Rust vs simplicity in Go really does come down to this part of the design space.
Rust has only succeeded in making a Memory Safe Language without garbage collection via significant complexity (that was a trade-off). No one really knows a sane way to do it otherwise, unless you also want to drop the general-purpose systems programming language requirement.
I'll be Very Interested if they find a new unexplored point in the design space, but at the moment I remain skeptical.
Folks like to mention Ada. In my understanding, Ada is not memory safe by contemporary definitions. So, this requires relaxing the definition. Zig goes in this direction: "let's make it as safe as possible without being an absolutist"
If you look at the Github, there's a design proposal (under docs/design) for that.
It looks like the idea at the present time is to have four modes: value types, affine types, linear types, and rc types. Instead, of borrowing, you have an inout parameter passing convention, like Swift. Struct fields cannot be inout, so you can't store borrowed references on the heap.
I'm very interested in seeing how this works in practice--especially given who is developing Rue. It seems like Rust spends a lot of work enabling the borrow checker to be quite general for C/C++-like usage. E.g. you can store a borrowed reference to a struct on the stack into the heap if you use lifetime annotations to make clear the heap object does not outlive the stack frame. On the other hand it seems like a lot of the pain points with Rust in practice are not the lifetime annotations, but borrowing different parts of the same object, or multiple borrows in functions further down the call stack, etc.
Not being able to store mutable ref in other type reduces expressiveness. The doc already mentions it cannot allow Iterator that doesn't consume container
Just to be clear, these proposals are basically scratch notes I have barely even validated, I just wanted to be able to iterate on some text.
But yes, there is going to inherently be some expressiveness loss. There is no silver bullet, that's right. The idea is, for some users, they may be okay with that loss to gain other things.
I am going to be cleaning these up, as they don't necessarily represent things I actually want to do in this exact way. My idea was to dump some text and iterate on them, but I think that's actually not great given some other process changes I'm making, so I want to start fresh.
Yeah, that stuff is very much a sketch of the area I want to play in. It’s not final syntax nor semantics just yet. Gotta implement it and play around with it first (I have some naming tweaks I definitely want to implement separate from those ADRs.)
I don’t struggle with lifetimes either, but I do think there’s a lot of folks who just never want to think about it ever.
> Rust has only succeeded in making a Memory Safe Language without garbage collection via significant complexity (that was a trade-off). No one really knows a sane way to do it otherwise, unless you also want to drop the general-purpose systems programming language requirement.
> I'll be Very Interested if they find a new unexplored point in the design space, but at the moment I remain skeptical.
They’re the somewhat sane “don’t allow dynamic allocations; just dimension all your arrays large enough” approach from the 1950s (Fortran, COBOL).
A variant could have “you can only allocate globals and must allocate each array exactly once before you ever access it”. That would allow dimensioning them from command line arguments or sizes of input files.
The type system then would have “pointer to an element of foo” types (could be implemented old-style as indices)
Yes, that would limit things, but with today’s 64-bit address spaces I think it could work reasonably well for many systems programming tasks.
It definitely would be significantly less complex than rust.
> Yes, that would limit things, but with today’s 64-bit address spaces I think it could work reasonably well for many systems programming tasks.
As long as the systems programming tasks are strictly sequential, without threads, coroutines or signal handlers.
There is more to memory access than just out-of-bounds access which could be solved by just allocating every accessed memory page on demand as a slightly alteration of your variant.
Good points. As to signal handlers, I’m not aware of any language that fully supports them by making it impossible to call other than async-safe functions (https://man7.org/linux/man-pages/man7/signal-safety.7.html) from asynchrony signal handlers.
There's a big difference between vibe-coding an entire project and having an AI build a component that you lack competency for. That is what is happening here.
It's the same principle as a startup that builds it core functionality itself in-house and then uses off-the-shelf libraries for all the other uninteresting details.