u/erg

I found it did a great job adding a feature, like first try, amazingly finding where to put some new react code and render it.

Refactoring the frontend to hit both solr/opensearch instead of just solr...it failed hard. Removing css that had nothing to do with the problem, getting lost on what it had done and applying four empty patches in a row (it should not offer to apply empty patches, seems like a bug). It couldn't understand the backend route to hit, tried to add query params that weren't honored, left out a crucial route parameter and would not add it back/understand. Tried for about 20m before I went back to claude code.

That's my preliminary report--let gemini add a feature or two that don't exist, use claude code for harder editing of existing code. I expect this to change in a week or so after some bugs are fixed or better instructions are written, gemini is really really good as a model, but just couldn't get it working in this use case.

Claude PRO MAX gets you 4x more than basic MAX. I can hit the opus limit in an hour if I'm cranking on two-three terminals but it resets. what are you gonna do, code by hand instead?

Expanded Usage: 5x more usage than Pro $100 per month Ideal for frequent users who work with Claude on a variety of tasks

Maximum Flexibility: 20x more usage than Pro $200 per month Ideal for daily users who collaborate often with Claude for most tasks

They just like to sleep in, ok? What's wrong with that?

Maybe https://github.com/Cloudef/zig-aio would work? It's under active development.

https://www.reddit.com/message/messages/138zrul

I would like to track deals on 4k/8k TVs as they pop up. I like the reddit format better than slickdeals. It's a shame to see this subreddit with no activity and I'd like to revive it. Thanks!

two left $1998 https://www.amazon.com/dp/B084L41QVJ

In Factor there's a thing called a "smart combinator" which can infer the number of outputs at compile-time.

2 4
[| foo bar |
    "a"
    foo bar < "b" "c" ?
    "d"
] output>array .
{ "a" "b" "d" }

You can't do a smart combinator that infers the number of outputs of an each because there may be any number of outputs. It's basically like varargs at that point.

https://docs.factorcode.org/content/article-combinators.smart.html

make also has % which flattens a sequence to the output sequence.

5 4 { 1 2 3 }
[| foo bar myArray |
    "a" ,
    foo bar < "b" "c" ? ,
    "d" ,
    myArray [ 2 * ] map-zip concat %
    ! after map-zip { { 1 2 } { 2 4 } { 3 6 } }
    ! after concat { 1 2 2 4 3 6 }
    ! % flattens that into the output sequence { }
] { } make .
{ "a" "c" "d" 1 2 2 4 3 6 }

There are other smart combinators like input<sequence which, given n quotations (lambdas), grabs that many things out of a sequence. You can use this with output>array or append-outputs-as and the stack checker infers everything.

The pack vocabulary is a good example:

https://github.com/factor/factor/blob/master/basis/pack/pack.factor#L98

! input<sequence is a smart combinator that grabs inputs from a seq
! append-outputs-as infers how many sequences to append from the code
MACRO: pack ( str -- quot )
    expand-pack-format
    [ pack-table at '[ _ execute ] ] { } map-as
    '[ [ [ _ spread ] input<sequence ] B{ } append-outputs-as ] ;

: pack-be ( seq str -- seq )
    '[ _ _ pack ] with-big-endian ; inline

pack unit tests: https://github.com/factor/factor/blob/master/basis/pack/pack-tests.factor

{ { 1 2 3 4 5 } } [
    { 1 2 3 4 5 }
    "cstiq" [ pack-be ] keep unpack-be
] unit-test

{ 1 2 3 4 5 } "cstiq" pack-be . ! char 2chars 3chars 4chars 8chars in big endian
B{ 1 0 2 0 0 3 0 0 0 4 0 0 0 0 0 0 0 5 }

Anyway, Factor has a make feature which outputs to a dynamically scoped variable which allows exactly what you're doing, but also smart combinators if the code is not varargs style and can be inferred at compile-time and you use the smart words that infer the inputs/outputs of a lambda by using the stack checker.

I wrote a version of simpson's integration in Factor in 2008:

USING: kernel math math.ranges math.vectors namespaces
sequences ;
IN: math.numerical-integration

SYMBOL: num-steps
180 num-steps set-global

: setup-simpson-range ( from to -- frange )
    2dup swap - num-steps get / <range> ;

: generate-simpson-weights ( seq -- seq )
    length 1 + 2/ 2 - { 2 4 } <repetition> concat
    { 1 4 } { 1 } surround ;

: integrate-simpson ( from to quot -- x )
    [ setup-simpson-range dup ] dip
    map dup generate-simpson-weights
    vdot swap [ third ] keep first - 6 / * ; inline

https://github.com/factor/factor/blob/da5d010c5b17472cf25e3ed6ebde14b1bde562a9/extra/math/numerical-integration/numerical-integration.factor

https://onyxboox.com/

I have an Android one that you can write on with a stylus. It's decent.

No worries. I regularly test on Ubuntu, Arch, and Debian. Thanks for following up!

Could you please file a bug with more details about these old libraries? I'm not sure which ones you're talking about, but I'd like to fix them! Thanks!

https://github.com/factor/factor/issues

If you want to get technical, it’s within the city limits and growing up there we always called it Austin, not Cedar Park, Round Rock, or Leander. And yes it’s a 20 minute drive to downtown without traffic.

How about Factor?

I'm listening to the Mahler 3 for Organ I just found on youtube and I remembered your post.

https://www.youtube.com/watch?v=YyDH1pPo2MU

Can you list some please?

Maybe you'd like Prokofiev Piano Concertos.

The plodding sounds like this to me https://youtu.be/1Kwajecmh2c?t=858

There's more: https://youtu.be/FgnE25-kvyk?t=712

I just started learning Haskell after putting it off for 18 years. Just gotta do it! Neither are that hard to learn.

(I clicked the button to release Factor.)

https://www.youtube.com/watch?v=F8T94sdiNjc

How about Scorpio?

https://www.videoblocks.com/video/scorpio-constellation-on-a-beautiful-starry-night-background-ruqjubwniswogoxj

Congrats on your new VW GTI with Ingo Noak widebody and Rotiform OZTs!

Steve Bannon in front with the camera?