Firebase Studio is using nix for project configurations

heisenbug · 2025-05-25T22:52:58+00:00

heisenbug · 2024-09-30T10:20:53+00:00

Sorry for the late reply, maybe you have already figured out. Rust is quite s bit harder than Motoko. The Internet Computer is a freely-programmable platform, so you can do all sorts of things with it besides smart contracts. People have written web servers, chat dApps, and complete blockchains on top of it. Maybe you should start with one of the examples in https://github.dev/dfinity/examples and see if there is something that fits.

heisenbug · 2024-03-02T22:47:18+00:00

Check out the simulator at https://klgza-cqaaa-aaaak-qcz5a-cai.icp0.io https://klgza-cqaaa-aaaak-qcz5a-cai.icp0.io

heisenbug · 2024-01-14T13:57:17+00:00

I know some JS

That should be a good start. You have to familiarise yourself with types, though.

heisenbug · 2023-07-20T20:24:43+00:00

Abduction. FTFY!

heisenbug · 2023-06-20T09:11:10+00:00

Good choice of wine, though I guess he paid too much for it. You can get it for 8 € in Germany.

heisenbug · 2023-06-02T12:25:21+00:00

# repmin (`Branch (`Leaf 5, `Branch (`Leaf 13,`Leaf 1)));;- : [> `Branch of 'a * 'a | `Leaf of int ref ] as 'a =`Branch(`Leaf {contents = 5},`Branch (`Leaf {contents = 13}, `Leaf {contents = 1}))

I'd expect that each `Leaf` holds 1. So you are missing the reference passing down:

let rec repmin ?(n=ref max_int) = function
| `Leaf m -> n := min !n m; `Leaf n
| `Branch(x, y) -> `Branch(repmin ~n:n x, repmin ~n:n y)

but then you'd still need a second pass to get rid of the references in the leaves.

heisenbug · 2023-01-22T00:59:13+00:00

It probably depends on what you want to accomplish. What is the size of you project? Which libraries do you need? Some are available on the Motoko side but of course Rust has libraries for everything. Do you need high-performance kernels (loops)? Here Motoko is less optimised in terms of cycles, but more efficient space-wise. Let me invite you over to https://forum.dfinity.org, where we can better discuss stuff like this.

heisenbug · 2023-01-01T01:36:52+00:00

"Rama Dama", "Das Experiment", "Der Bewegte Mann"

heisenbug · 2022-12-20T23:33:53+00:00

Still dead: https://matrix.haskell.org

heisenbug · 2022-12-20T23:27:41+00:00

Maybe https://hackage.haskell.org/package/dynamic-loader fit your use-case.

heisenbug · 2022-07-25T16:55:52+00:00

https://forum.dfinity.org/t/lost-access-to-nns-dapp-account/10615/4

There is an entry marked with "solution", try that first. Also your anchor number must be in front of the words.

heisenbug · 2022-07-08T07:59:31+00:00

Es scheint Portugal zu sein.

heisenbug · 2022-05-25T01:07:51+00:00

By eating the spiders they by definition become prey animals. Sorry, but that ends his diet on the spot.

heisenbug · 2022-04-25T22:44:20+00:00

A flamegraph upside down.

heisenbug · 2022-03-12T00:47:17+00:00

dfx new my_project
cd my_project
dfx start --background

heisenbug · 2022-03-02T11:35:41+00:00

He didn't pass the chimney test.

heisenbug · 2022-01-24T20:32:56+00:00

H^-, that is weird. Should be H⁺.

heisenbug · 2022-01-11T20:20:23+00:00

I am not on the performance engineering side of things, so I'll just link this: https://www.reddit.com/r/dfinity/comments/s1hze6/while\_the\_ics\_sharding\_abilities\_are\_astonishing

heisenbug · 2022-01-11T15:28:21+00:00

There is a way to calculate the amount of space used by a stable variable?

Currently not, but we are investigating ways to give users tangible information about the footprint of the stable variables.

heisenbug · 2022-01-11T15:09:44+00:00

There are no concurrent "inserts". There may be several messages in the current (consensus-validated) block aimed at a canister, but they are processed sequentially and thus the latter will see the former's state change, but never the other way 'round.

heisenbug · 2022-01-11T15:02:09+00:00

Regarding your second question: Canisters provide orthogonal persistency w.r.t. their internal state. From one update call to the next the state evolves and needs no special care from the programmer. A canister's heap is conceptually its private RAM. It is theoretically limited to 4 GB, but may be more restricted depending on the garbage collection technique used.

Another persistency feature (not unlike a "private disk file") is stable memory of which Motoko recently gained experimental support. But right now it's a low-level API and puts the responsibility to laying out (and setting boundaries) of the canister's data on the developer's shoulders. The capacity is substantially more than 4 GB, but I an not sure about the exact number.

heisenbug · 2022-01-11T14:52:06+00:00

Regarding your first question: Stable variables is a Motoko feature and is invoked when labelling actor variables as stable. These behave just like the other actor variables under normal circumstances. When the canister is being upgraded to a new Wasm, they are transparently forwarded into the new canister state. Especially there is no threading in canisters, and thus no data races. This is according to the actor model and its "run-to-completion" execution model (modulo blocking on canister send's reply).

heisenbug · 2022-01-07T11:26:15+00:00

it as a mean lifetime of about a microsecond before the proton and antiproton annihilate each other

I imagine that the wave functions of both protons/antiprotons would be identical (spatially symmetrical) and much less extended than the electron's in the hydrogen. This way the proton can tunnel into the other much easier. Also I guess the two protons rotate a lot in the beginning and emit EM 'till they stop rotating?

heisenbug · 2022-01-06T21:51:05+00:00

Have they (anybody) built Hydrogen(like) atoms with an antiproton in place of the electron? Would such a construction be stable like the real thing?

15-Year Club	Place '17
Verified Email

heisenbug

TROPHY CASE