How does the Internet work?

The "g" key is pressed

The following sections explains all about the physical keyboard and the OS interrupts. But, a whole lot happens after that which isn't explained. When you just press "g" the browser receives the event and the entire auto-complete machinery kicks into high gear. Depending on your browser's algorithm and if you are in private/incognito mode or not various suggestions will be presented to you in the dropbox below the URL bar. Most of these algorithms prioritize results based on search history and bookmarks. You are going to type "Google" so none of it matters, but a lot of code will run before you get there and the suggestions will be refined with each key press. It may even suggest "Google" before you type it.

The "enter" key bottoms out

To pick a zero point, let's choose the Enter key on the keyboard hitting the bottom of its range. At this point, an electrical circuit specific to the enter key is closed (either directly or capacitively). This allows a small amount of current to flow into the logic circuitry of the keyboard, which scans the state of each key switch, debounces the electrical noise of the rapid intermittent closure of the switch, and converts it to a keycode integer, in this case 13. The keyboard controller then encodes the keycode for transport to the computer. This is now almost universally over a Universal Serial Bus (USB) or Bluetooth connection, but historically has been over PS/2 or ADB connections.

In the case of the USB keyboard:

  • The USB circuitry of the keyboard is powered by the 5V supply provided over pin 1 from the computer's USB host controller.
  • The keycode generated is stored by internal keyboard circuitry memory in a register called "endpoint".
  • The host USB controller polls that "endpoint" every ~10ms (minimum value declared by the keyboard), so it gets the keycode value stored on it.
  • This value goes to the USB SIE (Serial Interface Engine) to be converted in one or more USB packets that follows the low level USB protocol.
  • Those packets are sent by a differential electrical signal over D+ and D- pins (the middle 2) at a maximum speed of 1.5 Mb/s, as an HID (Human Interface Device) device is always declared to be a "low speed device" (USB 2.0 compliance).
  • This serial signal is then decoded at the computer's host USB controller, and interpreted by the computer's Human Interface Device (HID) universal keyboard device driver. The value of the key is then passed into the operating system's hardware abstraction layer.

In the case of Virtual Keyboard (as in touch screen devices):

  • When the user puts their finger on a modern capacitive touch screen, a tiny amount of current gets transferred to the finger. This completes the circuit through the electrostatic field of the conductive layer and creates a voltage drop at that point on the screen. The screen controller then raises an interrupt reporting the coordinate of the key press.
  • Then the mobile OS notifies the current focused application of a press event in one of its GUI elements (which now is the virtual keyboard application buttons).
  • The virtual keyboard can now raise a software interrupt for sending a 'key pressed' message back to the OS.
  • This interrupt notifies the current focused application of a 'key pressed' event.

Interrupt fires [NOT for USB keyboards]

The keyboard sends signals on its interrupt request line (IRQ), which is mapped to an interrupt vector (integer) by the interrupt controller. The CPU uses the Interrupt Descriptor Table (IDT) to map the interrupt vectors to functions (interrupt handlers) which are supplied by the kernel. When an interrupt arrives, the CPU indexes the IDT with the interrupt vector and runs the appropriate handler. Thus, the kernel is entered.

(On Windows) A WM_KEYDOWNmessage is sent to the app

The HID transport passes the key down event to the KBDHID.sys driver which converts the HID usage into a scancode. In this case the scan code is VK_RETURN (0x0D). The KBDHID.sysdriver interfaces with the KBDCLASS.sys(keyboard class driver). This driver is responsible for handling all keyboard and keypad input in a secure manner. It then calls into Win32K.sys(after potentially passing the message through 3rd party keyboard filters that are installed). This all happens in kernel mode.

Win32K.sys figures out what window is the active window through theGetForegroundWindow() API. This API provides the window handle of the browser's address box. The main Windows "message pump" then callsSendMessage(hWnd, WM_KEYDOWN, VK_RETURN, lParam). lParam is a bitmask that indicates further information about the keypress: repeat count (0 in this case), the actual scan code (can be OEM dependent, but generally wouldn't be for VK_RETURN), whether extended keys (e.g. alt, shift, ctrl) were also pressed (they weren't), and some other state.

The Windows SendMessage API is a straightforward function that adds the message to a queue for the particular window handle (hWnd). Later, the main message processing function (called a WindowProc) assigned to the hWnd is called in order to process each message in the queue.

The window (hWnd) that is active is actually an edit control and the WindowProc in this case has a message handler for WM_KEYDOWN messages. This code looks within the 3rd parameter that was passed to SendMessage (wParam) and, because it is VK_RETURN knows the user has hit the ENTER key.

(On OS X) A KeyDown NSEvent is sent to the app

The interrupt signal triggers an interrupt event in the I/O Kit kext keyboard driver. The driver translates the signal into a key code which is passed to the OS X WindowServer process. Resultantly, the WindowServer dispatches an event to any appropriate (e.g. active or listening) applications through their Mach port where it is placed into an event queue. Events can then be read from this queue by threads with sufficient privileges calling the mach_ipc_dispatchfunction. This most commonly occurs through, and is handled by, an NSApplication main event loop, via an NSEvent of NSEventTypeKeyDown.

(On GNU/Linux) the Xorg server listens for keycodes

When a graphical X server is used, X will use the generic event driver evdev to acquire the keypress. A re-mapping of keycodes to scancodes is made with X server specific keymaps and rules. When the scancode mapping of the key pressed is complete, the X serversends the character to the window manager(DWM, metacity, i3, etc), so the window managerin turn sends the character to the focused window. The graphical API of the window that receives the character prints the appropriate font symbol in the appropriate focused field.

Parse URL

  • The browser now has the following information contained in the URL (Uniform Resource Locator):Protocol "http"Use 'Hyper Text Transfer Protocol'Resource "/"Retrieve main (index) page

Is it a URL or a search term?

When no protocol or valid domain name is given the browser proceeds to feed the text given in the address box to the browser's default web search engine. In many cases the URL has a special piece of text appended to it to tell the search engine that it came from a particular browser's URL bar.

Convert non-ASCII Unicode characters in hostname

  • The browser checks the hostname for characters that are not in a-z, A-Z, 0-9, -, or ..
  • Since the hostname is google.com there won't be any, but if there were the browser would apply Punycode encoding to the hostname portion of the URL.

Check HSTS list

  • The browser checks its "preloaded HSTS (HTTP Strict Transport Security)" list. This is a list of websites that have requested to be contacted via HTTPS only.
  • If the website is in the list, the browser sends its request via HTTPS instead of HTTP. Otherwise, the initial request is sent via HTTP. (Note that a website can still use the HSTS policy without being in the HSTS list. The first HTTP request to the website by a user will receive a response requesting that the user only send HTTPS requests. However, this single HTTP request could potentially leave the user vulnerable to adowngrade attack, which is why the HSTS list is included in modern web browsers.)

DNS lookup

  • Browser checks if the domain is in its cache. (to see the DNS Cache in Chrome, go to http://chrome://net-internals/#dns).
  • If not found, the browser calls gethostbyname library function (varies by OS) to do the lookup.
  • gethostbyname checks if the hostname can be resolved by reference in the local hostsfile (whose location varies by OS) before trying to resolve the hostname through DNS.
  • If gethostbyname does not have it cached nor can find it in the hosts file then it makes a request to the DNS server configured in the network stack. This is typically the local router or the ISP's caching DNS server.
  • If the DNS server is on the same subnet the network library follows the ARP processbelow for the DNS server.
  • If the DNS server is on a different subnet, the network library follows the ARP processbelow for the default gateway IP.

ARP process

In order to send an ARP (Address Resolution Protocol) broadcast the network stack library needs the target IP address to look up. It also needs to know the MAC address of the interface it will use to send out the ARP broadcast.

The ARP cache is first checked for an ARP entry for our target IP. If it is in the cache, the library function returns the result: Target IP = MAC.

If the entry is not in the ARP cache:

  • The route table is looked up, to see if the Target IP address is on any of the subnets on the local route table. If it is, the library uses the interface associated with that subnet. If it is not, the library uses the interface that has the subnet of our default gateway.
  • The MAC address of the selected network interface is looked up.
  • The network library sends a Layer 2 (data link layer of the OSI model) ARP request:

ARP Request:

Sender MAC: interface:mac:address:here
Sender IP: interface.ip.goes.here
Target MAC: FF:FF:FF:FF:FF:FF (Broadcast)
Target IP: target.ip.goes.here

Depending on what type of hardware is between the computer and the router:

Directly connected:

  • If the computer is directly connected to the router the router responds with an ARP Reply (see below)

Hub:

  • If the computer is connected to a hub, the hub will broadcast the ARP request out all other ports. If the router is connected on the same "wire", it will respond with an ARP Reply (see below).

Switch:

  • If the computer is connected to a switch, the switch will check its local CAM/MAC table to see which port has the MAC address we are looking for. If the switch has no entry for the MAC address it will rebroadcast the ARP request to all other ports.
  • If the switch has an entry in the MAC/CAM table it will send the ARP request to the port that has the MAC address we are looking for.
  • If the router is on the same "wire", it will respond with an ARP Reply (see below)

ARP Reply:

Sender MAC: target:mac:address:here
Sender IP: target.ip.goes.here
Target MAC: interface:mac:address:here
Target IP: interface.ip.goes.here

Now that the network library has the IP address of either our DNS server or the default gateway it can resume its DNS process:

  • Port 53 is opened to send a UDP request to DNS server (if the response size is too large, TCP will be used instead).
  • If the local/ISP DNS server does not have it, then a recursive search is requested and that flows up the list of DNS servers until the SOA is reached, and if found an answer is returned.

Opening of a socket

Once the browser receives the IP address of the destination server, it takes that and the given port number from the URL (the HTTP protocol defaults to port 80, and HTTPS to port 443), and makes a call to the system library function named socket and requests a TCP socket stream – AF_INET/AF_INET6 and SOCK_STREAM.

  • This request is first passed to the Transport Layer where a TCP segment is crafted. The destination port is added to the header, and a source port is chosen from within the kernel's dynamic port range (ip_local_port_range in Linux).
  • This segment is sent to the Network Layer, which wraps an additional IP header. The IP address of the destination server as well as that of the current machine is inserted to form a packet.
  • The packet next arrives at the Link Layer. A frame header is added that includes the MAC address of the machine's NIC as well as the MAC address of the gateway (local router). As before, if the kernel does not know the MAC address of the gateway, it must broadcast an ARP query to find it.

At this point the packet is ready to be transmitted through either:

  • Ethernet
  • WiFi
  • Cellular data network

For most home or small business Internet connections the packet will pass from your computer, possibly through a local network, and then through a modem (MOdulator/DEModulator) which converts digital 1's and 0's into an analog signal suitable for transmission over telephone, cable, or wireless telephony connections. On the other end of the connection is another modem which converts the analog signal back into digital data to be processed by the next network node where the from and to addresses would be analyzed further.

Most larger businesses and some newer residential connections will have fiber or direct Ethernet connections in which case the data remains digital and is passed directly to the next network node for processing.

Eventually, the packet will reach the router managing the local subnet. From there, it will continue to travel to the autonomous system's (AS) border routers, other ASes, and finally to the destination server. Each router along the way extracts the destination address from the IP header and routes it to the appropriate next hop. The time to live (TTL) field in the IP header is decremented by one for each router that passes. The packet will be dropped if the TTL field reaches zero or if the current router has no space in its queue (perhaps due to network congestion).

This send and receive happens multiple times following the TCP connection flow:

  • Client chooses an initial sequence number (ISN) and sends the packet to the server with the SYN bit set to indicate it is setting the ISN
  • Server receives SYN and if it's in an agreeable mood:Server chooses its own initial sequence numberServer sets SYN to indicate it is choosing its ISNServer copies the (client ISN +1) to its ACK field and adds the ACK flag to indicate it is acknowledging receipt of the first packet
  • Client acknowledges the connection by sending a packet:Increases its own sequence numberIncreases the receiver acknowledgment numberSets ACK field
  • Data is transferred as follows:As one side sends N data bytes, it increases its SEQ by that numberWhen the other side acknowledges receipt of that packet (or a string of packets), it sends an ACK packet with the ACK value equal to the last received sequence from the other
  • To close the connection:The closer sends a FIN packetThe other sides ACKs the FIN packet and sends its own FINThe closer acknowledges the other side's FIN with an ACK

TLS handshake

  • The client computer sends a ClientHellomessage to the server with its Transport Layer Security (TLS) version, list of cipher algorithms and compression methods available.
  • The server replies with a ServerHellomessage to the client with the TLS version, selected cipher, selected compression methods and the server's public certificate signed by a CA (Certificate Authority). The certificate contains a public key that will be used by the client to encrypt the rest of the handshake until a symmetric key can be agreed upon.
  • The client verifies the server digital certificate against its list of trusted CAs. If trust can be established based on the CA, the client generates a string of pseudo-random bytes and encrypts this with the server's public key. These random bytes can be used to determine the symmetric key.
  • The server decrypts the random bytes using its private key and uses these bytes to generate its own copy of the symmetric master key.
  • The client sends a Finished message to the server, encrypting a hash of the transmission up to this point with the symmetric key.
  • The server generates its own hash, and then decrypts the client-sent hash to verify that it matches. If it does, it sends its own Finished message to the client, also encrypted with the symmetric key.
  • From now on the TLS session transmits the application (HTTP) data encrypted with the agreed symmetric key.

HTTP protocol

If the web browser used was written by Google, instead of sending an HTTP request to retrieve the page, it will send a request to try and negotiate with the server an "upgrade" from HTTP to the SPDY protocol.

If the client is using the HTTP protocol and does not support SPDY, it sends a request to the server of the form:

GET / HTTP/1.1
Host: google.com
Connection: close
[other headers]

where [other headers] refers to a series of colon-separated key-value pairs formatted as per the HTTP specification and separated by single new lines. (This assumes the web browser being used doesn't have any bugs violating the HTTP spec. This also assumes that the web browser is using HTTP/1.1, otherwise it may not include the Host header in the request and the version specified in the GET request will either be HTTP/1.0 or HTTP/0.9.)

HTTP/1.1 defines the "close" connection option for the sender to signal that the connection will be closed after completion of the response. For example,

Connection: close

HTTP/1.1 applications that do not support persistent connections MUST include the "close" connection option in every message.

After sending the request and headers, the web browser sends a single blank newline to the server indicating that the content of the request is done.

The server responds with a response code denoting the status of the request and responds with a response of the form:

200 OK
[response headers]

Followed by a single newline, and then sends a payload of the HTML content ofwww.google.com. The server may then either close the connection, or if headers sent by the client requested it, keep the connection open to be reused for further requests.

If the HTTP headers sent by the web browser included sufficient information for the web server to determine if the version of the file cached by the web browser has been unmodified since the last retrieval (ie. if the web browser included an ETag header), it may instead respond with a request of the form:

304 Not Modified
[response headers]

and no payload, and the web browser instead retrieves the HTML from its cache.

After parsing the HTML, the web browser (and server) repeats this process for every resource (image, CSS, favicon.ico, etc) referenced by the HTML page, except instead of GET / HTTP/1.1the request will be GET /$(URL relative to www.google.com) HTTP/1.1.

If the HTML referenced a resource on a different domain than www.google.com, the web browser goes back to the steps involved in resolving the other domain, and follows all steps up to this point for that domain. The Host header in the request will be set to the appropriate server name instead of google.com.

HTTP Server Request Handle

The HTTPD (HTTP Daemon) server is the one handling the requests/responses on the server side. The most common HTTPD servers are Apache or nginx for Linux and IIS for Windows.

  • The HTTPD (HTTP Daemon) receives the request.
  • The server breaks down the request to the following parameters:HTTP Request Method (either GET, HEAD, POST, PUT,DELETE, CONNECT, OPTIONS, or TRACE). In the case of a URL entered directly into the address bar, this will be GET.Domain, in this case – Google.Requested path/page, in this case – / (as no specific path/page was requested, / is the default path).
  • The server verifies that there is a Virtual Host configured on the server that corresponds with Google.
  • The server verifies that Google can accept GET requests.
  • The server verifies that the client is allowed to use this method (by IP, authentication, etc.).
  • If the server has a rewrite module installed (like mod_rewrite for Apache or URL Rewrite for IIS), it tries to match the request against one of the configured rules. If a matching rule is found, the server uses that rule to rewrite the request.
  • The server goes to pull the content that corresponds with the request, in our case it will fall back to the index file, as "/" is the main file (some cases can override this, but this is the most common method).
  • The server parses the file according to the handler. If Google is running on PHP, the server uses PHP to interpret the index file, and streams the output to the client.

Behind the scenes of the Browser

Once the server supplies the resources (HTML, CSS, JS, images, etc.) to the browser it undergoes the below process:

  • Parsing – HTML, CSS, JS
  • Rendering – Construct DOM Tree → Render Tree → Layout of Render Tree → Painting the render tree

Browser

The browser's functionality is to present the web resource you choose, by requesting it from the server and displaying it in the browser window. The resource is usually an HTML document, but may also be a PDF, image, or some other type of content. The location of the resource is specified by the user using a URI (Uniform Resource Identifier).

The way the browser interprets and displays HTML files is specified in the HTML and CSS specifications. These specifications are maintained by the W3C (World Wide Web Consortium) organization, which is the standards organization for the web.

Browser user interfaces have a lot in common with each other. Among the common user interface elements are:

  • An address bar for inserting a URI
  • Back and forward buttons
  • Bookmarking options
  • Refresh and stop buttons for refreshing or stopping the loading of current documents
  • Home button that takes you to your home page

Browser High Level Structure

The components of the browsers are:

  • User interface: The user interface includes the address bar, back/forward button, bookmarking menu, etc. Every part of the browser display except the window where you see the requested page.
  • Browser engine: The browser engine marshals actions between the UI and the rendering engine.
  • Rendering engine: The rendering engine is responsible for displaying requested content. For example if the requested content is HTML, the rendering engine parses HTML and CSS, and displays the parsed content on the screen.
  • Networking: The networking handles network calls such as HTTP requests, using different implementations for different platforms behind a platform-independent interface.
  • UI backend: The UI backend is used for drawing basic widgets like combo boxes and windows. This backend exposes a generic interface that is not platform specific. Underneath it uses operating system user interface methods.
  • JavaScript engine: The JavaScript engine is used to parse and execute JavaScript code.
  • Data storage: The data storage is a persistence layer. The browser may need to save all sorts of data locally, such as cookies. Browsers also support storage mechanisms such as localStorage, IndexedDB, WebSQL and FileSystem.

HTML parsing

The rendering engine starts getting the contents of the requested document from the networking layer. This will usually be done in 8kB chunks.

The primary job of HTML parser to parse the HTML markup into a parse tree.

The output tree (the "parse tree") is a tree of DOM element and attribute nodes. DOM is short for Document Object Model. It is the object presentation of the HTML document and the interface of HTML elements to the outside world like JavaScript. The root of the tree is the "Document" object. Prior of any manipulation via scripting, the DOM has an almost one-to-one relation to the markup.

The parsing algorithm

HTML cannot be parsed using the regular top-down or bottom-up parsers.

The reasons are:

  • The forgiving nature of the language.
  • The fact that browsers have traditional error tolerance to support well known cases of invalid HTML.
  • The parsing process is reentrant. For other languages, the source doesn't change during parsing, but in HTML, dynamic code (such as script elements containing document.write() calls) can add extra tokens, so the parsing process actually modifies the input.

Unable to use the regular parsing techniques, the browser utilizes a custom parser for parsing HTML. The parsing algorithm is described in detail by the HTML5 specification.

The algorithm consists of two stages: tokenization and tree construction.

Actions when the parsing is finished

The browser begins fetching external resources linked to the page (CSS, images, JavaScript files, etc.).

At this stage the browser marks the document as interactive and starts parsing scripts that are in "deferred" mode: those that should be executed after the document is parsed. The document state is set to "complete" and a "load" event is fired.

Note there is never an "Invalid Syntax" error on an HTML page. Browsers fix any invalid content and go on.

CSS interpretation

  • Parse CSS files, <style> tag contents, and style attribute values using "CSS lexical and syntax grammar"
  • Each CSS file is parsed into a StyleSheet object, where each object contains CSS rules with selectors and objects corresponding CSS grammar.
  • A CSS parser can be top-down or bottom-up when a specific parser generator is used.

Page Rendering

  • Create a 'Frame Tree' or 'Render Tree' by traversing the DOM nodes, and calculating the CSS style values for each node.
  • Calculate the preferred width of each node in the 'Frame Tree' bottom up by summing the preferred width of the child nodes and the node's horizontal margins, borders, and padding.
  • Calculate the actual width of each node top-down by allocating each node's available width to its children.
  • Calculate the height of each node bottom-up by applying text wrapping and summing the child node heights and the node's margins, borders, and padding.
  • Calculate the coordinates of each node using the information calculated above.
  • More complicated steps are taken when elements are floated, positioned absolutely or relatively, or other complex features are used. Seehttp://dev.w3.org/csswg/css2/ and http://www.w3.org/Style/CSS/curr…for more details.
  • Create layers to describe which parts of the page can be animated as a group without being re-rasterized. Each frame/render object is assigned to a layer.
  • Textures are allocated for each layer of the page.
  • The frame/render objects for each layer are traversed and drawing commands are executed for their respective layer. This may be rasterized by the CPU or drawn on the GPU directly using D2D/SkiaGL.
  • All of the above steps may reuse calculated values from the last time the webpage was rendered, so that incremental changes require less work.
  • The page layers are sent to the compositing process where they are combined with layers for other visible content like the browser chrome, iframes and addon panels.
  • Final layer positions are computed and the composite commands are issued via Direct3D/OpenGL. The GPU command buffer(s) are flushed to the GPU for asynchronous rendering and the frame is sent to the window server.

GPU Rendering

  • During the rendering process the graphical computing layers can use general purpose CPU or the graphical processor GPU as well.
  • When using GPU for graphical rendering computations the graphical software layers split the task into multiple pieces, so it can take advantage of GPU massive parallelism for float point calculations required for the rendering process.

Window Server

Post-rendering and user-induced execution

After rendering has completed, the browser executes JavaScript code as a result of some timing mechanism (such as a Google Doodle animation) or user interaction (typing a query into the search box and receiving suggestions). Plugins such as Flash or Java may execute as well, although not at this time on the Google homepage. Scripts can cause additional network requests to be performed, as well as modify the page or its layout, causing another round of page rendering and painting.

SOURCE: Github

19 Replies to “How does the Internet work?”

  1. 1. What is the internet ?

    It is made up of millions of computers all over the world that are digitally connected to each other by cable, fibre or wireless links. You can use the internet to browse websites, communicate with people, download pictures and videos, listen to music or do lots of other amazing things.
    But have you ever wondered how the internet works?

    2. How it works ?

    Hello Miss Pigeon. You probably use the internet to coo to your pigeon friends on Tweeter! But have you ever wondered how it really works? If every bird’s nest was a computer, then the internet would be like connecting every bird’s nest together so they could all talk to each other. In computing speak, that’s called a network. But it’s not enough just to connect the nests together. The birds have to agree how they’ll use the connections too. Including how a message will be addressed and how it will get passed on. On the internet, these rules are called protocols. But what if you want to send something that’s too big? You would need to break it up into small pieces to get it there. The internet works in exactly the same way, but these small pieces are called packets. Each packet includes instructions about how it fits together and details about where it came from and where it is going. Each computer on the internet has a unique numeric address called an IP address, and these can be looked up automatically using a Domain Name Server, which is like a giant address book. When we have an address, the packets get guided through the internet by routers, which pass them along like a baton in a relay race. When the delivery arrives, the instructions explain how to put all the packets back together.
    Perfect!

    3. Making a request ?

    So how does information move around the internet?

    Let’s imagine you are visiting a webpage with an image on it. How does the image get to your computer?
    Sending a request
    The image is hosted on a web server. Your computer sends a request to the web server for the image.
    The request is sent in a ‘packet’. A packet is like a virtual parcel which has lots of important information attached to it. The two most important bits of information are the IP address of the web server that the image is stored on and the IP address of your computer.
    Special computers called routers, and devices called switches, direct the packet from your computer to the web server. The web server might be close by or on the other side of the world.
    Around the world

    The packet can be sent across the world through fibre optic cables under the sea or even by satellite.

    4. Receiving information ?

    Now that the packet has arrived the web server opens it and reads your computer’s request, in this case ‘please send me this image’.

    Images are often quite large so they need to be split up into lots of packets, often hundreds or thousands of them. All of these packets include information about how they should be put back together as well as where they are going and where they came from.

    Different routes
    The web server sends these packets back to your computer and once again routers and switches direct them.
    The routers try to find the fastest possible route for each packet. They might take different routes and might not arrive in the same order they were sent.

    Putting the packets back together
    Now that all the packets have been received the information attached to them tells your computer how to put them back together and the image will display on your screen.
    This whole process of sending a request and receiving the packets usually takes less than a second!

    5. Glossary

    Data packets :
    When information is being sent from one computer to another it is broken down into small bits of data called 'packets'. Each packet includes information about where the data is going to, where it is from and how to reassemble it.

    IP address :
    Computers use an IP address (Internet Protocol address) to identify each other. It's a bit like a postcode that is unique to each computer connected to the internet. An IP address is a set of numbers that might look like this: 195.188.87.10.

    Switch :
    A smart device that connects together many different devices so they can act as a network. Sometimes simpler devices called 'hubs' are used.

    Router :
    A smart device that directs or routes information around the internet. When a data packet arrives the router reads the IP address information and sends the packet along the best route to its destination.

    DNS :
    The DNS (Domain Name System) is a set of standards for how computers exchange data on the Internet. The DNS turns a user-friendly domain names like BBC – Homepage into an Internet Protocol (IP) address.

    that's how this  sea of information woks…

  2. Many people have mentioned the OSI model, so I'm going to take a slightly different crack, by rewording this question: How would you build the internet from the ground up?

    Basically the point of the OSI model is that for the most part, you shouldn't care about how the other layers work – just that they do what they're supposed to. So if we wanted to build the internet from scratch, we could do so layer by layer.

    So let's try to build our own little internet:

    1) The first thing we need is the ability to convert a piece of data inside my computer's memory to electric signals on a wire (or maybe radio waves, but let's stick to wired for now). This is called the "physical layer". A very common medium for this is twisted-pair copper cables (these are what many people call "ethernet wires"). So let's say a friend a of mine builds me the hardware I need to send data from one end of a twisted pair cable to another. Great!! Now I can connect two computers, and start sending raw ones and zeros from one computer to the other. Just a few problems though: What if some of these 1s and 0s get lost (due to electrical interference or otherwise)? What if my friend wants to send me some data at the same time as I want to send her data? What the hell is the other side going to do with these ones and zeros (we haven't said anything about format of the data we send)? And most importantly, an internet with just 2 computers is not very useful.

    2) The second layer (the "data link layer") addresses some of these problems. First, it tries to make point-to-point communication somewhat reliable – but coming up with strategies to deal with collisions, errors, etc … Second, it assigns a way of addressing devices on a network, so you can have more than two devices. If we are using twisted pair cables as our physical medium, the most common link layer protocol is called "Ethernet" (that's why the twisted pair wires are called ethernet wires). In Ethernet, each device has a MAC address – and you can connect computers to a device called "switch" which can forward "frames" from MAC address A to MAC address B. Pretty neat: Now instead of 2 computers, we can connect maybe 20-30 computers with each other, and we can be reasonably confident that a single unit of data (a "frame") will reach the other party. What we've built so far is called a "LAN segment", and is basically what you would have to connect all the computers in a small office, or all the computers in your home. Ok, I lied. We can use some tricks to go from 20 computers to maybe 200 or so (still in layer 2), and also use a trick called "bridging" to connect different physical mediums, but that still doesn't help us that much. Problem is, 20 (or even 200) computers is not a lot, all the computers need to be on the same physical network, and every computer needs to know the MAC address of every other computer. Of course we still haven't spoken about the hell we're going to send, but before we do that, we need to make our little internet more scalable.

    3) In walks layer 3 — the "network layer". This is the crux of what we call the internet. The key purpose of this layer is to be able to build a large network of networks, where every computer does not need to know about every other computer's existence. The internet uses a layer 3 protocol known as "IP" or the "Internet Protocol". Some key features of IP are: every computer has an address called an IP address. This IP address has two parts, the network address, and the host address. When trying to send messages to other computers on the same network (technically called a "subnet"), computers use something called "Address Resolution Protocol" to translate the IP address to a layer 2 MAC address and then send the packet the old way (by MAC address). But, here's the really neat part: when I'm sending something to a different network, we use something known as routing to figure out how to send it – even if I have no idea where that network is. Here's roughly how it works:
    I want to send a message to Google's web server (IP address: 173.194.219.105 — I'll talk about how I got that later). My computer looks at it's routing table, and says "hey, I don't know how to get there, but I do know that whenever I'm lost, I should send data to my "gateway" which for my computer is 192.168.0.1 (this is the "router" that sits in my apartment). Then the router in my apartment says: "hey, I don't know how to get to 173.x.x.x, but my routing table says when lost, send to 68.173.207.173 (the IP address of my ISP). And so on …. each step getting me a little closer to google. While at the first 2-3 steps (technically called "hops"), there's only one choice, later on the routers get much more complex and can send data in say 10 different directions. So they might have a routing table that looks like "send anything going to 160-192.x.x.x on one output (called an "interface"), send anything going to 32-64.x.x.x on another, etc ….". Eventually using this method, my message get's to google, even though neither me nor my computer have any clue where Google's server actually is. Amazing really.

    The IP suite of protocols also has useful things like "DNS" – which translates names like "http://www.google.com&quot; to 173.194.219.105. And a protocol called DHCP which allows computers to get assigned IP addresses automatically. And many others, but these are the key ones.

    4) So now I can send a message to Google. But what if I want to send many messages? Based on the above method, there's no guarantee they'll show up at Google in the same order I sent them. In fact, the reality is that some of them might now show up at all. So the next layer, "the transport layer", allows me to establish a "connection" to Google. This connection has things like sequence numbers, and a mechanism for "acknowledging" packets. This way if message 5 arrives before 4, Google's computer will know that they're out of order. Or if message 5 doesn't arrive but 6,7,8 arrive, Google will send a message back to my computer saying "hey can you send message 5 again". The protocol that does this is known as "TCP".

    6) Phew!! Now finally we can send messages from one end of the globe to another in a reliable way. And so now we can talk about what the hell we're sending to each other. The most common "application layer" protocol on the internet is called HTTP. This is used for browsing the web. Basically it defines a set of rules on how to "request" a webpage, and how the "web server" will send a "response". The browser running on my computer knows how to generate these requests, and decipher these responses, and then displays the response as a beautiful Google page on my screen. Phew, phew phew!!!!

    Now look this answer although extremely LOOOONNNGGG, barely scratches the surface. You can literally write many books on any one of these layers. If you want to learn more, a good place to start is: Computer Networks (5th Edition): Andrew S. Tanenbaum, David J. Wetherall: 9780132126953: Amazon.com: Books

  3. The Internet works because a collection of networks agree on protocols, methods and practices as a (scientific) community.  It's an open network, as long as you follow the open communities rules.  There are no significant politics involved, it's highly scientific in it's approach.  Protocols are developed in the open.

    It's all a collective effort.  Everyone benefits (or everyone suffers) the same.  I'm not sure there are m/any other good examples of such a collaborative effort among humans.  In this way, it's quite an amazing example of what humans can do together.

    The Internet is a collection of independent (autonomously run) networks.  Due to an open design and agreements between networks, the technology and protocols provide a very efficient method to exchange data between all networks connected.  Data is exchanged as "packets."  Each packet is a small chunk of data, generally between 50 and 1500 bytes per packet (on the open Internet).  "Jumbo" packets can traverse some networks, around 9000 bytes each.

    1MB (megaByte) of data takes approximately 690 packets, or more – depending on the host and network configuration, to transfer said data.  The overhead on such a transfer can vary, depending on the host and network configuration, but is as low as 2.7x%, and generally around the 3-4% area – in the real world.

    The Internet is efficient, salable, and the protocols and overhead provide very good resiliency.  The Internet is very effective at "guaranteeing" the delivery of data, without government intervention or regulation, without central authority.

    The Internet is a collection of many protocols, at many "layers" to allow applications to work over a network.  As a reference model, there is a 7 layer OSI model, which in todays reality is more like 5 layers… physical, data-link (switching/framing), network (routing/packets), transport (UDP/TCP / sessions) – the initial entry into the host OS, and the wider concept of application layer.

    The Internet works, as do computers, by how they process and transfer bits of data.  A bit is a 0 or 1 value.  It's all numbers.  The names we give things are layers on top of the underlying function.  One of the more important protocols, that few users give much thought to, is DNS.  DNS translates a name (domain name) to an IP address.  But many, many other protocols are needed to even allow that to happen… just some of the more common and basics are…  Ethernet, TCP/IP (TCP/UDP, IP addressing), BGP and more.

  4. Ok I'm trying to describe what actually happen when you type something in a browser in the simplest form possible.

    – You type Google into your browser  and the browser search for cache.
    – If cache cannot be found the browser will then ask your operating system  for the Google servers ip address.
    – OS now will make a DNS look up for Googles ip address.
    – When ip address has been found, the browser will pass it on to the              browser.
    – Now the browser will open a TCP (Transfer Control Protocol) connection to the Google's server and will send a HTTP request through it.
    – Upon receiving the HTTP response, the browser may close the open TCP connection or keep it connected for other purpose.
    – Browser then will check the Googles server response. Whether it is a 3xx Redirection request, 2xx Successful request,  4xx client or 5xx server         error.
    Browser will handle each response accordingly.
    – If Browser found that the Google's response is cacheble, it will store into the machine for future reference.
    – OK if your browser did found the cache while it searches for it in the first step, it will simply try to decode the response.
    – Then the browser will decide what to do with the response and what type of response is it (is it a video file, an image or a HTML file)
    – At last, the browser renders the response and you see the beautiful Google homepage on your screen, phew 🙂

  5. Using your computer, you can access  information (text, pics, vids) stored on other computers in other parts  of the world by connecting to them in the right way, just like houses  and businesses are all connected using road networks.

    Hardware – The Internet is really a collection of cables connecting users together.
    =  roads that connect us and allow us to drive around cities and countries

    Server – a computer that stores websites.  Servers  allow clients to connect to them and access their information from  anywhere in the Internet.
    = a mall, and each website saved on it is a shop in the mall

    Clients – The computers that use the Internet:  laptops, desktops, mobile phones, tablets, etc.  Every client has its  own unique address called an Internet Protocol (IP) address.
    = a house or shop with its own unique street address

    Internet Service Provider (ISP) – company that owns some Internet infrastructure and sells access to its network so that clients can use it
    = city with its own road networks, paid for with road tax (visitors can use the roads for free)

    Routers – computers that controls traffic of  messages between points on the Internet.  They keep information going  where it should and away from the places it should not.
    = trip planners, which choose the best route to travel

    Domain Name Servers (DNS) – servers that save lists of webpage names and direct traffic to the correct hosting servers
    = city phone book listing addresses

    Protocols – rules controlling the transfer of  information, so that all parts of the Internet can connect to all  others, and so all the machines connected can understand each other
    = traffic rules that all cars need to follow to avoid accidents (ex. driving on only one side of the street)

    Network Access Points (NAPs) – agreed points of connection between ISPs which allow users to connect to other parts of the Internet
    = points where the roads in one city connect to state or provincial highways

    Read more at How the Internet Works – KidsPressMagazine.com

  6. How the Internet Works (A Simple Explanation)

    I think it’s fair that most of us can’t imagine what it’d be like to live without the internet. Remember that time you dropped your iPhone in the toilet and had to live without an internet-connected phone for a couple of days? Tough, right? (Yea, I thought so) With the internet as ubiquitous as it is, how many of you have actually wondered what the internet is and how it works? It’s something I’ve wondered about and while I don’t prescribe to know all the intricate details of how this amazing system works, hopefully I can provide an analogy that gets us most of the way there.

    What is the Internet?

    When we talk about the Internet, what we’re actually referring to is an interconnected network of computers (hence, internet). Some of these computers are web servers, which are just specialized computers that contain and serve content from your favorite websites, and others are just the clientdevices we use everyday, like our laptops, tablets, and mobile phones. To make this discussion easier, take a look at the drawing below which I’ll be using for my internet analogy:

    For now, let’s ignore our own internet connected devices and focus on those web servers. Let’s imagine each of these web servers as a tall building and that they’re connected to each other via highways and roads. This network of highways and roads (which is made up of fiberoptic cables around the world) can be thought of as the Internet, and what travels along these highways and roads is data. Just like how physical buildings in real life have a mailing address, each of our web servers (which represents our favorite web sites like ESPN: The Worldwide Leader in Sports or Log In or Sign Up) have a unique address called an ip address.

    Now you might ask, “What about us? How do we connect to the internet?” That’s where our Internet Service Providers (ISP’s) come into play. You can imagine them as special buildings that allow our client devices to connect to the highways and roads. Continuing with our analogy, just think of each of our internet connected devices as a house with a driveway that leads to the ISP’s. And once your house is hooked up to the internet, you’re good to go!

    How does the Internet Work?

    Now that we have a (very) high level sense of what the internet is, how exactly does it work? This is where your browser comes into play.

    Your browser is what we call a “client application” and what this simply means is that its a program that allows you to make requests to different web sites and respond to the data that those web sites send back. To best explain how this works, I’ll list out some of the steps involved with making a request to ESPN: The Worldwide Leader in Sports:

    1. From our discussion above, remember how I said that each web server has its own unique ip address? Well, the web server for ESPN has its own ip address, which I found out is 199.181.33.61.
    2. When you type in “http://espn.go.com” into your browser, your browser somehow needs to know that this URL (i.e. uniform resource locator) actually means the ip address 199.181.33.61. So what the browser does is that it contacts the DNS (domain name service) and looks up the ip address for that url. You can think of the DNS as a phone book (do you kiddies even know what this is anymore??)
    3. Once the ip address is retrieved, your browser attempts to connect to the web server by opening up a socket connection. Without getting into the details, think of this as you physically calling the tall building (i.e. web server) and seeing if they’re still open. If someone responds, then you know they’re open and you’re connected.
    4. Now that your browser and the server have a open connection with each other, your request to a specific article on ESPN can be made. But before your request can be sent over the internet, it has to follow a set of rules that describe how the request must be formatted. These set of rules are known as TCP/IP and the HTTP protocol.
    5. Essentially, think of it like this: in order to travel along the highways and roads of the internet, every request made by your browser and every response sent by a web server must first be chopped up into small packets of data. You can think of your original request as a photo mosaic, and once its been chopped up, each tile represents a packet of data. Aside from containing the binary bits of data, each tile also knows the ip address its supposed to go to and how to reassemble itself once all the packets reach the destination ip address.
    6. Going back to our example of requesting a specific article on ESPN, the request for the article is chopped up into packets and sent along the highway and roads. Along the way, there are routers (and other similar devices) that basically act as traffic cops and direct the packets to the correct path leading to the ip address.
    7. Once all the packets of data arrive at the web server, the web server will look for the specific article, similar to how you’d look for a file in a cabinet drawer. Once the file has been located, the web server will chop up the response into data packets again, and send them back to your browser.
    8. Finally, when all the data packets arrive back at your browser, your browser will reassemble all packets into the HTML, CSS, JavaScript, and image files that represent the article. And once these files are processed, you’ll magically see the article displayed on screen.

    In a nutshell, that’s what the Internet is and how it works! And while I’ve glossed over MANY details of how this intricate system works, I think that for the majority of us, having this basic understanding of what happens behind the scenes will demystify some of the magic and help us appreciate the internet that we’ve come to rely on for, basically, everything.

  7. The Internet works by delivering packets, which are small chunks (20-1500 bytes) of data.  One at a time.  But doing so incredibly quickly.

    The basic protocol at the base of the Internet is called the (wait for it …) Internet Protocol (IP).  The current version of this protocol is version 4, so this is frequently called IPv4.  IPv4 packets use an address that helps them get to their destination.  Each IPv4 address is 32 bits long and unique to that host on the Internet [with the exception of NAT and RFC 1918 addresses]. 

    The address contains the location for its host, so by looking at the IP address, the switches in the Internet (known as routers) can pass the packet from router to router to the correct destination.

    Before a host can send a packet, it needs to figure out what address to use.  Usually, it ends up translating a Domain Name (e.g., http://www.quora.com) into an that IP address.  That is placed in the header of the packet as the destination address.  The packet is then handed over to the Internet, where routers will forward it up to the core of the Internet.

    In the core of the Internet, routers owned by various Internet Service Providers will coordinate with one another using the Border Gateway Protocol to exchange routing information.  This helps them direct traffic for particular destination hosts to particular routers, helping packets make their way to their final destination.  Eventually packets get there, are received, processed by the destination host, and then packets are returned back to the original sender simply by reversing the entire process.

  8. We bet you use the Internet every day. But do you actually know what happens when you type an address like http://djangogirls.org into your browser and press enter?

    The first thing you need to understand is that a website is just a bunch of files saved on a hard disk. Just like your movies, music, or pictures.However, there is one part that is unique for websites: they include computer code called HTML.

    If you're not familiar with programming it can be hard to grasp HTML at first, but your web browsers (like Chrome, Safari, Firefox, etc.) love it. Web browsers are designed to understand this code,follow its instructions, and present these files that your website is made of, exactly the way you want.

    As with every file, we need to store HTML files somewhere on a hard disk. For the Internet, we use special, powerful computers called servers. They don't havea screen, mouse or a keyboard, because their main purpose is to store data and serve it. That's why they're called servers — because they serve you data.

    OK, but you want to know how the Internet looks like, right?

    We drew you a picture! It looks like this:

    Looks like a mess, right? In fact it is a network of connected machines (the above mentioned servers). Hundreds of thousands of machines! Many, many kilometers of cables around the world! You can visit a Submarine Cable Map website (http://submarinecablemap.com) to see how complicated the net is. Here is a screenshot from the website:

    It is fascinating, isn't it? But obviously, it is not possible to have a wire between every machine connected to the Internet. So, to reach a machine (for example the one where http://djangogirls.org is saved) we need to pass a request through many, many different machines.

    It looks like this:

    Imagine that when you type http://djangogirls.org, you send a letter that says: "Dear Django Girls, I want to see the http://djangogirls.org website. Send it to me, please!"

    Your letter goes to the post office closest to you. Then it goes to another that is a bit nearer to your addressee, then to another, and another until it is delivered at its destination. The only unique thing is that if you send many letters (data packets) to the same place, they could go through totally different post offices (routers). This depends on how they are distributed at each office.

    Yes, it is as simple as that. You send messages and you expect some response. Of course, instead of paper and pen you use bytes of data, but the idea is the same!

    Instead of addresses with a street name, city, zip code and country name, we use IP addresses. Your computer first asks the DNS (Domain Name System) to translate http://djangogirls.org into an IP address. It works a little bit like old-fashioned phonebooks where you could look up the name of the person you want to contact and find their phone number and address.

    When you send a letter, it needs to have certain features to be delivered correctly: an address, stamp etc. You also use a language that the receiver understands, right? The same applies to the data packets you send to see a website. We use a protocol called HTTP (Hypertext Transfer Protocol).

    So, basically, when you have a website, you need to have a server (machine) where it lives. When the server receives an incoming request (in a letter), it sends back your website (in another letter).

    Since this is a Django tutorial, you will ask what Django does. When you send a response, you don't always want to send the same thing to everybody. It is so much better if your letters are personalized, especially for the person that has just written to you, right? Django helps you with creating these personalized, interesting letters :).

    Enough talk, time to create!.

    source:Choose a language

  9. There is no internet backbone, this is how the internet works:

    1. You request a web page or an email from Microsoft Outlook .
    2. Your local provider routes your request over their copper or fiber if you have fttp/c to their msan/exchange
    3. At the exchange your request goes onto a backhaul network to an IP-X (internet exchange)
    4. At the IP-X your provider "peers" with other providers. Some peers will demand payment for transport, some will do it for free (like facebook or google), some will exchange packets on a swap basis (for example "I will take as many packets as you send"). Your provider has to figure this out, but there is no free lunch people do not accept peering for nothing – Facebook and Google appear to, but in fact they are keen to have a request from you because it is what their business model (advertising) needs. The peers will advertise a route to the destination you want, the shorter the route the more likely it is to be picked. Facebook (for example) will advertise the shortest possible route to facebook (no surprises) and therefore will get the packets for facebook! On the other hand they will not be advertising any routes to, for example anotherfacebookclone. Other peers may propagate routes from other providers that they have peered with else where, providing (in aggregate) a route to anywhere from everywhere – the internet if you like. Some providers will offer "transit", and advertise many routes to geographically distant networks. This class of provider is often known as a "backbone", as they exist to connect other networks, a prime example would be Level 3.
    5. Your request goes to the service provider you asked it to, the server there sorts out a response and sends it back.
    6. The service provider sends the packets either over their local providers copper/fiber access and backhaul or over their private network (if they are Amazon, google ect ect)
    7. Your local provider peers onto that network, or a network that peers onto it, or a network that peers onto that one (on and on)
    8. Your local provider routes the packets to you over their backhaul, to the exchange/msan and the over the copper / fibre to your house.

    So – it's a big happy, mostly fair, a bit unjust, but sort of ok soup.

    The bit which is not soup, is the access network, the local bit to your house, which requires lots of trenches to be dug and a big investment to build – which is economically … problematic.

  10. The Internet is made up of computers all over the world. Each of these computers is connected by phone lines or cables…or even wireless connections!

    If your computer is connected to the Internet, it speaks a special language with other computers called TCP/IP. This language allows you to get information, send messages to friends, listen to music, watch videos, and visit HDCON2018!

    To get a practical understanding of how the Internet works, let's look at email. If you type an email to your friend, your computer, just like the post office, will want to know where to deliver the message. That is why you provide an email address.

    Your computer uses the information in the email address to figure out where to send your message. Unlike a phone, which transmits your voice, the computer transmits your message in the language of the Internet.

    You've probably heard of the World Wide Web by now. You may have even WONDERED what spiders are doing on the Internet! Fortunately, the "World Wide Web" has nothing to do with our eight-legged friends. The World Wide Web (WWW) is just a part of the internet that strings together bits of information to make them easier to find.

    Let's pretend you're writing a report on the history of your hometown. You head to your public library to find some local history books. Imagine how long it would take you to find the information you needed if all the books in the library were thrown in a giant pile.

    Thankfully, your library is logically organized into sections, and each section is clearly labeled. All you need to do is go to the non-fiction area, find the history shelf, and locate the local history section. Within minutes you have access to the information you need.

    This is how the World Wide Web works, too. Instead of all the information on the Internet being thrown together in an electronic pile, the World Wide Web creates links between related information to help keep it organized.

    Register today for #HDCON2018 to know about more web technologies.

  11. “How does the Internet work?”

    Let me try to explain it in a very simple way. Now, what you need to note here is that, internet is very complex and there are a lot of things going on to make it work efficiently and I might miss some of them in the process of making it simple, but this is the gist of how it actually happens.

    So, how does it work?

    Let’s say you open your browser and type google.com, the browser puts it in a letter in an envelope and sends it via apostman. Like any postman, this postman also has to follow certain rules. These rules are mandatory if he needs to reach Google. The ultimate goal of your postman is to reach Google (or your targeted website) with your letter and deliver it without any damage. But to reach there, there are some places where the postman needs to go first in order to get some help. The first of these places is your Internet Service Provider (ISP). The ISP directs your postman to one of the Domain Name System (DNS) server. DNS is an office which contains addresses of websites. There are many DNS’s and it your ISP’s job to guide the postman to the correct DNS. Postman gives the envelope to DNS, DNS converts it to an IP address and checks the IP address in its directory and tells the postman where google.com is located. On the way to google.com, there are many sign posts to help postman reach google.com. The postman follows that path and delivers your letter. In return, after reading the contents of your letter, google.com sends its own postman or postmen with a letter(s) in envelope addressing your requests (which can be anything, example: "How do I make a pizza?"). These new postmen are told where their letter is in the sequence. At your end, the letters are arranged in their correct order and you get to access the website.

    In this example, letter is the content of your request; website name, data you provide, etc.

    The envelope is encryption so that no one can see what you’re sending.

    Postman is a protocol like TCP/IP, UDP, etc.

    The sign posts along the way to Google are routers which use algorithms to determine best and shortest path for the postman.

    I have also posted this on LinkedIn as an article “How does the Internet work?”

    You can find it here: http://bit.ly/intwork

  12. Here is the sequence of steps

    1. When you hit enter in the address bar of the browser it triggers the function to make a "GET" request. This is known as a HTTP request.
    2. This function requests google.com to your gateway (it's the router which your network wire behind your system goes to)
    3. Your router makes a request to the DNS server it's configured to ask "Hey give me the IP of google.com". Depending on the configuration the router might be asking the DNS of your ISP (the company who provides your internet connection) or any open DNS servers. These DNS servers are basically the phone books of the internet mapping the website name to the IP address (which is equivalent to the physical address of a place)
    4. The DNS returns the IP of google (or one of it's servers) and the router requests the ISP to make the GET request to the server.
    5. The server decodes the GET request and since the user requests the front page of google it returns the HTML code for it in the same HTTP format. This is called a HTTP response.
    6. The browser which had a thread to make the request gets back the response and therefore starts to "render" the HTML code in it's window.
    7. Since the HTML code contains links to other images, etc. it makes several GET requests to the same server (it doesn't have to query the DNS as it already knows the google server location due to "caching")

    And that's how you see the loading happen and see the Google website in front of you. I have left out a lot of intricate details such as packetization, handshaking, chopping, sequencing, framing, reassembly, etc. which happens in between. These are rather too technical and are of concern to anyone who intends to make a career in the networking domain.

    Also take a look at this. It will help you get a better understanding of the web >> 20 Things I Learned About Browsers and the Web

  13. How do you use INTERNET…from electronic devices ..right.  Now how these electronic devices gets power/energy …from electronic signals (electric signals) .

    1) In electronics, a signal is an electric current or electromagnetic field used to convey data from one place to another. The simplest form of  signal is a direct current (DC) that is switched on and off; this is the  principle by which the early telegraph worked. More complex signals  consist of an alternating-current (AC) or electromagnetic carrier that  contains one or more data streams.

    Data is superimposed on a carrier current or wave by means of a process called modulation. Signal modulation can be done in either of two main ways: analog and digital.  In recent years, digital modulation has been getting more common, while  analog modulation methods have been used less and less. There are still  plenty of analog signals around, however, and they will probably never  become totally extinct.
     
    Except for DC signals such as telegraph and baseband, all signal carriers have a definable frequency or frequencies. Signals also have a property called wavelength, which is inversely proportional to the frequency.
     
     2) In some information technology contexts, a signal is simply "that  which is sent or received," thus including both the carrier (see 1) and  the data together.

  14. Question is perhaps worded badly. There are numerous layers at work on the "Internet", each more complex than the last!

    To simplify it somewhat, I will assume you mean how does it work when, say you enter http://quora.com into the browser?

    The first thing that happens is that the browser will do a DNS lookup. So it will ask the DNS server (usually your ISP, or on the network) what the IP address of http://quora.com is. It will return the IP address: 54.84.216.68. The browser will send a GET HTTP request to this address. to get the web page. the Server at quora will receive the request, processes it and return its HTML page.

    Slightly below that is the IP layer. So on your device it will break up the GET request into packets, each packet has a header that contains where it is going and where it came from etc etc. The packets go from switch to switch until it reaches the quora server network card. which will rebuild the packets into the request and pass it to the HTTP server. It will do the same to send back the request to your device.

  15. Internet, the one which changed everyone’s life today. If you are viewing this blog means, then you are connected to the internet. Thanks to the internet, because it helps you and me to connect. So, you are here for one of the two reasons, either you want to know about how internet works or simply you came by chance. Anyways, I am sure that you will understand how internet works when you finish this one.

    What Browser does ?

    I will start with you, because you are viewing this blog from your PC or your mobile phone. Your browser is an app which converts a code into suitable format and presents it to you. There are many types of coding languages available for a web page. If you have come across this word HTML, then you know something about web. Yes, HTML is one of the programming languages which can be used for creating websites. There are many but most basic one is HTML. Let us assume that my website is created using HTML. Then, it will look something like this,

    sample source code of website

    Your browser reads these codes and shows only the content to you. How easy it is…!!!. If it doesn’t do it, then we all will go crazy when we try to read the content. You can also try to see the actual code of my website by right clicking anywhere on my website and click ”View Page Source” or by simply using the keyword “CTRL + U” (for chrome users). A new tab containing the codes will show up. Now, you will realize the worth of your browser, won’t you ?

    How you connect to Internet ?

    So, now you know what your browser does, but still how my page reached you…??? Yes , obviously through the internet. Internet is a big pool. So, you must need access to swim into that pool. That access is provided by your Internet Service Provider (ISP). They charge you a fee for connecting you to the internet, because it involves lots of special equipment and labor. So, don’t think that what you pay for your mobile network company goes to the websites like google, facebook etc.. The money you pay is for ISP, which is used for connecting you to the internet.

    Again the same question, how my page reached you…??? Yes, through the internet only, but if you still go one step down, your browser has loaded my web address or IP (Internet Protocol) address. You may have clicked any link to my website or you have typed my address in the URL (Uniform Resource Locator), and that’s how you are viewing this blog. Remember, every website has its own unique address. Mine is College Blogger .

    Where is my Website?

    Then, where is this page in the internet. It is not in my home or in my PC. Because if I want to have it in my PC, then I need to setup huge data cables, high speed data connection, and all other technical stuffs which I don’t know. Then where it is ? I have placed in a web hosting service provider. There are many, I use godaddy at present. Web Hosting is similar to renting a house, you may not have enough money to build your own house, but you can get a room for rent. This is what I have done. I got a place for rent in godaddy, they have all the necessary stuff to get my content online. It’s simple, you will know if you go through my other blogs. Next step is getting an address for me, actually this is not next step, you can do the other way also. The address is the one that makes you to reach my page, if you don’t know that, then you can’t reach my page directly…!!!

    Then, what else, is it over…??? NO, it’s not. Every website has a unique address as I said. So, when you type an address (URL) in your browser, that address is sent as a command to the server. The server will try to locate the address in the internet and then take it and send it back to you. The servers are provided by the hosting companies. I am saying hosting company to make it clear, that the company has all the services required for a website. From getting domain name to selling a product online, you can get from them. Hope now you have an idea of how internet and websites work.

    please visit our website for further details

    http://collegeblogger.in/know-ho

  16. Internet a wonderful world of numbers bits data and all.

    Firstly generated was Web,  just 30 computers connected with a cable which makes you to exchange data. Which later coined as intranet.  Then with invention of wireless adapter ,  they tried to connect computer which they coined as Web (still you can connect with wires )

    Now one Genious person in bell laboratory (don't know his name )wanted to access these data or files of Web in his personal computer.  Here the journey of Internet started

    Firstly there were individual macro computers set up called servers were installed called domain servers. Then connected to that few more micro computers were installed called name servers. .  now this person on his computer set up an IP,  and all the other computers are also having IPs.

    As its hard to remember all these numbers or IPs  he gave names to it,  this ceremony of name giving is called DNS. 

     Now all the macro computers IPs are given names like, com,in,edu,UK,etc.  All micro computers are given names as  Co,., Google etc.  And WWW is the Web. Also known as world wide Web

    Now this man has created a technic,  when we search for http://WWW.Google.com it will first search the address in Web,  then Web will direct to micro server(Computer )Google and from Google it will get the address from macro server (computer) . Com.  Once you get the address of that computer with the whole part,  you will be able to access files from that computer (server)

    This is how Internet work

    Now why it varies from country to country
    It's because if u have a smart phone it works better than the ordinary phone,  similarly in India out service providers use some cheap material and hardware (servers) which makes it slow whereas in abroad they use optical fibers,  or high band network adapters or booster to get high speed

    The one who manage Internet are people working in data centers some government some private,  they operate flow of Internet they are the conissors

    P.S for the sake of illustration I used servers=computers the only difference in both is with hardware.

    P.S the story telling aspects here is only for understanding,  it's fictional.

  17. Domain Name System:

    As a internet user what we know are names of the web sites. But what happens when you type the domain name?
    On the backyard everything happens with ipaddress and data packets. Any thing that is connected via Internet should have a ip-address based on which communications are done.
    When ever you connect to internet, an ip address is assigned to your machine.

    Ip Address is a number system which will have four 3 digit numbers seperated by (.) dot. Each part can have a miximum value of 255. example: 192.167.11.222.

    This ip address is assigned to your PC by your ISP (Internet Service Provider). ISP is the company from which you have purchased the internet package.


    To explain in detail, we will assume that you are typing a website say XYZ.com in a browser. The following process takes place one by one.
    a) Your PC contacts your ISP name server (e.g: NS-A) and request for any detail of the ip-Address of ,suppose xyz.com

    Name Server
    Every ISP and servers (hosting company) will have a server called name server where the ip address to domain name mapping is done.

    b) NS-A gets in touch with the root servers and gets the address of the .com TLD server. There are totally around 13 root server located in different parts of the world. They give the information of TLD Name servers.
    c) NS-B is the name server that has ip-address info for xyz.com
    d) Each TLDs (e.g: .com, .net, .org,..) servers have the information of all the lower hierarchy Name Servers (e.g NS-B). Thus the .com TLD server fetches the hioxindia.com's ip-address from the NS-B to NS-A.
    e) Now the request data (called as packet) for required details is send from your PC with the from ip and destination ip (supose, xyz.com) thro internet.
    f) The data travels thro the internet network and reaches the destination ip.
    g) There the data if verified and it sends back the details with its ip-address as source and our PC's ip-address as destination
    h) The data travels thro the dense internet network and reaches you.
    Once the ip of a destination website is fetched it will remain in a cache for some period of time. So when ever the name server details is required it will be searched first in cache. Name Server will be requested for details only in the cache does not contain the required details.

  18. The internet is a net, i mean contless nodes connect with each other.
    How can they connect/communicate with each other ? they have common machine language: protocol (0|1,tcp/ip,ssl,sctp,etc. transport layer or application layer,whatever).
    Now suppose you are in USA as a client, me in China as a server, and a node in Japan between us as a routing helper,forwarding data that  we want to give or fetch.
    The role of server or client is not fixed .You have resources that others need, you can be a server unless you learned the common language (installed that protocol).

    Just now you requested a file named file.pdf lives on my server called robert.server. Wait ,how do you forge that request ? You may have clicked a (http)link on my
    website pointing to http:// robert.server /file.pdf using you opera(chrome/ie/android) browser. The browser now acts as an agent of you send this request from your pc(chromebook/pad/mobile) to the outside world reaching to me.

    Once the request is made, a dns lookup is fullfilled, finding out where the server is. As here,suppose robert.server is 58.61.47.180,an ip belongs to Chinanet Shenzhen City.

    Now begin a streamed line as the OSI model defines:
    1.  the request is translated into rawbit stream by the nic.
    2.the layer 2 device(maybe a switch) will check weather robert.server is in the same network(ie,LAN) with you. No ? forworded the request data to the layer 3
    3.the layer3 device,usually a routing machine that have a routing table knows how to reach a centain outside node.The table here tell you that you MAY (not have to) go through a japan node to reach me.
        we say the internet is flat and not any node is important, because if the japan node collapsed or is blocked, you can even reach me through a node in south africa (crazy but its true)(but a premise your isp have to do)
    4. can you express yourself in one breath ? what if you drunk too much and lost your words ? that's exactly the layer 4 protocol deals with.
    5/6 . What else you want from the server after this file.pdf ?  are u and the server are close friends and dont wan't the others listen what you talked ? the conversation and presentation layer solve these problems(not totally secure).
    7. the server get your request data and reply  you requested file.pdf .

    ps: i choose to ignore some aspects, because the mainframe above may better help to understand the internet relays, also i don't have the ability to illustrate the internet with details.
    And forgive my poor English.

  19. A2A, How does the Internet work?

    In its simplest form, the internet is a telecommunications system that allows computers and assorted other devices to communicate with each other using the same communications language, a protocol called TCP/IP, transmission control protocol / internet protocol.

    I could give a long lecture on all the nuts and bolts, and technical details, but what makes the internet possible is the common language, the protocols, that the computers speak. TCP/IP has spanned across generations of computers, using different operating systems.

    It doesn't matter if the humans using the computers are communicating in English, French, German, or Chinese, the computers are communicating in TCP/IP. That's pretty amazing if you think about it. How many other things are done exactly the same way, everywhere in the world?

    That's about as much of a quick and easy answer I would give without knowing more about the person asking the question. To go into much more detail on how TCP/IP really depends on the audience you are speaking with. To go into a detailed explanation of TCP/IP and packet switching, as others have attempted in answering this question, can be confusing.

    For a non technical person, to really understand how does the internet work, I would look at some of the questions here on Quora on the history of the internet, and how it evolved. The Internet we know today was not developed from a single network that simply grew and grew, it was an evolution of many different communications and technology tools coming together.

    For someone who is learning technology, and wants to understand how does the internet work, I would look at the J.C.R. Licklider paper “Man-Computer Symbiosis,” published in 1960, it provided a guide for decades of computer research to follow. I would follow that up with the work of Paul Baran who developed packet switching in the 1960s. The work of geeks like Licklider and Baran in the 1960 created the foundation for the work of Vinton Cerf and Bob Kahn who developed TCP/IP in the 1970s.

Leave a Reply

Your email address will not be published. Required fields are marked *