This description is outside the conventional definition of a null pointer error, but it can produce a null pointer nonetheless, though more often producing other errors, or none at all. It often gives no indication of its existence other than 'if or when' the program fails to perform as expected. This provides non-conventional examples and definitions of potential sources of null pointer assignment errors, rather than defining conventional understanding which is more an error in convention than an error in programming logic.
This type of error (undefined, or null) is much rarer. But modern programming, using benchtop devices like an Arduino, Raspberry PI, AMD, or any other computer on a chip programming exists in a myriad of forms, many of which are as simple today as yesteryear, this problem still exists today and can occur even in the most sophisticated of systems. Additionally, companies that build their own variable or data structures are probably also the most likely people to see this nowadays. The intention is to show examples that can aid in recognition.
For this to be a 'null' pointer error, the value assigned just has to be '0' or 'null'. But it has historically been called a 'null pointer error' not just being a simple null pointer; but because of their occurrence when clearing or zeroing out an array, the routine doing so overshoots or undershoots the boundaries of the array. However, simply it's an error created by array boundary miscalculations that can produce null pointer assignments and other errors. These are often not easily detected and may not generate an error immediately or at all, because the address that the pointer originally pointed to when defined has been overwritten and now contains an undesirable value (a bad address). And when, and by what it was overwritten can be almost impossible to find. This is included as part of the definition of types of error which produce null pointers. Where the pointer will be overwritten with a null, or zero and it will generate an error, and one is left with the problem of finding what modified it. Extra care must be taken to ensure that indexes are calculated properly with the appropriate consideration to base option 0 or 1. And also calculating correctly when moving data blocks. Fortunately many sophisticated development software applications and high level languages can catch a lot of these issues before or during compiling, when the variable array type is explicitly cast, or when the program can be written in a runtime environment and monitors array boundaries.
A null pointer is, as was defined in older days, any variable which gets used as a pointer and the address contents of the pointer's address, meaning the address the pointer points to, not the location it points to, is zero or null, OR has been modified, overwritten without the programmer's intent or knowledge, which could be a null, but could be any other value. Often only the null pointer creates an error message, even though the code may create an error, as it's often blocks of data containing nulls that's written to wrong locations. Instead of pointing to the original defined address where the data should reside, it now contains a null or unknown address moving data to an invalid or unwanted location overwriting and corrupting the code or data there. Because the failure caused to the data, or code may not immediately execute, or get used as it's moved to an existing unused memory location, when the code or data does cause a problem at a later time in the run, there can be no information on the 'real' location of the error, whether it creates or assigns null pointers or other corruption, it modifies code, and things can get weird, really weird.
To summarize, a null pointer is any null address used to point to a memory location regardless of what creates it. A null pointer assignment error, or many other errors, can be assigned to this issue and example.
In simpler architecture or programming environments, It can refer to any code which unintentionally ends up creating nulls as pointers, or creates a bug that in anyway halts the execution, like overwriting a byte in the return stack, overwriting code, putting code or data in the wrong location, not just as an address. So, while the examples above, work fine to define an example of a null pointer. So we expand the concept, A null pointer is any pointer which gets used as a variable pointer, and the address location of that variable for any one of multiple reasons now contains a 'null' or any unintended value that points to an undesirable memory location no matter how it got there.
So, finally, one can get a null pointer error, and upon examining the pointer finds it contains a null; but, cannot find the code that placed the null into the pointer or assigned it. This is a broad definition of null pointer assignment error, and is the worst case scenario of a null pointer error. When this occurs in a large program, this can be the death of the program because if the error existed previously, and was writing to the wrong memory location, and that location had yet to be allocated, the error goes unnoticed until the program gets expanded, and now the wrong memory location may exist inside of the new code, generating random errors. For example: the bad address value causes data to be written outside of the variable space defined, but goes unnoticed for some time because it's being written, and it being read, and everything 'appears' OK! But, the program expands, gets larger, new code exists in the same address space as the memory where the original old bug existed which writes data to the wrong address space and no one noticed, whether one byte, or a whole block of data! But, now, there's new code there. And it's gets corrupted by the old undiscovered bug, and to find the error which existed a year earlier is now almost, if not totally, impossible to find. Administrator logic usually dictates, why look there, it ran and worked just fine last year. But, now, nothing works, major pieces are broken, look and look and nothing do you find. It's as if the error doesn't exist, and yet it does. What's causing it, who suspects code written years earlier? Null pointers and many other errors are caused by this too.
Perhaps this answer is misplaced and would serve better to be listed elsewhere. Moderator? Perhaps, there is concern because this 'answer' is not considered pertinent because there is some concern over the use of the word "assignment" in the question, meaning intentionally assigned. However, the concept of assignment does not require knowledge or consent. An algorithm or code can assign values. Null pointers can be created many ways, the example here is probably the most common one outside of conventional errors.
It appears this information has 'a' place, and is included here as an answer. Positive fruitful feedback or suggestions are appreciated, rather than a simple down vote, if anyone cares to comment, perhaps a meta discussion is in order?
В течение часа то же самое случится с остальными пятью. После этого сюда полезут все, кому не лень. Каждый бит информации АНБ станет общественным достоянием. Фонтейн внимательно изучал ВР, глаза его горели.