Question: Here is my js code:

```
import axios from 'axios';

const quotes = document.querySelector('.quotes');

const getResults = async () => {

    try {

        const res = await axios('http://quotesondesign.com/wp-json/posts?filter[orderby]=rand&filter[posts_per_page]=1');

        quotes.innerHTML = res.data[0].content;

        console.log(res.data[0].content);

    } catch(err) {

        console.log(err);

    }

}
getResults();

```

It yields the following error: `Unexpected identifier 'axios'. import call expects exactly one argument`.
I am running it in browser and I am not using any bundler, any idea on why this is happening?

Answer: 
`NULL` has been overtaken from C into C++ and - prior to C++11 - adopted its C meaning:

> 
> until C++11: The macro NULL is an implementation-defined null pointer
>  constant, which may be an integral constant expression rvalue of
>  integer type that evaluates to zero.
> 
> 
> 

C++11 then introduced a dedicated null pointer literal `nullptr` of type `std::nullptr_t`. But - probably for backward compatibility - the macro `NULL` was not removed; its definition was just a bit relaxed in that compilers may now define it either as integral or as pointer type:

> 
> C++11 onwards: an integer literal with value zero, or a prvalue of
>  type std::nullptr\_t
> 
> 
> 

If you use `NULL`, then you get implementation-defined behaviour in overload resolution. Consider, for example, the following code with a compiler that uses the integral-version of `NULL`-macro. Then a call using `NULL` as parameter passed to a function may lead to ambiguities:

```
struct SomeOverload {

    SomeOverload(int x) {
        cout << "taking int param: " << x << endl;
    }
    SomeOverload(void* x) {
        cout << "taking void* param: " << x << endl;
    }
};

int main() {

    int someVal = 10;

    SomeOverload a(0);
    SomeOverload b(&someVal);

    // SomeOverload c(NULL);  // Call to constructor is ambiuous
    SomeOverload d(nullptr);
}

```

So it is recommended to use `nullptr` where ever you want to express pointer type. 

And don't use `__null`, as this is a compiler-specific, non-portable constant; `nullptr`, in contrast, is perfectly portable.
`NULL` is the old C symbol for a null pointer. C++ traditionally have used `0` for null pointers, and since the C++11 standard `nullptr`.

Considering that `x` doesn't seem to be a pointer then you can't initialize `x` to be a null pointer, and the `__null` symbol is perhaps some compiler-internal symbol for a null *value* (which is a concept that doesn't really exist in standard C++).

If you want `x` to initialized to some default state, then you have to rely on the `MyClass` default constructor to initialize the objects and its member variables to some suitable default values.