[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Claude code analyzed the donut script from a while back 44 frames per second to 100 frames per second

Right.
There's no more need in proprietary apps nor in open source ones, you just ask AI to make you what you want and get it. You couldn't do it yourself as fast and as effortless, so denying AI is simply loosing the competition and nothing else. You still can program for fun, but in Large Software Business there's no programming by hands anymore, it's just shooting yourself in a leg. That's why I asked Brian in the first place what his point was, since, obviously, AI can and will make any code better, that's what it's for. AI isn't creative, basically it can't create anything that hasn't been made already, but it's like having a programming assistant that has not only 100% knowledge of the language you program in, but it has 100% correct memory of everything ever written in it.  Which helps. You may ask it for help from time to time, but programmers don't do that anymore. Because copying and pasting takes too much time, and time is money. There's a term, "to put Ralph on it", which means just repeat a prompt for millions of times like Ralph Wiggum from Simpsons would, till the result program is 100% excellent. That's the whole code writing in business nowadays. 

04.11.2026 15:29, Fabien Bodard пишет:
I use excel clone, word clone, photoshop clone and illustrator clone .. all made by ia .. so well. So the question is not to use or not ia.. but how. If Ican .. local IA . 

Fabien Bodard

Le mer. 4 nov. 2026, 01:40, Admin <admin@xxxxxxxxxx> a écrit :

    As of today I'd say if it's not explicitly said something is
    written without Cloude, it's written with it. There is no reason
    to highlight it. No reason to not use it since everybody does for
    a long time. I don't think any Adobe or Microsoft project is
    written with any human effort whatsoever, for example. The last
    Apple Iphone is purely and officially AI-designed (but it's a bad
    example alright). I'm kinda surprised it's not obvious to
    everyone. Programming is a hobby. Commercial programming is done
    by AI, otherwise you will be very slow and make a lot of mistakes.
    A lot of my friends are making commercial games. They don't know
    how to program, never were into that. But since you don't need to
    be a programmer to make software anymore, they all do, and sell it
    quite successfully. Only thing I don't understand is who buys it,
    when you can create your own for free. People already replaced
    Photoshop without knowing how to program. I can see why project
    like Debian are calling meetings to discuss weather they will pass
    the AI-code or they wouldn't. Because of course naturally the code
    in Linux will be written by AI just like any other code nowadays,
    and if they don't want that they have to say it out loud, because
    by default any code today is AI-written. Concerning "write better
    code then us", well, AI cant invent anything, AI writes basically
    only what was already written before. It's just faster, cheaper
    and anybody can have a "programmer" in their team. Vibecoding has
    won years ago, look around closely.

    Dmitry.

    04.11.2026 03:04, Jussi Lahtinen пишет:

    I still have not seen any successful big project made by AI
    alone. Maybe they exist and I'm not just aware of them, but until
    I see that I'm not convinced they "write better code than us".



    Jussi

    On Tue, Nov 3, 2026 at 3:10 PM Admin <admin@xxxxxxxxxx> wrote:

        Well, what did you expect?
        Claude writes better code then us, so that's why many
        programmers are
        not writing any code anymore, for a long time now, worldwide.
        That's
        what AI was made for.
        So, what's your point?

        Dmitry.

        03.11.2026 06:38, Brian G пишет:
        > I just handed an old piece of code over to Claude code,
        asked it to
        > analyze the code and it did, without my intervention at
        all, it
        > produced and tested the updated code. This script code
        draws a 3d
        > donut on the screen, and then animates it in a way that
        makes it
        > appear to spin.
        >
        > In the original code, frame rate was about 44fps, the
        ctrl-c did not
        > work all the time, a lot of time was spend creating the
        output strings.
        >
        > Claude re-wrote the script with zero input from me, the
        script now
        > churns at a nice 100fps and ctrl-c always causes it to
        stop... ummm.
        > And as a bonus, you can now resize the terminal on the fly
        and the
        > code resizes the donut...new feature..
        > I am impressed/scratching my head/thoughtful....
        >
        > script code written by claude is attached.
        >
        >
        ___________________________________________________________________cut

        >
        here______________________________________________________________________
        >
        > #!/usr/bin/env gbs3
        > ' Gambas Script File Created 01/10/2021 20:11:31.237
        > ' Original Donut program by Andy Sloane
        > ' https://www.a1k0n.net/2011/07/20/donut-math.html
        > '
        > ' Usage:  ./donutSpiner       Press Ctrl-C to stop.
        > '
        > ' Changes from donutSpinner: by claude
        > '  - runs under gbs3
        > '  - has a Main, so the program actually starts
        > '  - Ctrl-C / SIGTERM / SIGHUP set a flag; the loop ends
        and the
        > cursor and
        > '    screen are restored (the original left the cursor hidden)
        > '  - no debug output (Hello world, linetrace)
        > '  - errors are not swallowed in render_frame; they end the
        program
        > with a message
        > '  - frame is built in one Byte[] (rows + newlines) and
        printed with
        > one ToString()
        > '  - output and z buffers are allocated once and cleared
        with Fill()
        > each frame
        > '  - points that project off screen are skipped instead of
        piling up
        > on the border
        > '  - terminal resize is detected each frame and the buffers
        are rebuilt
        >
        > Fast Unsafe
        > Use "gb.signal"
        >
        > Const theta_spacing As Float = 0.01
        > Const phi_spacing As Float = 0.01
        > Const TwoPi As Float = 6.28
        >
        > Const R1 As Float = 1.00
        > Const R2 As Float = 2.00
        > Const K2 As Float = 5.0
        > Const ShadeSource As String = " .,-~:;=!*$#@"
        >
        > Private Shader As Byte[]
        > Private ShadeMax As Integer
        >
        > Private screen_width As Integer     ' columns
        > Private screen_height As Integer    ' rows used by the
        donut (last row
        > is the status line)
        > Private K1 As Float
        > Private bOutput As Byte[]           ' (screen_width + 1) *
        > screen_height, includes a newline per row
        > Private zBuffer As Float[]          ' screen_width *
        screen_height
        >
        > Private bQuit As Boolean
        >
        > Public Sub Main()
        >
        >   Dim a, b As Float
        >   Dim fFrameStart, fFrameTime, fRateStart, fElapsed,
        fFrameRate As Float
        >   Dim iFrames As Integer
        >   Dim sTime, sRate As String
        >
        >   Signal[Signal.SIGINT].Catch
        >   Signal[Signal.SIGTERM].Catch
        >   Signal[Signal.SIGHUP].Catch
        >
        >   Shader = Byte[].FromString(ShadeSource)
        >   ShadeMax = Shader.Max
        >
        >   Print "\e[2J";
        >   fRateStart = Timer
        >
        >   While Not bQuit
        >     CheckScreenSize()
        >
        >     fFrameStart = Timer
        >     render_frame(a, b)
        >     fFrameTime = Timer - fFrameStart
        >
        >     a += 0.07
        >     b += 0.03
        >
        >     Inc iFrames
        >     fElapsed = Timer - fRateStart
        >     If fElapsed >= 1.0 Then
        >       fFrameRate = iFrames / fElapsed
        >       iFrames = 0
        >       fRateStart = Timer
        >     Endif
        >
        >     sTime = Format(fFrameTime, "0.0000")
        >     sRate = Format(fFrameRate, "0.0")
        >     Print sTime; "s  "; sRate; " fps\e[K";
        >     Flush
        >
        >     Wait 0   ' signals are delivered here
        >   Wend
        >
        > Finally
        >   ' Show the cursor again, clear the screen and home the cursor
        >   Print "\e[?25h\e[2J\e[H";
        >   Flush
        >
        > Catch
        >   Error "donutSpiner error:";; Error.Text;; "at";; Error.Where
        >   Quit 1
        >
        > End
        >
        > '' Called by gb.signal for the signals caught in Main
        > Public Sub Application_Signal(iSignal As Integer)
        >
        >   bQuit = True
        >
        > End
        >
        > '' Read the terminal size and (re)build the buffers if it
        changed
        > Private Sub CheckScreenSize()
        >
        >   Dim w As Integer = File.Out.Term.Width
        >   Dim h As Integer = File.Out.Term.Height - 1   ' keep the
        last row
        > for the status line
        >
        >   If w < 2 Then w = 2
        >   If h < 2 Then h = 2
        >   If w = screen_width And If h = screen_height Then Return
        >
        >   screen_width = w
        >   screen_height = h
        >
        >   ' K1 scales the projection to the screen width. With the
        divisor 9
        > the torus
        >   ' edge (x = R1 + R2, z = 0) lands at screen_width / 9
        from the
        > center; the
        >   ' parts closest to the viewer project further out.
        Increase the
        > divisor to
        >   ' make the donut smaller, decrease it to make it bigger.
        >   K1 = screen_width * K2 / (9.00 * (R1 + R2))
        >
        >   bOutput = New Byte[(screen_width + 1) * screen_height]
        >   zBuffer = New Float[screen_width * screen_height]
        >   Print "\e[2J";
        >
        > End
        >
        > Public Sub render_frame(a As Float, b As Float)
        >
        >   Dim cosA As Float = Cos(a)
        >   Dim sinA As Float = Sin(a)
        >   Dim cosB As Float = Cos(b)
        >   Dim sinB As Float = Sin(b)
        >   Dim stride As Integer = screen_width + 1
        >   Dim halfW As Float = screen_width / 2.00
        >   Dim halfH As Float = screen_height / 2.00
        >   Dim theta, phi As Float
        >   Dim costheta, sintheta, theta1, theta2, theta3, theta4,
        theta5,
        > circlex, circley As Float
        >   Dim cosphi, sinphi, L, x, y, z, ooz As Float
        >   Dim xp, yp, iShade, j As Integer
        >
        >   ' Clear the buffers and put a newline at the end of every row
        >   bOutput.Fill(32)
        >   zBuffer.Fill(0)
        >   For j = 1 To screen_height
        >     bOutput[j * stride - 1] = 10
        >   Next
        >
        >   For theta = 0.00 To TwoPi Step theta_spacing
        >     costheta = Cos(theta)
        >     sintheta = Sin(theta)
        >     theta1 = sinA * sintheta
        >     theta2 = costheta * sinB
        >     theta3 = cosA * costheta
        >     theta4 = cosA * sintheta
        >     theta5 = costheta * sinA
        >     circlex = R2 + (R1 * costheta)
        >     circley = R1 * sintheta
        >
        >     For phi = 0.00 To TwoPi Step phi_spacing
        >       cosphi = Cos(phi)
        >       sinphi = Sin(phi)
        >
        >       ' Luminance, ranges from -sqrt(2) to +sqrt(2). If
        it's <= 0 the
        > surface
        >       ' is pointing away from us, so we won't bother trying
        to plot it.
        >       L = (cosphi * theta2) - (theta3 * sinphi) - theta1 +
        (cosB *
        > (theta4 - (theta5 * sinphi)))
        >       If L <= 0 Then Continue
        >
        >       x = circlex * (cosB * cosphi + sinA * sinB * sinphi)
        - (circley
        > * cosA * sinB)
        >       y = circlex * (sinB * cosphi - sinA * cosB * sinphi)
        + (circley
        > * cosA * cosB)
        >       z = K2 + cosA * circlex * sinphi + circley * sinA
        >       ooz = 1.00 / z
        >
        >       ' x and y projection. y is negated because y goes up
        in 3D space
        >       ' but down on 2D displays.
        >       xp = CInt(halfW + K1 * ooz * x)
        >       yp = CInt(halfH - K1 * ooz * y)
        >
        >       ' Skip points that fall off screen (Unsafe: no array
        bounds
        > checking here)
        >       If xp < 0 Or If xp >= screen_width Then Continue
        >       If yp < 0 Or If yp >= screen_height Then Continue
        >
        >       If ooz > zBuffer[yp * screen_width + xp] Then
        >         zBuffer[yp * screen_width + xp] = ooz
        >         iShade = 1 + CInt(L * 8)
        >         If iShade > ShadeMax Then iShade = ShadeMax
        >         bOutput[yp * stride + xp] = Shader[iShade]
        >       Endif
        >     Next
        >   Next
        >
        >   ' Hide the cursor while drawing, home it and print the
        whole frame
        > at once.
        >   ' The last byte of the buffer is a newline, which moves
        us to the
        > status line.
        >   Print "\e[?25l\e[H"; bOutput.ToString();
        >
        > End
        >
        ------------------------------------------------------------------------------------------------cut

        > here
        >
        ---------------------------------------------------------------------------------------
        >