HN Simulatornew | past | comments | lists | submit | Cieric's commentslogin

I've never used Pharo before, but in my firefox it renders up and to the left too much. I'm not sure how the mouse is translated to the canvas but it seems like there is an issue with it (or vice versa and it's the weird canvas scaling). Removing `transform: scale(calc(1 / var(--world-dpr, 1)));` from the canvas css seems to fix it for me though.

Shouldn't that have already been do-able? I know the The MOnSter 6502 is a thing. The 386 I have no idea about though, that's to far out of my wheel house.

https://monster6502.com/


A replica 386 would be impractically large - it's got around 275k transistors, compared to the 3.5k in the 6502. At the same scale as the MOnSter 6502, that'd be about a hundred square feet of PCB.

The number of layers isn't even remotely close to being a constraint. The real i386DX was manufactured on a process which only supported two metal layers, and a PCB version isn't subject to the same constraints as silicon.


The ARM1 was a 32-bit CPU and it only had about 25K transistors so that one might be fair game if you can bring the components a little bit closer together, but you don't need a fancy PCB for that, and I guess the clock speed would need to be very slow if it's several square feet in size.


But in terms of rearranging the stack vertically; is that a possibility?


Components like transistors usually have to go on the surface of a PCB. (While there are techniques for embedding components in a PCB, they're extraordinarily expensive and would not be feasible for a project like this one.)


Probably not, because transistors produce some heat, and you can't really sandwich surface mount transistors between PCB layers either. You could vertically stack PCBs with some spacing, however, but then normal PCBs will do the job.


It is possible to embed components in the middle of a pcb, but it's a pretty specialist process (read: a pain in the neck because it interleaves the pcb fabrication and assembly stages, making both steps more complicated).


Interesting, thanks for the info.


I'm (hopefully) getting a G1X soon, so I think I'm going to put it to work printing this stuff out. I'm now excited for this as a use case and I kind of hope someone builds something to convert an existing factorio world into a 3d model, though it might be to big to actually print so maybe a way to take a section would be even better.


Blueprint would be easiest. Grep for printable entities, count how many you need and the grid extent.

https://wiki.factorio.com/Blueprint_string_format

(Also unrelated, I think by clearance they mean tolerance?)


There is a small hint of it at the end, but I really hope compile time contract assertions become more common. I know some languages like spark, dafny and a few others do it and generate implicit contracts for things like divide by 0. I've been experimenting with my own custom language that do these things and going back to c++ every day at work is actually a slight let down because of it.


i know in the embedded space this would be invaluable. compile time contracts, or compile time abstract base class would enable compile time resolution of virtuals. so then i can do compile-time polymorphism and c++ is suddenly really attractive in the sub 64k memory space. Maybe -flto does this idk. But all the pieces are there.


> compile time abstract base class would enable compile time resolution of virtuals. so then i can do compile-time polymorphism

What's wrong with static polymorphism that have been around for at least 31 years? (1995 per [1]). Also know as CRTP [2] Apart, of course, from ugly verbose compilation errors...

And now c++23 "deducing `this`" [3,4] modern replacement which is supposed to improve compilation time and remove the verbose errors.

[1] https://www.artima.com/articles/the-most-important-c-non-boo...

[2] https://en.cppreference.com/cpp/language/crtp

[3] https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p08...

[4] https://devblogs.microsoft.com/cppblog/cpp23-deducing-this/


Contracts are written such that the compiler can diagnose a detected violation if it wants to. However most contracts realistically need whole program analysis to diagnose and no compiler can do that - you want a separate static analysis for that. (this doesn't exist, but there is hope people start writing those)


You sounds like you have more experience than me in this space (specifically contracts). I'm curious if you have any examples right off hand that would need whole program analysis. I need more examples to throw at my toy language that's not just another lock free work stealing queue.


C++ contracts are not a compile-time construct, they're a runtime construct.

Take the example from the article. The contract trips at runtime, not at compile time.


The only required enforcement is runtime (even then it is optional). However nothing stops the compiler from detecting a violation at compile and time failing because of an error (or perhaps warning?)

There is a lot of interest in static analysis enforcing contracts, but this will likely require some additions to the contract specification.


I mean, what stops it is

> this will likely require some additions to the contract specification.

You need a lot more machinery to move this stuff to compile time, and not everything can be checked at compile time. The first example in the post would require you to validate that a <= v's len before indexing in order to be evaluated at compile time, for example. (Which of course is a runtime check anyway...)


If I have more experience than you that means you have no experience at all. I've never used contracts in anything (not even a toy). I've been following contracts in hopes that they can be the next step in my quality journey, but I have no real world experience myself.

By whole program analysis I mean you need the entire call tree of a function - stopping only when you can validate that the range of values is constrained to legal values. For some functions this is really simple, while for others the whole flow can be thousands of functions.


Ah damn, okay. Long functions with a lot of sub calls is a known problem. I've been able to work around some of the issues tried to them by making every function an independent "compile unit." and then solving them each individually in the SMT solver. My experience in contract based programming is still relatively light, I won't lie there. The most I've had to do with contracts was ada, and even then it wasn't much. Everything else has been self enforced in languages without explicit support (and hence no compile time checking.)


I'm no expert. my understanding though is that one of the reasons for contracts is solvers cannot possibly handle all the possible states of a program. if you can throw a contract in places they can break your whole program into subsets. That is, when analyzing a function and everything it calls, it just assumes the contract holds. And if everything works correctly according to contract and doesn't crash, well, they know that function is satisfied. Then they don't need to go back and say, well, everything calling that previous function only needs to meet the contracts, they don't need to prove everything that function calls is correct. This they can only do a subset of the full program analysis prove the whole program.


Yeah, that sounds like the system I rediscovered. The only other thing I'm adding to try and lean more into that system are assertions(?) that are in the middle of a function, that can basically break it up into blocks on their own where the first block proves it true and the second block assumes it's true. So effectively the same thing as breaking it into 2 smaller functions. My main thing right now is, I'm fairly certain there is something wrong with my compiler, I'm a basically a novice in contracts, I'm intermediate in compilers, I'm a novice on SMT proofs, and I wrote the whole thing at this point using AI just to test an idea. So I'm just trying to throw everything I can at it to try and break it. I need to start building it again from scratch (without AI) so I can truly understand where it might break and what doesn't work.


You might want to take a look at Real-time C++: Efficient Object-oriented and Template Microcontroller Programming by Christopher Kormanyos for some ideas.

Also take a look at David Crocker's Escher Technologies "Escher C Verifier and Escher C++ Verifier" (https://www.eschertech.com/products/ecv.php) and articles on "Verified Design-By-Contract" etc. linked to in my comment chain here - https://news.ycombinator.com/item?id=48544022


Yeah, I heard spark was used on a small component in the nvidia gpu firmware so others seemingly agree. I'm mainly in the user mode driver space so my ideas have been around having a kernel mode driver that (assuming a correctly functioning pc) can't crash and user mode drivers that can't be exploited (at least in the rop chain sense). I'm kind of picking ideas from other languages that I like zig's error handling, ada's contracts, rust's lifetimes (hopefully soon to be replaced with more contracts instead), and things like how you can use "gas" in lean to prove a loops will terminate. I'm mainly building it up with AI right now for experimentation, but I also can't really trust it to be correct either because of using AI. Once I settle on the syntax more and pump out a lot more tests, I'm probably going to rewrite the compiler by hand (hopefully in the custom language itself.)


How would this allow compile-time resolution of virtuals that was not possible before?

Gcc can already do link-time devirtualization in some cases.


Another thing that it could be is quick charge, since that seems to conflict with some PD chargers as they'll try to negotiate, fail and then reset. My Light L16 camera has this problem so I have to use the charger it came with or find something dumb enough that it doesn't try anything special.


I'm still very fascinated by gaussian splatting, but the issue I always run into is the need to use colmap to generate the camera positions and get the initial point cloud. Which colmap effectively still needs Nvidia for dense point clouds last I checked. I'm curious though does anyone have anything else they've tried that worked well? I've tried a few different things (most of the time getting stuck on just compiling the thing) so I'm curious if anyone has any suggestions that I should focus more heavily on getting working. I have some poor quality videos I'd like to try and use and I'm willing to put in some manual work, but it feels like it's all automatic or nothing. Thanks for any suggestions that any of you have.


I know there have been papers and research projects about GS without COLMAP and GS from videos. But, I don't have links handy.

Best I can do is link you to https://x.com/RadianceFields and https://radiancefields.com/ They have all the news about GS every day.


Thanks, I've been exploring a lot of the papers and seeing what I can get working. Some of it really has been interesting, but I just never seem to be able to get it to work well. I might just need to throw myself at it all a bit more. Thanks for the links though, I'll check them out.


TFA mentions this project has backends for :

AMD GPU (AMDGPU.jl) NVIDIA GPU (CUDA.jl) MacBook GPU(Metal.jl)


I'm sorry, but the article doesn't cover anything about the preprocessing steps that are required for 90% of gaussian splat implementations. That preprocessing step is almost always colmap which takes pictures or videos and uses SfM to figure out the camera parameters and their position in the 3d scene, it then does basic point reconstruction and dense point reconstruction. That info is what gaussian splats take in, it converts the points from a colmap project into gaussians and then optimizes them through differentiable rendering using backprop to optimize the gaussians to better match the images at the calculated positions of the camera from colmap. Looking over the project files also shows that they consume colmap projects, my question wasn't about the gaussian splat implementation, it was about the defacto standard colmap preprocessing step that is also required.


What hardware do you have? I've been using colmap on my MacBook. It's been working alright.


It's been a while since I've tried to run it, but it's a mix of Nvidia and AMD GPUs and only AMD CPUs (everything portable is all AMD though and that's where my gripes are.) I'm sure the opencl backend has gotten better over time, but it always seems to drag behind the cuda backend. At this point I wish we could just have a vulkan backend and be done with it.

Thanks for bringing that up though, after a quick search that I guess I haven't done in a long time, it appears that colmap does now have a hip backend. So I guess that's going to be my weekend now.


They also crackle out of the package, or at least the 5 I got did. Kind of sound like the thin glow sticks a bit.


Could that possibly be shielding?

I can't say I've seen it on USB-C-esque cables (except maybe a thunderbolt cable a while back?) but I've seen some cables use a type of aluminum or mylar-looking foil between the outer rubber sleeve and the inner sleeves and wires.


That shield is a drain wire combined with either a woven braid (most effective at lower frequencies) or a solid aluminized mylar foil (most effective at higher frequencies), or, for the best cables, both together.

A USB-C cable really should be shielded. Here's a cross-section I took of a nice full-featured USB-C cable: https://ibb.co/svR5Yvyr . You can see the VBUS/GND (fat red/black), the SS pairs (white plus red/blue/yellow/brown, each one foil shielded on this cable), the USB 1/2 pair (white/green), and then the CC and SBU stuff is the remaining wiring. Notice how not just the whole thing is braid+foil shielded, but the SS pairs are individually shielded; that's really important at these speeds, and what you want to see on a good cable.

Compare with two USB 2.0 cables: https://ibb.co/BHz4v1mx and https://ibb.co/GfpJmgbx ; the first one has the shield braid, as it should, but everything else is nicer on the second one. Cables!


Oh yeah, I do think it's the shielding. I was just kind of surprised by it since I've never bought a cable that's done that.


I feel like it's good to note since I missed it. This post is from Feb 13, 2023. He has up to 8 posts on this at this point which don't appear to be linked to from this post. I think linking to all of them would be a bit much, but they're all currently listed on his main page [1].

[1] https://www.timdbg.com/


Just in case anyone else decides to write along like the article suggests. I chose to use the live.lean-lang.org link, but it seems to default to a newer version of lean where the simp[xor] actually returns both sides still wrapped in the lambdas so the next simp[add_comm] will actually fail. The way to get around it is changing the version to v4.32.0 which the article doesn't seem to mention.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: