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` is a `g++` internal thing that serves roughly the same purpose as the standard `nullptr` added in C++11 (acting consistently as a pointer, never an integer).

`NULL` is defined as `0`, which can be implicitly used as integer, boolean, floating point value or pointer, which is a problem when it comes to overload resolution, when you want to call the function that takes a pointer specifically.

In any event, you shouldn't use `__null` because it's a `g++` implementation detail, so using it guarantees non-portable code. If you can rely on C++11 (surely you can by now?), use `nullptr`. If not, `NULL` is your only portable option.
`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.