text:
Microprocessor Design/Wire Wrap

Historically, most of the early CPUs were built by attaching integrated circuits (ICs) to circuit boards and wiring them up.

Nowadays, it's much faster to design and implement a new CPU in a FPGA -- the result will probably run faster and use less power than anything spread out over multiple ICs.

However, some people still design and build CPUs the old-fashioned way. Such a CPU is sometimes called a "home brew CPU" or a "home built CPU".

Some people feel that physically constructing a CPU in this way, since it allows students to probe the inner workings of the CPU, it helps them "Touch the magic", helps them learn and understand the underlying electronics and hardware.

Overview

A homebrew CPU is a central processing unit constructed using a number of simple integrated circuits, usually from the 7400 Series. When planning such a CPU, the designer must not only consider the hardware of the device but also the instructions the CPU will have, how they will operate, the bit patterns for each one, and their mnemonics. Before the existence of computer based circuit simulation, many commercial processors from manufacturers such as Motorola were first constructed and tested using discrete logic. Those commercial processors include the Motorola 6800, the Motorola 6809, , the 32-bit Motorola 68030, and the 32-bit Hewlett-Packard PA-RISC TS1.

Although no limit exists on data bus sizes when constructing such a CPU, the number of components required to complete a design increases exponentially as bus size gets wider. Common physical data bus sizes are 1-bit, 4-bits, 8-bits, and 16-bits. Incomplete design documents exist for a 40-bit CPU. A microcoded CPU may be able to present a significantly different instruction set to the application programmer than seems to be directly supported by the hardware used to implement it. For example, the 68000 presented a 32-bit instruction set to the application programmer -- a 32-bit "add" was a single instruction -- even though internally it was implemented with 16-bit ALUs. For example, the Zilog Z80, one of the most commonly used CPU families of all time, presented an 8-bit instruction set to the application programmer -- even though internally it was implemented with a single 4-bit ALU.

For example, serial computers, even though they do calculations one bit per clock cycle, present a instruction set that deals with much wider words -- often 12 bits (PDP-8/S; PDP-14), 24 bits (D-17B), or even wider -- 39 bits (Elliott 803).

Notable Homebrew CPUs

The Magic-1 is a CPU with an 8-bit data bus and 16-bit address bus running at about 3.75MHz 4.09 MHz.

The Mark I FORTH also has a 8-bit data bus and 16-bit address bus, but runs at 1MHz.

The V1648CPU is a CPU with a 16-bit data bus and 48-bit address bus that is currently being designed.

APOLLO181 is a homemade didactic 4-bit processor made of TTL logics and bipolar memories, based upon the Bugbook® I and II chips, in particular on the 74181 (by Gianluca.G, Italy, May 2012).

The ([FIXME named what?]) is an 8-bit TTL CPU re-implemented by many MIT students using the "MAYBE" lab kit.

The "Beta" is apparently a 32-bit CPU re-implemented by many MIT students. They implemented in at least 3 different ways:
 * an simulation running on an 8-bit CPU ([FIXME: named what?]) built from simple integrated circuits
 * A 32-bit CPU directly built from lots of simple integrated circuits
 * A 32-bit CPU simulated in software on some other CPU chip.

In 2005, eighteen high school students re-implemented and built their own version of "the CHUMP" ("Cheap Homebrew Understandable Minimal Processor"), a CPU with a 4-bit datapath.

Parts
...

bus
Practically all CPU designs include several 3-state buses -- an "address bus", a "data bus", and various internal buses.

A 3-state bus is functionally the same as a multiplexer. However, there is no physical part you can point to and say "that is the multiplexer" in a 3-state bus; it's a pattern of activity shared among many parts. The only reason to use a 3-state bus is when it requires fewer chips or fewer, shorter wires, compared to an equivalent multiplexer arrangement. When you want to select between very few pieces of data that are close together, and most of that data is stored on a chip that only has 2-state outputs, it may require fewer chips and less wiring to use actual multiplexer chips. When you want to select between many pieces of data (one of many registers, or one of many memory chips, etc.), or many of the chips holding that data already have 3-state outputs, it usually requires fewer chips to use a 3-state bus (even counting the "extra" 3-state buffer between the bus and each thing that doesn't already have 3-state outputs).

A typical register file connected to a 3-state 16-bit bus on a TTL CPU includes:
 * octal 2-state output registers (such as 74x273), 2 chips per 16-bit register
 * octal 3-state non-inverting buffers (such as 74x241), 2 chips per 16-bit register per bus
 * a demultiplexer with N inputs (driven by microcode) and 2^N output wires that select the 3-state buffers of one of up to 2^N possible things that can drive the bus, 1 chip per bus.

Later we discuss shortcuts that may require fewer chips.

74181
Like many historically important commercial computers, many home-brew CPUs use some version of the 74181, the first complete ALU on a single chip. (Versions of the 74181 include the 74F181, the 40181, the 74AS181, the 72LS181, the 74HCT181, etc.). The 74181 is a 4-bit wide ALU can perform all the traditional add / subtract / decrement operations with or without carry, as well as AND / NAND, OR / NOR, XOR, and shift.

A typical home-brew CPU uses 4 of these 74181 chips to build an ALU that can handle 16 bits at once, like the Data General SuperNova. The simplest home-brew CPUs have only one ALU, which at different times is used to increment the program counter, do arithmetic on data, do logic operations on data, and calculate addresses from base+offset.

Some people who build TTL CPUs attempt to "save chips" by building that one ALU of less than the largest word size (which is often 16 bits in TTL computers). For example, the earliest Data General Nova computers used a single 74181 and processed all data 4 bits at a time. Unfortunately, this adds complexity elsewhere, and may actually increase the total number of chips needed.

The simplest 16-bit TTL ALU wires the carry-out of each 74181 chip to the carry-in of the next, creating a ripple-carry adder.

Historically, some version of the look ahead carry generator 74182 was used to speed up "add" and "subtract" to be about the same speed as the other ALU operations.

Historically, some people who built TTL CPUs put two or more independent ALU blocks in a single CPU -- a general-purpose ALU for data calculations, a PC incrementer, an index register incrementer/decrementer, a base+offset address adder, etc.

We discuss ripple-carry adders, look-ahead carry generators, and their effects on other parts of a CPU at Microprocessor Design/Add and Subtract Blocks.

alternatives to 74181
Some people find that '181 chips are becoming hard to find.

Quite a few people building "TTL CPUs" use GAL chips (which can be erased and reprogrammed). A single GAL20V8 chip can replace a 74181 chip. Often another GAL chip can replace 2 or 3 other TTL chips.

Other people building "TTL CPUs" find it more magical to build a programmable machine entirely out of discrete non-programmable chips. Are there any reasonable alternatives to the '181 for building an ALU out of discrete chips? The Magic-1 uses 74F381s and a 74F382 ALUs; is there any variant of the '381 and '382 chips that are any easier to find than a '181? ... the 74HC283, 74HCT283, MC14008 chips only add; they don't do AND, NAND, etc. ...

Many commercial machines, such as the Data General Nova 4, used four AM2901 ALUs "in parallel" to build each 16 bit ALU. Alas, these are apparently even harder to find than the 74181.

One could build the entire CPU -- including the ALU -- out of sufficient quantities of the 74153 multiplexer.

One designer "built-from-scratch" a 4-bit ALU that does add, subtract, increment, decrement, "and", "or", "xor", etc. -- roughly equivalent to the 4-bit 74181 -- out of about 14 simple TTL chips: 2-input XOR, AND, OR gates.

Another designer has posted a 8-bit ALU design that has more functionality than two 74181 chips -- the 74181 can't shift right -- built from 14 complex TTL chips: two 74283 4-bit adders, some 4:1 mux, and some 2:1 mux.

The designers of the LM3000 CPU have proven that much of the 74181 is actually unnecessary. The 8 bit "ALU" in the LM3000 can't actually do any logical operations, only "add" and "subtract", built from two 74LS283 4-bit adders and a few other chips. Apparently those "logical" operations aren't really necessary.

The MC14500B Industrial Control Unit has even less functionality than the LM3000 CPU. It is arguable that the MC14500B has close to the minimum functionality to even be considered a "CPU". The MC14500B is perhaps the most famous "1-bit" CPU.

All of the earliest computers and most of the early massive parallel processing machines used a serial ALU, making them "1-bit CPUs".

solderless breadboard approach
Solderless breadboards are perhaps the fastest way to build experimental prototypes that involve lots of changes.

For about a decade, every student taking the 6.004 class at MIT was part of a team -- each team had one semester to design and build a simple 8 bit CPU out of 7400 series integrated circuits. These CPUs were built out of TTL chips plugged into several solderless breadboards connected with lots of 22 AWG (0.33 mm2) solid copper wires.

wire-wrap
Traditionally, minicomputers built from TTL chips were constructed with lots of wire-wrap sockets (with long square pins) plugged into perfboard and lots of wire-wrap wire, assembled with a "wire-wrap pencil" or "wire-wrap gun".

stripboard
More recently, some "retrocomputer" builders have been using standard sockets plugged into stripboard and lots of wire-wrap wire, assembled with solder and a soldering iron.

Tools
Logisim is a free logic simulator which permits digital circuits to be designed and simulated using a graphical user interface.

Design Tips
There are many ways to categorize CPUs. Each "way to categorize" represents a design question, and the various categories of that way represent various possible answers to that question that needs to be decided before the CPU implementation can be completed.

One way to categorize CPU that has a large impact on implementation is: "How many memory cycles will I hold one instruction before fetching the next instruction?"
 * 0: load-instruction on every memory cycle (Harvard architecture)
 * 1: At most 1 memory cycle between each load-instruction memory cycle ( load-store architecture )
 * more: some instructions have 2 or more memory cycles between load-instruction memory cycles (memory-memory architecture)

Another way to categorize CPUs is "Will my control lines be controlled by a flexible microprogramming, a fixed control store, or by hard-wired control decoder that directly decodes the instruction?"

The load-store and memory-memory architectures require a "instruction register" (IR). At the end of every instruction (and after coming out of reset), the next instruction is fetched from memory[PC] and stored into the instruction register, and from then on the information in the instruction register (directly or indirectly) controls everything that goes on in the CPU until the next instruction is stored in the instruction register.

For homebrew CPUs, the 2 most popular architectures are:
 * direct-decode Harvard architecture
 * flexible microprogramming that supports the possibility of memory-memory architecture.

Another way to categorize CPUs is "How many sub-states are in a complete clock cycle?"

Many textbooks imply that a CPU has only one clock signal -- a bunch of D flip-flops each hold 1 bit of the current state of the CPU, and those flip-flops drive that state out their "Q" output. Those flip-flops always hold their internal state constant, except at the instant of the rising edge of the one and only clock, where each flip-flop briefly "glances" at their "D" input and latches the new bit, and shortly afterwards (when the new bit is different from the old bit) changes the "Q" output to the new bit.

Single clock signals are nice in theory. Alas, in practice we can never get the clock signal to every flip-flop precisely simultaneously -- there is always some clock skew (differences in propagation delay). One way to avoid these timing issues is with a series of different clock signals. Another way is to use enough power and carefully design a clock distribution network (perhaps in the form of an H tree) with timing analysis to reduce the clock skew to negligible amounts.

Relay computers are forced to use at least 2 different clock signals, because of the "contact bounce" problem.

Many chips have a single "clock input" pin, giving the illusion that they use a single clock signal -- but internally a "clock generator" circuit converts that single external clock to the multiple clock signals used by the chip.

Many historically and commercially important CPUs have many sub-states in a complete clock cycle, with two or more "non-overlapping clock signals". Most MOS ICs used dual clock signals (a two-phase clock) in the 1970s

shortcuts
Building a CPU from individual chips and wires takes a person a long time. So many people take various shortcuts to reduce the amount of stuff that needs to be connected, and the amount of wiring they need to do.
 * 3-state bus rather than 2-state bus often requires fewer and shorter connections.
 * Rather than general-purpose registers that can be used (at different times) to drive the data bus (during STORE) or the address bus (during indexed LOAD), sometimes it requires less hardware to have separate address registers and data registers and other special-purpose registers.
 * If the software guy insists on general-purpose registers that can be used (at different times) to drive the data bus (during STORE) or the address bus (during indexed LOAD), it may require less hardware to emulate them: have all programmer-visible registers drive only one internal microarchitectural bus, and (at different times) load the microarchitectural registers MAR and MDR from that internal bus, and later drive the external address bus from MAR and the external data bus from MDR. This sacrifices a little speed and requires more microcode to make it easier to build.
 * Rather than 32-bit or 64-bit address and data registers, it usually requires less hardware to have 8-bit data registers (occasionally combining 2 of them to get a 16-bit address register).
 * If the software guy insists on 16-bit or 32-bit or 64-bit data registers and ALU operations, it may require less hardware to emulate them: use multiple narrow micro-architectural registers to store each programmer-visible register, and feed 1 or 4 or 8 or 16 bits at a time through a narrow bus to the ALU to get the partial result each cycle, or to sub-sections of the wide MAR or MDR. This sacrifices a little speed (and adds complexity elsewhere) to make the bus easier to build. (See: 68000, as mentioned above)
 * Rather than many registers, it usually requires less hardware to have fewer registers.
 * If the software guy insists on many registers, it may require less hardware to emulate some of them (like some proposed MMIX implementations) or perhaps all of them (like some PDP computers): use reserved locations in RAM to store most or all programmer-visible registers, and load them as needed. This sacrifices speed to make the CPU easier to build. Alas, it seems impossible to eliminate all registers -- even if you put all programmer-visible registers in RAM, it seems that you still need a few micro-architectural registers: IR (instruction register), MAR (memory address register), MDR (memory data register), and ... what else?
 * Harvard architecture usually requires less hardware than Princeton architecture. This is one of the few ways to make the CPU simpler to build *and* go faster.

Harvard architecture
The simplest kinds of CPU control logic use the Harvard architecture, rather than Princeton architecture. However, Harvard architecture requires 2 separate storage units -- the program memory and the data memory. Some Harvard architecture machines, such as "Mark's TTL microprocessor", don't even have an instruction register -- in those machines, the address in the program counter is always applied to the program memory, and the data coming out of the program memory directly controls everything that goes on in the CPU until the program counter changes. Alas, Harvard architecture makes storing new programs into the program memory a bit tricky.

microcode architecture
See Microprocessor Design/Microcodes.

Assembly Tips
...

""I don't recommend that anybody but total crazies wirewrap their own machines out of loose chips anymore, although it was a common enough thing to do in the mid- to late Seventies". -- Jeff Duntemann"

Programming Tips
...

reviews

 * Everyone who builds a CPU from "real" hardware (relays, TTL chips, FPGAs, vacuum tubes, etc.) is encouraged to add their design to the home-built computers web-ring.
 * Pavel Dovgalyuk. "Comparison of modern relay computers".
 * Svarychevski Michail Aleksandrovich. "Homemade CPU – from scratch". Briefly compares a few notable hobbyist-built CPUs.
 * Andrew Holme. other homemade CPUs
 * yet more homemade CPUs

relay computers

 * "History of Relay Computers" (jhallen) lists several relay CPUs.
 * "relaysbc: Single Board Relay Computer/Trainer" (jhallen) (83 relays, all identical DPDT DIP relays. CPU registers implemented with edge-triggered D flip-flops implemented with just 1.5 DPDT relays / bit.)
 * Harry Porter's Relay Computer (415 Relays, all identical 4PDT) ("RC1")
 * "RC-3 Relay Computer" (418 relays, all identical 4PDT. 421 lights and 134 switches on its front panel. Runs at 6 Hz). RC-3 Relay Computer (background). RC-3 Relay Computer (technical details).
 * "Relay Computer Two" by Jon Stanley (281 relays, of 2 types: 177 SPDT, and 104 4PDT) ("RC2")
 * "Relay Binary Adder" by Jon Stanley. "a simple 4-bit relay adder with two 4-bit input storage/registers." Shows a way to build a 1-bit memory cell with 1 relay, a 1-bit half adder with 1 DPDT relay, and a 1-bit full adder with 2 relays.
 * "i2 8-Bit Relay Computer" (about 300 relays, of 2 types: single-pole and double-pole, plus 2 kB static RAM for memory) by ???. The i2 instruction set is a modified version John Stanley's RC2 ISA.
 * Zusie - My Relay Computer by Fredrik Andersson (uses around 330 relays, of 2 types: 4-pole and 6-pole double-throw relays, plus ~30 integrated circuits for RAM and microcode)
 * relay computers by Kilian Leonhardt (in German): a "large computer" with around 1500 relays and a program EEPROM, and a "small computer" with 171 relays.
 * DUO 14 PREMIUM by Jack Eisenmann (around 50 relays, including 4 addressable "crumbs" of RAM where each crumb is 2 bits, plus 48 bits of program ROM in 6x8-switch DIP switches. The only semiconductor components: 555 timer, decade counter, and transistors in the clock generator. Each command has 6 bits, and the 8 commands in the program ROM are selected by a 3-bit program counter).
 * Z3 (computer), designed by Konrad Zuse, the world's first working programmable, fully automatic computing machine. built with 2,000 relays.
 * Z3 Nachbau, Horst Zuse's (Konrad Zuse's son) and Raul Rojas' 2001 reconstruction of the classic Z3. The 32-word, 22-bit-wide memory is also constructed entirely from relays, about 700 relays. (in German)
 * Horst Zuse's new Z3 reconstruction: Created 2010 for the 100 year anniversary of Konrad Zuse's birth. About 2500 modern relays. (in German)
 * Rory Mangles. Tim 7: A 4-bit relay CPU with the program stored on punch tape
 * Rory Mangles. Tim 8: "one of the smallest Turing complete relay computers in the world by relay count" an 8-bit relay CPU with the program stored on punch tape, data stored in discrete capacitors (!) (no RAM chips) with one relay pole per byte; uses 152 relays, most of them single-pole.
 * Pavel Dovgalyuk. A fistful of relays. Relay computer built of 4PDT relays.

discrete transistor computers

 * James Newman. The Mega-processor. "put LEDs on everything so we can actually SEE the data moving and the logic happening." No integrated circuit; only LEDs and resistors and about 14,000 (?) discrete transistors (2N7000 in through-hole TO-95 package ?) in the functional part of the CPU.
 * MT15 by Dieter Mueller is built almost entirely out of (around 3000) individual SMT transistors ... also has some essays on microprogramming and ALU design.
 * The Q1 Computer by Joe Wingbermuehle. Built almost entirely out of (3105) individual through-hole PN2222A transistors. "Clock phases are used so that transparent latches can be used for registers to reduce transistor count at the price of speed." 8 bit data bus, 16 bit address bus.
 * Svarichevsky Mikhail is apparently building a processor entirely out of discrete transistors. Using very careful analog tuning (12 resistors of various values), Svarichevsky Mikhail has developed a 4 transistor full adder: "BARSFA - 4-TRANSISTOR FULL ADDER". (Are the 4 Schottky diodes -- across the base and collector of each transistor -- really necessary, or just to improve performance?) (He also shows a canonical implementation of a CMOS full adder, requiring 28 transistors).
 * Simon Inns. "4-Bit Computer" shows a 4-bit adder built entirely from AND, OR, NOT gates in turn built entirely from discrete NPN transistors and resistors. Toggle switches for the "A" and "B" 4-bit inputs; 5 LEDs to output the sum (including carry bit). (A 22 transistor full adder).
 * Rory Mangles. Tiny Tim: diode-transistor logic (DTL); 400 2N3904 NPN Transistors plus diodes, resistors, capacitors, etc. gives "2700 components" (?). Has 4 registers: a Working Register (8 bit), Instruction Register (8 bit), Address Register (12 bit), Program Counter (12 bit), and a sequencer. (Also uses some Zero Page "Registers" stored in the SRAM chip).

pneumatic computers

 * "8 bit processor using logic gates made of pneumatic valves" by Minsoung Rhee and Mark Burns

K'nex computers
??? do these really count as "processors" ???
 * "The K'nuter - K'NEX Computer"
 * "K'nex Computer"

TTL computers

 * "TTL computers on Hackaday" and "Hackaday TTLers" show many people constructing their own CPU out of TTL integrated circuits.

Homebrew CPUs built from TTL chips include: (In no particular order -- should we sort these by # of ICs ?)

 * Alastair Hewitt’s "Novasaur CP/M TTL Retrocomputer"; see "Surfing the web with 7400 logic".
 * A Minimal TTL Processor for Architecture Exploration by Bradford J. Rodriguez (aka PISC, the Pathetic Instruction Set Computer)
 * Apollo Guidance Computer (AGC)
 * V1648: (16 bit data) (48 bit address bus?)
 * "the Ultimate RISC" and "the Minimal CISC"
 * alt.comp.hardware.homebuilt FAQ
 * Mark's TTL microprocessor (uses only 8 chips ... "Without using the two PALs I used, it would be 16 chips.") (is there a better URL for this?)
 * DUO Compact by Jack Eisenmann: The DUO Compact CPU was built out of 22 integrated circuit chips, including 2 EEPROMS for microcode and 1 EEPROM for boot ROM. It has some nice features -- a unified address space (16 bit address bus, 8 bit data bus); programs can run out of the boot ROM or the data RAM; memory-mapped I/O; etc. Also some odd features -- the instruction pointer is reloaded to a literal "next" value in every instruction -- it's not really a "program counter", because the CPU lacks the hardware to "count" or "increment" a value directly.
 * "Prehistoric Cpu's & Octal Amps" (18 bit data bus? 24 bit data bus?)

 * "Viktor's Amazing 4-bit Processor" ... can re-program in-circuit using manual switches. About 90 chips.
 * Galactic 4 bit CPU by Jon Qualey. Two, 2716 EPROMs are used to store the micro-instruction code and two, 2114 static RAMs are used for program memory. 25 ICs in all, 74LS TTL.
 * LM3000 CPU designed and built by five students at Bennington College, Vermont, using fifty-three integrated circuits.
 * The D16/M by John Doran is a 16-bit digital computer implemented with SSI and MSI HCMOS integrated logic and constructed using wire-wrap techniques. Its timing and control unit is microprogrammed (fully horizontal, with a 72-bit control word).
 * (FIXME: who?) has built a MC14500 clone out of (TTL) discrete logic. (FIXME: who else?) has built a MC14500 clone on a FPGA.
 * TANACOM-1 by Rituo Tanaka is a 16-bit TTL minicomputer built with a total of 146 ICs, including 4 SN74181s and a 74182 in the ALU.

 * BMOW 1 (Big Mess o' Wires) by Steve Chamberlin is an 8 bit CPU built from discrete 7400-series logic, and a few 22V10 and 20V8 GALs. All the digital electronics on a single large Augat wire-wrap board to interconnect the 50 or so chips. BMOW 1 contains roughly 1250 wires connecting the components. All data busses are 8 bit; the address bus is 24 bit. 3 parallel microcode ROMs generate the 24 bit microcode word. VGA video output is 512×480 with two colors, or 128×240 with 256 colors. The microcode emulates a 6502 (more or less). Uses two 4-bit 74LS181s to form the core 8 bit ALU.
 * Steve Chamberlin. "Nibbler 4 Bit CPU". 12-bit address space. 16 x 2 character LCD display, buzzer, pushbutton inputs. 13 standard 7400-series logic chips + 2 EEPROMs for microcode + 1 program EEPROM + 1 data 4K x 4 SRAM, a total of 17 chips + a 2-line LCD and a few buttons wire-wrapped together on a 5 inch x 4 inch perfboard. "Nibbler Demos!".
 * "a proprietary 8-bit engine built out 3 PROM's and a few dozen TTL chips" as described by Jeff Laughton.
 * "One-bit Computing at 60 Hertz": a tiny computer made from an EPROM and a few logic chips; designed by Jeff Laughton.
 * "Bride of Son of Cheap Video - the KimKlone": TTL chips and a EPROM add extra programmer-visible registers and instructions to a microcontroller (a 65C02).
 * The MyCPU - Project: "everybody is invited to participate and contribute to the project." The CPU is built from 65 integrated circuits on 5 boards. 1 MByte bank switched RAM. Originally developed by Dennis Kuschel. Apparently several MyCPU systems have been built? One MyCPU system runs a HTTP web server; another MyCPU system runs a (text-only) web browser).
 * HJS22 - a homebrew TTL computer. Nice front panels with lots of lights and switches.
 * The Electronics Australia EDUC-8 microcomputer: "one of the first build-it-yourself microcomputers". "The internal implementation is bit-serial which gives good economy of components as most data paths are only 1 bit wide."
 * "Learning to Build a Processor" shows some nice photos of early stages in a TTL CPU built on solderless breadboards.
 * Kyle Hovey. "How to Build an 8-Bit Computer"; "8_bit_spaghetti". A TTL CPU built on solderless breadboards with 11 types of 74LSxx chips.

 * Albert Malvino and Jerald Brown. In their book "Digital Computer Electronics" (1993), they describe the "SAP-1 Simple As Possible" processor.
 * Pong Guy has posted the SAP-1 schematics online
 * Alas, several of the parts used by the original SAP-1 are apparently no longer being manufactured. Pong Guy describes a few replacements that allow you to build a SAP-1 using parts that are still being manufactured.
 * Pong Guy discovered that replacing the SAP-1 hard-wired "control matrix" with a microcode ROM reduces the total number of ICs from 48 to 35.
 * Pong Guy suggests adding bit-shifting to the CPU by replacing a (74HC173) D flip-flop register with a (74HC194) bidirectional shift register.

 * Pong Guy. "ASAP-3 - Almost Simple As Possible Computer 3". Pong Guy designed an 8-bit computer, from 55 discrete TTL logic chips (including the RAM and program ROM chips). ASAP-3 schematics. Pong Guy also designed a nicely laid-out PCB to hold those 55 chips, the oscillator, a 10-digit LED display + 2-line LCD display, a 22-button keyboard and some toggle switches. ASAP-3 emulates much of the 8085 instruction set. Runs at over 500kHz. Inspired by the "SAP-1 Simple As Possible microprocessor".

 * John Peterson. "Wire-wrap Days". describes an "intense" hardware lab class building a working computer with serial I/O, lights and switches front panel, and 8-bit CPU entirely from 74Cxx chips, some 2716 UV erasable ROMs, and some SRAM. (The architecture is very close to the a PDP-8, using the URBUS bus similar to the PDP-11 Unibus).
 * Drs. Gugel and Schwartz. "G-CPU"
 * "Homebrew CPUs/Low Level Design" recommends a few books with low-level TTL CPU design information.

 * Randy Thelen. Mippy (millions of instructions per year) is a 1MHz, 16 bit Forth machine built from scratch using 74HCT00 series TTL chips. The data bus and address bus are separate, each 16 bits wide.

Commercial minicomputers built from TTL chips include:

(What ALU did this Tandem/16 use? the 74181?)
 * the Tandem/16 (NonStop I) was initially implemented by standard low-density TTL chips. It has high-availability features that are still relevant today.

(What ALU did this Tandem/16 use? the 74181?)
 * the TS-1, the first commercial implementation of the HP PA-RISC architecture, was built from discrete 74F TTL chips. The 32-bit CPU was spread over 6 boards with about 150 chips on each 8.4" x 11.3" board. Those six TS-1 boards implement the processor, a 4096-entry TLB, 64 KB (L1) instruction cache, and 64 KB (L1) data cache.

(What ALU did this Kenback-1 use? the 74181?)
 * the Kenback-1

 * the Datapoint 2200 included an 8-bit CPU made from standard TTL components.

(What ALU did the Nova use? the 74181?)
 * the Data General Nova included perhaps the first (?) CPU on a single PCB. Its "16-bit" (although it funneled calculations through a 4-bit math unit) CPU fit on a single 15" x 15" PCB.

 * The RCA 1802 "COSMAC" processor first prototype, FRED, was designed by Joseph Weisbecker and built at his home from 100 TTL chips.

 * The Cray-1 was the first Cray design to use integrated circuits. It used only 4 different IC part numbers: [FIXME: specifically which numbers?] an ECL NOR gate, a MECL NOR gate, 16x4-bit SRAM for registers, and 1024x1-bit SRAM for main memory.

 * The book "The Soul of a New Machine" by Tracy Kidder describes the design process of the computer code-named "Eagle", later called the Data General Eclipse MV/8000. The Eagle was the first DG computer to use programmable logic chips (PALs). Perhaps the first PALs used in any commercial computer?

 * The original VAX 11/780 was implemented in TTL and filled a four-by-five-foot cabinet with a single CPU. The VAX CPU was spread across 27 PCBs.

 * The 32-bit 20-MIPS DECWRL "Titan" processor was built from "100K ECL" MSI parts on four large boards.

title: Microprocessor Design/Wire Wrap


text:
User talk:213.42.21.59

Thanks for the formatting work! Ewen (talk) 10:35, 18 January 2008 (UTC)

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

title: User talk:213.42.21.59


text:
BASIC Programming/Subroutines and Functions

Introduction
Functions and Subroutines are lines of code that you use more than once. The purpose of functions and subroutines is to save time and space by just calling a function/subroutine. There is hardly a difference between the two, except that a function returns a value, where a subroutine just repeats lines of code (A function is not always used more than once).

An example of a function, say you are making a program that calculates sales tax. The function would ask for a subtotal, take that number and multiply it by 1.07 (If sales tax is 7%, the 1 is because you are adding onto the subtotal to make a total, not finding the sales tax itself). The function would take the new total and give it back to the program.

A subroutine would be code that is reused, like a shop in a game. Every time the user goes to the shop, the program will go back to the Shops Subroutine, and if the user bought an item, it would call a "Buy Item" function.

Parameters
Parameters are used in functions and subroutines. They pass data to be used with the function/parameter. For use with our two examples:

Function Parameters) The Subtotal passed to the function is a parameter.

Subroutine Parameters) The player's amount of gold could be sent to the subroutine so the shop knows how much money the player can spend.

There are two different ways to send parameters: by the value or by reference. By Value means that the function can not actually change the data outside of the function, but can use its data to manipulate other data that is returned. By Value is like making a carbon copy of a paper and then editing the carbon copy. By Reference sends the actual argument (parameter) to the function/subroutine, which is like editing the original copy of the paper. By Value is written as ByVal and By Reference is written as ByRef.

Functions
Ignore the line numbers; they are used for explaining the code.

Example 1 (FreeBASIC)

1. This line is the function's prototype. Functions must be declared as a prototype before they are used, and must be defined after the end (of the program) statement. Function means that the following is related to functions. salesTax is the function identifier or its name, and in parentheses are the parameters (If you have more than one parameter, separate them with a comma). After the parentheses tells what Data Type the function returns. Double is a Data Type that signifies a number with decimals (00.00).

2. Create the SubTotal2 variable (Parameters can not be the same as existing identifiers).

3. Create the Total2 variable.

4. Define SubTotal2 with the value 10.00 (Change this to get new outputs)

5. Define Total2 by passing SubTotal2 as an argument(parameter) to the function salesTax (The value of Total2 will be what the function returns).

6. Display the subtotal.

7. Display the total.

8. Wait for the user to press enter (So you can read the output with out it flashing away in a second).

9. End the program (In a sense. You can't interact with the user past the End point)

10. Blank Line, easier to read the code.

11. This is where you define the function, earlier you declared the function.

12. Create the variable Total (This variable can only be used in the function, because it was defined in the function. This is called the variable scope).

13. You do not need to declare subTotal, because it was defined as a parameter, this math finds the total with sales tax and assigns it to the variable Total.

14. This is what line 5 receives, the function shoots out the variable Total.

15. Ends the function definition.

Purpose:

To branch to, and return from, a subroutine. Syntax:

Comments:

line number is the first line number of the subroutine.

A subroutine may be called any number of times in a program, and a subroutine may be called from within another subroutine. Such nesting of subroutines is limited only by available memory.

A RETURN statement in a subroutine causes GW-BASIC to return to the statement following the most recent GOSUB statement. A subroutine can contain more than one RETURN statement, should logic dictate a RETURN at different points in the subroutine.

Subroutines can appear anywhere in the program, but must be readily distinguishable from the main program.

To prevent inadvertent entry, precede the subroutine by a STOP, END, or GOTO statement to direct program control around the subroutine. Examples:

The END statement in line 30 prevents re-execution of the subroutine.

Conclusion
Subroutines do not return any values, while functions return values. Subroutines are also allowed to change values of the parameters while functions are supposed to maintain.


text:
Minimizing Hard Disk Drive Failure and Data Loss

While every hard disk drive can eventually be expected to fail, some preparation and practical information can be used to minimize this failure, and to avoid data loss when failure is likely.

Contents

 * 1) Introduction
 * 2) Environmental Control
 * 3) Electricity Control
 * 4) Stress Control
 * 5) Detecting an Impending Drive Failure
 * 6) Data Redundancy
 * 7) Data Reduction
 * 8) Drive Life-Cycle Management
 * 9) Additional Measures
 * 10) /Case Study/
 * 11) /Popdisk/
 * 12) /Recovering Data After a Hard Disk Drive Failure/
 * 13) Reference


text:
User:Zirland

w:cs:User:Zirland

title: User:Zirland


text:
Talk:Minimizing Hard Disk Drive Failure and Data Loss

Human error protection
I've moved the following text from the article here. I've compacted and incorporated the ideas behind it in the sections on revision control and on managing backups and revisions. I think it is important that the article stays compact, and that information available in Wikipedia is not duplicated here.

 * It is all too easy to accidentally delete a file, or to accidentally delete parts of a file.

 * Many system administrators set up a file server that archives earlier versions of useful files.

 * The user at his computer (perhaps using a revision control GUI like TortoiseSVN or a periodic cron program on the file server (perhaps using something like the "backup" option of Unison installed on the user's computer) periodically copies the latest version from the user's computer to the file server.

 * Most such systems skip any files that have not changed, and compress the changes of files that have changed, such that storing 100 versions of a file folder, each version slightly different from the next, takes only a little more storage than storing only 1 version of that file folder.

 * The key to preventing data loss is that the file server itself is set up in such a way that normal users (or any virus running on the user's machine) can't accidentally (or deliberately) delete or change files on the file server.

 * Some system administrators set things up so obsolete versions are eventually purged. For example, a system administrator might make sure that today's version will still be accessible a month from now, by setting up a cron job that periodically scans the archive, keeping at least 1 version more than a month old, and automatically purging any versions older than that.

 * (Don't delete *every* version more than a month old; that's a common backup mistake. For example, the banner graphic file referenced by every page on a company's website -- often that file that hasn't changed in years. If I accidentally damage it, and then that damaged version gets saved in the archive, I'm going to be upset if I can't revert to "yesterday's version" because the system automatically purged that "obsolete 2-year-old version").

--Antibogon (talk) 19:16, 5 April 2008 (UTC)

Condensation control
The 'Condensation control' section says condensation occurs when something is moved from a cold to a warm place, so from outdoors to indoors. But isn't that the other way around? Cold air holds less water, so it condensates. So the condensation occurs not when you bring a computer back in, but earlier, when you bring it out. I am fairly sure of this, but not sufficiently so to change the article. Oh, hold on, if the computer has been outside for some time and is then brought inside, the cold metal will cool the air and cause condensation. Just like when you blow against a cold window. So it can be one of two effects, or both, depending on the circumstances. Right? DirkvdM (talk) 07:48, 1 August 2008 (UTC)

 * Thanks for bringing up the concern. The information I previously entered in the article was roughly obtained from another web article, the link to which I unfortunately cannot currently recall.

 * I'm certain that condensation will occur in the latter case when the computer is brought inside. About this, as per the Wikipedia article on condensation, water vapor will only condense onto another surface when the temperature of that surface is cooler than the temperature of the water vapor.

 * About your point "cold air hold less water", the Wikipedia article on dew point states that the claim "cold air cannot hold as much water as warm air" is only superficially true. It seems that the physics involved is complex, and at this time I really don't know what to make of this event of taking the computer outside. It is by no means certain that condensation will happen, or that it'll damage the hard drive even if it does happen. One easy way to answer the question may be to run several limited experiments. I will update this post if I learn anything new and concrete with regards to this matter. Until then, I will by no means be taking my laptop outside in the winter without it being in its case.

 * --Antibogon (talk) 03:43, 4 August 2008 (UTC)

Temperature control
There are 2 sections in this book that talk about the effects of temperature on hard drives: minimizing hard disk drive failure and data loss and minimizing hard disk drive failure and data loss. One section implies that cooling is good for hard drives. The other section says that cold drives have a higher failure rate than hot drives, implying that cooling is bad for hard drives.

Could we somehow merge those sections together into one section -- perhaps "controlling the temperature of hard drives"? --DavidCary (talk) 03:54, 2 November 2008 (UTC)

 * Thanks for your feedback. I have now done a preliminary merge of the two sections into a single large section on temperature control.
 * The details, as mentioned in the article, are important and shouldn't be overlooked. By and large, cooling is indeed important, as mentioned in the first part. I'm not so sure that the second part implies that cooling is bad; instead it prescribes having finer control, beyond the simple notion of hot versus cool.
 * I would welcome any further comments you may have. --Antibogon (talk) 02:32, 7 November 2008 (UTC)

 * Good job merging the sections.
 * It seems obvious that "cooling is indeed important". However, is there any evidence for this? Usually when we make measurements, the results are about what we expected. However, occasionally we are surprised by counter-intuitive results. Do we reject and ignore all measurements that don't match our preconceived biases? The Google measurements show that, the further the average temperatures is below 38 C, the higher the failure rate. What other implication can I draw other than "cooling below an average temperature of 38 C is bad" ? --DavidCary (talk) 08:30, 23 March 2009 (UTC)

 * Doesn't heat increase friction and wear and tear? We know the mean temperatures, yes, but do we know anything about the actual distributions of temperatures in the Google study, or are we simply assuming they were gaussian? Is the Google study the only study in this regard? I find it safe to assume that there have been studies with conflicting results in the past. Do we know what kind (makes and models) of drives Google used?
 * Based on the Google study, I personally find it safe to draw the conservative conclusion that I probably wouldn't want my drive running at less than 30C. I think air-based cooling is essential because without it the drives could easily be running in the mid 40s, and there's no way that internal air alone will bring the temperature below 30. --Antibogon (talk) 02:21, 24 March 2009 (UTC)

 * Yes, in theory I expected that heat would bad for hard drives. But in practice, the Google study says "In our study, we did not find much correlation between failure rate and either elevated temperature or utilization. It is the most surprising result of our study."
 * I'm looking on the graph on this page, "Minimizing hard disk drive failure and data loss". It shows the actual distribution of the mean temperatures of the hard drives studied. Or are you talking about the distribution of temperatures (over time) for any one hard drive? I can assure you I do not assume that was gaussian.
 * If there have been *any* other studies, I don't care whether their results are conflicting or not, *please* add a reference to those studies to this book.
 * I agree that, based on the Google study, I don't want my drives running at less than 30 C.
 * I agree that, in theory, it seems unlikely that air cooling will bring the temperature below 30 C. However, I see that same graph shows that over half of Google's hard drives had an average temperature below 30 C. Are you assuming that Google cools their hard drives using some kind of liquid cooling? --DavidCary (talk) 04:49, 30 March 2009 (UTC)
 * Google using liquid cooling? Entirely possibly, but I wouldn't bet on it - they're more likely to use air-cooled blade servers.
 * However, a lot of this may be a moot point. The computer needs to be cooled anyways, and most standard cooling systems are not going to get your HD into the lower ranges you're referring to. This of course depends on the hardware, but I'm not sure it's worth spending lots of time discussing in the text. — Mike.lifeguard | talk 16:27, 20 November 2009 (UTC)

Generalizing Google's results
Generalizing the results of the Google study to all HDDs would imply the assumption that the distribution of SMART values of HDDs used in the Google study and the distribution of SMART values of HDDs in general is the same. This assumption however is not entirely true, because: Having said this, as is obvious, the results would translate better to data centers that use mixed drives. --Antibogon (talk) 00:31, 29 March 2009 (UTC)
 * Google's HDDs probably have a very high uptime, whereas desktop HDDs probably don't.
 * Google's HDDs had temperature distributions that are possibly different from those of HDDs in other places, including many data centers.
 * Google used those HDDs in the study that didn't have infant mortality.
 * There are probably big differences in reliability of the HDDs of different manufacturers.

By "not true", are you saying that you have data that shows that other hard drives definitely do act differently than Google's HDDs? Or are you merely speculating that that they *might* act differently?

However,
 * Yes, Google's HDDs are turned on and spinning essentially all the time.
 * Yes, the temperature swings of Google's HDDs are probably very different desktop HDDs and even more different from laptop HDDs.
 * Yes, the Google study notes that different manufacturers had different "age-related results".
 * I assume that Google's data centers the same temperature distribution as other data centers. (Do you have any reason to think differently?)
 * The Google study specifically says that, even though it does not include infant mortality that occurs during the burn-in stress test, "our data should be consistent with what a regular end-user should see, since most equipment manufacturers put their systems through similar tests before shipment."
 * The Google study reports that "None of our SMART data results change significantly when normalized by drive model. The only exception is seek error rate, which is dependent on one specific drive manufacturer, ..."

Therefore, since Google specifically says that the SMART data results are the same for every manufacturer, it seems reasonable to me to assume that the results of the Google study are valid for all data centers. Including data centers that use all-one-manufacturer as well as data centers that use mixed drives. I would be very surprised if a data center's HDDs act differently than Google's HDDs.

Since I know of no contradictory information, it seems reasonable to me to assume that their results are also valid for desktop HDDs and laptop HDDs. Although I would be less surprised to learn that those HDDs act differently than Google's HDDs. --DavidCary (talk) 04:44, 30 March 2009 (UTC)

delta T
Neither the Google paper or other papers about this subject give attention to delta T, as opposed to absolute T, which is reported in the study. That delta T is a larger factor in drive failure is supported directly bu Google's study, in that lower temperature was associated with failure.

A machine, whether desktop PC or SAN (ambient temperature is not relevant) can be viewed as an enclosed system, where a volume of its surrounding air comprises the out-most surface of the system. By itself, this may not create an important thermal layer its presence may not come into effect.

A fact that is well-established by work in other areas shows that mechanical failure is the primary cause of failure in any electrical or electronic device. Consider a lightbulb as an example. Consumer data reported on boxes often rates a lamp in terms of hours. If you dig into engineering data you will find life-cycle data about the same lamp, to be measured in on-off cycles, not in hours of operation. The association between on-off cycles and change in temperature (delta T) should be straight forward -- the lamp is at higher T while powered and lower T while not powered. Thus, delta T increases in number as the lamp is turned from off to on, back to off, and is repeated over many cycles. In a lamp, metal that is part of the filament is ionized when power is turned on, as a function of the heat that is generated while electrons pass through it. When power is removed the energy level of the ionized atoms falls and most of the ionized metal returns to the filament. THe remaining metal is deposited on the inside of the glass lamp as residue.

While the lamp operates, and while it is off, its temperature is in steady-state. (While air currents may cause the lamp to change temperature slightly, from moment to moment, the change in temperature is negligible compared to the change in temperature that results during either power-up or power-down). Therefore, the length of time the lamp is in one state or the other is not a contributor to the build-up of residue. (Build-up of residue is directly related to loss of metal, from the filmanent, which is directly related to failure).

Semiconductor devices experience a similar life in that the n-p and p-n junctions within them, suffer as a result when the device changes temperatute. A semiconductor device is more likely to suffer from the loss of material than a tungsten lamp, so operation in an over-heated state is more likely to effect the semiconductor device. But operated within their specifications, the junctions will succomb to degradation in a manner similar to the filament of a tungsten bulb. As a result, the number of power cycles is a greater predictor of failure than is the time in operation.

The Google study reports on steady state condititions -- a logical use of data produced by SMART. Whether or not the Google data supports what I've written isn't likely to be obvious by reviewing the report itself, but it may be visible in the daw data used to by Google to support the report. As a matter of physics, or as a study of data collected by various manufacturing sectors, change in temperature a well-known contributor to failure and it is overlooked in the Google paper. However, examination of the temperature curve show greater area under the curve to the left, than to the right, where the center is taken as ambient for a given drive. This range correlates with the power-up and power-down cycles.

The characteristics of any system can include thermal conductivity. Thermal conductivity can be considered constant over certain, limited, temperature ranges. Exactly here the range causes this predictable parameter to fail in Google's study is uncertain but one thing does remain certain. It will fail, at least, in an area of temperature to the right of the center.

I've provided this for consideration by those who wish for a practical solution to drive-related problem, because it is empirically true and because most reports (all reports I've looked at) fall short of analyzing the effect of delta T. This is a shortcoming of the given report because the ubiquity of evidence about the effect of delta T is not hidden. If this is considered as removable information from Wikipedia, because no citations are offered, so be it. If one wishes to find relevant sources for it, they can be found. I hope it is useful to someone other than myself. Kernel.package (talk) 18:53, 20 October 2009 (UTC)

 * The article does have a section on power cycling control. --IO Device (talk) 17:19, 21 October 2009 (UTC)

Should text be split?
The template was recently added to the text. Should the text be split into smaller pages?

Personally I'm of the opinion that it should not be split at this time. One reason for this is that the individual sections are not very big, and are not expected to grow very much, given the limited historical growth. --IO Device (talk) 23:11, 26 November 2009 (UTC)

Advertising
Should a WikiMedia project really be promoting any particular (especially proprietary & commercial) software? I realise the benefit of giving examples, but in such cases Free (Libre/‘open source’) Software should be mentioned which removes the dubious nature of proprietary and/or commercial suggestions. As Jimmy Wales said, Free knowledge requires Free software, standards, and formats. — Lee Carré (talk) 14:45, 27 December 2010 (UTC)
 * Please specify the names of the software in question. I think mentioning freely usable proprietary software is fine, assuming there is no comparable open source alternative available. I am not in favor of including commercial software (that costs money) either. --IO Device (talk) 16:50, 2 January 2011 (UTC)

 * [Apologies for the very long delay.]

 * It seems that I had mistakenly added this entry to the main talk page, instead of for the specific sub-page. I, originally, was referring to the Case Study section, in which both Cobian BackUp and TransLogic are endorsed.

 * Proprietary software always has ethical entanglements by its very nature. Both upon the reader and the author. Particularly in the case of backups, which essentially comes down to copying of files for which no special (let alone proprietary) software is needed. Wikimedia, being a libre project, implies that the knowledge it imparts shouldn't require a reader to surrender their liberty in other contexts (especially on their own computer).

 * Commercial software is a different matter. Price is a mere practical concern. Your objection seems to exclude the possibility of non-gratis libre software.

 * I notice the use of certain buzz-terms, which may explain a few things. — Lee Carré (discuss • contribs) 17:35, 15 March 2021 (UTC)


text:
User:Pemdas

Jason Payne

Calculus

Algebra

Chemistry

title: User:Pemdas


text:
User:Emilie Scarlett

Hey my name is Emilie Ogden and I am in Physics 112. I am a junior at Clarion University majoring in Elementary Education. I currently work at Applebee's. I live with 7 roommates and they are my best friends. I have not had physics since the 10th grade so I forget a lot of what this class is about, but I look forward to learning about it again!

title: User:Emilie Scarlett


text:
Cookbook:Rustic Beer Bread

| Bread

This recipe makes dough for a 1.5 kg loaf of bread. It is intended for a bread machine but can also be made by hand.

Ingredients

 * 250 ml real ale (not lager), at room temperature (approx 21°C)
 * 3 tbsp (45 ml) sunflower oil
 * 2 tbsp (30 ml) malt extract
 * 1 tsp (5 ml) table salt
 * 150 g very strong (high-protein) white flour
 * 150 g country grain wholemeal flour
 * 70 g soft grain white flour
 * 70 g strong wholemeal flour
 * 2 tsp (5 ml) easy bake yeast

Bread Machine

 * 1) Add ingredients to a bread machine in the order listed, select appropriate white loaf setting (according to manufacturers instructions), and press start.
 * 2) Remove when cycle is complete. Cool and enjoy.

Hand Baking

 * 1) Mix the ingredients above into a dough, and knead on an unfloured surface until an smooth elastic dough is formed.
 * 2) Put into a greased baking tin or on a greased baking tray, cover with a dry towel and rest for approximately 1 hour.
 * 3) Place into a preheated oven at 180°C and bake for 20–40 minutes (baking times will change depending on altitude).

Notes, tips, and variations

 * 1) Use 1.5 tbsp (22.5 ml) demerara sugar instead of malt extract if you can't get hold of any.
 * 2) Reduce each flour measurement by 10 g and add 40 g loose polenta to add a different texture to the bread.
 * 3) Substitute bread flour for hard flour and/or pastry flour for soft flour.

title: Cookbook:Rustic Beer Bread


text:
Cookbook talk:Rustic Beer Bread

Location of page within Wikibooks
I do not know how to put this into the "Cookbook" section; any suggestions? DACS42 (talk) 14:33, 18 January 2008 (UTC)

Sans machine?
As with the basic bread, it'd be good to explain how to hand-make this bread as an alternative for people who don't have a breadmaker, or who just want to get their hands dirty. --Irrevenant (talk) 12:14, 9 July 2009 (UTC)

title: Cookbook talk:Rustic Beer Bread


text:
User talk:Jamsim86

Welcome!
Come introduce yourself at the new users page. If you have any questions, you can ask there or contact me personally.--Whiteknight (Page) (Talk) 15:15, 18 January 2008 (UTC)

title: User talk:Jamsim86


text:
User:Nick Rimer

Hello Everybody, my name is Nick Rimer. I am a senior here at Clarion University and I am taking Physical science mainly because It meets my requirments for a science course so I can graduate in May and be on my way to getting a job. I never had any physics courses or anything in high school. As a matter of fact I was told in high school with the courses I took mainly focusing on my interest in marketing and computers that I wouldnt even make it into college let alone last as long as I have. With that said I have made it almost the entire way through with a good grade point average and now I am facing physics for the first time and Im sure I will work hard enough to prove those people wrong.

title: User:Nick Rimer


text:
User:Dsolich45

Hello I'm Deanna and a Sophomore at Clarion. I like watching and participating in sports and just having a good times with friends and family. I'm looking forward to taking Physical Science this semester because I never had a Physics class before so I'm interested in learning what it is all about.

title: User:Dsolich45


text:
GRUB Installation After Windows Installation

GRUB Installation
Installation of GRUB is a two step process. The first step is to install or build GRUB in a host OS environment, and for this we will use Linux. The second step is to install and configure GRUB as the boot loader for your system.

Compile GRUB Source Code

The first step is the usual: download the source archive, untar it, configure and make install. Assuming you have found a source mirror (see the GRUB home page to find one) and downloaded the source distribution into a suitable working directory, continue with:

tar -xzvf grub-0.97.tar.gz cd grub-0.97 ./configure make make install

This should create the executables: grub, grub-install and mbchk; install support files in /usr/lib/grub/i386-pc/, and install the GNU information manual and man pages. For the second step of installation, we will first build and work with a GRUB bootable CD.

Preparing a GRUB Bootable CD

Follow the steps and build your GRUB Bootable CD

mkdir iso mkdir -p iso/boot/grub cp /usr/lib/grub/i386pc/stage2_eltorito iso/boot/grub mkisofs -R -b boot/grub/stage2_eltorito -no-emul-boot -boot-load-size 4 -boot-info-table -o grub.iso iso

Install GRUB on MBR

Reboot your system with “GRUB Installation CD”, after load stage1 you find a grub shell. Run the following command to find which partition of your system, Linux is installed.

grub>find /boot/grub/stage1

Suppose your Linux Distribution is installed on your first Primary partition, then the output is (hd0,1) then you install the GRUB on your Hard Disk Master Boot Record (MBR). The steps are as following.

grub>root (hd0,1) grub>setup (hd0) grub>quit

The GRUB Install process is now complete. Reboot your system.


text: VHDL for FPGA Design/State-Machine Design Example Serial Parity Generator


text: User talk:131.123.185.23

title: User talk:131.123.185.23


text: User talk:66.252.191.90

title: User talk:66.252.191.90


text:
User:SomeRandomEditorTest/monobook.js

import_script('MediaWiki:Gadget-morebits.js'); import_script('MediaWiki:Gadget-twinklespeedy.js');

title: User:SomeRandomEditorTest/monobook.js


text:
User talk:DianaChristineBoura

Diana -- Check your links and how you formatted them --J.M.Pearce (talk) 20:24, 18 January 2008 (UTC)

title: User talk:DianaChristineBoura


text:
User talk:Treadcey

Nice work --J.M.Pearce (talk) 20:49, 18 January 2008 (UTC)

title: User talk:Treadcey


text:
User:Lookatthis

 * Wikipedia:Lookatthis
 * Wiktionary:Lookatthis
 * Wikinews:Lookatthis
 * Wikibooks:Lookatthis
 * Wikiquote:Lookatthis
 * Wikisource:Lookatthis
 * Wikispecies:Lookatthis
 * Wikiversity:Lookatthis
 * Wikimedia Commons:Lookatthis
 * Wikimedia Meta-Wiki:Lookatthist
 * Wikimedia Incubator:Lookatthis

title: User:Lookatthis


text:
Talk:How to use a Motorola DVR/Setup

I'm looking for tech assistance on a Motorola DVR, model DCT6416III. The HDMI port is not enabled and it seems that I cannot get support from my cable company in addressing this issue. I can access the diagnostics and view the setting that indicates HDMI not enabled but not sure how to change the setting.

Thanks Frank

Advanced Audio/Video Settings
There is now an Advanced Audio/Video Settings sub-menu (at least on (some) DCX models). Dolby Volume Off/On Video Sharpness  1 2 3 4 5

The defaults are Off and 3.

What is the advise on setting these?

title: Talk:How to use a Motorola DVR/Setup


text:
User:Whiteknight/Simple Footer

 back to top ↑

Creating This Template
To create a page footer template using this design, go to the template page and type:

<>

Where <> is the title of your book. Click "Save page" to create the template. This will substitute in all the necessary code and text.

Options
You can customize the CSS style of the template by adding a second argument:

<>

If you add this style parameter, it will override all the default styles from the template. The default style, which you may want to duplicate in whole or in part, is:

width: 90%; clear: all; padding: 5px; margin: 5px auto;

Using This Template
To use this template in your book, use regular template syntax to include it at the bottom of every page. This template takes no arguments.

title: User:Whiteknight/Simple Footer


text:
Muggles' Guide to Harry Potter/Characters/Marcus Belby

Overview
Marcus Belby, a student in Ravenclaw house at Hogwarts of approximately Harry's age, is the nephew of Damocles Belby, the wizard who invented Wolfsbane Potion.

Half-Blood Prince
Horace Slughorn invites Marcus, along with a number of other people that he judges to be the potential movers and shakers of the Wizarding world, to lunch with him on the Hogwarts Express. When he learns that Marcus is estranged from his famous uncle, Slughorn effectively dismisses him.

Analysis
Belby is brought into the story, as far as we can see, only to cast a light on Slughorn and some specifics of his social climbing. We see that Slughorn is willing to cultivate Belby as long as he has hopes of making a connection with Belby's still living famous uncle. As Damocles is estranged from Marcus' side of the Belby family, he does not represent a useful connection. We suspect that this particular shallowness in Slughorn's character is one of the things that Harry dislikes, and one of the reasons Harry avoids the Slug Club.


text:
User talk:81.165.162.242

Why do you have changed the last edit?

CV

title: User talk:81.165.162.242


text:
Template:Why, and How, Should Geologists Use Compositional Data Analysis/Foot

Why, and How, Should Geologists Use Compositional Data Analysis back to top ↑


text:
User:Whiteknight/Nav Footer

  back to top ↑

Creating This Template
To create a page footer template using this design, go to the template page and type:

<>

Where <> is the title of your book. Click "Save page" to create the template. This will substitute in all the necessary code and text.

Options
You can customize the CSS style of the template by adding a second argument:

<>

If you add this style parameter, it will override all the default styles from the template. The default style, which you may want to duplicate in whole or in part, is:

width: 90%; clear: all; padding: 5px; margin: 5px auto;

Using This Template
To use this template in your book, use regular template syntax to include it at the bottom of every page. This template takes no arguments.

title: User:Whiteknight/Nav Footer


text:
User talk:204.108.96.19

Please use an account if you wish to edit Wikibooks. You cannot create an account from this IP, but you may create one from home and then use it at school. This block will be extended as long as vandalism persists. — Mike.lifeguard | talk 21:16, 9 September 2008 (UTC)

July 2010
You cannot edit for 6 months due to your persistent vandalism. You are welcome to contribute constructively when editing privileges are restored. You may appeal this action with a reasonable argument by adding the text below. – Adrignola talk 19:29, 29 July 2010 (UTC)

title: User talk:204.108.96.19


text:
Template:Bible verse

Use:

title: Template:Bible verse


text: User talk:217.43.153.25

title: User talk:217.43.153.25


text:
User:Druminjosh

Josh Shott teaches Algebra I at Memorial High School in Victoria, Texas.

title: User:Druminjosh


text:
User:Cordell~enwikibooks/monobook.js

document.write(' ');

title: User:Cordell~enwikibooks/monobook.js


text:
History of Greece

Chapters: -- /Introduction/ Appendices:
 * 1) /Minoan Civilization/ --3000-1100 BCE
 * 2) /Mycenaean Civilization/ --1600-1100 BCE
 * 3) /Greek Dark Ages/ --1100-750 BCE
 * 4) /Classical Greece/ --750-336 BCE
 * 5) /Hellenistic Greece/ --336-146 BCE
 * 6) /Roman Greece/ --146 BCE-330 CE
 * 7) /Byzantine Empire/ --330-1453 CE
 * 8) /Ottoman Greece/ --1453-1821 CE
 * 9) /Independent Greece/ --1821-1974 CE
 * 10) /Modern Greece/ --1974-2024 CE
 * /Contributors/
 * /Bibliography/

title: History of Greece


text: User talk:72.66.50.133

title: User talk:72.66.50.133


text:
C++ Programming/Code/Design Patterns/Behavioral Patterns

Chain of Responsibility
Chain of Responsibility pattern has the intent to avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chains the receiving objects and passes the requests along the chain until an object handles it.

Command
Command pattern is an Object behavioral pattern that decouples sender and receiver by encapsulating a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undo-able operations. It can also be thought as an object oriented equivalent of call back method.

Call Back: It is a function that is registered to be called at later point of time based on user actions.

Interpreter
Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.

Iterator
The 'iterator' design pattern is used liberally within the STL for traversal of various containers. The full understanding of this will liberate a developer to create highly reusable and easily understandable data containers.

The basic idea of the iterator is that it permits the traversal of a container (like a pointer moving across an array). However, to get to the next element of a container, you need not know anything about how the container is constructed. This is the iterators job. By simply using the member functions provided by the iterator, you can move, in the intended order of the container, from the first element to the last element.

Let us start by considering a traditional single dimensional array with a pointer moving from the start to the end. This example assumes knowledge of pointer arithmetic. Note that the use of "it" or "itr," henceforth, is a short version of "iterator."

This code works very quickly for arrays, but how would we traverse a linked list, when the memory is not contiguous? Consider the implementation of a rudimentary linked list as follows:

This linked list has non-contiguous memory, and is therefore not a candidate for pointer arithmetic. And we do not want to expose the internals of the list to other developers, forcing them to learn them, and keeping us from changing it.

This is where the iterator comes in. The common interface makes learning the usage of the container easier, and hides the traversal logic from other developers.

Let us examine the code for the iterator, itself.

With this implementation, it is now possible, without knowledge of the size of the container or how its data is organized, to move through each element in order, manipulating or simply accessing the data. This is done through the accessors in the MyIntLList class, Begin and End.

The following program gives the implementation of an iterator design pattern with a generic template:

Console output: ________________Iterator with int______________________________________ 0 1 2 3 4 5 6 7 8 9 ________________Iterator with Class Money______________________________ 100 1000 10000 ________________Set Iterator with Class Name___________________________ Amt Bmt Cmt Qmt

Mediator
Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.

Memento
Without violating encapsulation the Memento Pattern will capture and externalize an object’s internal state so that the object can be restored to this state later. Though the Gang of Four uses friend as a way to implement this pattern it is not the best design. It can also be implemented using PIMPL (pointer to implementation or opaque pointer). Best Use case is 'Undo-Redo' in an editor.

The Originator (the object to be saved) creates a snap-shot of itself as a Memento object, and passes that reference to the Caretaker object. The Caretaker object keeps the Memento until such a time as the Originator may want to revert to a previous state as recorded in the Memento object.

See memoize for an old-school example of this pattern.

Observer
The Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

 * Problem : In one place or many places in the application we need to be aware about a system event or an application state change. We'd like to have a standard way of subscribing to listening for system events and a standard way of notifying the interested parties. The notification should be automated after an interested party subscribed to the system event or application state change. There also should be a way to unsubscribe.

 * Forces : Observers and observables probably should be represented by objects. The observer objects will be notified by the observable objects.

 * Solution : After subscribing the listening objects will be notified by a way of method call.

State
The State Pattern allows an object to alter its behavior when its internal state changes. The object will appear as having changed its class.

Strategy
Defines a family of algorithms, encapsulates each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients who use it.

Template Method
By defining a skeleton of an algorithm in an operation, deferring some steps to subclasses, the Template Method lets subclasses redefine certain steps of that algorithm without changing the algorithm's structure.

Visitor
The Visitor Pattern will represent an operation to be performed on the elements of an object structure by letting you define a new operation without changing the classes of the elements on which it operates.

Model-View-Controller (MVC)
A pattern often used by applications that need the ability to maintain multiple views of the same data. The model-view-controller pattern was until recently a very common pattern especially for graphic user interlace programming, it splits the code in 3 pieces. The model, the view, and the controller.

The Model is the actual data representation (for example, Array vs Linked List) or other objects representing a database. The View is an interface to reading the model or a fat client GUI. The Controller provides the interface of changing or modifying the data, and then selecting the "Next Best View" (NBV).

Newcomers will probably see this "MVC" model as wasteful, mainly because you are working with many extra objects at runtime, when it seems like one giant object will do. But the secret to the MVC pattern is not writing the code, but in maintaining it, and allowing people to modify the code without changing much else. Also, keep in mind, that different developers have different strengths and weaknesses, so team building around MVC is easier. Imagine a View Team that is responsible for great views, a Model Team that knows a lot about data, and a Controller Team that see the big picture of application flow, handing requests, working with the model, and selecting the most appropriate next view for that client.

For example: A naive central database can be organized using only a "model", for example, a straight array. However, later on, it may be more applicable to use a linked list. All array accesses will have to be remade into their respective Linked List form (for example, you would change myarray[5] into mylist.at(5) or whatever is equivalent in the language you use).

Well, if we followed the MVC pattern, the central database would be accessed using some sort of a function, for example, myarray.at(5). If we change the model from an array to a linked list, all we have to do is change the view with the model, and the whole program is changed. Keep the interface the same but change the underpinnings of it. This would allow us to make optimizations more freely and quickly than before.

One of the great advantages of the Model-View-Controller Pattern is obviously the ability to reuse the application's logic (which is implemented in the model) when implementing a different view. A good example is found in web development, where a common task is to implement an external API inside of an existing piece of software. If the MVC pattern has cleanly been followed, this only requires modification to the controller, which can have the ability to render different types of views dependent on the content type requested by the user agent.


text:
C++ Programming/Code/Design Patterns/Structural Patterns

Adapter
Convert the interface of a class into another interface that clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.

Bridge
The Bridge Pattern is used to separate out the interface from its implementation. Doing this gives the flexibility so that both can vary independently.

The following example will output: API1.circle at 1:2 7.5 API2.circle at 5:7 27.5

Composite
Composite lets clients treat individual objects and compositions of objects uniformly. The Composite pattern can represent both the conditions. In this pattern, one can develop tree structures for representing part-whole hierarchies.

Decorator
The decorator pattern helps to attach additional behavior or responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality. This is also called “Wrapper”. If your application does some kind of filtering, then Decorator might be good pattern to consider for the job.

The output of the program above is:

Another example(C++14):

The output of the program above is:

Facade
The Facade Pattern hides the complexities of the system by providing an interface to the client from where the client can access the system on a unified interface. Facade defines a higher-level interface that makes the subsystem easier to use. For instance making one class method perform a complex process by calling several other classes.

The output of the program above is: AC is off TV is off Alarm is on and house is secured Alarm is off and you can go into the house Ac is on Tv is on

Flyweight
The pattern for saving memory (basically) by sharing properties of objects. Imagine a huge number of similar objects which all have most of their properties the same. It is natural to move these properties out of these objects to some external data structure and provide each object with the link to that data structure.

Proxy
The Proxy Pattern will provide an object a surrogate or placeholder for another object to control access to it. It is used when you need to represent a complex object with a simpler one. If creation of an object is expensive, it can be postponed until the very need arises and meanwhile a simpler object can serve as a placeholder. This placeholder object is called the “Proxy” for the complex object.

Curiously Recurring Template
This technique is known more widely as a. Mixins are described in the literature to be a powerful tool for expressing abstractions.

Interface-based Programming (IBP)
Interface-based programming is closely related with Modular Programming and Object-Oriented Programming, it defines the application as a collection of inter-coupled modules (interconnected and which plug into each other via interface). Modules can be unplugged, replaced, or upgraded, without the need of compromising the contents of other modules.

The total system complexity is greatly reduced. Interface Based Programming adds more to modular Programming in that it insists that Interfaces are to be added to these modules. The entire system is thus viewed as Components and the interfaces that helps them to co-act.

Interface-based Programming increases the modularity of the application and hence its maintainability at a later development cycles, especially when each module must be developed by different teams. It is a well-known methodology that has been around for a long time and it is a core technology behind frameworks such as CORBA.

This is particularly convenient when third parties develop additional components for the established system. They just have to develop components that satisfy the interface specified by the parent application vendor.

Thus the publisher of the interfaces assures that he will not change the interface and the subscriber agrees to implement the interface as whole without any deviation. An interface is therefore said to be a Contractual agreement and the programming paradigm based on this is termed as "interface based programming".


text:
C++ Programming/Code/Design Patterns/Creational Patterns

Creational Patterns
In software engineering, creational design patterns are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or added complexity to the design. Creational design patterns solve this problem by somehow controlling this object creation.

In this section we assume that the reader has enough familiarity with functions, global variables, stack vs. heap, classes, pointers, and static member functions as introduced before.

As we will see there are several creational design patterns, and all will deal with a specific implementation task, that will create a higher level of abstraction to the code base, we will now cover each one.

Builder
The Builder Creational Pattern is used to separate the construction of a complex object from its representation so that the same construction process can create different objects representations.

 * Problem : We want to construct a complex object, however we do not want to have a complex constructor member or one that would need many arguments.

 * Solution : Define an intermediate object whose member functions define the desired object part by part before the object is available to the client. Builder Pattern lets us defer the construction of the object until all the options for creation have been specified.

You can also use the latest version c++17 standard

Factory
Definition: A utility class that creates an instance of a class from a family of derived classes

Abstract Factory
Definition: A utility class that creates an instance of several families of classes. It can also return a factory for a certain group.

The Factory Design Pattern is useful in a situation that requires the creation of many different types of objects, all derived from a common base type. The Factory Method defines a method for creating the objects, which subclasses can then override to specify the derived type that will be created. Thus, at run time, the Factory Method can be passed a description of a desired object (e.g., a string read from user input) and return a base class pointer to a new instance of that object. The pattern works best when a well-designed interface is used for the base class, so there is no need to cast the returned object.

 * Problem : We want to decide at run time what object is to be created based on some configuration or application parameter. When we write the code, we do not know what class should be instantiated.

 * Solution : Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

In the following example, a factory method is used to create laptop or desktop computer objects at run time.

Let's start by defining, which is an abstract base class (interface) and its derived classes:   and.

The actual  class returns a , given a real world description of the object.

Let's analyze the benefits of this design. First, there is a compilation benefit. If we move the interface  into a separate header file with the factory, we can then move the implementation of the   function into a separate implementation file. Now the implementation file for  is the only one that requires knowledge of the derived classes. Thus, if a change is made to any derived class of, or a new   subtype is added, the implementation file for   is the only file that needs to be recompiled. Everyone who uses the factory will only care about the interface, which should remain consistent throughout the life of the application.

Also, if there is a need to add a class, and the user is requesting objects through a user interface, no code calling the factory may be required to change to support the additional computer type. The code using the factory would simply pass on the new string to the factory, and allow the factory to handle the new types entirely.

Imagine programming a video game, where you would like to add new types of enemies in the future, each of which has different AI functions and can update differently. By using a factory method, the controller of the program can call to the factory to create the enemies, without any dependency or knowledge of the actual types of enemies. Now, future developers can create new enemies, with new AI controls and new drawing member functions, add it to the factory, and create a level which calls the factory, asking for the enemies by name. Combine this method with an XML description of levels, and developers could create new levels without having to recompile their program. All this, thanks to the separation of creation of objects from the usage of objects.

Another example:

Prototype
A prototype pattern is used in software development when the type of objects to create is determined by a prototypical instance, which is cloned to produce new objects. This pattern is used, for example, when the inherent cost of creating a new object in the standard way (e.g., using the  keyword) is prohibitively expensive for a given application.

Implementation: Declare an abstract base class that specifies a pure virtual  method. Any class that needs a "polymorphic constructor" capability derives itself from the abstract base class, and implements the  operation.

Here the client code first invokes the factory method. This factory method, depending on the parameter, finds out the concrete class. On this concrete class, the  method is called and the object is returned by the factory method.

 * This is a sample implementation of Prototype method. We have the detailed description of all the components here.
 * class, which is a pure virtual class that has a pure virtual method.
 * ,  and   as concrete implementation of a   class.
 * An RecordType as one to one mapping of each concrete implementation of   class.
 * class that has a  method  . This method requires an  RecordType as parameter and depending on this parameter it returns the concrete implementation of   class.

Another example:

To implement the pattern, declare an abstract base class that specifies a pure virtual  member function. Any class that needs a "polymorphic constructor" capability derives itself from the abstract base class, and implements the  operation.

The client, instead of writing code that invokes the  operator on a hard-wired class name, calls the   member function on the prototype, calls a factory member function with a parameter designating the particular concrete derived class desired, or invokes the   member function through some mechanism provided by another design pattern.

A client of one of the concrete monster classes only needs a reference (pointer) to a  class object to be able to call the ‘Clone’ function and create copies of that object. The function below demonstrates this concept:

Now originalMonster can be passed as a pointer to CGreenMonster, CPurpleMonster or CBellyMonster.

Singleton
The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance. It is named after the singleton set, which is defined to be a set containing one element. This is useful when exactly one object is needed to coordinate actions across the system.

Check list
 * Define a private static attribute in the "single instance" class.
 * Define a public static accessor function in the class.
 * Do "lazy initialization" (creation on first use) in the accessor function.
 * Define all constructors to be protected or private.
 * Clients may only use the accessor function to manipulate the Singleton.

Let's take a look at how a Singleton differs from other variable types.

Like a global variable, the Singleton exists outside of the scope of any functions. Traditional implementation uses a static member function of the Singleton class, which will create a single instance of the Singleton class on the first call, and forever return that instance. The following code example illustrates the elements of a C++ singleton class, that simply stores a single string.

Variations of Singletons:

Applications of Singleton Class:

One common use of the singleton design pattern is for application configurations. Configurations may need to be accessible globally, and future expansions to the application configurations may be needed. The subset C's closest alternative would be to create a single global  . This had the lack of clarity as to where this object was instantiated, as well as not guaranteeing the existence of the object.

Take, for example, the situation of another developer using your singleton inside the constructor of their object. Then, yet another developer decides to create an instance of the second class in the global scope. If you had simply used a global variable, the order of linking would then matter. Since your global will be accessed, possibly before main begins executing, there is no definition as to whether the global is initialized, or the constructor of the second class is called first. This behavior can then change with slight modifications to other areas of code, which would change order of global code execution. Such an error can be very hard to debug. But, with use of the singleton, the first time the object is accessed, the object will also be created. You now have an object which will always exist, in relation to being used, and will never exist if never used.

A second common use of this class is in updating old code to work in a new architecture. Since developers may have used globals liberally, moving them into a single class and making it a singleton, can be an intermediary step to bring the program inline to stronger object oriented structure.

Another example:


text:
Anatomy and Physiology of Animals/Respiratory System/Test Yourself Answers

1. What is meant by the phrase “gas exchange”?
 * Gas exchange is the addition of oxygen to the blood and the removal of carbon dioxide.

2. Where does gas exchange take place?
 * Gas exchange takes place in the alveoli of the lungs.

3. What is the process by which oxygen moves from the alveoli into the blood?
 * Oxygen moves from the alveoli into the blood by diffusion.

4. Why does this process occur?
 * This process occurs because oxygen is at a much higher concentration in the alveoli than in the blood. Diffusion always occurs from a high to low concentration.

5. How does the structure of the alveoli make gas exchange efficient?
 * The thin walls of the alveoli and the capillaries give only a small distance for the oxygen and carbon dioxide to diffuse across making gas exchange efficient.
 * 6. How is oxygen carried in the blood?
 * Oxygen is carried in the blood combined with haemoglobin in the red blood cells.

7. List the structures that air passes on its way from the nose to the alveoli:
 * On its way to the alveoli of the lungs air travels through the nasal cavity, pharynx, larynx, trachea, bronchi and bronchioles.

8. What is the function of the mucous and cilia lining the respiratory passages?
 * The mucus and cilia in the respiratory passages trap dust particles and transport them to the mouth and nose for expulsion.

9. How do movements of the ribs and diaphragm bring about inspiration? Circle the correct statement below.

 * b) The diaphragm flattens and ribs move up and out.

10. What is the function of the epiglottis?
 * The epiglottis closes the larynx during swallowing so that food cannot enter the trachea.

11. What controls the rate of breathing?
 * The concentration of carbon dioxide in the blood controls the rate of breathing.


text:
Anatomy and Physiology of Animals/Chemicals/Test Yourself Answers

1. What is the difference between an atom and a molecule?

 * An atom is the simplest building block of matter – elements are made of atoms. Molecules are made of atoms joined together.

2. What is the chemical name for baking soda? And its formula?

 * Sodium Bicarbonate, NaHCO3

3. Write the equation for carbonic acid splitting into water and carbon dioxide.

H2CO3 • CO2 + H2O 4. A solution of table salt in water is an example of an electrolyte. What ions are present in this solution?

 * Na+ and Cl- (also H+ and OH-)

5. What element is always present in proteins but not usually in fats or carbohydrates?

 * Nitrogen

6. List three differences between glucose and glycogen.

 * Glucose is a monosaccharide, glycogen is a polysaccharide (and a much bigger molecule); glucose is sweet to taste and dissolves in water, glycogen is not sweet and is insoluble; glucose is used for energy whereas glycogen stores energy.

7. Which will provide you with the most energy – one gram of sugar or one gram of butter?

 * Fats provide approximately 2.5 times more energy than carbohydrates – so the butter wins hands down!


text:
Anatomy and Physiology of Animals/Classification/Test Yourself Answers

1a) Re-write this scientific name for an animal correctly: trichosurus Vulpecula.

 * Trichosurus vulpecula or Trichosurus vulpecula

1b) Can you find out what this animal is?

 * The animal is a possum

2. Rearrange these groups from the biggest to the smallest:

a) cars | diesel cars | motor vehicles | my diesel Toyota | transportation
 * transportation | motor vehicles | cars | diesel cars | my diesel Toyota

b) class | species | phylum | genus | order | kingdom | family | breed
 * kingdom | phylum | class | order | family | genus | species | breed

3. Is a rabbit a rodent?

 * No – it is in the order Lagomorpha, not Rodentia. It is a lagomorph!


text:
Anatomy and Physiology of Animals/The Cell/Test Yourself Answers

1.

2. Red blood cells placed in a 5% salt solution would shrink as water flowed out of them into the hypertonic salt solution round them.

3. Red blood cells placed in a 0.9% solution of salt would be in an isotonic solution.

4. White blood cells remove foreign bodies like bacteria from the body by phagocytosis.

5.

6. The cell division that causes an organism to grow and repairs tissues is called mitosis

7. The cell division that produces sperm and ova is called meiosis.

8. Two important differences between mitosis and meiosis are:
 * a) In mitosis the number of chromosomes in the cells formed is the same as in the original cell. In meiosis the number of chromosomes is halved.
 * b) In mitosis the cells formed are genetically identical to the original cell. In meiosis they are different.


text:
Anatomy and Physiology of Animals/Body Organisation/Test Yourself Answers

1. Living organisms can be distinguished from non-living matter because ''they usually move and grow. They also excrete, respire, are sensitive to the environment, reproduce and feed. '' 2. What tissue types would you find:
 * a) Columnar epithelial tissue lines the intestine.
 * b) Keratinised stratified squamous epithelium covers the body.
 * c) Skeletal muscle moves bones.
 * d) Blood (a type of connective tissue) flows through blood vessels.
 * e) Nerves link the eye to the brain
 * f) Transitional epithelium lines the bladder

3. Name the body cavity in which the following organs are found:
 * a) The heart is located in the pericardial cavity (situated in the thoracic cavity).
 * b) The bladder is situated in the pelvic cavity
 * c) The stomach is situated in the abdominal cavity
 * d) The lungs are situated in the pleural cavity (also situated in the thoracic cavity).

4. Body systems
 * a) The skeletal system includes the bones and joints
 * b) The reproductive system includes the ovaries and testes
 * c) The endocrine system produces hormones.
 * d) The circulatory system includes the heart, blood vessels and blood.

5. Homeostasis is the maintenance of constant conditions in an animal’s body.

6. Circle which is correct:
 * a) The head is cranial to the neck
 * b) The heart is medial to the ribs
 * c) The elbow is proximal to the fingers
 * d) The spine is dorsal to the heart

7. Indicate whether or not these statements are true.
 * a) The stomach is cranial to the diaphragm - false. It is caudal to the diaphragm.
 * b) The heart lies in the pelvic cavity - false. It lies in the thoracic cavity or to be more precise in the pleural cavity.
 * c) The spleen is roughly the same size as the stomach and lies near it - true
 * d) The small intestine is proximal to the kidneys - false (remember the term proximal is only used when describing the relationship of parts of the limbs to each other). Perhaps it would be better to say that the small intestine is ventral to the kidneys.
 * e) The bladder is medial to the hips - true
 * f) The liver is cranial to the heart - false. The liver is caudal to the heart.


text:
Anatomy and Physiology of Animals/The Skin/Test Yourself Answers

1. The two layers that form the skin are the: epidermis and dermis

2. The special protein deposited in epidermal cells to make them waterproof is keratin

3. Skin structures made of keratin include scales, beaks, claws, nails, hoofs, hairs and feathers.

4. Sweat, sebaceous and mammary glands are all exocrine glands. Meaning they all have ducts through which they expel their products to the outside.

5. The pigment deposited in skin cells that protects underlying skin layers from the harmful effects of the sun is melanin.

6. The skin helps cool an animal down when it is active or in a hot environment by producing sweat and dilating the capillaries in the dermis

7. The skin helps prevent heat loss when an animal is in a cold environment by:
 * a) contraction of the hair erector muscles to make the hairs stand up and trap an insulating layer of air.
 * b) constriction of the capillaries in the dermis to reduce heat loss through the body surface.


text:
Anatomy and Physiology of Animals/The Skeleton/Test Yourself Answers

1. Name the bones which move against (articulate with)...
 * a) the humerus: moves against the scapula, radius and ulna.
 * b) the thoracic vertebrae: move against adjacent cranial and caudal vertebrae & the ribs
 * c) the pelvis: moves against the femur and the sacrum

2. Name the bones in the forelimb:
 * From the scapula are the ''humerus, radius, ulna, carpals, metacarpals and digits.

'' 3. Where is the patella found?
 * ''The patella is the knee cap. It is found in the hind limb at the knee joint.

'' 4. Where are the following joints located?
 * a) The stifle joint: between the femur and the tibia on the hind limb.
 * b) The elbow joint: between the humerus, radius and ulna on the forelimb.
 * c) The hock joint: between the tarsals and metatarsals on the hind limb.
 * d) The hip joint: between the pelvis and the femur.

5. Attach the following labels to the diagram of the long bone shown below.

6. Attach the following labels to the diagram of a joint shown below.


text:
Anatomy and Physiology of Animals/Muscles/Test Yourself Answers

1. What kind of muscle tissue:
 * a) Skeletal muscle moves bones.
 * b) Cardiac muscle makes the heart pump blood.
 * c) Smooth muscle pushes food along the intestine.
 * d) Smiling is a voluntary action (usually!) so skeletal muscle is involved.
 * e) You cannot control “Goosebumps” so the muscles involved are smooth muscles.
 * f) Although breathing seems to be involuntary most of the time it is possible to control it voluntarily so the diaphragm (the main breathing muscle) is a skeletal muscle.

2. What structure connects a muscle to a bone?
 * A tendon connects a muscle to a bone.

3. What is the insertion of a muscle? The insertion of a muscle is the end attached to the bone that moves most when the muscle contracts.

4. Which muscle is antagonistic to the biceps?
 * ''The triceps is the muscle that forms the other half of the antagonistic pair with the biceps.

'' 5. When you flex your knee what movement are you making?
 * When you flex your knee you bend your knee.

6. When you extend your ankle joint what happens?
 * When you extend your ankle joint you point your toes.