Embedded Linux

Linux is free, and the source code base is required to remain open due to its use of the GPL (Gnu Public License)
It was designed to be a traditional time-sharing system based on Unix
It is not hard realtime, and in standard configuration requires more memory than is typically available
On the other hand, there are a large number of tools and a large software base
It has a huge number of device drivers supporting a huge variety of devices
There is an active open source developer community, and increasing support from vendors such as IBM

Reducing Linux size - filesystem

Linux has support for a number of different file systems
It can support the various Windows FAT filesystems, a variety of Linux filesystems, Minix, Xenix, OS/2, etc
Several of these are included in major Linux kernels
Each of these requires code to handle the filesystem type
Just include the filesystem(s) you actually need on your ROM device

Unix/Linux has over 1800 utilities available for anyone to use, and this increases every time someone releases more open source
The files in /bin and /usr/bin on Redhat Linux 7.2 use 100+ Megabytes of disk
Some are almost essential: ls to list a directory and cd to change directories are examples
Throw away everything you don't need

Linux supports hundreds of devices: hard disks, CDROMS, floppy disks, ethernet cards, wireless cards, infrared, etc
Each installed device uses memory - both ROM and RAM
Leave out all unused devices
e.g. a system that uses a serial port as I/O device may be able to just use the serial driver (as well as devices for kernel support such as kmem). The parallel port driver etc, can be omitted

You can write portable C programs using the standard C library - which uses 1.2M of disk on Redhat 7.2 on a Pentium. It includes functions such as printf() which allow formatted output
```
	printf("The name is %S with size %d\n", name, size)
	
```
The POSIX API is lower level. It gives a portable interface to Linux/Unix kernels. I/O is more primitive, though
```
	write(fd, ".....")
	
```
Linux uses some kernel-specific functions such as printk() for use to get error messages out to something. These calls are non-standard and liable to change. They also run in protected mode rather than user mode

A static library is linked into the compiled application and uses extra disk space
A dynamic library (DLL) is kept in one copy, and linked as needed when called by an application
DLLs use less disk space, but are slightly slower to call (an attempt is made to call a function, if not there an interrupt is generated to load the library containing the function.)
If you only have a couple of applications, use static linking