The Blue Screen of Death (also known as a stop error, BSoD, bluescreen, or Blue Screen of Doom) is a colloquialism used for the error screen displayed by some operating systems, most notably Microsoft Windows, after encountering a critical system error that can cause the system to shut down to prevent irreversible damage to the system’s integrity. It serves to present information for diagnostic purposes that was collected as the operating system issued a bug check.
The term Blue Screen of Death originated during OS/2 pre-release development activities at Lattice Inc, the makers of an early Windows and OS/2 C compiler.
BSoDs are commonlyobserved in Macintosh operating systems, Windows operating systems, PlayStation 3 and PlayStation Portable
2. STACK OVERFLOW
In software, a stack overflow occurs when too much memory is used on the call stack. The call stack contains a limited amount of memory, often determined at the start of the program. The size of the call stack depends on many factors, including the programming language, machine architecture, multi-threading, and amount of available memory. When too much memory is used on the call stack the stack is said to overflow, typically resulting in a program crash. This class of software bug is usually caused by one of two types of programming errors.
3. BROWSER COMPATIBILITY ISSUES
A few years ago, there weren’t many different versions of web browsers to choose from. Now there are dozens. Actually, there’s over 100 different browsers, not counting different versions of the same product
Choice is a wonderful thing, but the proliferation of browser software has also increased confusion in consumers as to what they should use. It has also been the major bugbear of web developers.
The good news for developers is that the vast majority of web surfers use either Internet Explorer, Firefox and Netscape – approximately 95%. The bad news is that there are over 200 flavours of Internet Explorer, Firefox and Netscape. Web pages can look totally different between the different versions.
PIXEL SIZES – You have elements sized in pixels (px), which is highly discouraged for anything but images. It will cause one’s page to become inflexible and thereby inaccessible, since the user will be unable
to adapt the page to his/her needs. Pixels are absolute sizes on the screen, and their real-life size may differ drastically between resolutions.
EM FONT SIZES – You have specified one or more of your font sizes in ems (em). While ems may seem the ideal unit for specifying font sizes, they have poor support in some versions of Internet Explorer. Percentages should be used for sizing fonts instead.
5. DATATYPE BUGS:
Modern tech world has huge number of programming languages. Each of these programming languages use their own specific syntax or derived from other languages. Whenever there is an inter language communication portability becomes very difficult.
There are few languages which use only single data type (like var in Visual Basic & $variable in perl/php). But majority of them use primitive data types which are machine dependent. So we need to use languages like xml or depend on var variables.
Surely this becomes a bug/issue bugging most programmers working on multiple platforms simultaneously.
6. Coffman deadlock [Multi-threading programming bug]
In computer science, Coffman deadlock refers to a specific condition when two or more processes are each waiting for each other to release a resource, or more than two processes are waiting for resources in a circular chain (see Necessary conditions). Deadlock is a common problem in multiprocessing where many processes share a specific type of mutually exclusive resource known as a software lock or soft lock. Computers intended for the time-sharing and/or real-time markets are often equipped with a hardware lock (or hard lock) which guarantees exclusive access to processes, forcing serialized access. Deadlocks are particularly troubling because there is no general solution to avoid (soft) deadlocks.
This situation may be likened to two people who are drawing diagrams, with only one pencil and one ruler between them. If one person takes the pencil and the other takes the ruler, a deadlock occurs when the person with the pencil needs the ruler and the person with the ruler needs the pencil to finish his work with the ruler. Neither request can be satisfied, so a deadlock occurs.
The telecommunications description of deadlock is weaker than Coffman deadlock because processes can wait for messages instead of resources. Deadlock can be the result of corrupted messages or signals rather than merely waiting for resources. For example, a dataflow element that has been directed to receive input on the wrong link will never proceed even though that link is not involved in a Coffman cycle
7. Infinite loop [Logic bug]
An infinite loop is a sequence of instructions in a computer program which loops endlessly, either due to the loop having no terminating condition, having one that can never be met, or one that causes the loop to start over. In older operating systems with cooperative multitasking, infinite loops normally caused the entire system to become unresponsive. With the now-prevalent preemptive multitasking model, infinite loops usually cause the program to consume all available processor time, but can usually be terminated by the user. Busy-wait loops are also sometimes misleadingly called “infinite loops”. One possible cause of a computer “freezing” is an infinite loop; others include deadlock and access violations.
8. Off-by-one error [Logic bug]
An off-by-one error (OBOE) is a logical error involving the discrete equivalent of a boundary condition. It often occurs in computer programming when an iterative loop iterates one time too many or too few. Usually this problem arises when a programmer fails to take into account that a sequence starts at zero rather than one (as with array indices in many languages), or makes mistakes such as using “is less than or equal to” where “is less than” should have been used in a comparison. This can also occur in a mathematical context.
9. Division by zero [Arithmetic bug]
The IEEE floating-point standard, supported by almost all modern processors, specifies that every floating point arithmetic operation, including division by zero, has a well-defined result. The standard supports signed zero, as well as infinity and NaN (not a number). There are two zeroes, +0 (positive zero) and −0 (negative zero) and this removes any ambiguity when dividing. In IEEE 754 arithmetic, a ÷ +0 is positive infinity when a is positive, negative infinity when a is negative, and NaN when a = ±0. The infinity signs change when dividing by −0 instead.
Integer division by zero is usually handled differently from floating point since there is no integer representation for the result. Some processors generate an exception when an attempt is made to divide an integer by zero, although others will simply continue and generate an incorrect result for the division. The result depends on how division is implemented, and can either be zero, or sometimes the largest possible integer.
Because of the improper algebraic results of assigning any value to division by zero, many computer programming languages (including those used by calculators) explicitly forbid the execution of the operation and may prematurely halt a program that attempts it, sometimes reporting a “Divide by zero” error. In these cases, if some special behavior is desired for division by zero, the condition must be explicitly tested for (for example, using an if statement). Some programs (especially those that use fixed-point arithmetic where no dedicated floating-point hardware is available) will use behavior similar to the IEEE standard, using large positive and negative numbers to approximate infinities. In some programming languages, an attempt to divide by zero results in undefined behavior.
In two’s complement arithmetic, attempts to divide the smallest signed integer by − 1 are attended by similar problems, and are handled with the same range of solutions, from explicit error conditions to undefined behavior.
10. Arithmetic overflow and underflow [Arithmetic bug]
The term arithmetic overflow or simply overflow has the following meanings.
2. In a computer, the amount by which a calculated value is greater than that which a given register or storage location can store or represent. Note that the overflow may be placed at another location.
Most computers distinguish between two kinds of overflow conditions. A carry occurs when the result of an addition or subtraction, considering the operands and result as unsigned numbers, does not fit in the result. Therefore, it is useful to check the carry flag after adding or subtracting numbers that are interpreted as unsigned values. An overflow proper occurs when the result does not have the sign that one would predict from the signs of the operands (e.g. a negative result when adding two positive numbers). Therefore, it is useful to check the overflow flag after adding or subtracting numbers that are represented in two’s complement form (i.e. they are considered signed numbers).
11. Buffer overflow [Resource Bug]
In computer security and programming, a buffer overflow, or buffer overrun, is an anomaly where a program, while writing data to a buffer, overruns the buffer’s boundary and overwrites adjacent memory. This may result in erratic program behavior, including memory access errors, incorrect results, program termination (a crash), or a breach of system security.
Buffer overflows can be triggered by inputs that are designed to execute code, or alter the way the program operates. They are thus the basis of many software vulnerabilities and can be maliciously exploited. Bounds checking can prevent buffer overflows.
Programming languages commonly associated with buffer overflows include C and C++, which provide no built-in protection against accessing or overwriting data in any part of memory and do not automatically check that data written to an array (the built-in buffer type) is within the boundaries of that array.
12. INVITE of Death [VOIP bug]
An INVITE of Death is a type of attack on a VoIP-system that involves sending a malformed or otherwise malicious SIP INVITE request to a telephony server and causes a crash of that server. Because telephony is usually a critical application, this damage causes significant uproar amongst the users and poses tremendous acceptance problems with VoIP. Those kinds of attacks do not necessarily affect only SIP-based systems; all implementations with vulnerabilities in the VoIP area are affected. However, sending INVITE packets is the most popular way of attacking telephony systems.
The name is a reference to the ping of death attack that caused serious trouble in the 1990s.
The DoS attack can also be transported in other messages than INVITE. For example, in December 2007 there was a report about a vulnerability in the BYE message (“BYE BYE”) by using an obsolete header with the name “Also”.
13. Teamworking bugs
Unpropagated updates; e.g. programmer changes “myAdd” but forgets to change “mySubtract”, which uses the same algorithm. These errors are mitigated by the Don’t Repeat Yourself philosophy.
In software engineering, Don’t Repeat Yourself (DRY) or Duplication is Evil (DIE) is a principle of software development aimed at reducing repetition of information of all kinds, especially useful in multi-tier architectures. The DRY principle is stated as “Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.” The principle has been formulated by Andy Hunt and Dave Thomas in their book The Pragmatic Programmer.
1. Comments out of date or incorrect: many programmers assume the comments accurately describe the code.
2. Differences between documentation and the actual product.
14. Segmentation fault
A segmentation fault (often shortened to segfault) or access violation is a particular error condition that can occur during the operation of computer software. A segmentation fault occurs when a program attempts to access a memory location that it is not allowed to access, or attempts to access a memory location in a way that is not allowed (for example, attempting to write to a read-only location, or to overwrite part of the operating system).
Segmentation is one approach to memory management and protection in the operating system. It has been superseded by paging for most purposes, but much of the terminology of segmentation is still used, “segmentation fault” being an example. Some operating systems still have segmentation at some logical level although paging is used as the main memory management policy.
On Unix-like operating systems, a signal called SIGSEGV is sent to a process that accesses an invalid memory address. On Microsoft Windows, a process that accesses invalid memory receives the STATUS_ACCESS_VIOLATION exception.
A crash (or system crash) in computing is a condition where a program (either an application or part of the operating system) exits abnormally after encountering an error. Often the offending program may simply appear to freeze or hang until a crash reporting service documents details of the crash. If this program is a critical part of the operating system kernel the entire computer may crash. This is different from a hang or freeze where the application or OS continues to run without obvious response to input.
On earlier personal computers, it was actually possible to cause hardware damage through trying to write to hardware addresses outside of the system’s main memory. Occasionally, execution of arbitrary data on a system will result in a breakup of screen display. This is widely considered a severe system crash.
Website server crashes
The software running the server behind a website may crash, rendering it inaccessible entirely or providing only an error message instead of normal content. For example: If a site was using a SQL database (such as MySQL) for a script (such as php) and that SQL server crashed, then php would display a connection error.
This crash also results in Application Crashes and Operating System Crashes.
16. Y2K problem
The Year 2000 problem (also known as the Y2K problem, the millennium bug, the Y2K bug, or simply Y2K) was a problem for both digital (computer-related) and non-digital documentation and data storage situations which resulted from the practice of abbreviating a four-digit year to two digits.
In computer programs, the practice of representing the year with two digits becomes problematic with logical error(s) arising upon “rollover” from x99 to x00. This has caused some date-related processing to operate incorrectly for dates and times on and after January 1, 2000 and on other critical dates which were billed “event horizons“. Without corrective action, it was suggested that long-working systems would break down when the “…97, 98, 99, 00…” ascending numbering assumption suddenly became invalid. Companies and organizations worldwide checked, fixed, and upgraded their computer systems.
While no globally significant computer failures occurred when the clocks rolled over into 2000, preparation for the Y2K problem had a significant effect on the computer industry. There were plenty of Y2K problems, and that none of the glitches caused major incidents is seen as vindication of the Y2K preparation. However, some questioned whether the absence of computer failures was the result of the preparation undertaken or whether the significance of the problem had been overstated.
17. Google Chrome Issue
Eventhough google came up with a wonderful browser which is very fast, it still lacks some of the basic features. Even today google chrome is in beta version, constantly waiting for google’s innovation. Believe it or not, it still doesn’t support hand button on flash module.
Google seem to have accepted this as a known issue. Please refer below
18. Style tags limit in Internet Explorer
All style tags after the first 30 style tags on an HTML page are not applied. Occasionally, you may also receive the following error message:
The page you are looking for might have been moved or had its name changed.
If you use a network monitor tool to capture network traffic, you may notice that a TCP reset occurs when Internet Explorer is receiving the page. Internet Explorer then generates another POST request if the original request was a POST request. Or, Internet Explorer may send a GET request instead.
This style tag limitation may also affect the viewing of .xml files by using .xsl files. When the .xsl file has style tags embedded inside the document, you receive the following error message when you try to view the .xml file:
Internet Explorer could not open the Internet Site: file://c:\aaa.xml
It is not important if you use an inline style sheet, or if you point to a cascading style sheet (CSS) file. The problem occurs in either case.