Google

Thursday, January 10, 2008

A software bug

A software bug
A software bug (or just "bug") is an error, flaw, mistake, failure, or fault in a computer program that prevents it from behaving as intended (e.g., producing an incorrect result). Most bugs arise from mistakes and errors made by people in either a program's source code or its design, and a few are caused by compilers producing incorrect code. A program that contains a large number of bugs, and/or bugs that seriously interfere with its functionality, is said to be buggy. Reports detailing bugs in a program are commonly known as bug reports, fault reports, problem reports, trouble reports, change requests, and so forth.

Philosophy

Philosophy
Philosophy is the discipline concerned with questions of how one should live (ethics); what sorts of things exist and what are their essential natures (metaphysics); what counts as genuine knowledge (epistemology); and the reasons why humans create & consider things beautiful (aesthetics).[1][2] The word is of Greek origin: φιλοσοφία (philosophía), meaning love of wisdom or knowledge.[3]

A mnemonic

A mnemonic
A mnemonic (pronounced /nəˈmɒnɪk/) is a memory aid. Mnemonics are often verbal, something such as a very short poem or a special word used to help a person remember something, particularly lists. Mnemonics rely not only on repetition to remember facts, but also on associations between easy-to-remember constructs and lists of data, based on the principle that the human mind much more easily remembers insignificant data attached to spatial, personal, or otherwise meaningful information than that occurring in meaningless sequences. The sequences must make sense though; if a random mnemonic is made up, it is not necessarily a memory aid.[citation needed]
The word mnemonic is derived from the Ancient Greek word μνημονικός mnemonikos ("of memory") and is related to Mnemosyne ("remembrance"), the name of the goddess of memory in Greek mythology. Both of these words refer back to μνημα mnema ("remembrance").[1] The first known reference to mnemonics is the method of loci described in Cicero's De Oratore.
The major assumption is that there are two sorts of memory: the "natural" memory and the "artificial" memory. The former is inborn, and is the one that everyone uses every day. The artificial memory is one that is trained through learning and practicing a variety of mnemonic techniques. The latter can be used to perform feats of memory that are quite extraordinary, impossible to carry out using the natural memory alone.

Saturday, December 22, 2007

Memory

Memory
Block I AGC memory was organized into 1024 word banks. The lowest bank (bank 0) was erasable memory (RAM). All banks above bank 0 were fixed memory (ROM). Each AGC instruction had a 12-bit address field. The lower bits (1-10) addressed the memory inside each bank. Bits 11 and 12 selected the bank: 00 selected the erasable memory bank; 01 selected the lowest bank (bank 1) of fixed memory; 10 selected the next one (bank 2); and 11 selected a BANK register that could be used to select any bank above 2. Banks 1 and 2 were called "fixed-fixed" memory, because they were always available, regardless of the contents of the BANK register. Banks 3 and above were called "fixed-switchable" because the selected bank was determined by the BANK register.
The Block I AGC initially had 12K words of fixed memory, but this was later increased to 24K. Block II had 32K of fixed memory and 4K of erasable memory.
The AGC transferred data to and from memory through the G register in a process called the "memory cycle." The memory cycle took 12 timing pulses (11.72 microseconds). The cycle began at timing pulse 1 (TP1) when the AGC loaded the memory address to be fetched into the S register. The memory hardware retrieved the data word from memory at the address specified by the S register. Words from erasable memory were deposited into the G register by timing pulse 6 (TP6); words from fixed memory were available by timing pulse 7. The retrieved memory word was then available in the G register for AGC access during timing pulses 7 through 10. After timing pulse 10, the data in the G register was written back to memory.
The AGC memory cycle occurred continuously during AGC operation. Instructions needing memory data had to access it during timing pulses 7-10. If the AGC changed the memory word in the G register, the changed word was written back to memory after timing pulse 10. In this way, data words cycled continuously from memory to the G register and then back again to memory.
The lower 15 bits of each memory word held AGC instructions or data. Each word protected by a 16th "odd parity" bit. This bit was set to 1 or 0 by a parity generator circuit so a count of the 1's in each memory word would always produce an odd number. A parity checking circuit tested the parity bit during each memory cycle; if the bit didn't match the expected value, the memory word was assumed to be corrupted and a PARITY ALARM panel light was illuminated