Windows systems provide the Windows Task Manager, a tool that includes information for current applications as well as processes, CPU and memory usage, and networking statistics. A screen shot of the task manager in Windows 10 appears in Figure 2.19.

Virtualization

Operating systems keep track of system activity through a series of counters, such as the number of system calls made or the number of operations performed to a network device or disk. The following are examples of Linux tools that use counters:

We mentioned earlier that performance tuning seeks to improve performance by removing processing bottlenecks. To identify bottlenecks, we must be able to monitor system performance. Thus, the operating system must have some means of computing and displaying measures of system behavior. Tools may be characterized as providing either per-process or system-wide observations. To make these observations, tools may use one of two approaches—counters or tracing. We explore each of these in the following sections.

Operating-system debugging and process debugging frequently use different tools and techniques due to the very different nature of these two tasks. Consider that a kernel failure in the file-system code would make it risky for the kernel to try to save its state to a file on the file system before rebooting. A common technique is to save the kernel's memory state to a section of disk set aside for this purpose that contains no file system. If the kernel detects an unrecoverable error, it writes the entire contents of memory, or at least the kernel-owned parts of the system memory, to the disk area. When the system reboots, a process runs to gather the data from that area and write it to a crash dump file within a file system for analysis. Obviously, such strategies would be unnecessary for debugging ordinary user-level processes.

Debugging user-level process code is a challenge. Operating-system kernel debugging is even more complex because of the size and complexity of the kernel, its control of the hardware, and the lack of user-level debugging tools. A failure in the kernel is called a crash. When a crash occurs, error information is saved to a log file, and the memory state is saved to a crash dump.

If a process fails, most operating systems write the error information to a log file to alert system administrators or users that the problem occurred. The operating system can also take a core dump—a capture of the memory of the process—and store it in a file for later analysis. (Memory was referred to as the “core” in the early days of computing.) Running programs and core dumps can be probed by a debugger, which allows a programmer to explore the code and memory of a process at the time of failure.

We have mentioned debugging from time to time in this chapter. Here, we take a closer look. Broadly, debugging is the activity of finding and fixing errors in a system, both in hardware and in software. Performance problems are considered bugs, so debugging can also include performance tuning, which seeks to improve performance by removing processing bottlenecks. In this section, we explore debugging process and kernel errors and performance problems. Hardware debugging is outside the scope of this text.

Finally, boot loaders for most operating systems—including Windows, Linux, and macOS, as well as both iOS and Android—provide booting into recovery mode or single-user mode for diagnosing hardware issues, fixing corrupt file systems, and even reinstalling the operating system. In addition to hardware failures, computer systems can suffer from software errors and poor operating-system performance, which we consider in the following section.

To save space as well as decrease boot time, the Linux kernel image is a compressed file that is extracted after it is loaded into memory. During the boot process, the boot loader typically creates a temporary RAM file system, known as initramfs. This file system contains necessary drivers and kernel modules that must be installed to support the real root file system (which is not in main memory). Once the kernel has started and the necessary drivers are installed, the kernel switches the root file system from the temporary RAM location to the appropriate root file system location. Finally, Linux creates the systemd process, the initial process in the system, and then starts other services (for example, a web server and/or database). Ultimately, the system will present the user with a login prompt. In Section 11.5.2, we describe the boot process for Windows.

Many recent computer systems have replaced the BIOS-based boot process with UEFI (Unified Extensible Firmware Interface). UEFI has several advantages over BIOS, including better support for 64-bit systems and larger disks. Perhaps the greatest advantage is that UEFI is a single, complete boot manager and therefore is faster than the multistage BIOS boot process.

Some computer systems use a multistage boot process: When the computer is first powered on, a small boot loader located in nonvolatile firmware known as BIOS is run. This initial boot loader usually does nothing more than load a second boot loader, which is located at a fixed disk location called the boot block. The program stored in the boot block may be sophisticated enough to load the entire operating system into memory and begin its execution. More typically, it is simple code (as it must fit in a single disk block) and knows only the address on disk and the length of the remainder of the bootstrap program.

At a slightly less tailored level, the system description can lead to the selection of precompiled object modules from an existing library. These modules are linked together to form the generated operating system. This process allows the library to contain the device drivers for all supported I/O devices, but only those needed are selected and linked into the operating system. Because the system is not recompiled, system generation is faster, but the resulting system may be overly general and may not support different hardware configurations.

Configuring the system involves specifying which features will be included, and this varies by operating system. Typically, parameters describing how the system is configured is stored in a configuration file of some type, and once this file is created, it can be used in several ways.

Most commonly, a computer system, when purchased, has an operating system already installed. For example, you may purchase a new laptop with Windows or macOS preinstalled. But suppose you wish to replace the preinstalled operating system or add additional operating systems. Or suppose you purchase a computer without an operating system. In these latter situations, you have a few options for placing the appropriate operating system on the computer and configuring it for use.

It is possible to design, code, and implement an operating system specifically for one specific machine configuration. More commonly, however, operating systems are designed to run on any of a class of machines with a variety of peripheral configurations.

Because Android can run on an almost unlimited number of hardware devices, Google has chosen to abstract the physical hardware through the hardware abstraction layer, or HAL. By abstracting all hardware, such as the camera, GPS chip, and other sensors, the HAL provides applications with a consistent view independent of specific hardware. This feature, of course, allows developers to write programs that are portable across different hardware platforms.

Software designers for Android devices develop applications in the Java language, but they do not generally use the standard Java API. Google has designed a separate Android API for Java development. Java applications are compiled into a form that can execute on the Android RunTime ART, a virtual machine designed for Android and optimized for mobile devices with limited memory and CPU processing capabilities. Java programs are first compiled to a Java bytecode .class file and then translated into an executable .dex file. Whereas many Java virtual machines perform just-in-time (JIT) compilation to improve application efficiency, ART performs ahead-of-time (AOT) compilation. Here, .dex files are compiled into native machine code when they are installed on a device, from which they can execute on the ART. AOT compilation allows more efficient application execution as well as reduced power consumption, features that are crucial for mobile systems.

The Android operating system was designed by the Open Handset Alliance (led primarily by Google) and was developed for Android smartphones and tablet computers. Whereas iOS is designed to run on Apple mobile devices and is close-sourced, Android runs on a variety of mobile platforms and is open-sourced, partly explaining its rapid rise in popularity. The structure of Android appears in Figure 2.18.

Apple has released the Darwin operating system as open source. As a result, various projects have added extra functionality to Darwin, such as the X-11 windowing system and support for additional file systems. Unlike Darwin, however, the Cocoa interface, as well as other proprietary Apple frameworks available for developing macOS applications, are closed.

In Section 2.8.3, we described how the overhead of message passing between different services running in user space compromises the performance of microkernels. To address such performance problems, Darwin combines Mach, BSD, the I/O kit, and any kernel extensions into a single address space. Thus, Mach is not a pure microkernel in the sense that various subsystems run in user space. Message passing within Mach still does occur, but no copying is necessary, as the services have access to the same address space.

Beneath the system-call interface, Mach provides fundamental operating-system services, including memory management, CPU scheduling, and interprocess communication (IPC) facilities such as message passing and remote procedure calls (RPCs). Much of the functionality provided by Mach is available through kernel abstractions, which include tasks (a Mach process), threads, memory objects, and ports (used for IPC). As an example, an application may create a new process using the BSD POSIX fork() system call. Mach will, in turn, use a task kernel abstraction to represent the process in the kernel.

Whereas most operating systems provide a single system-call interface to the kernel—such as through the standard C library on UNIX and Linux systems—Darwin provides two system-call interfaces: Mach system calls (known as traps) and BSD system calls (which provide POSIX functionality). The interface to these system calls is a rich set of libraries that includes not only the standard C library but also libraries that provide networking, security, and progamming language support (to name just a few).

The iOS operating system is generally much more restricted to developers than macOS and may even be closed to developers. For example, iOS restricts access to POSIX and BSD APIs on iOS, whereas they are openly available to developers on macOS.

Because macOS is intended for desktop and laptop computer systems, it is compiled to run on Intel architectures. iOS is designed for mobile devices and thus is compiled for ARM-based architectures. Similarly, the iOS kernel has been modified somewhat to address specific features and needs of mobile systems, such as power management and aggressive memory management. Additionally, iOS has more stringent security settings than macOS.

Kernel environment. This environment, also known as Darwin, includes the Mach microkernel and the BSD UNIX kernel. We will elaborate on Darwin shortly.

Core frameworks. This layer defines frameworks that support graphics and media including, Quicktime and OpenGL.

Application frameworks layer. This layer includes the Cocoa and Cocoa Touch frameworks, which provide an API for the Objective-C and Swift programming languages. The primary difference between Cocoa and Cocoa Touch is that the former is used for developing macOS applications, and the latter by iOS to provide support for hardware features unique to mobile devices, such as touch screens.

User experience layer. This layer defines the software interface that allows users to interact with the computing devices. macOS uses the Aqua user interface, which is designed for a mouse or trackpad, whereas iOS uses the Springboard user interface, which is designed for touch devices.

In practice, very few operating systems adopt a single, strictly defined structure. Instead, they combine different structures, resulting in hybrid systems that address performance, security, and usability issues. For example, Linux is monolithic, because having the operating system in a single address space provides very efficient performance. However, it also modular, so that new functionality can be dynamically added to the kernel. Windows is largely monolithic as well (again primarily for performance reasons), but it retains some behavior typical of microkernel systems, including providing support for separate subsystems (known as operating-system personalities) that run as user-mode processes. Windows systems also provide support for dynamically loadable kernel modules. We provide case studies of Linux and Windows 10 in Chapter 20 and Chapter 21, respectively. In the remainder of this section, we explore the structure of three hybrid systems: the Apple macOS operating system and the two most prominent mobile operating systems—iOS and Android.

The idea of the design is for the kernel to provide core services, while other services are implemented dynamically, as the kernel is running. Linking services dynamically is preferable to adding new features directly to the kernel, which would require recompiling the kernel every time a change was made. Thus, for example, we might build CPU scheduling and memory management algorithms directly into the kernel and then add support for different file systems by way of loadable modules.

Perhaps the best current methodology for operating-system design involves using loadable kernel modules (LKMs). Here, the kernel has a set of core components and can link in additional services via modules, either at boot time or during run time. This type of design is common in modern implementations of UNIX, such as Linux, macOS, and Solaris, as well as Windows.

Unfortunately, the performance of microkernels can suffer due to increased system-function overhead. When two user-level services must communicate, messages must be copied between the services, which reside in separate address spaces. In addition, the operating system may have to switch from one process to the next to exchange the messages. The overhead involved in copying messages and switching between processes has been the largest impediment to the growth of microkernel-based operating systems. Consider the history of Windows NT: The first release had a layered microkernel organization. This version's performance was low compared with that of Windows 95. Windows NT 4.0 partially corrected the performance problem by moving layers from user space to kernel space and integrating them more closely. By the time Windows XP was designed, Windows architecture had become more monolithic than microkernel. Section 2.8.5.1 will describe how macOS addresses the performance issues of the Mach microkernel.

Another example is QNX, a real-time operating system for embedded systems. The QNX Neutrino microkernel provides services for message passing and process scheduling. It also handles low-level network communication and hardware interrupts. All other services in QNX are provided by standard processes that run outside the kernel in user mode.

Perhaps the best-known illustration of a microkernel operating system is Darwin, the kernel component of the macOS and iOS operating systems. Darwin, in fact, consists of two kernels, one of which is the Mach microkernel. We will cover the macOS and iOS systems in further detail in Section 2.8.5.1.

One benefit of the microkernel approach is that it makes extending the operating system easier. All new services are added to user space and consequently do not require modification of the kernel. When the kernel does have to be modified, the changes tend to be fewer, because the microkernel is a smaller kernel. The resulting operating system is easier to port from one hardware design to another. The microkernel also provides more security and reliability, since most services are running as user—rather than kernel—processes. If a service fails, the rest of the operating system remains untouched.

The main function of the microkernel is to provide communication between the client program and the various services that are also running in user space. Communication is provided through message passing, which was described in Section 2.3.3.5. For example, if the client program wishes to access a file, it must interact with the file server. The client program and service never interact directly. Rather, they communicate indirectly by exchanging messages with the microkernel.

We have already seen that the original UNIX system had a monolithic structure. As UNIX expanded, the kernel became large and difficult to manage. In the mid-1980s, researchers at Carnegie Mellon University developed an operating system called Mach that modularized the kernel using the microkernel approach. This method structures the operating system by removing all nonessential components from the kernel and implementing them as user-level programs that reside in separate address spaces. The result is a smaller kernel. There is little consensus regarding which services should remain in the kernel and which should be implemented in user space. Typically, however, microkernels provide minimal process and memory management, in addition to a communication facility. Figure 2.15 illustrates the architecture of a typical microkernel.

Layered systems have been successfully used in computer networks (such as TCP/IP) and web applications. Nevertheless, relatively few operating systems use a pure layered approach. One reason involves the challenges of appropriately defining the functionality of each layer. In addition, the overall performance of such systems is poor due to the overhead of requiring a user program to traverse through multiple layers to obtain an operating-system service. Some layering is common in contemporary operating systems, however. Generally, these systems have fewer layers with more functionality, providing most of the advantages of modularized code while avoiding the problems of layer definition and interaction.

Each layer is implemented only with operations provided by lower-level layers. A layer does not need to know how these operations are implemented; it needs to know only what these operations do. Hence, each layer hides the existence of certain data structures, operations, and hardware from higher-level layers.

The main advantage of the layered approach is simplicity of construction and debugging. The layers are selected so that each uses functions (operations) and services of only lower-level layers. This approach simplifies debugging and system verification. The first layer can be debugged without any concern for the rest of the system, because, by definition, it uses only the basic hardware (which is assumed correct) to implement its functions. Once the first layer is debugged, its correct functioning can be assumed while the second layer is debugged, and so on. If an error is found during the debugging of a particular layer, the error must be on that layer, because the layers below it are already debugged. Thus, the design and implementation of the system are simplified.

An operating-system layer is an implementation of an abstract object made up of data and the operations that can manipulate those data. A typical operating-system layer—say, layer M—consists of data structures and a set of functions that can be invoked by higher-level layers. Layer M, in turn, can invoke operations on lower-level layers.

The monolithic approach is often known as a tightly coupled system because changes to one part of the system can have wide-ranging effects on other parts. Alternatively, we could design a loosely coupled system. Such a system is divided into separate, smaller components that have specific and limited functionality. All these components together comprise the kernel. The advantage of this modular approach is that changes in one component affect only that component, and no others, allowing system implementers more freedom in creating and changing the inner workings of the system.

Despite the apparent simplicity of monolithic kernels, they are difficult to implement and extend. Monolithic kernels do have a distinct performance advantage, however: there is very little overhead in the system-call interface, and communication within the kernel is fast. Therefore, despite the drawbacks of monolithic kernels, their speed and efficiency explains why we still see evidence of this structure in the UNIX, Linux, and Windows operating systems.

The Linux operating system is based on UNIX and is structured similarly, as shown in Figure 2.13. Applications typically use the glibc standard C library when communicating with the system call interface to the kernel. The Linux kernel is monolithic in that it runs entirely in kernel mode in a single address space, but as we shall see in Section 2.8.4, it does have a modular design that allows the kernel to be modified during run time.

An example of such limited structuring is the original UNIX operating system, which consists of two separable parts: the kernel and the system programs. The kernel is further separated into a series of interfaces and device drivers, which have been added and expanded over the years as UNIX has evolved. We can view the traditional UNIX operating system as being layered to some extent, as shown in Figure 2.12. Everything below the system-call interface and above the physical hardware is the kernel. The kernel provides the file system, CPU scheduling, memory management, and other operating-system functions through system calls. Taken in sum, that is an enormous amount of functionality to be combined into one single address space.

The simplest structure for organizing an operating system is no structure at all. That is, place all of the functionality of the kernel into a single, static binary file that runs in a single address space. This approach—known as a monolithic structure—is a common technique for designing operating systems.

A system as large and complex as a modern operating system must be engineered carefully if it is to function properly and be modified easily. A common approach is to partition the task into small components, or modules, rather than have one single system. Each of these modules should be a well-defined portion of the system, with carefully defined interfaces and functions. You may use a similar approach when you structure your programs: rather than placing all of your code in the main() function, you instead separate logic into a number of functions, clearly articulate parameters and return values, and then call those functions from main().

As is true in other systems, major performance improvements in operating systems are more likely to be the result of better data structures and algorithms than of excellent assembly-language code. In addition, although operating systems are large, only a small amount of the code is critical to high performance; the interrupt handlers, I/O manager, memory manager, and CPU scheduler are probably the most critical routines. After the system is written and is working correctly, bottlenecks can be identified and can be refactored to operate more efficiently.

The advantages of using a higher-level language, or at least a systems-implementation language, for implementing operating systems are the same as those gained when the language is used for application programs: the code can be written faster, is more compact, and is easier to understand and debug. In addition, improvements in compiler technology will improve the generated code for the entire operating system by simple recompilation. Finally, an operating system is far easier to port to other hardware if it is written in a higher-level language. This is particularly important for operating systems that are intended to run on several different hardware systems, such as small embedded devices, Intel x86 systems, and ARM chips running on phones and tablets.

Early operating systems were written in assembly language. Now, most are written in higher-level languages such as C or C++, with small amounts of the system written in assembly language. In fact, more than one higher-level language is often used. The lowest levels of the kernel might be written in assembly language and C. Higher-level routines might be written in C and C++, and system libraries might be written in C++ or even higher-level languages. Android provides a nice example: its kernel is written mostly in C with some assembly language. Most Android system libraries are written in C or C++, and its application frameworks—which provide the developer interface to the system—are written mostly in Java. We cover Android's architecture in more detail in Section 2.8.5.2.

Policy decisions are important for all resource allocation. Whenever it is necessary to decide whether or not to allocate a resource, a policy decision must be made. Whenever the question is how rather than what, it is a mechanism that must be determined.

We can make a similar comparison between commercial and open-source operating systems. For instance, contrast Windows, discussed above, with Linux, an open-source operating system that runs on a wide range of computing devices and has been available for over 25 years. The “standard” Linux kernel has a specific CPU scheduling algorithm (covered in Section 5.7.1), which is a mechanism that supports a certain policy. However, anyone is free to modify or replace the scheduler to support a different policy.

The separation of policy and mechanism is important for flexibility. Policies are likely to change across places or over time. In the worst case, each change in policy would require a change in the underlying mechanism. A general mechanism flexible enough to work across a range of policies is preferable. A change in policy would then require redefinition of only certain parameters of the system. For instance, consider a mechanism for giving priority to certain types of programs over others. If the mechanism is properly separated from policy, it can be used either to support a policy decision that I/O-intensive programs should have priority over CPU-intensive ones or to support the opposite policy.

One important principle is the separation of policy from mechanism. Mechanisms determine how to do something; policies determine what will be done. For example, the timer construct (see Section 1.4.3) is a mechanism for ensuring CPU protection, but deciding how long the timer is to be set for a particular user is a policy decision.

Specifying and designing an operating system is a highly creative task. Although no textbook can tell you how to do it, general principles have been developed in the field of software engineering, and we turn now to a discussion of some of these principles.

There is, in short, no unique solution to the problem of defining the requirements for an operating system. The wide range of systems in existence shows that different requirements can result in a large variety of solutions for different environments. For example, the requirements for Wind River VxWorks, a real-time operating system for embedded systems, must have been substantially different from those for Windows Server, a large multiaccess operating system designed for enterprise applications.

The first problem in designing a system is to define goals and specifications. At the highest level, the design of the system will be affected by the choice of hardware and the type of system: traditional desktop/laptop, mobile, distributed, or real time.

In sum, all of these differences mean that unless an interpreter, RTE, or binary executable file is written for and compiled on a specific operating system on a specific CPU type (such as Intel x86 or ARMv8), the application will fail to run. Imagine the amount of work that is required for a program such as the Firefox browser to run on Windows, macOS, various Linux releases, iOS, and Android, sometimes on various CPU architectures.

Each operating system has a binary format for applications that dictates the layout of the header, instructions, and variables. Those components need to be at certain locations in specified structures within an executable file so the operating system can open the file and load the application for proper execution.

In theory, these three approaches seemingly provide simple solutions for developing applications that can run across different operating systems. However, the general lack of application mobility has several causes, all of which still make developing cross-platform applications a challenging task. At the application level, the libraries provided with the operating system contain APIs to provide features like GUI interfaces, and an application designed to call one set of APIs (say, those available from IOS on the Apple iPhone) will not work on an operating system that does not provide those APIs (such as Android). Other challenges exist at lower levels in the system, including the following.

In theory, these three approaches seemingly provide simple solutions for developing applications that can run across different operating systems. However, the general lack of application mobility has several causes, all of which still make developing cross-platform applications a challenging task. At the application level, the libraries provided with the operating system contain APIs to provide features like GUI interfaces, and an application designed to call one set of APIs (say, those available from IOS on the Apple iPhone) will not work on an operating system that does not provide those APIs (such as Android). Other challenges exist at lower levels in the system, including the following.

1. The application can be written in an interpreted language (such as Python or Ruby) that has an interpreter available for multiple operating systems. The interpreter reads each line of the source program, executes equivalent instructions on the native instruction set, and calls native operating system calls. Performance suffers relative to that for native applications, and the interpreter provides only a subset of each operating system's features, possibly limiting the feature sets of the associated applications.

Based on our earlier discussion, we can now see part of the problem—each operating system provides a unique set of system calls. System calls are part of the set of services provided by operating systems for use by applications. Even if system calls were somehow uniform, other barriers would make it difficult for us to execute application programs on different operating systems. But if you have used multiple operating systems, you may have used some of the same applications on them. How is that possible?

Object files and executable files typically have standard formats that include the compiled machine code and a symbol table containing metadata about functions and variables that are referenced in the program. For UNIX and Linux systems, this standard format is known as ELF (for Executable and Linkable Format). There are separate ELF formats for relocatable and executable files. One piece of information in the ELF file for executable files is the program's entry point, which contains the address of the first instruction to be executed when the program runs. Windows systems use the Portable Executable (PE) format, and macOS uses the Mach-O format.

Source files are compiled into object files that are designed to be loaded into any physical memory location, a format known as an relocatable object file. Next, the linker combines these relocatable object files into a single binary executable file. During the linking phase, other object files or libraries may be included as well, such as the standard C or math library (specified with the flag -lm).

The view of the operating system seen by most users is defined by the application and system programs, rather than by the actual system calls. Consider a user's PC. When a user's computer is running the macOS operating system, the user might see the GUI, featuring a mouse-and-windows interface. Alternatively, or even in one of the windows, the user might have a command-line UNIX shell. Both use the same set of system calls, but the system calls look different and act in different ways. Further confusing the user view, consider the user dual-booting from macOS into Windows. Now the same user on the same hardware has two entirely different interfaces and two sets of applications using the same physical resources. On the same hardware, then, a user can be exposed to multiple user interfaces sequentially or concurrently.

Program loading and execution. Once a program is assembled or compiled, it must be loaded into memory to be executed. The system may provide absolute loaders, relocatable loaders, linkage editors, and overlay loaders. Debugging systems for either higher-level languages or machine language are needed as well.

File management. These programs create, delete, copy, rename, print, list, and generally access and manipulate files and directories.

Another aspect of a modern system is its collection of system services. Recall Figure 1.1, which depicted the logical computer hierarchy. At the lowest level is hardware. Next is the operating system, then the system services, and finally the application programs. System services, also known as system utilities, provide a convenient environment for program development and execution. Some of them are simply user interfaces to system calls. Others are considerably more complex. They can be divided into these categories:

Typically, system calls providing protection include set_permission() and get_permission(), which manipulate the permission settings of resources such as files and disks. The allow_user() and deny_user() system calls specify whether particular users can—or cannot—be allowed access to certain resources. We cover protection in Chapter 17 and the much larger issue of security—which involves using protection against external threats—in Chapter 16.

Protection provides a mechanism for controlling access to the resources provided by a computer system. Historically, protection was a concern only on multiprogrammed computer systems with several users. However, with the advent of networking and the Internet, all computer systems, from servers to mobile handheld devices, must be concerned with protection.

Both of the models just discussed are common in operating systems, and most systems implement both. Message passing is useful for exchanging smaller amounts of data, because no conflicts need be avoided. It is also easier to implement than is shared memory for intercomputer communication. Shared memory allows maximum speed and convenience of communication, since it can be done at memory transfer speeds when it takes place within a computer. Problems exist, however, in the areas of protection and synchronization between the processes sharing memory.

There are two common models of interprocess communication: the message-passing model and the shared-memory model. In the message-passing model, the communicating processes exchange messages with one another to transfer information. Messages can be exchanged between the processes either directly or indirectly through a common mailbox. Before communication can take place, a connection must be opened. The name of the other communicator must be known, be it another process on the same system or a process on another computer connected by a communications network. Each computer in a network has a host name by which it is commonly known. A host also has a network identifier, such as an IP address. Similarly, each process has a process name, and this name is translated into an identifier by which the operating system can refer to the process. The get_hostid() and get_processid() system calls do this translation. The identifiers are then passed to the general-purpose open() and close() calls provided by the file system or to specific open_connection() and close_connection() system calls, depending on the system's model of communication. The recipient process usually must give its permission for communication to take place with an accept_connection() call. Most processes that will be receiving connections are special-purpose daemons, which are system programs provided for that purpose. They execute a wait_for_connection() call and are awakened when a connection is made. The source of the communication, known as the client, and the receiving daemon, known as a server, then exchange messages by using read_message() and write_message() system calls. The close_connection() call terminates the communication.

Many operating systems provide a time profile of a program to indicate the amount of time that the program executes at a particular location or set of locations. A time profile requires either a tracing facility or regular timer interrupts. At every occurrence of the timer interrupt, the value of the program counter is recorded. With sufficiently frequent timer interrupts, a statistical picture of the time spent on various parts of the program can be obtained.

Many system calls exist simply for the purpose of transferring information between the user program and the operating system. For example, most systems have a system call to return the current time() and date(). Other system calls may return information about the system, such as the version number of the operating system, the amount of free memory or disk space, and so on.

Once the device has been requested (and allocated to us), we can read(), write(), and (possibly) reposition() the device, just as we can with files. In fact, the similarity between I/O devices and files is so great that many operating systems, including UNIX, merge the two into a combined file–device structure. In this case, a set of system calls is used on both files and devices. Sometimes, I/O devices are identified by special file names, directory placement, or file attributes.

The various resources controlled by the operating system can be thought of as devices. Some of these devices are physical devices (for example, disk drives), while others can be thought of as abstract or virtual devices (for example, files). A system with multiple users may require us to first request() a device, to ensure exclusive use of it. After we are finished with the device, we release() it. These functions are similar to the open() and close() system calls for files. Other operating systems allow unmanaged access to devices. The hazard then is the potential for device contention and perhaps deadlock, which are described in Chapter 8.

We may need these same sets of operations for directories if we have a directory structure for organizing files in the file system. In addition, for either files or directories, we need to be able to determine the values of various attributes and perhaps to set them if necessary. File attributes include the file name, file type, protection codes, accounting information, and so on. At least two system calls, get_file_attributes() and set_file_attributes(), are required for this function. Some operating systems provide many more calls, such as calls for file move() and copy(). Others might provide an API that performs those operations using code and other system calls, and others might provide system programs to perform the tasks. If the system programs are callable by other programs, then each can be considered an API by other system programs.

As generative AI becomes further ingrained into higher education, it’s important to be intentional about how we navigate its complexities.

While AI is a powerful tool, the human touch remains crucial. By working together, we can make the most of what AI offers while mitigating its known limitations.

Problems with bias in AI systems predate generative AI tools. For example, in the Gender Shades project, Buolamwini (2017) tested AI-based commercial gender classification systems and found significant disparities in accuracy across different genders and skin types. These systems performed better on male and lighter-skinned faces than others. The largest disparity was found in darker-skinned females, where error rates were notably high.

Generative AI models are trained on vast amounts of internet data. This data, while rich in information, contains both accurate and inaccurate content, as well as societal and cultural biases. Since these models mimic patterns in their training data without discerning truth, they can reproduce any

. These generative AI biases can have real-world consequences. For instance, adding biased generative AI to “virtual sketch artist” software used by police departments could “put already over-targeted populations at an even increased risk of harm ranging from physical injury to unlawful imprisonment”

temperature regimes of northern Germany are not comparable to those of Eastern Australia (e.g. Buschbaum et al., 2009; Cole, 2010) where mussels are likely acclimated to warmer environments

2.4. Data analysis

Temperature also affected the behavioural preferences of the infauna associated with mussels. Polychaetes, crustaceans, and molluscs altered their behaviour to colonise the habitat created by one species of mussel to another. This altered behavioural preference of infauna can be driven by habitat-specific cues and the ability of infauna to make habitat choices

After the 4-week acclimation period, the mussels were defaunated by carefully removing all infauna and separating adult mussels (>1 cm) into 10-cm-diameter clumps (Cole, 2010).

The outdoor experiment was performed in a purpose-built facility (Pereira et al., 2019) at the Sydney Institute of Marine Science (SIMS), Chowder Bay, Sydney Harbour, New South Wales, Australia. The experiment was performed during the summer peak recruitment period of marine invertebrates in Sydney Harbour.

Previous studies have shown that the loss of a biogenic habitat in an ecosystem can be functionally replaced (or the loss of function is slowed to some extent) by another habitat-forming organism (Nagelkerken et al., 2016; Sunday et al., 2017).

For example, under acidification, fleshy seaweeds outcompete calcareous species

Molluscs actively chose to colonise T. hirsuta and actively avoided M. galloprovincialis, regardless of warming or pCO2 levels (Table 1).

The native mussel T. hirsuta grew more under warming (Fig. 1; ANOVA Species × Temperature F1,32 = 6.13, P < 0.05; Supplementary Table 2). In contrast, M. galloprovincialis grew the same at ambient and elevated temperatures (Fig. 1; Supplementary Table 2). There was no effect of elevated pCO2 on growth in either of the mussel species (ANOVA CO2 F1,32 = 0.53, P > 0.05; Supplementary Table 2).

Trade and Trust” addresses the misconception amongsome libertarians that the institutional infrastructure neededto support specialization and trade is minimal.

iscovering new patterns of sustainablespecialization and trade is more complex and subtle and lessmechanical than what is assumed by the Keynesian and mon-etarist traditions.

If trade entails trust among strangers, then financial inter-mediation entails trust over time. If people lose trust infinancial intermediaries, then financial intermediation candecline precipitously. That sharp decline can have a broadeffect on the structure of production in the economy

Unfortunately, once they have taught the simple exam-ple of comparative advantage, with two producers and twotasks, most economists are done with the issue of specializa-tion. Instead, textbooks want to focus on scarcity and choice.Often, the student will read that economics is about the allo-cation of scarce resources given our unlimited wants. Or heor she may be told that economics is the study of how peoplemake rational choices among competing priorities.Scarcity and choice are certainly important concepts, butmaking them the central focus can lead to economic analysisthat is simplistic and mechanistic. In fact, the approach to eco-nomics that took hold after World War II treats the economyas a machine governed by equations.

Look at the list of ingredients in the cereal. Those ingre-dients had to be refined and shipped to the cereal manu-facturer. Again, those processes required many machines,which in turn had to be manufactured. The cereal grainsand other ingredients had to be grown, harvested, and pro-cessed. Machines were involved in those processes, and thosemachines had to be manufactured.

hat econo-mists have lost the art of critical thinking.

“Policy in Practice” corrects the misconception that diagno-sis and treatment of “market failure” is straightforward. Thissection looks at challenges facing economists and policymak-ers trying to use the theory of market failure. The example Iuse is housing finance policy during the run-up to the finan-cial crisis of 2008. The policy process was overwhelmed bythe complexity of the specialization that emerged in housingfinance. Moreover, the basic thrust of policy was determinedby interest-group influence. The lesson is that a very large gapexists between the economic theory of public goods and thepractical execution of policy.

He knows that his breakfast depends upon workerson the coffee plantations of Brazil, the citrus groves ofFlorida, the sugar fields of Cuba, the wheat farms ofthe Dakotas, the dairies of New York; that it has beenassembled by ships, railroads, and trucks, has beencooked with coal from Pennsylvania in utensils madeof aluminum, china, steel, and glass.

yourself mine the metals, process them, combine them, andshape them. To mine the metals, you would have to be ableto locate them. You would need machinery, which you wouldhave to build yourself

“Filling in Frameworks” wrestles with the misconceptionthat economics is a science. This section looks at the difficul-ties that economists face in trying to adopt scientific methods. Isuggest that economics differs from the natural sciences in thatwe have to rely much less on verifiable hypotheses and muchmore on hard-to-verify interpretative frameworks. Economicanalysis is a challenge, because judging interpretive frame-works is actually harder than verifying scientific hypotheses.

“Instructions and Incentives” deals with the misconceptionthat economic activity is directed by planners. This sectionexplains that although people within a firm are guided totasks through instruction from managers, the economy as awhole is not coordinated that way. Instead, the price systemfunctions as the coordination mechanism.

Scarcity and choice are certainly important concepts, butmaking them the central focus can lead to economic analysisthat is simplistic and mechanistic. In fact, the approach to eco-nomics that took hold after World War II treats the economyas a machine governed by equations. Textbooks using thatapproach purport to offer a repair manual, with policy toolsto fix the economic machine when something goes wrong.The mechanistic metaphor is inappropriate and even dan-gerous. A better metaphor would be that of a rainforest. Theeconomy is a complex, evolving system

Even more strikingis the fact that almost everything you consume is somethingyou could not possibly produce. Your daily life depends on thecooperation of hundreds of millions of other people

If trade entails trust among strangers, then financial inter-mediation entails trust over time. If people lose trust infinancial intermediaries, then financial intermediation candecline precipitously. That sharp decline can have a broadeffect on the structure of production in the economy

Instead of headlines, the “crawl” on the TV lists all of thetasks and people needed to produce your breakfast. Your cerealwas manufactured in a factory that had a variety of workersand many machines. People had to manage the factory. Orga-nization of the firm required many functions in finance andadministration. First, however, people had to build the factory

When patterns of specialization become unsustainable, theindividuals affected can face periods of unemployment. Theyare like soldiers waiting for new orders, except that the orderscome not from a commanding general but from the decen-tralized actions of many entrepreneurs testing ideas in searchof profit.

Look at the list of ingredients in the cereal. Those ingre-dients had to be refined and shipped to the cereal manu-facturer. Again, those processes required many machines,which in turn had to be manufactured. The cereal grainsand other ingredients had to be grown, harvested, and pro-cessed. Machines were involved in those processes, and thosemachines had to be manufactured.

onomists who ignore the key features of capitalism will be less able tounderstand and explain how capitalism actually works. So purely from a scientificperspective, it’s important to be frank about what we are dealing with

Of course, capitalism can change its “look” a lot, while still preserving its core,underlying features. Indeed, one of the most impressive features of capitalism is itsflexibility: its capacity to change and adapt. Many economists and commentatorshave argued that capitalism today is not at all like capitalism in its early days (backin the soot and grime of the Industrial Revolution). Here are some of the terms usedto describe modern capitalism, implying (falsely) that it’s a whole “new” system:

So the economy is about work: organizing it, doing it, and dividing up andmaking use of its final output. And in our work, one way or another, we alwayswork (directly or indirectly) with other people.The link between the economy and society goes two ways. The economy is afundamentally social arena. But society as a whole depends strongly on the stateof the economy. Politics, culture, religion, and international affairs are all deeplyinfluenced by the progress of the economy. Governments are re-elected or turfedfrom office depending on the state of the economy. Family life is organized aroundthe demands of work (both inside and outside the home). Being able to comfortablysupport oneself and one’s family is a central determinant of happiness.

land and driven into cities, where they suffered horrendous exploitation andconditions that would be considered intolerable today: seven-day working weeks,twelve-hour working days, child labour, frequent injury, early death. Vast profitswere earned by the new class of capitalists, most of which they ploughed backinto new investment, technology, and growth – but some of which they used tofinance their own luxurious consumption. The early capitalist societies were not atall democratic: the right to vote was limited to property owners, and basic rights tospeak out and organize (including to organize unions) were routinely (and oftenviolently) trampled.

Instead, economists refer simply to “the economy” – as if there is only one kindof economy, and hence no need to name or define it. This is wrong. As we havealready seen, “the economy” is simply where people work to produce the things weneed and want. There are different ways to organize that work. Capitalism is justone of them.

Instead, economists refer simply to “the economy” – as if there is only one kindof economy, and hence no need to name or define it. This is wrong. As we havealready seen, “the economy” is simply where people work to produce the things weneed and want. There are different ways to organize that work. Capitalism is justone of them

An economy in which private, profit-seeking companies undertake mostproduction, and in which wage-earning employees do most of the work, is acapitalist economy. We will see that these twin features (profit-driven productionand wage labour) create particular patterns and relationships, which in turn shapethe overall functioning of capitalism as a system.Any economy driven by these two features – production for profit and wagelabour – tends to replicate the following trends and patterns, over and over again:• Fierce competition between private companies for markets, sales, and profit.• Innovation, as companies constantly experiment with new technologies,new products, and new forms of organization – in order to succeed in thatcompetition.• An inherent tendency to growth, resulting from the desire of each individualcompany to make more profit.• Deep inequality between those who own successful companies, and the restof society who do not own companies.• A general conflict of interest between those who work for wages, and theemployers who hire them.• Economic cycles or “rollercoasters,” with periods of strong growth followedby periods of stagnation or depression; sometimes these cycles even producedramatic economic and social crises

Conventionally trained economists take it as a proven fact that free tradebetween two countries always makes both sides better off. People who questionor oppose free trade – trade unionists, social activists, nationalists – must eitherbe acting from ignorance, or else are pursuing some narrow vested interest thatconflicts with the broader good. These troublesome people should be lectured to(and economists love nothing better than expounding their beautiful theory ofcomparative advantage*), or simply ignored. And that’s exactly what mostgovernments do. (Ironically, even some conventional economists now recognizethat traditional free trade theory is wrong, for many reasons – some of whichwe’ll discuss in Chapter 22 of this book. But that hasn’t affected the profession’snear-religious devotion to free trade policies.)

At its simplest, the “economy” simply consists of all the work that human beingsperform, in order to produce the things we need and use in our lives. (By work,we mean all productive human activity, not just employment; we’ll discuss thatdistinction later.) We need to organize and perform our work (economists call thatproduction). And then we need to divide up the fruits of our work (economistscall that distribution), and use it

Economics is the study of human economic behaviour: the production anddistribution of the goods and services we need and want. Hence, economicsis a social science, not a physical science.

Never trust an economist with your job

But quite apart from whether you think capitalism is good or bad, capitalism issomething we must study. It’s the economy we live in, the economy we know. Andthe more ordinary people understand about capitalism

I alsobelieve that it is ultimately possible to build an alternative economic system guideddirectly by our desire to improve the human condition, rather than by a hunger forprivate profit. (Exactly what that alternative system would look like, however, isnot at all clear today.) We’ll consider these criticisms of capitalism, and alternativevisions, in the last chapters of this book

Unfortunately, most professional economists don’t think about economics inthis common-sense, grass-roots context. To the contrary, they tend to adopt arather superior attitude in their dealings with the untrained masses. They invokecomplicated technical mumbo-jumbo – usually utterly unnecessary to theirarguments – to make their case. They claim to know what’s good for the people

Most production of goods and services is undertaken by privately-ownedcompanies, which produce and sell their output in hopes of making a profit.This is called production for profit.2. Most work in the economy is performed by people who do not own theircompany or their output, but are hired by someone else to work in return for amoney wage or salary. This is called wage labour.

nimulavagula, blandula,Hospes comesquecorporis,QuaenuncabibisinlocaPallidula,rigida,nudula,Nec,utsolis,dabisiocos...P.AELIUSHADRIANUS,Imp.

In short, science classes pair a description of our best knowledge at the present with a story of discovery of how we came to know what we know now, with the clear implication that this method is how we will continue to discover new things. By contrast in history this same story (we call it historiography – the history of the history) doesn’t generally attract sustained attention until graduate school. Students learn the names of rulers and thinkers and key figures but they rarely learn the names of historians. Likewise, instead of being presented with a process of historical discovery they are given a narrative of human development – it is not until advanced undergraduate courses that they begin to engage meaningfully with how we know these things. In my own experience the exceptions to this were almost invariably stories about the knowledge-making achievements of other disciplines – archaeology and linguistics, mostly – rather than narratives of historical investigation. So it is not surprising that many students at those introductory levels come away assuming that the narrative is pretty much fixed and has been known and understood effectively forever.

Speaking: Explain how igneous, sedimentary, and metamorphic rocks differ to a partner using compare and contrast language

If we don’t challenge the status quo regarding the improvement of educational opportunities for multilingual learners through equitable practices and policies, who will?

Additionally, multilingual learners may face challenges when teachers use “tricky” language, such as idiomatic expressions (e.g., “learn this by heart” or “the assignment is a walk in the park”

acknowledging the implicit and explicit ideologies and power structures inherent in language, (2) understanding that the use of such language, even unintentionally, can and does legitimate and reproduce social inequalities, and (3) striving to become agents of long-term change in society

Getting to know your students should begin on the first day—or even earlier, if possible, by meeting them (and their families) before the academic year starts—and should continue throughout the year

“I’m not sure what the problem is. These kids can’t speak well in English or Spanish. Rather than teaching them both languages, we should just focus on English

Although the concept of self-fulfilling prophecies was originally developed to be applied to social inequality and discrimination, it has since been applied in many other contexts, including interpersonal communication. This research has found that some people are chronically insecure, meaning they are very concerned about being accepted by others but constantly feel that other people will dislike them.

Americans "Cinderella" is not a story of rags to riches, but rather riches recovered; not poor girl into princess but rather rich girl (or princess) rescued from improper or wicked enslavement; not suffering Griselda enduring but shrewd and practical girl persevering and winning a share of the power. It is really a story that is about "the stripping away of the disguise that conceals the soul from the eyes of others "

Since then, America's Cinderella has been a coy, helpless dreamer, a "nice" girl who awaits her rescue with patience and a song.

The idea in the West is to make a product which will sell well.

But each person’s self-concept is also influenced by context, meaning we think differently about ourselves depending on the situation we are in. In some situations, personal characteristics, such as our abilities, personality, and other distinguishing features, will best describe who we are.

I’m sure you have a family member, friend, or coworker with whom you have ideological or political differences.

In the conflict thus far, success has been on our side

our social fabric is firmly planted; and I cannot permit myself to doubt the ultimate success of a full recognition of this principle throughout the civilized and enlightened world.

The architect, in the construction of buildings, lays the foundation with the proper material-the granite-then comes the brick or the marble. The substratum of our society is made of the material fitted by nature for it, and by experience we know that it is the best, not only for the superior but for the inferior race, that it should be so. It is, indeed, in conformity with the Creator.

We also organize information that we take in based on difference. In this case, we assume that the item that looks or acts different from the rest doesn’t belong with the group. Perceptual errors involving people and assumptions of difference can be especially awkward, if not offensive.

In answering this letter, please state if there would be any safety for my Milly and Jane, who are now grown up, and both good-looking girls. You know how it was with poor Matilda and Catherine. I would rather stay here and starve—and die, if it come to that—than have my girls brought to shame by the violence and wickedness of their young masters. You will also please state if there has been any schools opened for the colored children in your neighborhood. The great desire of my life now is to give my children an education, and have them form virtuous habits.

But in the last analysis, it is the people themselves who are filed away through the lack of creativity, transformation, and knowledge in this (at best) misguided system

This is the "banking" concept of education, in which the scope of action allowed to the students extends only as far as receiving, filing, and storing the deposits.

Words are emptied of their concreteness and become a hollow, alienated, and alienating verbosity.

The contents, whether values or empirical dimensions of reality, tend in the process of being narrated to become lifeless and petrified.

Acceptable Use of AI in this Course

1 final reflection worth 10 points

Define important concepts such as: authority, peer review, bias, point of view, editorial process, purpose, audience, information privilege and more.

trial and error

herefore of making a provi-sional determination of the absolute values ofthe charges carried by the drop

supported by evidence from many sourcesthat all electrical charges,

The error in a single ob-servation need not exceed one third of oneper cent.

mean free path

Others have been tempted to argue that implicit bias is overrated (maybe even justified) and that minorities simply need to toughen up.

Take the example of the Müller-Lyer illusion. Your task is to decide whether line A or line B is the longer one.

The act of study demands a sense of modesty.

In fact, a book reflects its author’s confrontation with the world. It expresses thisconfrontation.

This critical attitude is precisely what“banking education” does not engender.

f the reader is transformed into a “vessel” filled by extracts from an internalizedtext

In our study, developers accepted around 30% of GitHub Copilot’s suggestions

In our survey, respondents most commonly reported using the time they save with AI coding tools to design systems, collaborate, and learn.

nearly all of the survey participants reported using AI coding tools both outside of work or at work at some point

Easier to work with new programming languages, and understand existing codebases.

It is not often that educators are permitted to strike because they are employed by the state and are considered vital to public service.

Therefore, some states have begun to change tenure laws to adhere to the accountability requirements stipulated by the U.S. Department of Education as it relates to teacher evaluation and student achievement.

(CCSSO, InTASC Standard #9, 2013).

“There has never been a more important time for children to become storytellers, and there have never been so many ways for them to share their stories” (p. 3). Our students and their stories should be an essential part of our teaching. As educators, we need to encourage students to tell their stories and help build community. Each shared story has the potential of teaching us.

When students’ lives are taken off the margins and placed in the curriculum, they don’t feel the same need to put down someone else” (p. 7). Students need to feel that their voices matter, that they have a story to contribute or share and that their stories are a rich part of the curriculum

Students who search their memories for details about an event as they are telling it orally will later find those details easier to capture in writing

“there has probably never been a human society in which people did not tell stories”

one critical problem

Having said that, always remember that artificial intelligence is only an assistant; an executive’s value comes from his or her own intelligence.

That which diverges from the run-of-the-mill is not only valuable; it is indeed becoming invaluable in the age of AI.

Our priority should be to discover and innovate, not imitate neural networks.

We can use AI for unengaging and repetitive tasks, but we should also remember that humaneness is the key to creativity.

has almost innumerable advantages over the human mind

The Egyptian empires lasted for nearly 2300 years before being conquered, in succession, by the Assyrians, Persians, and Greeks between about 700 BCE and 332 BCE.

Farming developed in a number of different parts of the ancient world, before the beginning of recorded history. That means it’s very difficult for historians to describe early agricultural societies in as much detail as we’d like. Also, because there are none of the written records historians typically use to understand the past, we rely to a much greater extent on archaeologists, anthropologists, and other specialists for the data that informs our histories. And because the science supporting these fields has advanced rapidly in recent years, our understanding of this prehistoric period has also changed – sometimes abruptly.

All work turned in must adhere to the following format.

All assignments for this course must be written and submitted directly in Google Docs

It places too high of aburden on me to investigate and evaluate AI possible AI usage instead of focusingon the important educational aspects of the course.

The speculative bubble created by railroad financing burst in the Panic of 1873, which began a period called the Long Depression that lasted until nearly the end of the century and was so bad that before the Great Depression of the 1930s the period was known simply as “The Depression”.

Nearly 100 Americans died in “The Great Upheaval.” Workers destroyed nearly $40 million worth of property. The strike galvanized the country. It convinced laborers of the need for institutionalized unions, persuaded businesses of the need for even greater political influence and government aid, and foretold a half century of labor conflict in the United States.

not only can such freedom be granted without prejudice to the public peace, but also, that without such freedom, piety cannot flourish nor the public peace be secure.

How many evils spring from luxury, envy, avarice, drunkenness, and the like, yet these are tolerated

but what question was ever settled so wisely that no abuses could possibly spring therefrom?

I mean the pace of the finished film, how the edits speed up or slow down to serve the story, producing a kind of rhythm to the edit.

ther ways cinema manipulates time include sequences like flashbacks and flashforwards. Filmmakers use these when they want to show events from a character’s past, or foreshadow what’s coming in the future.

The most obvious example of this is the ellipsis, an edit that slices out time or events we don’t need to see to follow the story. Imagine a scene where a car pulls up in front of a house, then cuts to a woman at the door ringing the doorbell. We don’t need to spend the screen time watching her shut off the car, climb out, shut and lock the door, and walk all the way up to the house.

He wants you to feel the terror of those peasants being massacred by the troops, even if you don’t completely understand the geography or linear sequence of events. That’s the power of the montage as Eisenstein used it: A collage of moving images designed to create an emotional effect rather than a logical narrative sequence.

he audience was projecting their own emotion and meaning onto the actor’s expression because of the juxtaposition of the other images. This phenomenon – how we derive more meaning from the juxtaposition of two shots than from any single shot in isolation – became known as The Kuleshov Effect.

While navigating through the text, you’ll notice that the major part of the text you’re working within is identified at the top of the page