The future of computer chess

[mclane]

Ok but the engines Ram and rom was extremely limited.
Ed Schröder was nevertheless capable to make his engine stronger on the same 6502 5 mhz if you look the elo rating for

Mephisto Rebel 1734
Mephisto MM4 1814
Mephisto MM5. 1883
Mephisto Nigel Short. 1950

So Ed was capable to make 216 ELO Progress . These computers were only 5 mhz „fast“.

Similar with Dave Kittinger:
Super Forte A. 1749
Super Forte B. 1828
Super Forte C 1868

119 Elo progress.

The next jump came with the 68000 cpu because address area for rom and ram was bigger.
Then came hash tables. Singular extensions and even learning. All due to the 16 bit hatdware.

[towforce]

* you might need to write the code in 6502 assembly language to compete with the old masters (and, at this time, you won't get any useful help from ChatGPT or any other LLM to do that)

ChatGPT may be able to give some help. I tried asking it:

How can I implement selection sort in assembly language for a 6502 CPU?

It gave the following answer:

Implementing selection sort in assembly language for a 6502 CPU involves breaking down the algorithm into its basic steps and translating each step into 6502 assembly instructions. Here's a simplified version of selection sort algorithm in assembly language for 6502 CPU:

Code: Select all

; Selection Sort implementation in 6502 assembly language

    ; Constants
ARRAY_SIZE = 10          ; Define the size of the array
ARRAY_START = $0200      ; Memory location where the array starts

    ; Main program
    .org $0800           ; Starting address of the program

start:
    LDX #0              ; Initialize outer loop index
outerLoop:
    LDA ARRAY_START,X   ; Load the value at ARRAY[X] into accumulator
    STA MIN_INDEX       ; Store the current index as the index of minimum value

    LDX #1              ; Initialize inner loop index
innerLoop:
    CMP ARRAY_START,X   ; Compare with the next element
    BCC updateMin       ; If the next element is smaller, update MIN_INDEX
    DEX                 ; Decrement inner loop index
    CPX #ARRAY_SIZE     ; Check if reached end of inner loop
    BNE innerLoop       ; If not, continue inner loop

updateMin:
    STA TEMP_INDEX      ; Store the current index temporarily
    LDA MIN_INDEX       ; Load the index of minimum value
    STA MIN_VALUE       ; Store the value at that index temporarily
    LDA ARRAY_START,X   ; Load the value at ARRAY[X] into accumulator
    STA ARRAY_START,TEMP_INDEX  ; Swap the current element with the minimum element
    LDA MIN_VALUE       ; Load the minimum value
    STA ARRAY_START,X   ; Store the minimum value at ARRAY[X]

    INX                 ; Increment outer loop index
    CPX #ARRAY_SIZE     ; Check if reached end of outer loop
    BNE outerLoop       ; If not, continue outer loop

end:
    BRK                 ; End of program

    ; Variables
MIN_INDEX: .byte 0      ; Index of minimum value
TEMP_INDEX: .byte 0     ; Temporary index storage
MIN_VALUE: .byte 0      ; Minimum value storage

    ; Array Data
    .fill ARRAY_SIZE, 0  ; Fill the array with initial values

This assembly code assumes you have a memory region starting from $0200 where your array is stored. You can adjust the constants ARRAY_SIZE and ARRAY_START to fit your specific array size and memory location. The program starts at address $0800. It compares adjacent elements in the array and swaps them if they are in the wrong order. Finally, it iterates through the array until it is sorted.

I did not try to verify if the suggested code actually works though.

Kudos for trying - I'm amazed you got back anything sensible!

Neither of the following emulators will run it:

https://skilldrick.github.io/easy6502/
https://www.masswerk.at/6502/assembler.html

Gemini came out with the following, which also failed:

Code: Select all

; Define loop counters and register usage
.data
  ARRAY_SIZE .equ $FF  ; Replace with actual array size

.bss
  ARRAY .space ARRAY_SIZE

.code
  LDA #0              ; Initialize outer loop counter
loop_outer:
  STA LOOP_OUTER_CNT  ; Store outer loop counter

loop_inner:
  LDA #ARRAY_SIZE - 1  ; Initialize inner loop counter (last element)
  STA LOOP_INNER_CNT  ; Store inner loop counter

  LDY #0              ; Initialize minimum index

compare_loop:
  LDX LOOP_INNER_CNT,Y ; Load inner loop counter (Y offset)
  LDA (ARRAY),X        ; Load element from array
  CPY LOOP_OUTER_CNT,Y ; Compare with current minimum

  BNE not_min         ; Branch if not minimum

  LDY X                ; Update minimum index

not_min:
  DEY                  ; Decrement inner loop counter
  BPL compare_loop      ; Loop if positive (more elements to compare)

  ; Swap minimum element with current position
  LDX LOOP_OUTER_CNT  ; Load outer loop counter
  LDY #0              ; Reset Y for array offset
  TAY                  ; Transfer Y to accumulator for LDA

swap_loop:
  LDA (ARRAY),Y        ; Load element from current position
  STA (ARRAY,X)        ; Store in minimum element position
  LDX LOOP_INNER_CNT  ; Load inner loop counter
  LDY X                ; Set Y for offset in array
  LDA (ARRAY),Y        ; Load minimum element
  STA (ARRAY,X)        ; Store in current position

  DEY                  ; Decrement Y for next element
  BPL swap_loop        ; Loop if positive (more elements to swap)

  ; Decrement outer loop counter
  INY                  ; Increment Y for loop counter offset
  LDA LOOP_OUTER_CNT,Y ; Load outer loop counter
  DEY                  ; Decrement outer loop counter
  STA LOOP_OUTER_CNT,Y ; Store decremented counter
  BPL loop_outer       ; Loop if positive (more elements to sort)

  RTS                  ; Return from subroutine

LOOP_OUTER_CNT .equ 0  ; Outer loop counter (initialized with LDA #0)
LOOP_INNER_CNT .equ 1  ; Inner loop counter (initialized with LDA #ARRAY_SIZE-1)

[Christopher Martin]

One more day. The air slips through my body and caresses every corner of my anatomy. Dogs can be heard barking. As usual, the hounds of programmed chess pollute the atmosphere with their barking. Their meticulous meter shudders. LOS (likelihood of superiority) is a dry bird shit. Fishtest makes use of asymmetrical workers, with dissimilar architectures, once again muddying his science. This set of traditions, waxed with the tympanum of the elderly, sinks, never to resurface. Notable and farting members such as Vladimir Viz (pet of the Leningrad ogre), pepegrinder (pet of Viz, pet by double title), vondelol and disservant hasten to bite the leftovers of the past solemnity. Their entire scheme of progress is based on a little man who trains neural networks, for the rest ignore the finesse of this art, and a bungling tryharder who changes values at random until one of them turns green in his degraded test sorting. Today is just another day, a good day not to be a Stockfish programmer.

[Sylwy]

One more day. The air slips through my body and caresses every corner of my anatomy. Dogs can be heard barking. As usual, the hounds of programmed chess pollute the atmosphere with their barking. Their meticulous meter shudders. LOS (likelihood of superiority) is a dry bird shit. Fishtest makes use of asymmetrical workers, with dissimilar architectures, once again muddying his science. This set of traditions, waxed with the tympanum of the elderly, sinks, never to resurface. Notable and farting members such as Vladimir Viz (pet of the Leningrad ogre), pepegrinder (pet of Viz, pet by double title), vondelol and disservant hasten to bite the leftovers of the past solemnity. Their entire scheme of progress is based on a little man who trains neural networks, for the rest ignore the finesse of this art, and a bungling tryharder who changes values at random until one of them turns green in his degraded test sorting. Today is just another day, a good day not to be a Stockfish programmer.

The art of the state:

https://www.seaart.ai/explore/detail/44 ... a1005944f1

AI art, of course.....

[mclane]

I doubt AI can do what Morsch, Kittinger or Schroeder and all the others did in the 80ies.


Most dedicated chess engines were written in Assembler simply because the speed gain was enormous.

As far as i remember only Mephisto III / III S (on 68000)

https://www.schach-computer.info/wiki/i ... _3-Projekt

was written not in Assembler but in CDL2.
And this language was maybe 1.5-2 times slower then Assembler.

Ed Schroeders fine tuning on his engine on 6502 showed that you can make a lot of progress simply by making the algorithms more efficient. We can assume that if we count his experimental versions appearing long before (2 years before Rebel) commercial release of Rebel, that his baby made even more ELO distance . So maybe 250 ELO progress over the same hardware platform.

[Christopher Martin]

Age, a reputed programmer and a better person, made the tough decision to take his belongings and leave Stockfish headquarters after a heated argument. Sources close to Chess Com claimed that, hours after the incident, little Age was found alone in a shopping mall, asking for his mom. "The bad guys from Stockfish sat on my face and stole my innocence. Mommy! I want my mommy!". The little AGE was escorted to the nearest police station, and the officers allowed him to listen to the car sirens, at the young savant's request. "Regarding the recent accusations that Torch copies Stockfish commits, I have to say that it is all false. This is a smear campaign. Stockfish releases a new commit at 15:30 and we apply it at 15:30, or 16:30, depending on latitude. We are the torch that shines the knowledge, the Stockfish knowledge so we can copy it." A strange man who identified himself as dkappe approached the vicinity of the site, intending to pick up his friend. He kept spouting incoherent ramblings about adversarial data and dinosaurs at the center of the Earth. He had to be ejected due to several complaints about his body odor. The online chess CEO defended itself in a statement. "We treat Torch programmers very well. They work part-time, a total computation of 12 hours, half the day, 7 days a week. In return, we provide them with a bucket to relieve themselves and some fish scrapes under the door."

[towforce]

Polite request: may we have a single thread for these stories, please?

A suitable title for the thread would be "Christopher's Parables".

[Viz]

Ngl, I have good laugh when I read this person posts.
Kinda obvious it's someone from stockfish discord, just idk who.

[mclane]

The point was: is the huge progress in computerchess part of hardware or software development.

With the 16 bit cpus the adress range was much bigger.
Suddenly not only 32 or with bank switching 96 kb was usable. But lot of memory more.

Suddenly we were in megabyte range.
That made hash tables possibe.
The engine could grow and use heavier evaluations and lot of new stuff.

So was this a feature of software or more a feature of hardware change from 8 bit adress room to 16 bit addresses ?

With the new 68000 cpu richard lang was capable to program a very strong engine in assembler.
And with the use of 68020 or 68030 and the increase of the mhz from 12 to 33 or 66 or even 133 mhz
the software was made faster.


The next big step was that the pcs made progress from a few mhz into much more mhz.
We remember 8086, 286, 386, 486-33, 486-66 and more. Then came pentiums much more speed.
And one day we had cpus with 2 cores, then with 4 cores and the race continues,

Today we have very fast cpus with lot memory, high speed and several cores,


So how big was the software progress that was not due to big hardware progress ?

Can somebody create a 6502 engine that beats ed schroeder , dave kittinger ?

[RubiChess]

So was this a feature of software or more a feature of hardware change from 8 bit adress room to 16 bit addresses ?

It is address space.
And please show me some hardware that uses 8 bit address space and is running a chess program.
You know how many addresses you can index with 8 bits?

Regards, Andreas