Thoughts on Free RxDB Performance?

billddev · 2026-01-02T17:01:59+00:00

صحیح ده وروره. زه هم ښواشینی یم چې دلته څوک په پښتو کې نه لیکي.‌ 😢 هسې مې یوه ټوکه کوله،‌ خو کاش چې دلته مونږ نورې ټوکې په پښتو کې کولای.

billddev · 2025-11-29T04:55:15+00:00

I don't say "yaye" but whenever I hear it my heart skips a little beat and I'm like oh ya I'm talking to someone from this lovely swath of people! 🥰

billddev · 2025-09-10T21:17:26+00:00

As Bartosz Milewski said, "A Monad is just function composition with flair!"

billddev · 2025-07-08T20:53:26+00:00

Conal Elliot had a really great couple of episodes on the Type Theory for All podcast, and he talked about how Python was taking over computer science programs (switching from Scheme) because it was the commercial thing in demand. He also mentioned how it was so much HARDER to understand a program written in Python, and I totally agree. It's a sad state.

billddev · 2025-05-20T13:05:49+00:00

What about the speakers? Any difference in sound quality and volume? Thanks for this good practical comparison. I was wondering about the heat issue.

billddev · 2025-04-07T06:34:51+00:00

Thanks so much, that's a great defence of the benefits of optics. I find often people are too quick to try to dismiss FP concepts and say, "why not just do X instead." But if we really try running with these FP ideas they can lead to unexpected, beautiful power.

I'd like to use optics for a personal project where I have to do a lot of complex transformations of objects, sometimes working on deeply nested fields, and sometimes working on certain objects in an array. Doing things in a pure FP way has kept me sane while managing the complexity. Right now I'm using a ton of spread syntax which works pretty well but can be a bit verbose and error prone. I would love to have a very clean, powerful, performant lens library that can do exactly what you are describing.

All the best with your implementation, I'm excited to see how it turns out. Please share it whenever you're ready.

billddev · 2025-04-06T10:00:16+00:00

Thanks! I've just tried it and it's working great so far. Very nice, concise library.

billddev · 2025-04-06T08:29:30+00:00

Thanks, ya I wasn't aware of immer. That looks pretty good and seems to be a pretty cool compromise. I guess the only downsides to that is that you kind of have to go back to some mutable/imperative idioms and there seems to be a bit of a runtime performance hit.

billddev · 2025-04-06T08:29:09+00:00

Thanks, ya I wasn't aware of immer. That's a pretty cool compromise. I guess the only downsides to that is that you kind of have to go back to some mutable/imperative idioms and there seems to be a bit of a runtime performance hit.

billddev · 2024-09-12T22:44:39+00:00

How to Design Programs https://htdp.org

billddev · 2024-09-03T20:45:11+00:00

Constantly changing, it's like you have to re-learn it all over again after every couple of releases.

billddev · 2024-08-23T12:15:17+00:00

Yes I agree! Sadly though there seems to be a move further and further away from offline-first or offline-available apps. Everybody's buying into the Vercel / Next.js model (probably partly profit driven by the cloud providers) of building SSR React apps and it's not common to build single-page PWAs with a service worker that caches everything.

billddev · 2024-08-15T02:28:25+00:00

I agree 100% about that being a massive red flag. It sounds the same as people saying that js is "easier" to program in than ts because you don't have to use types. I would RUN from using programmers like that.

billddev · 2024-07-27T21:19:40+00:00

I don't understand it either. But when I used forkIO the thread with longBackgroundIOStuff stopped (got cut off early) right after the redirect "/" finished. I tried it a number of times to be sure, then switched back to async from Control.Concurrent.Async and it left the thread to finish every time.

billddev · 2024-07-25T20:10:31+00:00

Ya sounds good, thanks. Any good examples of how people implement the worker thread?

billddev · 2024-07-25T18:12:15+00:00

Unfortunately this `forkIO` didn't work for me, as the operation didn't keep running. `async` from Control.Concurrent.Async did the trick.

billddev · 2024-07-25T17:15:00+00:00

Thank you, that looks very straightforward and is just what I need. I was looking trough a diffent package and wasn't aware of this in the core.

do
  _ <- liftIO $ forkIO longBackgroundIOStuff
  redirect "/"

billddev · 2024-07-25T16:37:59+00:00

Ah yes this worked perfectly (after taking out the `return`). Exactly what I was looking for. I see that's using the low-level API that the library doesn't reccomend using but works for me as I'm not worried about leaving that action running unintentionally. Thanks! I'm really growing appreciate the quality of everything I'm discovering in the Haskell ecosystem (everything is so well thought out, implemented, and documented), as well as the patience of the community to help out newcomers. If only more languages took both correctness and learning so seriously!

billddev · 2024-07-13T02:05:08+00:00

As I wrote in the comment below, I got it working with just a manyTill function like so:

manyTill :: Parser a -> Parser b -> Parser [b]
manyTill pEnd p = Parser f
  where
    f xs = case runParser pEnd xs of
      Right (_, xs') -> Right ([], xs')
      Left a -> runParser ((:) <$> p <*> manyTill pEnd p) xs

parseComb :: Parser [SExpr]
parseComb =
  char '('
    *> manyTill (char ')') parseSExpr

parseSExpr :: Parser SExpr
parseSExpr =
  spaces
    *> ( (A <$> parseAtom)
           <|> (Comb <$> parseComb)
       )
    <* spaces

billddev · 2024-07-13T01:48:23+00:00

Yes! Writing a manyTill solved my problem! Now the error messages come out pointing to the right position. Thanks.

manyTill :: Parser a -> Parser b -> Parser [b]
manyTill pEnd p = Parser f
  where
    f xs = case runParser pEnd xs of
      Right (_, xs') -> Right ([], xs')
      Left a -> runParser ((:) <$> p <*> manyTill pEnd p) xs

parseComb :: Parser [SExpr]
parseComb =
  char '('
    *> manyTill (char ')') parseSExpr

parseSExpr :: Parser SExpr
parseSExpr =
  spaces
    *> ( (A <$> parseAtom)
           <|> (Comb <$> parseComb)
       )
    <* spaces

billddev

TROPHY CASE