Tag: ai

  • Is This the Real Art?

    People often criticize AI generated pictures or music for taking money away from real artists who should be paid for what they made with their time, blood, sweat, and tears. These concerns are valid, but it raises larger questions. Can humans tell the difference between pictures, music, or videos made by Artificial Intelligence compared to what a human can make?

    From what I have seen, I would argue that it is usually impossible to see the difference between something made from an AI vs a human. AI is getting so good that I can’t tell what is real. What even is real art? All artists take inspiration from other sources and generate remixes based on what they know. The reason AI threatens artists is because it knows everything and has been fed the writings, music, and visual art made by people who were never paid.

    But it goes deeper than that, people are not given the sources used to generate art. The AI bots will never give credit to the people whose art was used to train the AI in the first place. And sometimes, the original creator of the art gets automatically banned for copyright infringement by a robot even though a robot stole it from them.

    So the issue is not only that it potentially prevents people from buying the original work due to not knowing where it came from, but that the original work is deleted from the internet because the artist is banned and accused of stealing what was actually stolen from them.

    Once again, the issue is that the truth is hidden from the public and the AI can take credit for knowing how to make art that seems original because we don’t know which human made it originally. Even if the humans were paid billions of dollars by the AI companies, they would still not receive credit for their creations. But since they are not receiving money either. two crimes are being committed against real humans by machines controlled by the owners who are profiting from someone else’s work.

    Sources:

    AI companies accused of hoarding and destroying millions of books:

    The facts about AI companies destroying books:

  • What are the reasons why some people say that Assembly is not worth learning, even though it is a fundamental part of computers?

    People say it is not worth learning because it is not a good strategy for making money. If, however, your goal is gaining a better understanding of how computers work, then clearly it is “worth it” to learn Assembly. Many people consider it a waste of time because they can write software faster in C or C++ than they could in Assembly.

    In programming, you can either spend a lot of time writing software that runs fast, or you can write it fast and then let the compiler optimize it and expect people to run it on faster machines. There is always a tradeoff between quality work and the time limits imposed by the industry. But when you are a hobbyist, you have no time limit and can do what you like.

    People are still learning old Assembly languages for machines that no longer exist for pure joy. I will always fondly remember the 6502 as a relic of the past that was simple to understand and powered the Nintendo Entertainment System.

    Intel Assembly will serve you well because most desktop and laptop PCs are still using 32-bit and 64-bit descendants of the Intel 8086 CPU.

    ARM assembly may interest you if you are using special Linux or Mac laptops that use ARM chips for their lower power consumption compared to Intel.

    RISC-V Assembly is one of the newer architectures, but it is an open standard, and some people believe it will replace Intel and ARM one day because of its lower cost to produce, as it doesn’t require licensing fees paid to the makers of Intel or ARM.

    Of all these, I have the most experience with Intel Assembly, and I have written books on programming using Assembly for DOS and Linux. If you are interested, I can help you get started.

  • What Microsoft Copilot says about Assembly Arithmetic Algorithms

    I tried something new. I asked Microsoft Copilot what it could tell me about my own series of books on Assembly. I have to say I am impressed with the nice summary it came up with. I really think it highlights how unique this series is because it is written from the perspective of my autism and math obsession.

    Assembly Arithmetic Algorithms is a series of assembly‑language programming books written by Chastity White Rose, covering DOS, Windows (32‑ and 64‑bit), and Linux editions. They teach low‑level programming by focusing on arithmetic, binary/hex math, system calls, and how computers actually perform operations like addition, subtraction, multiplication, and division.

    📘 What the books are

    Chastity White Rose has published multiple editions of Assembly Arithmetic Algorithms, each targeting a different operating system:

    1. 16‑bit DOS Edition

    • Teaches how to write .com programs for MS‑DOS.
    • Focuses heavily on binary/hex arithmetic and low‑level operations.
    • Includes explanations of interrupts, pointers, memory addresses, and arithmetic routines.
    • Emphasizes learning how computers “think” numerically.
    • MS-DOS | Definition, Features, Importance, & Facts | Britannica
    • MS-DOS - Wikipedia
    • Difference Between Assembly And Binary at Donna Bull blog
    • Program Development and Execution | Assembly language, Assembly ...

    2. 32‑ and 64‑bit Windows Edition

    • Covers Windows API calls (GetStdHandle, WriteFile, ExitProcess).
    • Introduces registers, stack behavior, and bit operations.
    • Provides “Hello World” examples for both 32‑bit and 64‑bit Windows.
    • Designed for beginners and intermediate programmers wanting deeper control.
    • 理解 Windows API 调用过程 - 厚积薄发 - 开发者Cpp博客
    • Architecture Overview - Win32 apps | Microsoft Learn
    • X64 registers
    • PPT - Introduction to Machine-Level Programming: Basics of x86 ...

    3. 32‑bit Linux Edition (co‑authored with Chandler Klebs)

    • Focuses on POSIX system calls: read, write, open, close, lseek, exit.
    • Includes C programs to help explain assembly routines.
    • Teaches how to write fast, minimal Linux console applications.
    • Manage Your Linux System Resources With These 7 Terminal Commands
    • Timer In Linux Terminal at Rita Skelley blog
    • x86 Assembly Guide-CSDN博客
    • Assembly Language Tutorial No. 1 : Introduction To Registers - YouTube

    🧠 What the books emphasize

    Across all editions, the core themes are:

    • Binary arithmetic (addition, subtraction, multiplication, division)
    • Understanding CPU registers and flags
    • Memory addressing and pointer arithmetic
    • System calls and OS‑level interaction
    • Writing extremely small, efficient programs
    • Learning how computers actually perform math internally

    Chastity frames arithmetic as the foundation of all computation — the CPU’s “native language.”

    📚 Why these books stand out

    • They are modern books about old‑school assembly, which is rare.
    • They teach assembly through arithmetic, not through abstract theory.
    • They are written by a transgender Christian author who blends technical instruction with personal philosophy and creativity.
    • They aim to preserve low‑level programming knowledge that is becoming harder to find.

  • chastdin for FreeBASIC

    I have rewritten my chastdin program (the stack based calculator that reads keyboard input from standard input) into the FreeBASIC programming language. I did it as an exercise to prepare myself for a future book on the BASIC programming language which was my first programming language. FreeBASIC is compatible with QBASIC which is what I first started on. Luckily, BASIC is not so different from C but I had to spend a lot of time on the documentation to refresh my memory in how I used to do things with it.

    Eventually I would like to make a GUI version of this command line calculator. I am trying to take baby steps in working my way into programs that the average person would use. However, command line utilities are still the easiest to build and that is an acceptable place to start.

    main.bas

    #include "chastelib.bi"
    #include "chastdin.bi"
    
    dim shared as integer chastack(256)
    dim shared as integer csi=0 'Chastity's Stack Index
    
    radix=10
    
    dim as integer a,b
    dim shared as string s
    
    sub help()
    ?  "chastdin is a stack based interactive calculator"
    ?  "Numbers are pushed on the stack and commands can do math."
    ?  "It is a fork of chastack that reads from stdin instead of arguments."
    ?  "Each line can contain multiple numbers or commands."
    ?
    ?  "Math commands are add,sub,mul,div,rem"
    ?  "And use the top two stack numbers for their operations"
    ?
    ?  "The setradix command uses the top of stack as the new radix"
    ?  "The exit command ends the program"
    ?  "The ? command prints the entire stack"
    ?
    end sub
    
    sub stack_check()
     if csi>0 then
      chastack(csi+1)=0 /'erase old top of stack because command was successful'/
     else
      print "Error: two numbers required for command: ";s
      csi+=1 /'increment the pointer to what it was before the failed command'/
     end if
    end sub
    
    help():
    
    while s<>"exit"
    
    s=""
    
     s=getstr() 'read and ignore empty strings
    
    'print entire stack
    if s="?" or s="print" then
     b=csi
     while csi>0
      print intstr(chastack(csi))
      csi-=1
     wend
     csi=b
    
    elseif s="exit" then
    exit while
    
    elseif s="help" then
    help()
    
    elseif s="setradix" then
     if csi>0 then
     radix=chastack(csi)
     chastack(csi)=0
     csi-=1
     else
      print "Error: need one number on stack for command: ";s
     end if
    
    elseif s="add" then
    b=chastack(csi)
    csi-=1
    a=chastack(csi)
    a+=b
    chastack(csi)=a
    stack_check()
    
    elseif s="sub" then
    b=chastack(csi)
    csi-=1
    a=chastack(csi)
    a-=b
    chastack(csi)=a
    stack_check()
    
    elseif s="mul" then
    b=chastack(csi)
    csi-=1
    a=chastack(csi)
    a*=b
    chastack(csi)=a
    stack_check()
    
    elseif s="div" then
    b=chastack(csi)
    csi-=1
    a=chastack(csi)
    a\=b
    chastack(csi)=a
    stack_check()
    
    elseif s="rem" then
    b=chastack(csi)
    csi-=1
    a=chastack(csi)
    a=a mod b
    chastack(csi)=a
    stack_check()
    
    else
    
    'try to interpret string as a number if not empty
     a=strint(s)
     if strint_errors<>0 or len(s)=0 then
     'print s;" cannot be added to the stack because it is not a valid number"
     else
     csi+=1
     chastack(csi)=a
     print intstr(a);" was added to the stack"
     end if
    
    end if
    
    wend
    
    /'
     This is a FreeBASIC program.
    
     compile and run as:
    
     fbc main.bas && ./main
    '/
    
    

    chastelib.bi

    /'
     global variables to define radix and formatting
     for the intstr function
    '/
    dim shared as integer radix=2
    dim shared as integer int_width=1
    
    /'
     translation of intstr function for FreeBASIC
     by original C programmer Chastity White Rose
    '/
    function intstr(i as uinteger) as string
     dim as string s=""
     dim as integer w=0
     dim as byte c
    
     while i<>0 or w<int_width 
    
      c=i mod radix                  
      i\=radix                     
    
      if c<10 then 
      c+=48
      else
      c+=55
      end if
    
      s=chr(c)+s
    
      w+=1                     
     wend
    
    return s
    end function
    
    /'
     global variable for error detection in strint function
     this variable will be zero if last string was a number
    '/
    dim shared as integer strint_errors=0
    
    /'
     translation of strint function for FreeBASIC
     by original C programmer Chastity White Rose
    '/
    function strint(s as string) as uinteger
    dim as uinteger i=0
    dim as integer x=0,y=len(s)
    dim as byte c
    
    strint_errors = 0 /' clear errors '/
    
    while x<y
    
     /' read digit from string '/
     c=s[x]
    
     /' 0 to 9 '/
     if c >= 48 and c <= 57 then
     c-=48
     /' A to Z '/
     elseif c >= 65 and c <= 90 then
     c-=65
     c+=10
     /' a to z '/
     elseif c >= 97 and c <= 122 then
     c-=97
     c+=10
     /' whitespace '/
     elseif c >= 0 and c <= 32 then
      exit while /' exit correctly at string end '/
     else
      strint_errors+=1
      print "Error: ";chr(s[x]);" is not an alphanumeric character!"
      exit while /' exit at invalid character '/
     end if
    
     if c>=radix then
      strint_errors+=1
      print "Error: ";chr(s[x]);" is not a valid character for radix ";radix
      exit while /' exit at digit wrong for radix '/
     end if
    
     /'multiply by radix then add digit'/
     i*=radix
     i+=c
    
    x+=1
    wend
    
    return i
    end function
    

    chastdin.bi

    dim shared as string stdin_buf
    dim shared as integer stdin_buf_index
    dim shared as integer stdin_buf_length=0
    
    function getstr() as string
    dim as string s=""         'create empty string
    dim as byte c              'temporary byte/char variable
    
    /'
    this section gets a line of text
    if the length of the string/buffer is 0
    '/
    
    if stdin_buf_length=0 then      'check if there are characters in the buf
    input "-> ",stdin_buf           'if not, read a line of text
    stdin_buf_index=0               'set index to zero
    stdin_buf_length=len(stdin_buf) 'set the length
    end if
    
    /'
    regardless of whether input was added above
    or if it still had bytes from the last input
    we then extract characters one at a time into the
    substring s to be returned from the function
    '/
    
    while stdin_buf_index<stdin_buf_length
    c=stdin_buf[stdin_buf_index]
    stdin_buf_index+=1
    if(c>=33) and (c<=126) then
    s=s+chr(c)
    else
    exit while
    endif
    wend
    
    /'
    if the index matches the length of buffer
    set length to zero so that more will be read
    next time this function is called
    '/
    
    if stdin_buf_index=stdin_buf_length then
    stdin_buf_length=0
    end if
    
    return s
    end function
    
    /'
    the getline function always gets an entire line of text
    I don't really need it but it is here as a reminder of
    how to use the input statement in FreeBASIC
    '/
    
    function getline() as string
    dim as string s=""
    input "-> ",stdin_buf
    s=stdin_buf
    return s
    end function
    

  • chastelib for Pascal Programming Language

    I managed to hack my four functions from chastelib into the Pascal programming language. This program includes the functions and the test suite which works just like the C version. The code is a bit more complex than the C version because strings and characters are handled very differently than they are in the C programming language. The strint function was the hardest to write but it seems to be working according to the standards I require.

    I am doing this for education and possibly a future book on old programming languages. Pascal is nice but I will also be studying BASIC again.

    program chastelib;
    
    const
     string0='Official test suite for the Pascal version of chastelib.'#10;
    
    var //this is the global variable section
     a:integer;
     b:integer;
     
     radix:integer;       //current radix being used
     int_width:integer=1; //global integer width
     strint_errors:integer=0; //error result for strint function
    
    (*
    A function to print a string using Pascal's write function.
    *)
    procedure putstr(s:string);
    begin
     write(s);
    end;
    
    (*
     a function to return a string form of an integer
     using the global radix variable
    *)
    function intstr(i:integer):string;
    var
     s:string=''; //string that will be built and returned from this function
     width:integer=0; //the current width
     c:integer;
     ch:char;
    begin
     while (i>0) or (width<int_width) do
     begin
    
      c:=i mod radix; //get integer division modulus or remainder
      i:=i div radix; //get integer division quotient
    
      (*turn remainder c into character ch for digit in this radix*)
      if c<10 then
      begin
       ch:=chr(c+48);
      end
      else
      begin
       ch:=chr(c+55);
      end;
    
       s:=ch+s; //prefix the string with this character
       width+=1;
    
     end;
    
     intstr:=s; //return this string from the function
    
    end;
    
    (*use both putstr and intstr to print an integer*)
    procedure putint(i:integer);
    begin
     putstr(intstr(i));
    end;
    
    (*
    Because characters and integers are separate types in Pascal,
    it is required to get the ASCII value of characters in the string
    for the strint function so I can do the math the same way
    as I did in the C version of the function.
    *)
    
    function strint(s:string):integer;
    var
     i:integer=0; //integer that will be built and returned from this function
     x:integer=1; //index used to scan forward through the string
     c:integer=0;
    begin
     strint_errors := 0; (*set zero errors before we parse the string*)
     if (radix<2) or (radix>36 ) then
     begin
      strint_errors+=1;
      writeln('Error: radix ',radix,' is out of range!');
     end;
     while(x<=length(s)) do
     begin
      c:=ord(s[x]);
      if (c>=ord('0')) and (c<=ord('9')) then 
      begin
       c-=ord('0')
      end
      else if (c>=ord('A')) and (c<=ord('Z')) then
      begin
       c-=ord('A');
       c+=10;
      end
      else if (c>=ord('a')) and (c<=ord('z')) then
      begin
       c-=ord('a');
       c+=10;
      end
      
      else if (c < $21 ) then
      begin
       break; (*end loop because we have found whitespace*)
      end
      
      else
      begin
       strint_errors+=1;
       writeln('Error: ',s[x],' is not an alphanumeric character!');break;
      end;
      
      if(c>=radix) then
      begin
       strint_errors+=1;
       writeln('Error: ',s[x],' is not a valid character for radix ',radix);
       break;
      end;
      
      i*=radix; //multiply by the radix
      i+=c;     //add the digit from the character processed
    
      x:=x+1;
     end;
     strint:=i;
    end;
    
    
    
    
    begin
     radix:=16; //set the radix used by both intstr and strint functions
    
     a:=0;
     b:=strint('100');
    
     putstr(string0);
    
     while a<b do
     begin
      radix:=2;
      int_width:=8;
      putint(a);
      putstr(' ');
      radix:=16;
      int_width:=2;
      putint(a);
      putstr(' ');
      radix:=10;
      int_width:=3;
      putint(a);
    
      if (a>=$20) and (a<=$7E) then
      begin
       putstr(' ');
       putstr(chr(a));
      end;
    
      putstr(#10);
      a+=1;
     end;
     
     putstr(string0);
    
    end.
    
    (*
     fpc main.pas && ./main
    *)