> What is the difference between `char word[length]` and `char *word =
> malloc(sizeof(char) * LENGTH)`??

A char * is a pointer to a char (or a sequence of chars -- aka a string) while a char[] is an array of chars. They're both interchangeably used, but here are some main differences

 1. If you use a char *, you have to allocate memory for it separately using malloc() while if you used a char[], all you need to do is to specify the size of that array. So for example,

        typedef struct node
        {
            char *str;
        }
        node;
    
        // some code
        node *ptr = malloc(sizeof(node)); // allocate memory for a node
    
        // if we wanna use ptr->str, we have to allocate memory separately for it
        ptr->str = malloc(sizeof(LENGTH)); // allocate memory for str
    
        // some code

    On the other hand,
        
        typedef struct node
        {
            char arr[LENGTH];
        }
        node;
    
        // some code
        node *ptr = malloc(sizeof(node)); // allocate memory for a node
    
        // you can now initialize arr directly here without mallocing memory for it
        
 2. Since you're allocating memory for char * variables separately, you also need to free them manually while a char[], assuming it's a member of a struct, is automatically freed when you call free on a pointer to this specific struct. For example,

        typedef struct node
        {
            char *str;
        }
        node;
    
        // some code
        node *ptr = malloc(sizeof(node)); // allocate memory for a node
    
        // if we wanna use ptr->str, we have to allocate memory separately for it
        ptr->str = malloc(sizeof(LENGTH)); // allocate memory for str
    
        // some code
        
        free(ptr->str); // we have to free ptr->str first
        free(ptr); // then free ptr itself

    On the other hand,
        
        typedef struct node
        {
            char arr[LENGTH];
        }
        node;

        // some code

        node *ptr = malloc(sizeof(node)); // allocate memory for a node
        // do some stuff
        free(ptr); // no need to free arr

        // some code

 3. One last thing is that you won't be able to initialize a char[] with a string literal if you've declared it separately as it's the case here. You have to initialize it character by character while a char * can be initialized with a string literal anytime. So in case of,

        typedef struct node
        {
            char *str;
        }
        node;
    
        // some code
        node *ptr = malloc(sizeof(node)); // allocate memory for a node
    
        // if we wanna use ptr->str, we have to allocate memory separately for it
        ptr->str = malloc(sizeof("hello")); // allocate memory for str
        
        ptr->str = "hello"; // initialize ptr->str
        
        // some code
        
        free(ptr->str); // we have to free ptr->str first
        free(ptr); // then free ptr itself

    On the other hand,
        
        typedef struct node
        {
            char arr[LENGTH];
        }
        node;

        // some code

        node *ptr = malloc(sizeof(node)); // allocate memory for a node
        
        // initialize ptr->arr
        ptr->arr[0] = 'h';
        ptr->arr[1] = 'e';
        ptr->arr[2] = 'l';
        ptr->arr[3] = 'l';
        ptr->arr[4] = 'o';
        ptr->arr[5] = '\0';

        // do some stuff
        
        free(ptr); // no need to free arr

        // some code

> In `char * word`, what is the meaning of `&word`,`word` and `*word`?

In this situation, `word` is a *pointer to a char* (or a sequence of chars). It contains the address of the block of memory it points to. `&word` is *the address of that pointer*. It returns the address of `word`. `*word` deferences the address that `word` contains which gives us the first character in that block (since the address of the first character is the same as the address of the whole block). This [answer][1] has a good visual representation to this. 

> What is the meaning of NULL in pointer, does it mean word points to
> memory but memory have nothing OR word doesn't point to memory at all
> in case word has NULL?

`NULL` is a special value. It represents a memory address. It's actually equal to *0x0* and that's the zeroth location in memory. And it's a special location that you can't read/write data from and to it. Usually we set pointer values to `NULL` when we want them to point to nothing.

> If there is function that receive something as pointer, How do i pass
> an argument to it? For example i want to send char * word as
> parameter, How do i do it?

Given this simple program,

    #include <stdio.h>
    
    // prototypes
    unsigned int getLength(char *str);
    
    int main(void)
    {
        char *str = "hello"; // create a string
        unsigned int l = getLenght(str); // pass str to a function
        printf("Length: %u\n", l); // print the length
    }
    
    unsigned int getLength(char *str) // accepts a char *
    {
        // calculate the length of str
        unsigned int length = 0;
        
        // while the current character is not the null terminator
        while (str[length] != '\0')
        {
            length++; // increase the length by 1
        }
    
        return length;
    }

Hope that helps!
  [1]: http://stackoverflow.com/a/24468853/1797347