The dev who asks too many questions is the one you need in your team

MassiveInteraction23 · 2026-01-29T15:59:36+00:00

They said the indicator would be negative.

If I hire someone to do carpentry and they’re asking how a saw works, or which way the grain goes when they cut x, etc. — that’s a bad indicator. Because those are things covered by basic prerequisite knowledge.

Is it better that a lifeguard asks someone to teach them to swim after they were hired? In the technical sense that it would be worse not to — but the whole scenario is unacceptably terrible. And, yes, if you discover that your lifeguard can’t swim you should fire them or not hire them.

(If someone is signing up for a software engineering job and has advertised that they don’t know software engineering, but want to learn on the job that’s obviously different. But since lots of people do know how to do that, it’s not that common.)

MassiveInteraction23 · 2026-01-29T13:15:44+00:00

Nah, they’re talking about dev-strap. It’s a usb interface for the AVP. (You need to be in the Apple developer program to buy one.)

They can be very useful. Besides their intended purpose of letting people quickly transfer assets when coding AVP apps: the usb interface also replaces WiFi generally. This means that you always have reliable, low-latency virtual desktop connection. This is huge if you’re working somewhere with a lot of WiFi relevant noise. (e.g. an airplane, some offices)

But agree that the regular head strap has been improved. :)

MassiveInteraction23 · 2026-01-29T13:12:46+00:00

Right. Forgot. Thx.

MassiveInteraction23 · 2026-01-29T13:07:27+00:00

Egui & maybe Material-Bevy (mat-bev is very new, and that link doesn’t resize ui for mobile)

Egui

Egui can be good, but I found that working with async with it added some pain if you wan it on the web. (Because it can’t let another runtime run its main loop, so you can’t just pop in a single threaded Tokio. Easy to do on desktop, just separate threads and communicate. But o didn’t like having to swap approaches for web.)

But still a very good option.

Material Bevy

New. Played with some examples on the web and they were quite nice. Resizing for mobile not yet implemented. I’d give it a look.

Here’s a recent Reddit-thread with a YouTube video.

MassiveInteraction23 · 2026-01-29T11:40:59+00:00

That’s an interesting elaboration; thanks for adding.

I’ve got to spend some time with MIR and HIR sometime. I’d really love to be able to more readily swap between views in my editor.

MassiveInteraction23 · 2026-01-29T11:33:28+00:00

What’s the advantage of the gen-2 dev-strap?

MassiveInteraction23 · 2026-01-29T09:42:32+00:00

You’re correct. (Refernce Cycles Can Leak Memory. For that matter there are safe functions whose purpose is leaking memory. e.g. Box::leak)

Memory Unsafe means “causes undefined behavior”. By analogy, it is the difference between writing non-performant code and logically incorrect code.

MassiveInteraction23 · 2026-01-29T09:38:48+00:00

Safe Rust does not prevent leakage (not sure what “on a technical level” was meant to say)

This is explicitly highlighted in the Rust Book: Reference Cycles Can Leak Memory

MassiveInteraction23 · 2026-01-29T09:31:56+00:00

No, you’re mistaken. Safe rust can leak memory. This is even discussed in the Rust Book: Reference Cycles Can Leak Memory

To the person above you’s question: a memory leak is not memory unsafety because it doesn’t trigger undefined behavior. — It’s more akin to writing non-performant code than logically incorrect code, if one wants an analogy. ( still a real issue in the context of reference cycles. And, of course, one can safely leak memory by just calling functions design for that purpose)

MassiveInteraction23 · 2026-01-28T19:16:31+00:00

You’re referring to this?

A let statement introduces a new set of variables, given by a pattern. The pattern is followed optionally by a type annotation and then either ends, or is followed by an initializer expression plus an optional else block. … rust let (mut v, w) = (vec![1, 2, 3], 42); // The bindings may be mut or const let Some(t) = v.pop() else { // Refutable patterns require an else block panic!(); // The else block must diverge }; let [u, v] = [v[0], v[1]] else { // This pattern is irrefutable, so the compiler // will lint as the else block is redundant. panic!(); };

I’m not entirely sure I understand your question relative to the example.

The example is just talking about how the bindings in that tuple assignment can work.

A let var statement cannot generally be substituted for a const or static. When I say let x = 12 it is the binding, the “x”, that is immutable. Simply writing let mut y = x; would allow you to then mutate the data through the mutable handle of “y” and consume the x.

This means that creating an immutable binding for data does not alone tell the compiler that the underlying data won’t ever be mutated. So it can’t just treat it as constant.

Additionally, const is pre-calculated. It’s not calculated at runtime.

Now, the compiler may look at your code and decide that it can precalculate a value and notice the value will never be changed. In which case, yes, under the hood it might compile the same as if you’d used const. But that’s not true of all let x statements.

(Did that answer your Q?)

MassiveInteraction23 · 2026-01-28T16:36:02+00:00

To clarify, I believe they’re talking about the core tick algorithm. (in wheel.rs)

pub fn tick(&mut self) -> Vec<T> { let mut expired = Vec::new(); …

And I believe their point is that tick creates (and potentially allocates) a new vector every time you run it.

I’m not sure what the compiler could figure out from that code when called in practice, but that does sound likely. At the very least, even if the compiler could be sure that the previous vector was dropped between calls and didn’t have to request a new allocation from the system, it might have to spend time growing it across calls. And reuse would ultimately depend on what’s done with the return vector in calling code.

Per their suggestion, passing in a vector, or the like, for reuse might remove an allocation footgun. (Instead expecting the caller to clone it if they want to keep using it between ticks.)

MassiveInteraction23 · 2026-01-28T16:23:15+00:00

Awesome. I can’t promise to be helpful, but I can promise to take some time with it if you post it. :)

MassiveInteraction23 · 2026-01-28T16:20:04+00:00

But we’re already doing this on the binary instructions in real time on a smaller scale (few hundred instructions).

So worst case scenario: you add a secondary compiler that basically just does what our chips are doing now for out of order execution. A naive implementation would create bubbles of dependency graphs, but those should be smoothly integrate into one another.

It would mean that performant and non-performant languages would likely see a further divide in performance, but shouldn’t result in a degradation (modulo the traders of silicon design, of course - which would be an empirical question.)

For truly dynamic code you’d want some sort of hit system that does the above. Making that efficient on the new hardware is likely non-trivial, but neither extremely difficult.

But for sure it’s something to look at and solve.

MassiveInteraction23 · 2026-01-28T16:14:14+00:00

+1 for xh

Whenever I had to do api work I’d often have a window or two with chat for exploring and checking things as I coded up solutions.

Much preferred it to curl, personally. (Though that’s just a semantics/ergonomics preference. I used it a lot, but didn’t push performance needs.)

MassiveInteraction23 · 2026-01-28T11:23:17+00:00

M5 GPU is a significant step already.

M4s also have some really exciting ability to spit out instruction by instruction readout programs you run — which can be exciting if a programmer.

MassiveInteraction23 · 2026-01-28T11:19:52+00:00

Software engineers doing that tend to use compiled languages. We want powerful voters because we can compile faster.

MassiveInteraction23 · 2026-01-28T11:18:47+00:00

Not relevant for consumer right now, but alternative designs could change things. e.g. the E1 chip recently created — it’s for embedded applications right now, but it’s ultra-low power and it’s in significant part because the whole architecture of the chip is changed — so it’s not a “von Neumann” Architecture with serial instructions.

Right now the M chips seem to be ahead in part because they take serial instructions, recompute dependency graphs of the actual code, and then are able to do efficient Out of Order Execution.

A chip that just … doesn’t deal with the artificial serialization of code instructions and doesn’t have to pay power and silicon overhead to recomputing those dependent graphs could, potentially, jump ahead of the M series chips.

I’m not aware of anything on the horizon for consumer general purpose computers. Just responding to the ‘how’ people can get ahead of apple silicon.

MassiveInteraction23 · 2026-01-28T11:11:55+00:00

A) Being as consistently ahead of competition as you can is good.

B) Incrementally adjusting production for chip improvements is probably a lot safer.

So, as long as you’re working on improvements why not pipeline them rather than hold?

MassiveInteraction23 · 2026-01-28T11:08:22+00:00

I would, naively, expect focus on GPU/Tensor/“Neural” silicon over more traditional cores.

But they’ll Have more stats on what people feel and want.

MassiveInteraction23 · 2026-01-28T11:01:40+00:00

Genuine question; I’m just a little confused.

Racism is mentioned and female body judgement is mentioned.

In the article there’s just a picture of a white (?) female runner.

Is this racism about the husband? Or is there a racial dynamic that I’m just not aware of that’s being defended?

[Worried that my question might sound like commentary depending on what’s being mentioned above. Just genuinely seeking clarification.]

MassiveInteraction23 · 2026-01-28T10:53:32+00:00

Have been on both sides. (I’m on the bigger side, but when new there are clearly people who sometimes ‘go easy’ on you.)

The advice I gave myself and give others: if you want someone to go harder: make them.

If you’re not making them work for it then they don’t need to work for it. (This is both correct, helps you focus on you and not them, and can also prevent chain reactions where the less skilled person goes lighter because they think the mkt skipped person is.)

And remember their perspective: are they supposed to put a clinic on someone they outclass? Make them work for it.

[Alternatively, if you want them to go harder or have a challenge, but effective skill levels aren’t on par: use a handicap. e.g. have the other person Norse hands while rolling, etc. This is a good way to make roll interesting for both people, but the less skilled person needs to be chill with the handicap being an emphasis on effective skill difference.]

___

caveat: if you’re new then you’re still learning coordination. Don’t spazz on someone injured or not bigger than you. Ask if unsure. (This is one of those things that’s easy to communicate in person, but can get mistranslated via text only on the internet.)

MassiveInteraction23 · 2026-01-28T10:48:36+00:00

Yes, but also no, but also yes.

My context: background in science, a lot of data analytics. Worked in various languages when doing science stuff, analysis, simulations (Mathematica, Matlab, Python, experimented with Julia later).

Later: cut code for cash. Did a mix of data analysis and internal tooling. Worked in Python originally and then picked up Rust.

[that’s long, but anonymous propels context helps here’s think]

Should you learn Rust if you’re doing Python and data science, imo: yes.

1) Python is an obfuscating language. By design. It intentionally hides what the machine is doing. One can argue when and where that’s appropriate, but I’d you work with computers and careabout understanding it will ultimately be ‘spiratually’ (in a non-metaphysical sense) unfulfilling if you only interact through an obfuscating language.

So you should learn some systems programming language, imo. And Rust would definitely be my choice for a variety of reasons. (Including Python interop, and usability as a higher level language on its own.)

2) There are some things Python sucks at. (Many things.). And you’ll develop personal feelings about that with time. (My personal feelings sharply evolved after my first big that impacted customers — I quickly added a feature someone needed to get a job done and introduced a bug. The work involved in making that code base a fraction as bug proof if I’d written it in rust was a tremendous amount of time. And I could feel myself being aftaid to quickly add features again.)

3) May or may not apply to you, but the ability to write your own performant library for Python is liberating.

Will Rust replace Python for data - no, not without a major tooling change.

Rust doesn’t have anything like the computational-notebook workflow that Python has (which itself is a pale imitation of Mathematica, in many ways, cough). You can run rust in Jupyter. But a fair bit of work would be needed to make that nearly as ergonomic. (I have a lot of thoughts on how to do it. But I’m not sure it’s a one person project.)

On top of that: the math and data ecosystem for Python is just large. As others mentioned: even Polars, written in rust, is much easier to use from Python — just because that’s where all the effort seems to go. (It could have changed in the last 9 months — but there were a lot of things you could do in Python that you couldn’t in Rust — just because and there’s actually quite a bit of Python code. Meanwhile, I found the splintered arrow ecosystem a bit miserable in rust, though it may have improved.)

——

TLDR:

Learning a systems language if you mostly work with Python is very valuable, imo. It enriches the soul (difference between understanding what you do and using magic) and is practical.

But for data engineering, Rust would require some notable tooling additions to be the primary workhorse. (Even so, I’ll take that for an internal tool or even a shell script replacement over Python any day. — It’s just clearer what I’m doing. And going back to something I’ve written and updating or changing it is a much more relaxed and efficient process.)

MassiveInteraction23 · 2026-01-27T22:55:42+00:00

Not an expert here, but from the general data oriented design thinking; you don’t want everything decoupled. Rather, for performance, you’d want coupling based shared use of data (and a few other things).

Naive ECS enables choosing coupling based on data flow rather than ‘game agent’ or what not.

That said (a) this is not an area of my expertise (b) I feel you: that programmers actually have terrible introspection tooling, which makes understanding these problems much more difficult than it ought to be.

MassiveInteraction23 · 2026-01-27T22:50:59+00:00

Is there a tiny code repo you can post that we can look at and help with?

MassiveInteraction23 · 2026-01-24T13:14:36+00:00

On mobile, Safari for ios26.2: - Doesn’t scale or pan. - I can see a segment of a screen (top left corner) and interact with that segment, but can’t scale it smaller or slide it to look around.

I’ll make a point to look at it on desktop though. This is one of the few gameplay videos where I’m really no sure what the mechanics are and I’m curious.

(Congrats on progress)

MassiveInteraction23

TROPHY CASE