"Arrays are not pointers". Right. And wrong, actually.

The article says that arrays are different from pointers, but it does not prove it. It is quite simple to prove, see the program below.

Also, it's not interesting to limit the definition of arrays to just the locally and statically declared ones. If you do that then something like 90% of C programs (if not more, I think I never wrote such a C program except for exercises in class) don't use arrays at all. In all the other case (arrays passed as argument to a function, dynamically allocated arrays…), the are the same as pointers. Again, see the program below.

In reality, it is a bit pedantic to insist on this distinction, except for the rare case where it is a performance issue (the arrays of the article require one less memory access, the one to get the address of the memory at which the array starts).

    #include <stdio.h>
    #include <stdlib.h>
    
    void
    f (char a[], char *b, char *c)
    {
      printf("Once passed to a function as arguments:\n\n");
    
      printf("What the article limits the definition of array to:\n");
      printf("&a      = %p\n", &a);
      printf("a       = %p\n", a);
      printf("&(a[0]) = %p\n", &(a[0]));
      printf("a + 1   = %p\n", a + 1);
      printf("&(a[1]) = %p\n", &(a[1]));
      printf("\n");
    
      printf("Pointer to an array:\n");
      printf("&b      = %p\n", &b);
      printf("b       = %p\n", b);
      printf("&(b[0]) = %p\n", &(b[0]));
      printf("b + 1   = %p\n", b + 1);
      printf("&(b[1]) = %p\n", &(b[1]));
      printf("\n");
    
      printf("Pointer to dynamically allocated memory:\n");
      printf("&c      = %p\n", &c);
      printf("c       = %p\n", c);
      printf("&(c[0]) = %p\n", &(c[0]));
      printf("c + 1   = %p\n", c + 1);
      printf("&(c[1]) = %p\n", &(c[1]));
      printf("\n");
    }
    
    int
    main (int argc, char *argv[])
    {
      char a[4];
      char *b = a;
      char *c = malloc(sizeof(*c) * 4);
    
      printf("What the article limits the definition of array to:\n");
      printf("&a      = %p\n", &a); /* behavior differs only here, this is the
                                       difference with pointers */
      printf("a       = %p\n", a);
      printf("&(a[0]) = %p\n", &(a[0]));
      printf("a + 1   = %p\n", a + 1);
      printf("&(a[1]) = %p\n", &(a[1]));
      printf("\n");
    
      printf("Pointer to an array:\n");
      printf("&b      = %p\n", &b);
      printf("b       = %p\n", b);
      printf("&(b[0]) = %p\n", &(b[0]));
      printf("b + 1   = %p\n", b + 1);
      printf("&(b[1]) = %p\n", &(b[1]));
      printf("\n");
    
      printf("Pointer to dynamically allocated memory:\n");
      printf("&c      = %p\n", &c);
      printf("c       = %p\n", c);
      printf("&(c[0]) = %p\n", &(c[0]));
      printf("c + 1   = %p\n", c + 1);
      printf("&(c[1]) = %p\n", &(c[1]));
      printf("\n");
    
      f(a, b, c);
    
      return 0;
    }

Here is a possible output of this program:

    What the article limits the definition of array to:
    &a      = 0x7fff5590ff00
    a       = 0x7fff5590ff00
    &(a[0]) = 0x7fff5590ff00
    a + 1   = 0x7fff5590ff01
    &(a[1]) = 0x7fff5590ff01
    
    Pointer to an array:
    &b      = 0x7fff5590fef8
    b       = 0x7fff5590ff00
    &(b[0]) = 0x7fff5590ff00
    b + 1   = 0x7fff5590ff01
    &(b[1]) = 0x7fff5590ff01
    
    Pointer to dynamically allocated memory:
    &c      = 0x7fff5590fef0
    c       = 0x202f010
    &(c[0]) = 0x202f010
    c + 1   = 0x202f011
    &(c[1]) = 0x202f011
    
    Once passed to a function as arguments:
    
    What the article limits the definition of array to:
    &a      = 0x7fff5590fec8
    a       = 0x7fff5590ff00
    &(a[0]) = 0x7fff5590ff00
    a + 1   = 0x7fff5590ff01
    &(a[1]) = 0x7fff5590ff01
    
    Pointer to an array:
    &b      = 0x7fff5590fec0
    b       = 0x7fff5590ff00
    &(b[0]) = 0x7fff5590ff00
    b + 1   = 0x7fff5590ff01
    &(b[1]) = 0x7fff5590ff01
    
    Pointer to dynamically allocated memory:
    &c      = 0x7fff5590feb8
    c       = 0x202f010
    &(c[0]) = 0x202f010
    c + 1   = 0x202f011
    &(c[1]) = 0x202f011

As we can see, for their practical use arrays and pointers can really be seen as the same thing. So again, except if you are optimizing a program where you can statically declare your arrays and access them a lot (i.e., you are doing matrix multiplication), the difference between arrays and pointers does not really matter.