Re: GPT-4 knows Guile! :)

[Mikael Djurfeldt]

Hi James, I agree with most of what you say.

What I find amazing, though, is that a comparably simple network
architecture can still be so capable. It shows the power of the large
volume of training data. After all, it is a large portion of the part of
human culture that is exposed on the internet. It is in this direction that
GPT-4 has capabilities that I think not even the developers at OpenAI have
fully explored. Together with a friend, we have discussed concepts in art
and physics with it, and it can be truly useful and enlightening.

Already at this level, it will likely be revolutionizing to society.

At the same time, it is "just" a text prediction engine. Of course, if you
later complete it with other stuff similar to what we have in our heads,
like working memory plus a range of other components, well, then it will be
interesting.

Here's a commentary in Nature:

https://www.nature.com/articles/d41586-023-00816-5

Best regards,
Mikael

On Sat, Mar 18, 2023 at 8:53 AM James Crake-Merani <james@jamescm.co.uk>
wrote:

> Hi,
>
> I think some students think that ChatGPT is this magical AI which can do
> their work for them, when in reality ChatGPT is really poor at writing
> code. According to the paper on ChatGPT 4[1], in easy Leetcode
> challenges, ChatGPT 4 does decently although 3.5 still does poorly with
> a score of 12/41 compared to 4's 31/41. However, when the difficulty was
> increased, ChatGPT only got 21/80 on the medium Leetcode, and a measly
> 4/45 on the hard Leetcode. Results are even worse with ChatGPT 3.5, with
> it getting 8/80 on the medium challenges, and nothing on the hard
> challenges.
>
> Anecdotally, one of my friends at university prompted it to write some
> code in Java. It started to come out with Python code. But that's
> alright, because the first line had 'import java'. Unfortunately, my
> friend had cut it off before it got any further so we didn't get to see
> what it came out with.
>
> I think, at least for now, that our jobs are safe. I suspect
> potentially, AI like ChatGPT could help automate more trivial tasks so
> the humans can be left just with the tasks that are done best by humans.
> But at the moment, while ChatGPT has made improvements in this regard,
> it is still too erroneous to be used for even that purpose.
>
> James Crake-Merani.
>
> [1]: https://openai.com/research/gpt-4 (click 'read paper' for the
> actual paper.)
>
> On 17/03/2023 19:28, Damien Mattei wrote:
> > finally i can reconnect to chatGPT server and here is the result:
> >
> > (define (min-dnf expr)
> >    (let* ((vars (variables expr))
> >           (truth-table (generate-truth-table vars))
> >           (rows (filter (lambda (row) (eval expr (make-environment vars
> > row))) truth-table))
> >           (clauses (map (lambda (row) (create-clause vars row)) rows))
> >           (dnf (fold-right or #f clauses)))
> >      (simplify dnf)))
> >
> > (define (variables expr)
> >    (let ((vars '()))
> >      (define (collect-variables exp)
> >        (cond ((symbol? exp) (unless (memq exp vars) (set! vars (cons exp
> > vars))))
> >              ((pair? exp) (map collect-variables exp))))
> >      (collect-variables expr)
> >      vars))
> >
> > (define (generate-truth-table vars)
> >    (let ((n (length vars)))
> >      (map (lambda (i) (list->vector (reverse (map (lambda (b) (if b 1 0))
> >                                                    (reverse (binary i
> > n)))))) (range (expt 2 n)))))
> >
> > (define (binary n bits)
> >    (let loop ((n n) (bits bits) (acc '()))
> >      (if (zero? bits) acc
> >          (let ((bit (remainder n 2)))
> >            (loop (quotient n 2) (- bits 1) (cons bit acc))))))
> >
> > (define (create-clause vars row)
> >    (let ((clause '()))
> >      (define (create-term var value)
> >        (if value var (cons 'not (list var))))
> >      (map (lambda (pair) (set! clause (cons (create-term (car pair) (cdr
> > pair)) clause)))
> >           (map cons vars row))
> >      (reverse clause)))
> >
> > (define (make-environment vars row)
> >    (let ((env '()))
> >      (map (lambda (pair) (set! env (cons pair env)))
> >           (map cons vars row))
> >      (reverse env)))
> >
> > (define (simplify expr)
> >    (let ((simp (simplify-expr expr)))
> >      (if (eq? expr simp) expr (simplify simp))))
> >
> > (define (simplify-expr expr)
> >    (cond ((symbol? expr) expr)
> >          ((and (pair? expr) (eq? (car expr) 'not) (pair? (cdr expr)))
> >           (let ((arg (simplify-expr (cadr expr))))
> >             (cond ((symbol? arg) (list 'not arg))
> >                   ((and (pair? arg) (eq? (car arg) 'not))
> >                    (simplify-expr (cadr arg)))
> >                   (else (list 'not arg))))))
> >          ((and (pair? expr) (memq (car expr) '(and or)))
> >           (let ((op (car expr))
> >                 (args (map simplify-expr (cdr expr))))
> >             (let loop ((args args) (acc '()))
> >               (if (null? args)
> >                   (if (eq? op 'and) #t (fold-right or #f acc))
> >                   (let ((arg (car args)))
> >                     (if (eq? arg (if (eq? op 'and) #f #t))
> >                         (if (eq? op 'and) #f (fold-right or #f acc))
> >                         (loop (cdr args) (cons arg acc)))))))))
> >          (else expr)))
> >
> > ;;; /Users/mattei/chatGPTminimaldisjunctivenormalform.scm:6:26: source
> > expression failed to match any pattern in form or
> > ice-9/boot-9.scm:1685:16: In procedure raise-exception:
> > Syntax error:
> > unknown location: source expression failed to match any pattern in form
> or
> >
> > Entering a new prompt.  Type `,bt' for a backtrace or `,q' to continue.
> >
> > and my conclusion is chatGPT is a very bad student that does not know the
> > difference between a Scheme procedure and a special form :-)
> >
> > and the 65lines chatGPT code is far from my > 5000 lines code to minimize
> > in disjunctive normal forms.......
> >
> > but you will continue to read a lot of newspaper saying AI is able to
> write
> > programs....
> >
> > chatGPT is only a "predictor of the next word" ,okay perheaps a bit
> more....
> >
> > On Fri, Mar 17, 2023 at 8:09 PM Damien Mattei <damien.mattei@gmail.com>
> > wrote:
> >
> >> i understand the fun thing... :-)
> >>
> >> and i did not check the program with Guile but asked a Racket version of
> >> the bouncing ball and it is full of errors even if i try to correct
> them by
> >> hand...
> >>
> >> Welcome to DrRacket, version 8.7 [cs].
> >> Language: racket/gui, with debugging; memory limit: 8192 MB.
> >> . . send: no such method
> >>    method name: register-event-callback
> >>    class name: canvas%
> >>
> >>
> >> after i asked this question to chatGPT:
> >>
> >> "Can you write a Guile Scheme program that put a logical expression in
> >> minimal disjunctive normal form?"
> >>
> >> i got a truncated program trying to code a QuineMcCluskey algorithm
> >> implementation that i can not redisplay here because i got a connection
> >> error to server and that looked like a bit,but from very very very far
> away
> >> my own logic code in github that i spend many years to wrote,
> >>
> >> and the Chat finished  like this:
> >>
> >> "Hmm...something seems to have gone wrong. Maybe try me again in a
> little
> >> bit"
> >>
> >> :-)
> >>
> >> Damien
> >>
> >> On Fri, Mar 17, 2023 at 6:26 PM Mikael Djurfeldt <mikael@djurfeldt.com>
> >> wrote:
> >>
> >>> Can you write a Guile Scheme program which displays a bouncing ball?
> >>>
> >>> As an AI language model, I cannot create a full graphical program
> directly
> >>> within this text-based environment. However, I can provide you with an
> >>> example of a simple bouncing ball simulation using the Guile Scheme
> >>> programming language and the SDL2 (Simple DirectMedia Layer) library,
> >>> which
> >>> is commonly used for creating graphical applications.
> >>>
> >>> To start, you'll need to have Guile and the Guile-SDL2 bindings
> installed.
> >>> The following instructions are for a Debian-based system:
> >>>
> >>>     1. Install Guile:
> >>>
> >>> csharp
> >>>
> >>> sudo apt-get install guile-2.2
> >>>
> >>>
> >>>     1. Install SDL2 development libraries:
> >>>
> >>> csharp
> >>>
> >>> sudo apt-get install libsdl2-dev libsdl2-image-dev libsdl2-ttf-dev
> >>>
> >>>
> >>>     1. Clone and build the Guile-SDL2 library:
> >>>
> >>> bash
> >>>
> >>> git clone https://github.com/davexunit/guile-sdl2.gitcd guile-sdl2
> >>> autoreconf -vif
> >>> ./configure
> >>> make
> >>> sudo make install
> >>>
> >>> Now you can create the bouncing ball program in a file called
> >>> bouncing-ball.scm:
> >>>
> >>> scheme
> >>>
> >>> (use-modules (sdl2)
> >>>               (sdl2 video)
> >>>               (sdl2 events)
> >>>               (sdl2 timer)
> >>>               (sdl2 rect))
> >>>
> >>> (define screen-width 640)
> >>> (define screen-height 480)
> >>> (define ball-size 20)
> >>>
> >>> (define ball-x (make-parameter (/ (- screen-width ball-size) 2)))
> >>> (define ball-y (make-parameter (/ (- screen-height ball-size) 2)))
> >>> (define ball-x-velocity (make-parameter 4))
> >>> (define ball-y-velocity (make-parameter 4))
> >>>
> >>> (define (process-events)
> >>>    (let loop ((event (poll-event)))
> >>>      (when event
> >>>        (case (event-type event)
> >>>          ((quit) #f)
> >>>          (else (loop (poll-event)))))))
> >>>
> >>> (define (update-ball)
> >>>    (parameterize ((x (ball-x))
> >>>                   (y (ball-y))
> >>>                   (vx (ball-x-velocity))
> >>>                   (vy (ball-y-velocity)))
> >>>      (ball-x (+ x vx))
> >>>      (ball-y (+ y vy))
> >>>
> >>>      (when (or (<= (+ x vx) 0) (>= (+ x vx ball-size) screen-width))
> >>>        (ball-x-velocity (- vx)))
> >>>
> >>>      (when (or (<= (+ y vy) 0) (>= (+ y vy ball-size) screen-height))
> >>>        (ball-y-velocity (- vy)))))
> >>>
> >>> (define (draw-ball renderer)
> >>>    (let ((ball-rect (make-rect (ball-x) (ball-y) ball-size ball-size)))
> >>>      (set-render-draw-color renderer 255 0 0 255)
> >>>      (render-fill-rect renderer ball-rect)))
> >>>
> >>> (define (main)
> >>>    (init! +init-video+)
> >>>    (let ((window (create-window "Bouncing Ball" +window-pos-undefined+
> >>> +window-pos-undefined+ screen-width screen-height +window-shown+))
> >>>          (renderer (create-renderer window -1 +renderer-accelerated+)))
> >>>      (set-render-draw-color renderer 0 0 0 255)
> >>>      (let loop ()
> >>>        (unless (process-events)
> >>>          (update-ball)
> >>>          (render-clear renderer)
> >>>          (draw-ball renderer)
> >>>          (render-present renderer)
> >>>          (delay 16)
> >>>          (loop)))))
> >>>
> >>> (main)
> >>>
> >>> This example sets up a window using SDL2 and creates a simple ball that
> >>> bounces off the edges of the window. You can run the program using the
> >>> following command:
> >>>
> >>> bash
> >>>
> >>> guile bouncing-ball.scm
> >>>
> >>> Keep in mind that this is a simple example, and there are many ways to
> >>> improve or expand upon it, such as using images
> >>> [image: mikael@djurfeldt.com]
> >>> I get the following error message: ;;; note: auto-compilation is
> enabled,
> >>> set GUILE_AUTO_COMPILE=0 ;;; or pass the --no-auto-compile argument to
> >>> disable. ;;; compiling /home/mdj/guile/bouncing-ball.scm ;;;
> >>> /home/mdj/guile/bouncing-ball.scm:19:13: warning: possibly unbound
> >>> variable
> >>> `event-type' ;;; /home/mdj/guile/bouncing-ball.scm:24:18: warning:
> >>> possibly
> >>> unbound variable `x' ;;; /home/mdj/guile/bouncing-ball.scm:25:18:
> warning:
> >>> possibly unbound variable `y' ;;;
> /home/mdj/guile/bouncing-ball.scm:26:18:
> >>> warning: possibly unbound variable `vx' ;;;
> >>> /home/mdj/guile/bouncing-ball.scm:27:18: warning: possibly unbound
> >>> variable
> >>> `vy' ;;; /home/mdj/guile/bouncing-ball.scm:39:5: warning: possibly
> unbound
> >>> variable `set-render-draw-color' ;;;
> >>> /home/mdj/guile/bouncing-ball.scm:40:5: warning: possibly unbound
> variable
> >>> `render-fill-rect' ;;; /home/mdj/guile/bouncing-ball.scm:43:3: warning:
> >>> possibly unbound variable `init!' ;;;
> >>> /home/mdj/guile/bouncing-ball.scm:43:9: warning: possibly unbound
> variable
> >>> `+init-video+' ;;; /home/mdj/guile/bouncing-ball.scm:44:17: warning:
> >>> possibly unbound variable `create-window' ;;;
> >>> /home/mdj/guile/bouncing-ball.scm:44:47: warning: possibly unbound
> >>> variable
> >>> `+window-pos-undefined+' ;;; /home/mdj/guile/bouncing-ball.scm:44:120:
> >>> warning: possibly unbound variable `+window-shown+' ;;;
> >>> /home/mdj/guile/bouncing-ball.scm:45:19: warning: possibly unbound
> >>> variable
> >>> `create-renderer' ;;; /home/mdj/guile/bouncing-ball.scm:45:35: warning:
> >>> possibly unbound variable `window' ;;;
> >>> /home/mdj/guile/bouncing-ball.scm:45:45: warning: possibly unbound
> >>> variable
> >>> `+renderer-accelerated+' ;;; /home/mdj/guile/bouncing-ball.scm:50:9:
> >>> warning: possibly unbound variable `render-clear' ;;;
> >>> /home/mdj/guile/bouncing-ball.scm:52:9: warning: possibly unbound
> variable
> >>> `render-present' ;;; compiled
> >>>
> >>>
> /home/mdj/.cache/guile/ccache/3.0-LE-8-4.6/home/mdj/guile/bouncing-ball.scm.go
> >>> Backtrace: In ice-9/boot-9.scm: 1752:10 6 (with-exception-handler _ _
> >>> #:unwind? _ # _) In unknown file: 5 (apply-smob/0 #<thunk
> 7f79f1cd8300>)
> >>> In
> >>> ice-9/boot-9.scm: 724:2 4 (call-with-prompt _ _ #<procedure
> >>> default-prompt-handle…>) In ice-9/eval.scm: 619:8 3 (_ #(#(#<directory
> >>> (guile-user) 7f79f1cdbc80>))) In ice-9/boot-9.scm: 2836:4 2
> >>> (save-module-excursion _) 4388:12 1 (_) In
> >>> /home/mdj/guile/bouncing-ball.scm: 43:3 0 (main)
> >>> /home/mdj/guile/bouncing-ball.scm:43:3: In procedure main: Unbound
> >>> variable: init!
> >>>
> >>> Apologies for the confusion. It seems I made a mistake in the provided
> >>> code, and some symbols were not correctly imported. Let's fix the
> imports
> >>> by using the appropriate modules and functions. Replace the
> (use-modules
> >>> ...) line in the code with the following:
> >>>
> >>> scheme
> >>>
> >>> (use-modules (sdl2) (sdl2 video) (sdl2 events) (sdl2 timer) (sdl2
> >>> rect) (sdl2 rwops) (sdl2 surface) (sdl2 sdl))
> >>>
> >>> Additionally, it seems that the init! function is not being
> recognized. It
> >>> should be SDL_Init instead. So, replace the line (init! +init-video+)
> >>> with:
> >>>
> >>> scheme
> >>>
> >>> (SDL_Init +SDL_INIT_VIDEO+)
> >>>
> >>> After making these changes, the updated bouncing-ball.scm should look
> like
> >>> this:
> >>>
> >>> scheme
> >>>
> >>> (use-modules (sdl2)
> >>>               (sdl2 video)
> >>>               (sdl2 events)
> >>>               (sdl2 timer)
> >>>               (sdl2 rect)
> >>>               (sdl2 rwops)
> >>>               (sdl2 surface)
> >>>               (sdl2 sdl))
> >>>
> >>> (define screen-width 640)
> >>> (define screen-height 480)
> >>> (define ball-size 20)
> >>>
> >>> (define ball-x (make-parameter (/ (- screen-width ball-size) 2)))
> >>> (define ball-y (make-parameter (/ (- screen-height ball-size) 2)))
> >>> (define ball-x-velocity (make-parameter 4))
> >>> (define ball-y-velocity (make-parameter 4))
> >>>
> >>> (define (process-events)
> >>>    (let loop ((event (poll-event)))
> >>>      (when event
> >>>        (case (event-type event)
> >>>          ((quit) #f)
> >>>          (else (loop (poll-event)))))))
> >>>
> >>> (define (update-ball)
> >>>    (parameterize ((x (ball-x))
> >>>                   (y (ball-y))
> >>>                   (vx (ball-x-velocity))
> >>>                   (vy (ball-y-velocity)))
> >>>      (ball-x (+ x vx))
> >>>      (ball-y (+ y vy))
> >>>
> >>>      (when (or (<= (+ x vx) 0) (>= (+ x vx ball-size) screen-width))
> >>>        (ball-x-velocity (- vx)))
> >>>
> >>>      (when (or (<= (+ y vy) 0) (>= (+ y vy ball-size) screen-height))
> >>>        (ball-y-velocity (- vy)))))
> >>>
> >>> (define (draw-ball renderer)
> >>>    (let ((ball-rect (make-rect (ball-x) (ball-y) ball-size ball-size)))
> >>>      (set-render-draw-color renderer 255 0 0 255)
> >>>      (render-fill-rect renderer ball-rect)))
> >>>
> >>> (define (main)
> >>>    (SDL_Init +SDL_INIT_VIDEO+)
> >>>    (let ((window (create-window "Bouncing Ball" +window-pos-undefined+
> >>> +window-pos-undefined+ screen-width screen-height +window-shown+))
> >>>          (renderer (create-renderer window -1 +renderer-accelerated+)))
> >>>      (set-render-draw-color renderer 0 0 0 255)
> >>>      (let loop ()
> >>>        (unless (process-events)
> >>>          (update-ball)
> >>>          (render-clear renderer)
> >>>          (draw-ball renderer)
> >>>          (render-present renderer)
> >>>          (delay 16)
> >>>          (loop)))))
> >>>
> >>> (main)
> >>>
> >>> Now, the program should run without any issues. Run it with:
> >>>
> >>> bash
> >>>
> >>> guile bouncing-ball.scm
> >>>
> >>> [image: mikael@djurfeldt.com]
> >>> I think it should be make-window instead of create-window.
> >>>
> >>> You are correct. The function should be make-window instead of
> >>> create-window.
> >>> I apologize for the confusion. Here's the updated bouncing-ball.scm
> code
> >>> with the corrected function name:
> >>>
> >>> scheme
> >>>
> >>> (use-modules (sdl2)
> >>>               (sdl2 video)
> >>>               (sdl2 events)
> >>>               (sdl2 timer)
> >>>               (sdl2 rect)
> >>>               (sdl2 rwops)
> >>>               (sdl2 surface)
> >>>               (sdl2 sdl))
> >>>
> >>> (define screen-width 640)
> >>> (define screen-height 480)
> >>> (define ball-size 20)
> >>>
> >>> (define ball-x (make-parameter (/ (- screen-width ball-size) 2)))
> >>> (define ball-y (make-parameter (/ (- screen-height ball-size) 2)))
> >>> (define ball-x-velocity (make-parameter 4))
> >>> (define ball-y-velocity (make-parameter 4))
> >>>
> >>> (define (process-events)
> >>>    (let loop ((event (poll-event)))
> >>>      (when event
> >>>        (case (event-type event)
> >>>          ((quit) #f)
> >>>          (else (loop (poll-event)))))))
> >>>
> >>> (define (update-ball)
> >>>    (parameterize ((x (ball-x))
> >>>                   (y (ball-y))
> >>>                   (vx (ball-x-velocity))
> >>>                   (vy (ball-y-velocity)))
> >>>      (ball-x (+ x vx))
> >>>      (ball-y (+ y vy))
> >>>
> >>>      (when (or (<= (+ x vx) 0) (>= (+ x vx ball-size) screen-width))
> >>>        (ball-x-velocity (- vx)))
> >>>
> >>>      (when (or (<= (+ y vy) 0) (>= (+ y vy ball-size) screen-height))
> >>>        (ball-y-velocity (- vy)))))
> >>>
> >>> (define (draw-ball renderer)
> >>>    (let ((ball-rect (make-rect (ball-x) (ball-y) ball-size ball-size)))
> >>>      (set-render-draw-color renderer 255 0 0 255)
> >>>      (render-fill-rect renderer ball-rect)))
> >>>
> >>> (define (main)
> >>>    (SDL_Init +SDL_INIT_VIDEO+)
> >>>    (let ((window (make-window "Bouncing Ball" +window-pos-undefined+
> >>> +window-pos-undefined+ screen-width screen-height +window-shown+))
> >>>          (renderer (create-renderer window -1 +renderer-accelerated+)))
> >>>      (set-render-draw-color renderer 0 0 0 255)
> >>>      (let loop ()
> >>>        (unless (process-events)
> >>>          (update-ball)
> >>>          (render-clear renderer)
> >>>          (draw-ball renderer)
> >>>          (render-present renderer)
> >>>          (delay 16)
> >>>          (loop)))))
> >>>
> >>> (main)
> >>>
> >>> Now, the program should run as expected:
> >>>
> >>> bash
> >>>
> >>> guile bouncing-ball.scm
> >>>
> >>> [image: mikael@djurfeldt.com]
> >>> Please write the program according to the guile-sdl2 manual.
> >>>
> >>> Apologies for the confusion. Here's an updated version of the bouncing
> >>> ball
> >>> program according to the guile-sdl2 manual:
> >>>
> >>> scheme
> >>>
> >>> (use-modules (sdl2)
> >>>               (sdl2 video)
> >>>               (sdl2 events)
> >>>               (sdl2 timer)
> >>>               (sdl2 rect)
> >>>               (sdl2 rwops)
> >>>               (sdl2 surface)
> >>>               (sdl2 sdl))
> >>>
> >>> (define screen-width 640)
> >>> (define screen-height 480)
> >>> (define ball-size 20)
> >>>
> >>> (define ball-x (make-parameter (/ (- screen-width ball-size) 2)))
> >>> (define ball-y (make-parameter (/ (- screen-height ball-size) 2)))
> >>> (define ball-x-velocity (make-parameter 4))
> >>> (define ball-y-velocity (make-parameter 4))
> >>>
> >>> (define (process-events)
> >>>    (let loop ((event (SDL_PollEvent)))
> >>>      (when event
> >>>        (case (event-type event)
> >>>          ((quit) #f)
> >>>          (else (loop (SDL_PollEvent)))))))
> >>>
> >>> (define (update-ball)
> >>>    (parameterize ((x (ball-x))
> >>>                   (y (ball-y))
> >>>                   (vx (ball-x-velocity))
> >>>                   (vy (ball-y-velocity)))
> >>>      (ball-x (+ x vx))
> >>>      (ball-y (+ y vy))
> >>>
> >>>      (when (or (<= (+ x vx) 0) (>= (+ x vx ball-size) screen-width))
> >>>        (ball-x-velocity (- vx)))
> >>>
> >>>      (when (or (<= (+ y vy) 0) (>= (+ y vy ball-size) screen-height))
> >>>        (ball-y-velocity (- vy)))))
> >>>
> >>> (define (draw-ball renderer)
> >>>    (let ((ball-rect (make-rect (ball-x) (ball-y) ball-size ball-size)))
> >>>      (SDL_SetRenderDrawColor renderer 255 0 0 255)
> >>>      (SDL_RenderFillRect renderer ball-rect)))
> >>>
> >>> (define (main)
> >>>    (SDL_Init +SDL_INIT_VIDEO+)
> >>>    (let ((window (SDL_CreateWindow "Bouncing Ball"
> >>> +SDL_WINDOWPOS_UNDEFINED+ +SDL_WINDOWPOS_UNDEFINED+ screen-width
> >>> screen-height +SDL_WINDOW_SHOWN+))
> >>>          (renderer (SDL_CreateRenderer window -1
> >>> +SDL_RENDERER_ACCELERATED+)))
> >>>      (SDL_SetRenderDrawColor renderer 0 0 0 255)
> >>>      (let loop ()
> >>>        (unless (process-events)
> >>>          (update-ball)
> >>>          (SDL_RenderClear renderer)
> >>>          (draw-ball renderer)
> >>>          (SDL_RenderPresent renderer)
> >>>          (SDL_Delay 16)
> >>>          (loop))
> >>>      (SDL_DestroyRenderer renderer)
> >>>      (SDL_DestroyWindow window)))
> >>>
> >>> (SDL_Quit)
> >>> (main)
> >>>
> >>> Now, the program should run as expected:
> >>>
> >>> bash
> >>>
> >>> guile bouncing-ball.scm
> >>>
> >>> [image: mikael@djurfeldt.com]
> >>> But all those SDL_ calls look like C bindings. Please use guile-sdl2
> >>> bindings.
> >>>
> >>> I apologize for the confusion. Here's the bouncing ball program
> >>> implemented
> >>> using the Guile-SDL2 bindings:
> >>>
> >>> scheme
> >>>
> >>> (use-modules (sdl2)
> >>>               (sdl2 video)
> >>>               (sdl2 events)
> >>>               (sdl2 timer)
> >>>               (sdl2 rect)
> >>>               (sdl2 rwops)
> >>>               (sdl2 surface)
> >>>               (sdl2 sdl))
> >>>
> >>> (define screen-width 640)
> >>> (define screen-height 480)
> >>> (define ball-size 20)
> >>>
> >>> (define ball-x (make-parameter (/ (- screen-width ball-size) 2)))
> >>> (define ball-y (make-parameter (/ (- screen-height ball-size) 2)))
> >>> (define ball-x-velocity (make-parameter 4))
> >>> (define ball-y-velocity (make-parameter 4))
> >>>
> >>> (define (process-events)
> >>>    (let loop ((event (poll-event)))
> >>>      (when event
> >>>        (case (event-type event)
> >>>          ((quit) #f)
> >>>          (else (loop (poll-event)))))))
> >>>
> >>> (define (update-ball)
> >>>    (parameterize ((x (ball-x))
> >>>                   (y (ball-y))
> >>>                   (vx (ball-x-velocity))
> >>>                   (vy (ball-y-velocity)))
> >>>      (ball-x (+ x vx))
> >>>      (ball-y (+ y vy))
> >>>
> >>>      (when (or (<= (+ x vx) 0) (>= (+ x vx ball-size) screen-width))
> >>>        (ball-x-velocity (- vx)))
> >>>
> >>>      (when (or (<= (+ y vy) 0) (>= (+ y vy ball-size) screen-height))
> >>>        (ball-y-velocity (- vy)))))
> >>>
> >>> (define (draw-ball renderer)
> >>>    (let ((ball-rect (make-rect (ball-x) (ball-y) ball-size ball-size)))
> >>>      (set-render-draw-color! renderer 255 0 0 255)
> >>>      (render-fill-rect! renderer ball-rect)))
> >>>
> >>> (define (main)
> >>>    (init! +init-video+)
> >>>    (let ((window (make-window "Bouncing Ball" +window-pos-undefined+
> >>> +window-pos-undefined+ screen-width screen-height +window-shown+))
> >>>          (renderer (make-renderer window -1 +renderer-accelerated+)))
> >>>      (set-render-draw-color! renderer 0 0 0 255)
> >>>      (let loop ()
> >>>        (unless (process-events)
> >>>          (update-ball)
> >>>          (render-clear! renderer)
> >>>          (draw-ball renderer)
> >>>          (render-present! renderer)
> >>>          (delay 16)
> >>>          (loop))
> >>>      (destroy-renderer! renderer)
> >>>      (destroy-window! window)))
> >>>
> >>> (quit!)
> >>> (main)
> >>>
> >>> Now, the program should run as expected:
> >>>
> >>> bash
> >>>
> >>> guile bouncing-ball.scm
> >>>
> >>> ---
> >>>
> >>> Turns out there are multiple problems with that program also. Here I
> >>> (mikael) fixed a number of problems and actually *got* a bouncing
> >>> ball. :)
> >>>
> >>> (use-modules (sdl2)
> >>>               (sdl2 video)
> >>>               (sdl2 events)
> >>>               ;(sdl2 timer)
> >>>               (sdl2 rect)
> >>>               ;(sdl2 rwops)
> >>>               (sdl2 surface)
> >>>                                          ;(sdl2 sdl)
> >>>               (sdl2 render))
> >>>
> >>> (define screen-width 640)
> >>> (define screen-height 480)
> >>> (define ball-size 20)
> >>>
> >>> (define ball-x (make-parameter (/ (- screen-width ball-size) 2)))
> >>> (define ball-y (make-parameter (/ (- screen-height ball-size) 2)))
> >>> (define ball-x-velocity (make-parameter 4))
> >>> (define ball-y-velocity (make-parameter 4))
> >>>
> >>> (define (process-events)
> >>>    (let loop ((event (poll-event)))
> >>>      (if event
> >>>          (cond
> >>>           ((quit-event? event) #t)
> >>>           (else (loop (poll-event))))
> >>>          #f)))
> >>>
> >>> (define (update-ball)
> >>>    (let ((x (ball-x))
> >>>          (y (ball-y))
> >>>          (vx (ball-x-velocity))
> >>>          (vy (ball-y-velocity)))
> >>>      (ball-x (+ x vx))
> >>>      (ball-y (+ y vy))
> >>>
> >>>      (when (or (<= (+ x vx) 0) (>= (+ x vx ball-size) screen-width))
> >>>        (ball-x-velocity (- vx)))
> >>>
> >>>      (when (or (<= (+ y vy) 0) (>= (+ y vy ball-size) screen-height))
> >>>        (ball-y-velocity (- vy)))))
> >>>
> >>> (define (draw-ball renderer)
> >>>    (let ((ball-rect (make-rect (ball-x) (ball-y) ball-size ball-size)))
> >>>      (set-renderer-draw-color! renderer 255 0 0 255)
> >>>      (render-fill-rect renderer ball-rect)))
> >>>
> >>> (define (main)
> >>>    (sdl-init)
> >>>    (let* ((window (make-window #:title "Bouncing Ball" #:size (list
> >>> screen-width screen-height)))
> >>>           (renderer (make-renderer window)))
> >>>      (set-renderer-draw-color! renderer 0 0 0 255)
> >>>      (let loop ()
> >>>        (unless (process-events)
> >>>          (update-ball)
> >>>          (set-renderer-draw-color! renderer 0 0 0 0)
> >>>          (clear-renderer renderer)
> >>>          (draw-ball renderer)
> >>>          (present-renderer renderer)
> >>>                                          ;(delay 16)
> >>>          (loop))
> >>>      (delete-renderer! renderer)
> >>>                                          ;(destroy-window! window)
> >>>      )))
> >>>
> >>> ;(quit!)
> >>> (main)
> >>>
>
>