Case Study : Comparison of LINUX and Windows
Features LINUX
The history of Linux began in 1991 with
the commencement of a personal
project by Finnish student Linus
Torvalds to create a new free operating
system kernel. Since then, the
History resulting Linux kernel has been marked
by constant growth throughout its
history. Since the initial release of
its source code in 1991, it has grown
from a small number of C files under a
license prohibiting commercial
distribution to the 4.2.3 version in 2015
with more than 18 million lines of
source code under the GNU General
Public License v2.
Modern Unix-derivatives are generally
based on module-loading monolithic
kernels. Examples of this are the Linux
kernel in its many distributions as well
as the Berkeley Software
Distribution variant kernels such
Kernel as FreeBSD, DragonflyBSD, OpenBSD, Ne
tBSD,and macOS. Apart from these
alternatives, amateur developers
maintain an active operating system
development community, populated by
self-written hobby kernels which mostly
end up sharing many features with
Linux, FreeBSD, DragonflyBSD, OpenBSD
or NetBSD kernels and/or being
compatible with them.
Windows
Microsoft Windows was announced by Bill
Gates on November 10, 1983.
Microsoft introduced Windows as a graphical
user interface for MS-DOS, which had been
introduced a couple of years earlier. In the
1990s, the product line evolved from
an operating environment into a fully
complete, modern operating system over two
lines of development, each with their own
separate codebase.
Microsoft also developed Windows NT, an
operating system with a very similar interface,
but intended for high-end and business users.
This line started with the release of Windows
NT 3.1 in 1993, and was introduced to general
users with the release of Windows XP in
October 2001—replacing Windows 9x with a
completely different, much more sophisticated
operating system. This is the line that continues
with Windows 10.
The architecture of Windows NT's kernel is
considered a hybrid kernel because the kernel
itself contains tasks such as the Window
Manager and the IPC Managers, with a
client/server layered subsystem model.
 Shell is a UNIX term for the interactive
user interface with an operating system.
The shell is the layer of programming
that understands and executes the
commands a user enters. In some
Shell systems, the shell is called a command
interpreter
A Shell provides you with an interface to
the Unix system. It gathers input from
you and executes programs based on
that input. When a program finishes
executing, it displays that program's
output.
Shell is an environment in which we can
run our commands, programs, and shell
scripts. There are different flavors of a
shell, just as there are different flavors
of operating systems. Each flavor of
shell has its own set of recognized
commands and functions.
Linux creates a process whenever a
program is launched, either by you or by
Linux. This process is a container of
Process information about how that program is
Management running and what’s happening.
If the process runs and terminates
correctly, then everything is hunky-dory;
however, if it hogs the CPU, or refuses
to go when its time is up, then the Linux
commands described below may help
you to restore law and order.
The Windows shell is the graphical user
interface for the Microsoft Windows operating
system. Their readily identifiable element
consists of the desktop, the taskbar, the Start
menu, the task switcher and the Autoplay
feature. On some versions of Windows, it also
includes Flip 3D and the charms. However, the
Windows shell also implements a shell
namespace that enables computer programs
running on Windows to access the computer's
resources via the hierarchy of shell objects.
"Desktop" is the top object of the hierarchy;
below it there are a number of files and folders
stored on the disk, as well as a number of
special folders whose contents are either
virtual or dynamically created.
Process management is an integral part of any
modern-day operating system (OS). The OS
must allocate resources to processes, enable
processes to share and exchange information,
protect the resources of each process from
other processes and enable synchronization
among processes. To meet these requirements,
the OS must maintain a data structure for each
process, which describes the state and resource
ownership of that process, and which enables
the OS to exert control over each process.
Memory Management in LINUX:
The memory management subsystem is one of the most important parts of the
operating system. Since the early days of computing, there has been a need for more
memory than exists physically in a system. Strategies have been developed to overcome
this limitation and the most successful of these is virtual memory. Virtual memory
makes the system appear to have more memory than it actually has by sharing it
between competing processes as they need it.
Virtual memory does more than just make your computer's memory go further. The
memory management subsystem provides:
 Large Address Spaces:
The operating system makes the system appear as if it has a larger amount of
memory than it actually has. The virtual memory can be many times larger than
the physical memory in the system.
 Protection:
Each process in the system has its own virtual address space. These virtual
address spaces are completely separate from each other and so a process running
one application cannot affect another. Also, the hardware virtual memory
mechanisms allow areas of memory to be protected against writing. This protects
code and data from being overwritten by rogue applications.
 Memory Mapping:
Memory mapping is used to map image and data files into a processes address
space. In memory mapping, the contents of a file are linked directly into the
virtual address space of a process.
 Fair Physical Memory Allocation:
The memory management subsystem allows each running process in the system a
fair share of the physical memory of the system.
 Shared Virtual Memory:
Although virtual memory allows processes to have separate (virtual) address
spaces, there are times when you need processes to share memory. For example
there could be several processes in the system running the bash command shell.
Rather than have several copies of bash, one in each processes virtual address
space, it is better to have only one copy in physical memory and all of the
processes running bash share it. Dynamic libraries are another common example
of executing code shared between several processes.
Memory Management in Windows:
Microsoft provides an resource describing Windows Operating System Memory
Management on their Windows Development Desktop technologies site. Each process
on 32-bit Microsoft Windows has its own virtual address space that enables addressing
up to 4 gigabytes of memory. Each process on 64-bit Windows has a virtual address
space of 8 terabytes. All threads of a process can access its virtual address space.
However, threads cannot access memory that belongs to another process, which
protects a process from being corrupted by another process.

 32-bit memory architecture:

The 32-bit Windows Operating System addressable memory space is shared

between active applications and the kernel as shown in Figure B1.1. The kernel
address space includes a System Page Table Entry (PTE) area (kernel memory
thread stacks), Paged Pool (page tables, kernel objects), System Cache (file cache,
registry), and a Non Paged Pool (images, etc).
The default 32-bit Windows Operating System (OS) configuration provides up to 4
GB (2^32) of addressable memory space divided equally between the kernel and
the user applications. With 4 GB of physical memory available, 2 GB will be
allocated to the kernel and 2 GB to application memory. The kernel mode address
space is shared across processes and the application mode access space is
allocated for each user process (each process has it’s own space).

 64-bit memory architecture:

The 64-bit Windows Operating System addressable memory space is shared

between active applications and the kernel as shown in Figure B1.2. The kernel
address space includes a System Page Table Entry (PTE) area (kernel memory
thread stacks), Paged Pool (page tables, kernel objects), System Cache (file cache,
registry), and Non Paged Pool (images, etc).
File Management in LINUX:

All data in Unix is organized into files. All files are organized into directories. These
directories are organized into a tree-like structure called the filesystem.
When you work with Unix, one way or another, you spend most of your time working
with files. This tutorial will help you understand how to create and remove files, copy
and rename them, create links to them, etc.

In Unix, there are three basic types of files –

1. Ordinary Files: An ordinary file is a file on the system that contains data, text, or
program instructions. In this tutorial, you look at working with ordinary files.

2. Directories: Directories store both special and ordinary files. For users familiar with
Windows or Mac OS, Unix directories are equivalent to folders.

3. Special Files: Some special files provide access to hardware such as hard drives, CD-
ROM drives, modems, and Ethernet adapters. Other special files are similar to aliases or
shortcuts and enable you to access a single file using different names.
File Management in Windows:

File management is organizing and keeping track of files and folders, helping you stay
organized, so information is easily located. A folder is a container for storing programs
and files, similar to a folder in a file cabinet. As with a file cabinet, working with poorly
managed files is like looking for a needle in a haystack—it is frustrating and time-
consuming to search through irrelevant, misnamed, and out-of-date files to find the one
you want. Windows allows you to organize folders and files in a file hierarchy, imitating
the way you store paper documents in real folders. Just as a file cabinet contains several
folders, each containing related documents with dividers grouping related folders
together, so the Windows file hierarchy allows you to organize your files in folders, and
then place folders in other folders. Windows 7 comes with four libraries: Documents,
Pictures, Music, and Videos. Libraries (New!) are special folders that catalog folders and
files in a central location. A library includes and displays folders that are stored in
different locations on your computer, Homegroup, or network.

Using the file management tools, you can save files in folders with appropriate names
for easy identification, quickly and easily create new folders so you can reorganize
information and delete files and folders that you no longer need. You can also search for
a file when you cannot remember where you stored it, create shortcuts to files and
folders for quick and easy access, and even compress files and folders to save space.

A folder can hold different types of files, such as text, spreadsheets, and presentations.
The Documents folder is the main location in Windows 7 where you store your files.
However, there are some special folders, such as Pictures and Music, designed with
specialized features to store specific types of files.
Comparison of networking in LINUX and Windows:

 Linux is a multiuser operating system: More than one user can log on and use a Linux
computer at the same time:
Two or more users can log on to a Linux computer from the same keyboard and monitor
by using virtual consoles, which let you switch from one user session to another with a
special key combination.
Users can log on to the Linux computer from a terminal window running on another
computer on the network.

 Linux doesn’t have a built-in graphical user interface (GUI) as Windows does:The GUI
in Linux is provided by an optional component called X Window System. You can run
Linux without X Window, in which case you interact with Linux by typing commands. If
you prefer to use a GUI, you must install and run X Window.
X Window is split into two parts:
A server component — X Server — manages multiple windows and provides graphics
services for application programs.
A UI component — a window manager — provides user interface (UI) features, such as
menus, buttons, toolbars, and a taskbar.

 Linux can’t run Windows programs: Nope, you can’t run Microsoft Office on a Linux
system; instead, you must find a similar program that’s written specifically for Linux.
Many Linux distributions come with the OpenOffice suite, which provides word
processing, spreadsheet, presentation, graphics, database, email, calendar, and
scheduling software. Thousands of other programs are available for Linux.

 Linux doesn’t do Plug and Play the way Windows does: Major Linux distributions come
with configuration programs that can automatically detect and configure the most
common hardware components, but Linux doesn’t have built-in support for Plug-and-
Play hardware devices. You’re more likely to run into a hardware-configuration problem
with Linux than with Windows.
Input Output in LINUX:

Linux and other Unix-like operating systems feature the concept of standard
streams of data. Each command, and therefore each process (i.e., running instance of
a program), is automatically initialized with (i.e., assigned) three data streams: one input
stream, called standard input, and two output streams, called standard
outputand standard error. These streams consist of data in plain text form (i.e., human
readable characters) and are considered to be special types of files.

This terminology can be confusing to new users. However, it is useful to become familiar
with it because it is commonly employed in documentation (including the
online man pages, which are found on almost all Unix-like systems).

Users familiar with the C programming language (in which the Linux kernel and many of
its utilities are written) will be aware that it includes routines to perform basic
operations on standard input and output. Examples include printf, which allows text to
be sent to standard output, and scanf, which allows a program to read from standard
input.

Programs that run from a console (i.e., an all-text display mode) or from a terminal
window (i.e., an all-text display window in a GUI) can receive input data in several ways.
One is through command line arguments, which are names of files entered on the
command line after the name of the program (or command) and any options. In the
following example, file1 and file2 are arguments for the wc command:

wc -w file1 file2

That is, file1 and file2 provide the input data for wc, which by default counts the number
of lines, words and characters in any given text. The -w option customizes wc by telling
it to count only the number of words in each file and ignore the number of lines and
characters.
Input Output in Windows:

There are two different approaches to console I/O, the choice of which depends on how
much flexibility and control an application needs. The high-level approach enables
simple character stream I/O, but it limits access to a console's input and screen buffers.
The low-level approach requires that developers write more code and choose among a
greater range of functions, but it also gives an application more flexibility.+

An application can use the file I/O functions, ReadFile and WriteFile, and the console
functions, ReadConsole and WriteConsole, for high-level I/O that provides indirect
access to a console's input and screen buffers. The high-level input functions filter and
process the data in a console's input buffer to return input as a stream of characters,
discarding mouse and buffer-resizing input. Similarly, the high-level output functions
write a stream of characters that are displayed at the current cursor location in a screen
buffer. An application controls the way these functions work by setting a console's I/O
modes.

The low-level I/O functions provide direct access to a console's input and screen buffers,
enabling an application to access mouse and buffer-resizing input events and extended
information for keyboard events. Low-level output functions enable an application to
read from or write to a specified number of consecutive character cells in a screen
buffer, or to read or write to rectangular blocks of character cells at a specified location
in a screen buffer. A console's input modes affect low-level input by enabling the
application to determine whether mouse and buffer-resizing events are placed in the
input buffer. A console's output modes have no effect on low-level output.

The high-level and low-level I/O methods are not mutually exclusive, and an application
can use any combination of these functions. Typically, however, an application uses one
approach or the other exclusively.
REFERENCES:

 https://en.wikipedia.org/wiki/History_of_Linux
 https://en.wikipedia.org/wiki/History_of_Microsoft_Windows
 https://en.wikipedia.org/wiki/Kernel_(operating_system)
 https://en.wikipedia.org/wiki/Windows_shell
 https://www.tutorialspoint.com/unix/unix-what-is-shell.htm
 http://www.hostingadvice.com/blog/linux-process-management-
commands-know/
 https://en.wikipedia.org/wiki/Process_management_(computing)
 http://wiki.gis.com/wiki/index.php/Windows_Memory_Management
 http://iimk.ac.in/gsdl/cgi-bin/library?e=d-000-00---0inftec--00-0-0--
0prompt-10---4------0-1l--1-en-50---20-about---00031-001-1-0utfZz-8-
00&a=d&cl=CL2&d=HASHff1360e9f0c206ab2b78ea.5
 https://www.tutorialspoint.com/unix/unix-file-management.htm
 http://www.informit.com/articles/article.aspx?p=1393064
 http://www.linfo.org/stdio.html
 https://docs.microsoft.com/en-us/windows/console/input-and-output-
methods
 http://www.dummies.com/programming/networking/comparison-
linux-windows-networking/