Difference between Unix/Linux & Windows

After my previous article showing the difference between a PowerPC based Mac and IBM PC, I was compelled to research again, so here I am again compiling another article from the Internet trying to understand a very complicated topic in simple terms.

Like always in this article too attempts to make it as laymen possible have been made.

Also, I may not be absolutely accurate at some places which can be corrected.

What is the difference between Unix and Windows?

The difference is at the core and the way the core functions thereby everything that follows also behaves differently.

The core of an OS is known as Kernel:

The kernel is the central component of most computer operating systems (OS). Its responsibilities include managing the system’s resources and the communication between hardware and software components. As a basic component of an operating system, a kernel provides the lowest-level abstraction layer* for the resources (especially memory, processors and I/O devices) that application software must control to perform its function. It typically makes these facilities available to application processes through inter-process communication mechanisms and system calls.

The Computer system consists of 5 abstraction levels which are:

The kernel does this:

The UNIX system kernel:

The kernel allocates memory, keeps track of the physical location of files on the computer’s hard disks, loads and executes binary programs such as shells, and schedules the task swapping without which UNIX systems would be incapable of doing more than one thing at a time.

The kernel accomplishes all these tasks by providing an interface between the other programs running under its control and the physical hardware of the computer; this interface, effectively insulates the other programs on the UNIX system from the complexities of the computer.

For example:

When a running program needs access to a file, it cannot simply open the file; instead it issues a system call which asks the kernel to open the file. The kernel takes over and handles the request, then notifies the program whether the request succeeded or failed. To read data in from the file takes another system call; the kernel determines whether or not the request is valid, and if it is, the kernel reads the required block of data and passes it back to the program.

The kernel has subsystems like process management, memory management, file management, device management and network management. Each of the subsystem has some features:

  • Concurrency: As UNIX is a multiprocessing OS, many processes run concurrently to improve the performance of the system.
  • Virtual Memory (VM): Memory management subsystem implements the virtual memory concept and a user need not worry about the executable program size and the RAM size.
  • Paging: It is a technique to minimize the internal as well as the external fragmentation in the physical memory.
  • Virtual File System (VFS): A VFS is a file system used to help the user to hide the different file systems complexities. A user can use the same standard file system related calls to access different file systems.

The kernel provides these and other basic services: interrupt and trap handling, separation between user and system space, system calls, scheduling, timer and clock handling, file descriptor management.

Now something about the Windows Kernel:

Windows Kernel Organization

Kernel-mode organized into:

NTOS: (Kernel-Mode Services)
  • Run-time Library, Scheduling, Executive services, object manager, services for I/O, memory, processes,

Hal: (Hardware-Adaptation Layer)

  • Insulates NTOS & drivers from hardware dependencies
  • Providers facilities, such as device access, timers, interrupt
    servicing, clocks, spinlocks.

Kernel Extensions (primarily for device access).

The Windows NT operating system family’s architecture:

Major Kernel Services:

  • Process management: Process/thread creation.
  • Security reference monitor: Access checks, token management.
  • Memory manager: Pagefaults, virtual address, physical frame, and pagefile management; Services for sharing, copy-on-write, mapped files, GC support, large apps.
  • Lightweight Procedure Call (LPC): Native transport for RPC and user-mode system services.
  • I/O manager (& plug-and-play & power): Maps user requests into IRP requests, configures/manages I/O devices; implements services for drivers.
  • Cache manager: Provides file-based caching for buffer file system I/O; built over the memory manager.
  • Scheduler: Schedules thread execution on each processor.

Some more difference between UNIX and Windows:

Everything in UNIX is treated as file (even the hardware devices like printers, scanners etc!) but it is not the case in Windows, also

In Unix, a shared object (.so) file contains code to be used by the program, and also the names of functions and data that it expects to find in the program. When the file is joined to the program, all references to those functions and data in the file’s code are changed to point to the actual locations in the program where the functions and data are placed in memory. This is basically a link operation.

In Windows, a dynamic-link library (.dll) file has no dangling references. Instead, an access to functions or data goes through a lookup table. So the DLL code does not have to be fixed up at runtime to refer to the program’s memory; instead, the code already uses the DLL’s lookup table, and the lookup table is modified at runtime to point to the functions and data.

In Unix, there is only one type of library file (.a) which contains code from several object files (.o). During the link step to create a shared object file (.so), the linker may find that it doesn’t know where an identifier is defined. The linker will look for it in the object files in the libraries; if it finds it, it will include all the code from that object file.

In Windows, there are two types of library, a static library and an import library (both called .lib). A static library is like a Unix .a file; it contains code to be included as necessary. An import library is basically used only to reassure the linker that a certain identifier is legal, and will be present in the program when the DLL is loaded. So the linker uses the information from the import library to build the lookup table for using identifiers that are not included in the DLL. When an application or a DLL is linked, an import library may be generated, which will need to be used for all future DLLs that depend on the symbols in the application or DLL.

Unix possess the process hierarchy. When a new process is created by a UNIX application, it becomes a child of the process that created it. This hierarchy is very important, so there are system calls for influencing child processes. Windows processes on the other hand do not share a hierarchical relationship. Receiving the process handle and ID of the process it created, the creating process of a Windows system can maintain or simulate a hierarchical relationship if it is needed. The Windows operating system ordinarily treats all processes as belonging to the same generation.

UNIX uses daemons, Windows has service processes. Daemons are processes that are started when UNIX boots up that provide services to other applications. Daemons typically do not interact with users. A Windows service is the equivalent to a UNIX daemon. When a Windows system is booted, a service may be started. This is a long running application that does not interact with users, so they do not have a user interface. Services continue running during a logon session and they are controlled by the Windows Service Control Manager.

I have some things that I want to cover but that require a little more research and time.

Source: The Internet
PS: A little something I found: List of Viruses for Linux.