HackerTrans
TopNewTrendsCommentsPastAskShowJobs

emmanueloga_

no profile record

comments

emmanueloga_
·पिछला माह·discuss
Right! [0] Apparently there are not many standard connectors like these, but I found at least one [1] ...

0: https://www.zojirushi.com/blog/design-explained-our-easy-rel...

1: https://www.mcmaster.com/products/breakaway-magnetic-connect...
emmanueloga_
·4 माह पहले·discuss
The excessive size of Go binaries is a common complain. I last recall seeing a related discussion on Lobsters [1]. Who knows, maybe the binary could be shrunk a bit? IMHO 12mb binary size is not that big of a deal.

--

1: https://lobste.rs/s/tzyslr/reducing_size_go_binaries_by_up_7...
emmanueloga_
·5 माह पहले·discuss
good point, could be some 10 years ago now, I think...
emmanueloga_
·5 माह पहले·discuss
I got into OCaml for a while, which naturally led me to try F#. What pushed me away back then was that the tooling lagged behind C#, especially in VS Code, and the C#/F# interop wasn’t as ergonomic as I expected. I liked the idea of using F# for the core and C# around the edges, but it didn’t feel smooth in practice. This was years ago, so maybe the tooling has improved since.

I’ve always wondered whether tighter integration with C# would have led to broader adoption, though that might have changed the character of the language.
emmanueloga_
·5 माह पहले·discuss
How about framing this in terms of two orthogonal axes the article doesn’t name: concurrency (actors) and continuity (durable execution).

* Durable execution: long‑running, resumable workflows with persistence, replay, and timeouts.

* Actors: isolated entities that own their state and logic, process one message at a time, and get concurrency by existing in large numbers (regardless of whether the runtime uses threads, async/await, or processes under the hood).

Combine the two and you get a "Durable actor", which seems close to what the article calls an “async agent”: a component that can receive messages, maintain state, pause/resume, survive restarts, and call out to an LLM or any other API.

And since spawning is already a primitive in the actor model, the article’s "subagent" fits naturally here too: it’s just another actor the first one creates.
emmanueloga_
·6 माह पहले·discuss
I’ve been thinking that defaulting to durable execution over lower‑level primitives like queues makes sense a lot of the time, what do you think?

A lot of the "simple queue" use cases end up needing extra machinery like a transactional‑outbox pattern just to be reliable. Durable‑execution frameworks (DBOS/Temporal/etc.) give you retries, state, and consistency out of the box. Patterns like Sagas also tend to get stitched together on top of queues, but a DE workflow gives you the same guarantees with far less complexity.

The main tradeoff I can think of is latency: DE engines add overhead, so for very high throughput, huge fan‑out, or ultra‑low‑latency pipelines, a bare‑bones queue + custom consumers might still be better.

Curious where others draw the line between the two.
emmanueloga_
·8 माह पहले·discuss
Tried writing an electrostatic particle simulator in Turbo Pascal 7 with BGI as a teen, a handful of particles before it crawled. Then saw a galaxy collision sim on a CD-ROM magazine disc handling thousands of bodies smoothly. Thought it was assembly tricks.. now I'm sure it's algorithmic (avoiding N**2 runtime) but never dug into the specifics. Are charges vs gravity sims essentially the same n-body problem?
emmanueloga_
·10 माह पहले·discuss
I haven't used ruby in more than a decade, but I remember there was always some controversy around the corner. Up next: Zed Shaw comes out from his cave, joins forces with the mummy of _why to combat DHH's anti-woke agenda.
emmanueloga_
·10 माह पहले·discuss
Page Object Models trade off clarity for encapsulation. Concrete example [1]. They can make tests look "cleaner" but often obscure what's actually happening. For example:

    await page.getStarted(); // what does this actually do?
vs

    await page.locator('a', { hasText: 'Get started' }).first().click();
    await expect(page.locator('h1', { hasText: 'Installation' })).toBeVisible();
The second version is explicit and self-documenting. Tests don't always benefit from aggressive DRY, but I've seen teams adopt POMs to coordinate between SDETs and SWEs.

--

1: https://playwright.dev/docs/pom
emmanueloga_
·11 माह पहले·discuss
I just found that someone posted a showHN for an utility to solve this issue [1].

I think this reinforces the idea that is something that could be built into verdaccio.

--

1: https://news.ycombinator.com/item?id=44891786
emmanueloga_
·11 माह पहले·discuss
I wonder if anyone use https://verdaccio.org/ to vendor packages?

In theory for each package one could:

* npm install pkg

* npm pack pkg

* npm publish --registry=https://verdaccio.company.com

* set .npmrc to "registry=https://verdaccio.company.com/ when working with the actual app.

...this way, one could vet packages one by one. The main caveat I see is that it’s very inconvenient to have to vet and publish each package manually.

It would be great if Verdaccio had a UI to make this easier, for example, showing packages that were attempted to install but not yet vetted, and then allowing approval with a single click.
emmanueloga_
·पिछला वर्ष·discuss
I like it! Suggestions:

* Clarify relationship with https://hckrnews.com/

* Don't put the settings in localStorage, use URL params. That has a lot of usability improvements including being able to share the state, bookmark it, and heads up the current state. Use Rison [1] for the URL params to make it nice to read.

* The settings overview is too terse. What does something like "Timeline, Top 20, Day, Comments"? Maybe you could turn that into a concise natural language sentence.

--

1: https://github.com/kou64yama/rison2?tab=readme-ov-file
emmanueloga_
·पिछला वर्ष·discuss
a "no brown M&Ms" razor!
emmanueloga_
·पिछला वर्ष·discuss
I think brew's author point holds even if you replace "invert binary tree" with any other LC problem.

In terms of the problem itself, a binary tree can be expressed something like:

    type Node<T> = { value: T, left?: Node<T>, right?: Node<T> }
Given a root, you can invert it recursively with some code like this:

    function invertTree(root) {
      if (!root) return null;

      // Swap!
      const tmp = root.left;
      root.left = invertTree(root.right);
      root.right = invertTree(tmp);

      return root;
    };
Or using an explicit stack:

    function invertTree(root) {
      const stack = [root];
      while (stack.length > 0) {
        const node = stack.pop(); if (!node) continue;

        // Swap!
        const tmp = node.right;
        node.right = node.left;
        node.left = tmp;

        stack.push(node.left);
        stack.push(node.right);
      }
      return root;
    }
I think without prep would be harder to come up with the non-recursive version.
emmanueloga_
·2 वर्ष पहले·discuss
Wow this looks fantastic! Good open-source tools for design are so necessary [1].

You should probably add Graphite to this list [2]. I'll definitely try Graphite and follow its progress.

Good luck!

--

1: https://www.youtube.com/watch?v=lthVYUB8JLs

2: https://github.com/KenneyNL/Adobe-Alternatives
emmanueloga_
·3 वर्ष पहले·discuss
sounds useful for sandboxing
emmanueloga_
·3 वर्ष पहले·discuss
where do you work?
emmanueloga_
·5 वर्ष पहले·discuss
GUI algorithms like these are not well documented anywhere (except, of course, all over the web and in source code! :-) ...

Would be nice to have a site, maybe a wiki, dedicated to this kind of thing.

Other interesting problems in this area:

* Layout algorithms

* Automatic assignment of keys for navigation (for nav w/o using a mouse)

* Popup menu prediction [1]

* Text breaking / paragraph layout [2]

* Etc, etc, etc ...

1: https://bjk5.com/post/44698559168/breaking-down-amazons-mega...

2: https://xxyxyz.org/line-breaking/
emmanueloga_
·12 वर्ष पहले·discuss
I used to rather long names too... but now I think short variables have their place, and sometimes they even improve readability.

This code seems to follow a lot of conventions (if I see the var "i" I could bet a million dollars is an int that is being used as a counter, probably to go through the positions of an array). It uses plenty of enumerated constants, which is good too.

I've been doing some functional programming, where you find that often types are more important than names. See the "Names are overrated" section of this article [1] ( although this point may not apply to this piece of software... C being the language that it is :p).

1: http://techblog.realestate.com.au/the-abject-failure-of-weak...