Answer to the question that may never be asked.

This is the place to discuss any topic Alchemical or otherwise.

Answer to the question that may never be asked.

Postby Ghislain » Sat Dec 07, 2013 9:36 am

I want to show people the answer to a question they may never ask. I want people to see the complexity & simplicity of access to your every day computer RAM chip, how data is moved to and from it and it may surprise you to see what goes onto this chip you just call Memory.

To follow this thread please keep an open mind; and don’t think you won’t understand it as I am going to keep it as simple as possible then at the end whether you followed it or not you will understand the conclusion even if you didn't see how it was reached.

My technical description may be a little outdated as I haven’t worked in this field for over a decade, but it should give you the idea. The greatest difficulty in reading this thread is that it is very logical, but needs to be followed letter for letter. I hope you have the staying power. ;)

The next picture (Figure.1) is a simplified drawing of four bytes within a RAM chip...believe me four is enough…in the first part we are going to look at how we get the data out of one location, i.e. one byte of memory.


First I will explain the picture above. (It is assumed the reader understands binary notation). It is not necessary to understand the technology just try and follow the logic. We are going to talk about logic gates, if you can’t follow it then take this part of what I say for granted as it isn’t the point of this thread.

The "Black" lines represent wires that have no (or low) voltage representing a “0”, and the "Red" lines have a voltage representing a “1”. If it makes it easier, think of the “0” and “1” as “OFF” or “ON” respectively.

The D shapes with MEM ADDR (Memory address) written in them are “AND” gates, and a simple AND gate has two inputs, one output and works as follows:

Only if both the input lines are “1” {two in =D- one out} does the gate give an output of “1” else the output is “0”.

Now you can see in Figure.1 that these AND gates have eight inputs and only one output so to get the eight input configuration you need four AND gates together, but this gives four outputs and we only want one.

So a further two AND gates are placed in front of the four outputs giving two outputs, and one last AND gate is placed in front of these giving the one output that is required. This gives a configuration that looks like figure.2 below, and the D shape in fig.1 is a simplified representation of Figure.2. Follow it so far? Good :)


Remember that even the simple two input AND gate is only a representation. The circuitry for this can be seen in Figure 5 below.

In Fig.1, at the inputs to the AND gates you can see little circles, these represent “NOT” gates. A simple NOT gate has one input and one output and its function is to flip the input, thus if the input is “1” the output is “0” and vice versa. You can see the circuitry of the NOT gate in Figure 3. The circles in Fig.1 are simplified representations of this.


So now we are ready to extract our data…hopefully this is the easy bit to follow. :?

At the bottom of fig.1 you can see an address byte of memory – we won’t go into how that gets there…perhaps in another post lol – in this byte there is the binary number 00000010 which represents decimal 2 so we are addressing byte 2 of the RAM.

If we just follow the red line from the address byte we first come to Byte 0. You will notice that all inputs to Byte 0 have NOT gates so the AND gate sees all inputs as “1” except for the red line on input 1, which it sees as “0”, so the output is “0”, i.e. there is “0” on the “select” line for Byte 0.

Moving on we get to Byte 1. Here you will notice that all the inputs have NOT gates except for
input 0. Here the AND gate sees “1” on inputs 2 to 7, but “0” on inputs 0 and 1, so the output is “0”, i.e. there is “0” on the “select” line for Byte 1.

Now we get to Byte 2. Here you can see all inputs except input 1 have NOT gates and therefore the AND gate sees all these inputs as “1”, on input line 1 there is “1” and as this does not go through a NOT gate the AND gate sees this as “1” also. Now we have all inputs as “1” so the output is “1” and the Byte is selected. What happens next?

With the select line set to “1” this instructs the BIT cells in the byte to transfer their content onto the data lines and thus the content is received at the Data Byte…follow the red lines. You can now see that the Data Byte at the bottom of Fig.1 reflects the content of the data in Byte 2; Job done.

Note there is quite a bit that has been left out such as the read write line, which tells the Byte cells if they are putting data onto the data bus or retrieving data from it.

The Conclusion or The interesting bit.

Now we need to look at the circuitry of the previous components then the “AND gate” and the “BIT cells”; bear with me there is method in my madness.

Image Image

OK looking first at Fig.3, The NOT gate, we can see it contains three components; two resistors R1,R2 and one transistor Q1; as the NOT gates will differ depending on the Byte Address I will average those at four per Byte which gives us twelve components.

Now looking at Fig.4, The SRAM BIT Cell contains six components; transistors M1 to M6, there are eight bits to a Byte therefore we have forty eight components.

On to Fig.5, The AND gate contains 10 components; four resistors R1 to R4, four transistors Q1 to Q4 and two diodes D1 and D2. Remember that was for a two input AND gate and we had to use seven to get our eight input AND gate, which gives us seventy components.

Now if we tally the number of components we need per Byte we come to 130 components.
The average RAM chip is 256Mbytes 256,000,000 Bytes so the components contained in one chip is… 33.28 Billion or… 33,280,000,000.

Now you do the maths, you can take the area of a chip – remembering that the chip is not what you actually see, the chip is inside a protective case, then divide that area by the 33.28 Billion and you get a rough idea of the size of the components we are manufacturing; obviously at the atomic level, but also probably at the quantum level today.

The address Byte we were using in figure one can address 256 addresses in memory, therefore we usually use a 16 bit address which allows 65,536 adresses. After this we can either page in different sections of memory and use the same 16 bits again (bit slow) or up the addressing to 32 bits which gives us 4,294,967,296 memory addresses or up it to 64 Bits which allows addresses up to 1.8447 x 10^19 memory addresses lol I'm not writing that one out.

So next time you hold a RAM chip in your hand be aware of the wonder you caress.

Hope you followed that…I’m sure there will be some that say they don’t use this or that lol, but it’s a good guestimate.

Thanks for staying with it. :)

Last edited by Ghislain on Mon Dec 23, 2013 2:28 am, edited 10 times in total.
User avatar
Posts: 17
Joined: Sun Sep 08, 2013 11:59 am

Re: Answer to the question that may never be asked.

Postby FR3E » Sat Dec 07, 2013 3:40 pm

Nice, very interesting, and easy to understand.

A great explanation of what is going on in our micro sized gizmos...

...and there was me thinking alien magic made my phone work? Doh! ;0DP

Thanks for spreading some light on the matter.

I want more! :)
Posts: 1
Joined: Wed Sep 25, 2013 4:27 pm

Re: Answer to the question that may never be asked.

Postby Ghislain » Wed Dec 11, 2013 11:39 pm


Below is an extended explanation of the addressing. I have taken one Byte of memory
from the initial post to use as an example.


Note: only a selected memory byte will put its data onto the Data Bus
Get your head around that while I try to put together a further explanation in
Layman's terms.

User avatar
Posts: 17
Joined: Sun Sep 08, 2013 11:59 am

Using the Z80 chip as the CPU

Postby Ghislain » Sat Dec 14, 2013 8:58 pm

Under construction; Text to follow!

In the image below I have used the Zilog Z80 CPU (Central Processing Unit) for example.

Note the image is too big and does not fit on the page. To see the full Image go HERE or click on the image.

If I had made it any smaller it would have got messy :) or messier lol


Last edited by Ghislain on Mon Dec 23, 2013 3:03 am, edited 2 times in total.
User avatar
Posts: 17
Joined: Sun Sep 08, 2013 11:59 am

BASE Numbers

Postby Ghislain » Thu Dec 19, 2013 6:05 pm

This could be the most boring post ever or the most interesting depending on your
perspective, but if one is going to see the simplicity of the subject then nothing can be taken
for granted.

BINARY…what is it?

When we talk of binary many people immediately think of “1’s” and “0’s”, but do they
understand the WHAT and the WHY of it?

Here is the explanation.

We can represent numbers in what is known as Bases, for instance we normally count in
decimal, which is base 10.

What is base 10?

Base 10 is a way to classify a “column” of numbers and in each column we can have one less
than the base number, so in base 10 (decimal) we can have up to nine in any one column and
if we exceed that then we have to put one into the next column and that represents an order
increment. The columns go up in order of the base number and in decimal this is 10 so the
columns looks like:

10,000 │ 1,000 │ 100 │10 │ 1 (or units)

Sounds confusing, but all it is saying is that we can have 1, 2, 3, 4, 5, 6, 7, 8 or 9 all under
one column, but if we add one more after we reach 9 the we put 1 into the next column and
start at zero again in the first column and we represent that as 10…one ten and no units. This
is the same for all the columns.

Columns are calculated by powers of the base, so column one in any base number is the
base number to the power of zero; if you didn’t already know, any number to the power of
zero is “one”; if you have a calculator that can do powers then put in the numbers and see
for yourself.

The next column is the base to the power of one. Any number to the power of one is the
number itself, i.e. it doesn’t change; again try it yourself; so ten to the power of one is just ten
and this will always be in the second column so if we know our BASE we know the second
column is representing whatever number is in it multiplied by the BASE…in the case of
decimal (base 10) 10 represents 1 x 10 = 10. To represent twenty we put 2 in the second
column and we get 2 x 10 = 20

Thus if we have 3 lots of 100’s, 5 lots of 10’s and 4 lots of 1’s we just write it as 354 and take
it for granted that this is what we have, three hundred and fifty four, so the number 354 in columns
looks like:


Now if we were to count in base 6, then each column could only have 1, 2, 3, 4, or 5, for if
we added one more after 5 we would put 1 into the next column and start at zero again in the
first column and we represent that as 10…one six and no units. Again the columns go up in
orders of the base. We can still have the number 354, but this is not the same value as we
had in base 10, for now we have 3 lots of 36’s, 5 lots of 6’s and 4 lots of 1’s; if we add this up
then we can see that 354 in base 6 only represents 142 in base 10.


This doesn’t mean we can’t represent decimal 354 in base 6 it just means it is going to look
a little different as below:


Therefore 1350 (Base 6) = 354 (base 10)

I hope that wasn’t too confusing because we are now going to apply the exact same
principle to base 2 (BINARY). I won’t write the explanation just look at the picture and see if
you can understand what is happening.


Note: 1 in column 2 is 1 x 2 = 2 which is the BASE...get it? base 2.

The point I am trying to make is that if we see 10 then we say ten, but that is only true
in decimal.

10 in base 2 is two, 10 in base 7 is seven. We miss the true representation and that
is why we find working in anything other than decimal complex, when it isn't at all if you look
at it correctly.

If you understood that then you now know the WHAT! Now the WHY!

In an electrical circuit the easiest action to perform is to turn something “on” or “off”
and this can represent two states, which we can call “1” or “0” respectively; this then lends
itself so well to binary notation and there is the WHY, we can represent all we want in zero’s
and one’s.

I can understand if people find that a bit simple, this is not trying to tell your granny how to
suck eggs, but hopefully it puts things into the correct perspective to move on.

I find this interesting, but if others don’t then it is pointless for me to take this any further.
Please tell me if you are interested in more as this does take quite a bit of time to put into
layman’s terms. Also I have made it as simple as I can and if that isn’t simple enough I can
do no more.

This post isn’t irrelevant because we will later need to look at hexadecimal notation and
understanding the above makes that a lot simpler.

The next stage will be to look at how the computer deals with characters; if I get around to it

Last edited by Ghislain on Sat Jan 11, 2014 2:49 pm, edited 1 time in total.
User avatar
Posts: 17
Joined: Sun Sep 08, 2013 11:59 am

Addressing Memory

Postby Ghislain » Sun Dec 22, 2013 9:16 pm

Before we move on to the explanation of how the CPU manipulates data let's consider in more detail how an address is unique to one byte of memory storage space.

Below is a drawing of the "memory addresses" from fig.1 in the first post, up-ended to give a better view of the gate input patterns. You may notice the omission of NOT gates on certain input lines on the gates. This is not random; the gates are missing to form a binary pattern.

If you look at the inputs with the NOT gates, they require an input of zero to turn them on "0", and if you look at the inputs without NOT gates they require an input of one to turn them on "1".

Above each input I have placed the binary key needed to turn on the particular gate. You may now see that the pattern needed is the binary representation of the gates number. In this way we can be sure that at any given moment only one address in memory can be active and so no memory address can be accessed by mistake.


Now look at the internal structure of the Z80 chip, top left of the picture in the post "Using the Z80 chip as the CPU" above, and notice the registers.

There are certain specialised registers such as the SP, PC, IX, IY and then there are the general registers BC, DE, HL that
have some special functions when using certain instructions.

SP is the Stack Pointer
PC is the Program Counter
IX and IY are Index Registers

The registers are in two byte, 2x8 bit pairs and can also be used as 8 Bit, 1 byte single registers.

There are two other registers "A" (the accumulator) and "F" (the flag register), we only need to talk of the "A" register of these two in the next bit.

The PC register is used by the CPU and is called the Program Counter, the user does not have to worry about this one as the CPU will patch it in and out on the address bus on its own depending on the instruction it receives. The PC addresses the current instruction within the program; it is not used to fetch data for the user, it just fetches instructions for the CPU. It is when the instruction tells the CPU to fetch a bit of data from memory it will switch to the register pair that the instruction tells it to use to address the data in memory.

You may see how few registers there are performing all the tasks your computer is executing. It all appears to happen straight away, but even the screen you are looking at right now has been created from memory using the CPU registers to turn on every pixel one by one then give it its colour and brightness; imagine how many pixels that is.

Computing is like juggling with numbers!

There are many different makes of CPU’s and many different instruction sets. The instruction set is built into the chip itself.

One example of an instruction for the Z80 is:


The LD part can be considered as the word “Load” and this instruction is telling the CPU to load the “A” register with the data in memory pointed to by the address held on the HL register.

Below you can see this instruction and explanation on a page taken from the “Z80 CPU Users Manual”. Click on the pic to go to the PDF for the whole manual and complete instruction set.


This instruction will be carried out as soon as the PC has pointed to the memory location containing the instruction. The CPU will switch the address bus from the PC to the HL register. Note that in the pic above the <-r-> is replaced with 111 for the “A” register, giving the data instruction the form 01111110. Note: r = register and can be replaced with any of the registers listed.

The whole operation can be seen in the .GIF below. Note: At the beginning of the GIF image you will see the word “START” in the bottom left. At this point the PC register contains the address 00000111 decimal 7, and the HL register contains the address 00001110 decimal 15. The address 00001001 decimal 9 holds the instruction. (note: don’t try to understand any of the other data in memory as I just made it up to fill in the spaces for the purpose of the example :))


If you want to reset the gif to "START" refresh the web page.

User avatar
Posts: 17
Joined: Sun Sep 08, 2013 11:59 am

Character to Screen

Postby Ghislain » Sat Dec 28, 2013 11:31 am

OK finally we get to the character set. How does the computer place a character on the screen after you press a key on your keyboard?

A quick note; I have set up some graphics on separate links so that you can open them in a new window and look at them while reading the text. Right click on the links and then click on "open link in new window"...might make things a little easier. Also note that even though this post may seem a little long it will give you an idea of what your computer actually does if you take a little time to follow and understand this post...I hope you do as it took me a lot longer to write it than it will for you to read it ;).

There are many ways to skin a cat, and in computing there are many ways to carry out a task; especially text manipulation.

I will show one “simple” way this is done. The reason for this is that there are many algorithms used today to manipulate the text you see on the screen and what is stored to print that text. To give you an example if you type into MS WORD, “The cat sat on the Mat”, and save it as a text file, the file would be approximately 24 bytes in size. Now save the same file as a word document and the file size will be approximately 9,000+ bytes long as the Word file needs to store all the formatting that goes along with the text; we won’t be looking at that lol.

The Keyboard has a matrix that will put a data/instruction byte onto a data bus and send it to the computer via an input port. The data byte value will depend on which key or combination of keys has been pressed. This is beyond the scope of this post, but the link may give a bit more information.

This data could be a control code, such as “cursor up”, or it could be a character. As you can imagine we can send a lot of different types of data to the computer via the keyboard, but we are only interested here in the character code.

The computer industry set up a standard for character codes so that we can all sing from the same hymn sheet; this is known as the American Standard Code for Information Interchange (ASCII).

You can see the codes and their reference numbers HERE, this is the key codes and the resulting characters using the Arial font; most fonts will follow this same pattern except specialist fonts like “Webdings” and such; with a little effort you can even create your own character set.

You can access any of these codes in any text editor (even when writing a forum post) by turning on the “Num Lock” key on your computer and then, while holding down the “Alt” key, type in the reference number on your number keypad; the character will appear after you release the “Alt” key.

Example: Alt 171 = ½, Alt 30 = ▲

The Explanation

In the gif at the end of post 22 we fetched a byte of data, addressed by the HL register, from a memory location and put it into the “A” register. In a similar way we can get a byte of data from a keyboard. The keyboard matrix sends out a code, this is interpreted by the keyboard driver and the end result is that the ASCII code for the character key pressed is stored in the “A” register of the CPU.

The ASCII code for the capital letter “A” is 01000001 (decimal 65), which is the byte of data we happened to retrieve from the HL location in memory in the above post.

The “A” register does not care where the code comes from i.e. it could come from the keyboard or a file stored in memory; you can now find the map or graphic for the character in memory.

When you select a font in a text editor the graphics for that particular font is transferred into RAM memory and each character is store in the same amount of bytes. So first let’s look at a character and its makeup.


In the gif above you can see that the Capital letter “A” is made up of pixels. If you click on the image you will see an exploded view of this and how the computer stores it; remember to open in new widow.

In the blow up you can see that there is a thick black line down the centre of the character, this is to show that the character is broken down into eight bit segments (1 Byte) and that there are twenty-four bytes of information in this character, 0 to 23.

How is this translated to what we see on the screen?

Imagine the screen you are looking at is a window into a section of your computer’s memory and this section of memory is reserved just for this. Each pixel on your screen corresponds to one Bit in a Byte of memory; if that Bit is “1” you see it, if it is “0” you don’t.

It is a bit more complex as there is the colour and hue of the pixel to take into consideration, Even a black character is coloured to give the illusion of crisp staight lines. Again if you look at the blown up link for the character I have included, on the left hand side, an image of what the character would look like if all the pixels were black. We won’t cover colour attributes here.

I am not conversant with computer graphics so this is a crude example of how the information from the keyboard gets onto your screen.

The character maps for display are stored in memory in the same order they are in the ASCII character set.

The accumulator (A register) now carries out a calculation to find the first byte of the character sent to it from the keyboard. It does this by multiplying the number of bytes in a character by the position of the character in the character set.

The capital letter “A” has the position 65 (Bin 01000001) and we know the character images in our example are stored in 24 bytes of memory, so 65 x 24 = 1560 (Bin 11000011000) gives us the location within the character image file of the first byte for the capital letter “A”.This result is stored in the BC register set.

We would already know the address where the character images have been loaded into memory, let’s make up a section of memory and say we loaded the images starting at address 32500 (Bin 111111011110100). This number is stored in the HL register set.

We now add the HL, BC registers, 32500 + 1560 = 34060 (Bin 1000010100001100), and store the result in the HL register set. HL now points to the address where the first byte of the capital letter “A’s” image is stored in memory.

For our screen structure we will assume that the first byte of screen memory is the top left of the screen and if we put Bin 11111111 into that memory we would get a dash “─” in the top left corner of the screen, i.e. all the eight pixels would be turned on.

The next byte of memory would display next to the first byte to the right “──” giving you a longer dash and so on. If we get to the eighty first character we would place a dash under our first entry on the next line down giving us a thicker line in the top left of the screen "▬". We have assumed the screen is 80 bytes wide and know the character itself is 12 bytes high and two bytes wide, now we have to do an increment of 80 x 12 to get down to the first byte of screen memory to place our character, from the bottom up. There is one extra line to tidy things up and leave a space above the character so that it is not touching the top of the screen or the letters that may be above it; 80 x 12 puts us 13 pixel lines down.

On each pass of our program we will place two character bytes next to each other and as the character is 24 bytes we need 12 passes. Again let’s make up the place in memory that is seen on the display where we are going to transfer the image to. if we say the first byte of screen memory is 45000 (Bin 1010111111001000) and store this in the DE register set. We now do the calculation 80 x 12 and store this in the BC register set and add DE and BC storing the result in DE, so we get 45000 + 960 = 45960 (Bin 1011001110001000) and store this in the DE register set.

Note: this address is easy to find as it is the address where the cursor image has been flashing away on the screen. Also note that different operating systems may have a different screen structure.

The last thing we need is the address in memory of the program that instructs the CPU what to do with this information. This we will store at memory location 20000 (Bin 100111000100000) and store that in the PC register set ready to send data to the Instruction Register IR (this is a single byte register not to be confused with the Interrupt Register set as shown in the schematic above as IR)

OK now we know what we want to do lets see it in action.

Below is the operation of the CPU when placing a character onto the monitor. This is written in Assmbly Language and the presentation is in video format to allow the viewer to pause at positions of thier choice to take further time to study what is going on as there is quite a lot to take in as simple as it is. In the top left corner of the screen there is a changing reference point so the user can return to any given page for revision.

In the screen pixel display you will see some greyed out pixels, these show the pixel position pointed to by the DE register; eight pixels = 1 byte of information.

I have called the program CHAR_PRNT for Character Print and this would be the entry point of the program and the name to address the program ("call" instruction) within the control loop of the program.

The entry conditions are:

B register - holds the number of lines that make up the character.
C register - holds the number of bytes in the screen width +1
DE register - holds the address of the screen memory to be printed to.
HL register - holds the address of the font memory byte to be sent to the monitor at DE

In the following program listing the bold text is the program instuctions the rest is a description of the instruction.

There are two labels used here, CHAR_PRNT and NEXT_LN the purpose of these is expalined in the video.

LD A,(HL) CHAR_PRNT; This loads the A register with the data from the font memory pointed to by the address held on the HL register.
LD (DE),A; This loads the byte of screen memory with the data now on the A register.
INC HL; This increases the address held on the HL register by one to point to the next byte of font data for the character build.
INC DE; This increases the screen position address held on the DE register to point to the next screen position.
LD A,(HL); This loads the A register with the second byte of data from the font memory pointed to by the address held on the HL register.
LD (DE),A; This loads the next byte of screen memory next to the first with the data now on the A register. (Character is two bytes wide)
LD A,C; This loads the page width into the A register to use as a counter for the amount of bytes to decrease the DE register for the next screen position.

Note the next three instructions create a loop that will execute until the A register DECreases to zero. The NEXT_LN part is a label that takes the form of the current address of the instruction it is written next to; when the label is then used in another instruction it is replaced by that address. Labels are normally written to the left but as many forums don't have indent capability I have written them on the right just to keep things tidy.

DEC DE NEXT_LN; This is the beginning of a loop that will DECrease the DE register until it points to the screen position above the first byte of screen data.
DEC A; This DECreases the count in the A register.
JP NZ,NEXT_LN; JP=Jump and the NZ=Not Zero, so the program will jump if the A register is not zero to NEXT_LN the address of the DEC DE instruction.

INC HL; This increments the font memory position address held on the HL register to point to the next data byte of the character image in memory.
DEC B; This DECreases the count held in the B register for the number of lines left for the character build.
JP NZ,CHAR_PRNT The program will jump to the first instruction if the B register has not reached zero; this is another loop between this position and the first instruction where the label CHAR_PRNT was placed in the label field.
RET; RET=RETurn and returns the Program Counter to the address just after a CALL instruction that would be used to access this subroutine; the call instruction could be used anywhere in memory and would look like CALL CHAR_PRNT.

Note: I have used the colours the character is actually built up with, but this program does not account for this and would normally do this in black & white.

It may be best to watch the video in full screen.


If that seemed a little long winded remember the computer, depending on the speed of its clock, can perform the whole program in nano-seconds and that you only have to write the code once. In higher level languages much of the program would be written for you, but you have less control over how it performs these operations; swings and roundabouts.

In the words of Forest Gump, "That's all I have to say about that!"

Welcome to the world of computer programming!

Last edited by Ghislain on Sat Jan 25, 2014 1:37 pm, edited 2 times in total.
User avatar
Posts: 17
Joined: Sun Sep 08, 2013 11:59 am

Re: Answer to the question that may never be asked.

Postby Ghislain » Mon Jan 20, 2014 2:48 am

It is not necessary to understand the technology ... if you can’t follow it then take this part of what I say for granted as it isn’t the point of this thread.

Perhaps some who have an interest in how computers work may have gathered some useful information from the previous posts, however computing was not the primary intension of this thread as I said in the first post.

This brings me to the point of this thread; it is that to find the answers we seek we have to be sure we are asking the right question.

I don't know what that question is and thus I ask many hoping that I may recognise the right one if it comes along.

The important thing is not to stop questioning. Curiosity has its own reason for existing. One cannot help but be in awe when he contemplates the mysteries of eternity, of life, of the marvelous structure of reality. It is enough if one tries merely to comprehend a little of this mystery every day. Never lose a holy curiosity.

-- Albert Einstein

All authority of any kind, especially in the field of thought and understanding, is the most destructive, evil thing. Leaders destroy the followers and followers destroy the leaders. You have to be your own teacher and your own disciple. You have to question everything that man has accepted as valuable, as necessary.

-- J. Krishnamurti

The genius of our ruling class is that it has kept a majority of the people from ever questioning the inequity of a system where most people drudge along, paying heavy taxes for which they get nothing in return.

-- Gore Vidal

What we observe is not nature itself, but nature exposed to our method of questioning.

-- Werner Heisenberg

The creative individual has the capacity to free himself from the web of social pressures in which the rest of us are caught. He is capable of questioning the assumptions that the rest of us accept.

-- John W. Gardner

He who has a why can endure any how

-- Friedrich Nietzsche

The power to question is the basis of all human progress.

-- Indira Gandhi

You can tell whether a man is clever by his answers. You can tell whether a man is wise by his questions.

-- Naguib Mahfouz

Go to your bosom: Knock there, and ask your heart what it doth know

-- William Shakespeare

It is not the possession of truth, but the success which attends the seeking after it, that enriches the seeker and brings happiness to him.

-- Max Planck

The test of a good teacher is not how many questions he can ask his pupils that they will answer readily, but how many questions he inspires them to ask him which he finds it hard to answer

-- Alice Wellington Rollins

He who asks a question is a fool for five minutes; he who does not ask a question remains a fool forever.

-- Chinese proverb by Unknown Author

User avatar
Posts: 17
Joined: Sun Sep 08, 2013 11:59 am

Return to General Discussion

Who is online

Users browsing this forum: No registered users and 0 guests