Articles

10.9E: Exercises


Practice Makes Perfect

In the following exercises, write each expression in terms of (i) and simplify if possible.

  1. a. (sqrt{-16}) b. (sqrt{-11}) c. (sqrt{-8})
  2. a. (sqrt{-121}) b. (sqrt{-1}) c. (sqrt{-20})
  3. a. (sqrt{-100}) b. (sqrt{-13}) c. (sqrt{-45})
  4. a. (sqrt{-49}) b. (sqrt{-15}) c. (sqrt{-75})
Answer

1. a. (4i) b. (isqrt{11}) c. (2isqrt{2})

3. (10i) b. (isqrt{13}) c. (3isqrt{5})

In the following exercises, add or subtract, putting the answer in (a + bi) form.

5. (sqrt{-75}+sqrt{-48})

6. (sqrt{-12}+sqrt{-75})

7. (sqrt{-50}+sqrt{-18})

8. (sqrt{-72}+sqrt{-8})

9. ((1+3 i)+(7+4 i))

10. ((6+2 i)+(3-4 i))

11. ((8-i)+(6+3 i))

12. ((7-4 i)+(-2-6 i))

13. ((1-4 i)-(3-6 i))

14. ((8-4 i)-(3+7 i))

15. ((6+i)-(-2-4 i))

16. ((-2+5 i)-(-5+6 i))

17. ((5-sqrt{-36})+(2-sqrt{-49}))

18. ((-3+sqrt{-64})+(5-sqrt{-16}))

19. ((-7-sqrt{-50})-(-32-sqrt{-18}))

20. ((-5+sqrt{-27})-(-4-sqrt{-48}))

Answer

5. (0+left(9sqrt{3} ight)i)

7. (0+left(8sqrt{2} ight)i)

9. (8+7i)

11. (14+2i)

13. (-2+2i)

15. (8+5i)

17. (7-13i)

19. (25-left(2 sqrt{2} ight) i)

In the following exercises, multiply, putting the answer in (a+bi) form.

21. (4 i(5-3 i))

22. (2 i(-3+4 i))

23. (-6 i(-3-2 i))

24. (-i(6+5 i))

25. ((4+3 i)(-5+6 i))

26. ((-2-5 i)(-4+3 i))

27. ((-3+3 i)(-2-7 i))

28. ((-6-2 i)(-3-5 i))

Answer

21. (12+20i)

23. (-12+18i)

25. (-38+9 i)

27. (27+15i)

In the following exercises, multiply using the Product of Binomial Squares Pattern, putting the answer in (a+bi) form.

29. ((3+4 i)^{2})

30. ((-1+5 i)^{2})

31. ((-2-3 i)^{2})

32. ((-6-5 i)^{2})

Answer

29. (-7+24i)

31. (-5-12i)

In the following exercises, multiply, putting the answer in (a+bi) form.

33. (sqrt{-25} cdot sqrt{-36})

34. (sqrt{-4} cdot sqrt{-16})

35. (sqrt{-9} cdot sqrt{-100})

36. (sqrt{-64} cdot sqrt{-9})

37. ((-2-sqrt{-27})(4-sqrt{-48}))

38. ((5-sqrt{-12})(-3+sqrt{-75}))

39. ((2+sqrt{-8})(-4+sqrt{-18}))

40. ((5+sqrt{-18})(-2-sqrt{-50}))

41. ((2-i)(2+i))

42. ((4-5 i)(4+5 i))

43. ((7-2 i)(7+2 i))

44. ((-3-8 i)(-3+8 i))

Answer

33. (30i = 0 + 30i)

35. (-30 = -30 + 0i)

37. (-44+left(4 sqrt{3} ight) i)

39. (-20-left(2 sqrt{2} ight) i)

41. (5 = 5 + 0i)

43. (53 = 53 + 0i)

In the following exercises, multiply using the Product of Complex Conjugates Pattern.

45. ((7-i)(7+i))

46. ((6-5 i)(6+5 i))

47. ((9-2 i)(9+2 i))

48. ((-3-4 i)(-3+4 i))

Answer

45. (50)

47. (85)

In the following exercises, divide, putting the answer in (a+bi) form.

49. (dfrac{3+4 i}{4-3 i})

50. (dfrac{5-2 i}{2+5 i})

51. (dfrac{2+i}{3-4 i})

52. (dfrac{3-2 i}{6+i})

53. (dfrac{3}{2-3 i})

54. (dfrac{2}{4-5 i})

55. (dfrac{-4}{3-2 i})

56. (dfrac{-1}{3+2 i})

57. (dfrac{1+4 i}{3 i})

58. (dfrac{4+3 i}{7 i})

59. (dfrac{-2-3 i}{4 i})

60. (dfrac{-3-5 i}{2 i})

Answer

49. (i = 0 + i)

51. (frac{2}{25}+frac{11}{25} i)

53. (frac{6}{13}+frac{9}{13} i)

55. (-frac{12}{13}-frac{8}{13} i)

57. (frac{4}{3}-frac{1}{3} i)

59. (-frac{3}{4}+frac{1}{2} i)

In the following exercises, simplify.

61. (i^{41})

62. (i^{39})

63. (i^{66})

64. (i^{48})

65. (i^{128})

66. (i^{162})

67. (i^{137})

68. (i^{255})

Answer

61. (i^{41} = i^{40}cdot i = left(i^{4} ight)^{10}cdot i= i)

63. (i^{66} = i^{64}cdot i^{2} = left(i^{4} ight)^{16}cdot (-1)= -1)

65. (i^{128} = left(i^{4} ight)^{32} = 1)

67. (i^{137} = i^{136}cdot i = left(i^{4} ight)^{34}cdot i = 1 cdot i = i)

69. Explain the relationship between real numbers and complex numbers.

70. Aniket multiplied as follows and he got the wrong answer. What is wrong with his reasoning?
(egin{array}{c}{sqrt{-7} cdot sqrt{-7}} {sqrt{49}} {7}end{array})

71. Why is (sqrt{-64}=8 i) but (sqrt[3]{-64}=-4).

72. Explain how dividing complex numbers is similar to rationalizing a denominator.

Answer

69. Answers may vary

71. Answers may vary

Self Check

a. After completing the exercises, use this checklist to evaluate your mastery of the objectives of this section.

b. On a scale of 1-10, how would you rate your mastery of this section in light of your responses on the checklist? How can you improve this?


Your Request Originates from an Undeclared Automated Tool

To allow for equitable access to all users, SEC reserves the right to limit requests originating from undeclared automated tools. Your request has been identified as part of a network of automated tools outside of the acceptable policy and will be managed until action is taken to declare your traffic.

Please declare your traffic by updating your user agent to include company specific information.

For best practices on efficiently downloading information from SEC.gov, including the latest EDGAR filings, visit sec.gov/developer. You can also sign up for email updates on the SEC open data program, including best practices that make it more efficient to download data, and SEC.gov enhancements that may impact scripted downloading processes. For more information, contact [email protected]

For more information, please see the SEC’s Web Site Privacy and Security Policy. Thank you for your interest in the U.S. Securities and Exchange Commission.

Reference ID: 0.d68e655f.1625602931.c6eb7529


9.E: Solutions (Exercises)

Calcium nitrate reacts with sodium carbonate to precipitate solid calcium carbonate:

[Ca(NO_3)_ <2(aq)>+ Na_2CO_ <3(aq)> ightarrow CaCO_ <3(s)>+ NaNO_<3(aq)>]

  1. Balance the chemical equation.
  2. How many grams of Na2CO3 are needed to react with 50.0 mL of 0.450 M Ca(NO3)2?
  3. Assuming that the Na2CO3 has a negligible effect on the volume of the solution, find the osmolarity of the NaNO3 solution remaining after the CaCO3 precipitates from solution.

The compound HCl reacts with sodium carbonate to generate carbon dioxide gas:

  1. Balance the chemical equation.
  2. How many grams of Na2CO3 are needed to react with 250.0 mL of 0.755 M HCl?
  3. Assuming that the Na2CO3 has a negligible effect on the volume of the solution, find the osmolarity of the NaCl solution remaining after the reaction is complete.

Estimate the freezing point of concentrated aqueous HCl, which is usually sold as a 12 M solution. Assume complete ionization into H + and Cl &minus ions.

Estimate the boiling point of concentrated aqueous H2SO4, which is usually sold as an 18 M solution. Assume complete ionization into H + and HSO4 &minus ions.

Seawater can be approximated by a 3.0% m/m solution of NaCl in water. Determine the molarity and osmolarity of seawater. Assume a density of 1.0 g/mL.

Human blood can be approximated by a 0.90% m/m solution of NaCl in water. Determine the molarity and osmolarity of blood. Assume a density of 1.0 g/mL.

How much water must be added to 25.0 mL of a 1.00 M NaCl solution to make a resulting solution that has a concentration of 0.250 M?

Sports drinks like Gatorade are advertised as capable of resupplying the body with electrolytes lost by vigorous exercise. Find a label from a sports drink container and identify the electrolytes it contains. You should be able to identify several simple ionic compounds in the ingredients list.

Occasionally we hear a sensational news story about people stranded in a lifeboat on the ocean who had to drink their own urine to survive. While distasteful, this act was probably necessary for survival. Why not simply drink the ocean water? (Hint: See Exercise 5 and Exercise 6 above. What would happen if the two solutions in these exercises were on opposite sides of a semipermeable membrane, as we would find in our cell walls?)


Chapters

Chapter 1: Introduction to the Internet and World Wide Web

This brief introduction covers the terms and concepts related to the Internet and the Web with which Web developers need to be familiar. For many students, some of this will be a review. Chapter 1 provides the base of knowledge on which the rest of the textbook is built.

Chapter 2: HTML Basics

As HTML5 and XHTML are introduced, examples and exercises encourage students to create sample pages and gain useful experience. Students are encouraged to create sample pages as they read through the text.

Chapter 3: Configuring Color and Text with CSS

The technique of using Cascading Style Sheets to configure the color and text on web pages is introduced.

Chapter 4: Visual Elements and Graphics

This chapter discusses the use of graphics and visual eff ects on web pages, including image optimization, CSS borders, CSS image backgrounds, new CSS3 visual eff ects, and new HTML5 elements. Students are encouraged to create web pages as they read through the text.

Chapter 5: Web Design

This chapter focuses on recommended web design practices and accessibility. Some of this is reinforcement because tips about recommended website design practices are incorporated into the other chapters.

Chapter 6: Page Layout

This chapter continues the study of CSS begun earlier and introduces techniques for positioning and floating web page elements, including a two-column CSS page layout. New HTML5 semantic elements are also introduced.

Chapter 7: More on Links, Layout, and Mobile

This chapter revisits earlier topics and introduces more advanced techniques related to hyperlinks, using CSS sprites, a three-column page layout, configuring CSS for print, and designing pages for the mobile web. CSS media queries are introduced as students configure a web page for both desktop and mobile display. The chapter also introduces CSS Flexible Box Layout and CSS Grid Layout.

Chapter 8: Tables

This chapter focuses on the HTML elements used to create tables. Methods for configuring a table with CSS are introduced.

Chapter 9: Forms

This chapter focuses on the HTML elements used to create forms. Methods for confi guring the form with CSS are introduced. New HTML5 form control elements and attribute values are introduced.

Chapter 10: Web Development

This chapter focuses on the process of website development, including the job roles needed for a large-scale project, the web development process, and web hosting.

Chapter 11: Web Media and Interactivity

This chapter off ers an overview of topics related to adding media and interactivity to web pages. These topics include HTML5 video and audio, Flash, Java applets, a CSS Image Gallery, CSS3 transform and transition properties, interactivity with HTML5 Details and Summary elements, JavaScript, and AJAX.

Chapter 12: E-Commerce Overview

This chapter introduces e-commerce, security, and order processing on the Web.

Chapter 13: Web Promotion

This chapter discusses site promotion from the web developer's point of view and introduces search engine optimization.

Chapter 14: A Brief Look at JavaScript & jQuery

This chapter provides an introduction to client-side scripting using JavaScript and jQuery.


1 Answer 1

You CA certificates has the following extensions:

Apart from the fact that there is no need for Subject Alternative Name extension and TLS Web Client/Server Authentication key usage for a CA certificate none of the given key usages is needed for a CA but the one which is needed is missing.

Lets see what the key usages you have are needed for. The relevant citations are taken from RFC 5280 section 4.2.1.3 Key Usage.

  • Digital Signature
    The digitalSignature bit is asserted when the subject public key is used for verifying digital signatures, other than signatures on certificates (bit 5) and CRLs (bit 6), such as those used in an entity authentication service, a data origin authentication service, and/or an integrity service.
  • Key Encipherment
    The keyEncipherment bit is asserted when the subject public key is used for enciphering private or secret keys, i.e., for key transport. For example, this bit shall be set when an RSA public key is to be used for encrypting a symmetric content-decryption key or an asymmetric private key.

In other words: none of these key usages is relevant when validating the signature on certificates.

But there is one important key usage needed when validating certificates:

  • Certificate Sign
    The keyCertSign bit is asserted when the subject public key is used for verifying signatures on public key certificates. If the keyCertSign bit is asserted, then the cA bit in the basic constraints extension (Section 4.2.1.9) MUST also be asserted.

Only, this key usage is missing on your CA certificate. That's why it will not use this CA certificate to validate the signature of the leaf certificate and thus it fails to build the trust chain. Once you add this key usage to your CA certificate (and preferable remove all the unneeded key usage, purpose and SAN) it will successfully be used to validate the leaf certificate.


Title: Test Bank Business Law: Text and Exercises
Author(s): Roger LeRoy Miller William Eric Hollowell
Edition: 9
Year: 2019
ISBN-13: 9781337624657 (978-1-337-62465-7)
ISBN-10: 1337624659 (1-337-62465-9)

Related Products


Physical constants in R

The packages marelac and dielectric both have some physical constants, but not that one in particular. marelac::convert_T will do the temperature conversions.

It's a fairly large task to assemble this information but some of the thermodynamic constants are available in marelac:

In addition to the R resources in my answer to the question that that @joran cited these are further resources at NIST:

I took on the task of reading the NIST Constants Table, editing it so the conversion to numeric would be reasonable, and this was the input code:

. and here is the dput version:

May I recommend 2 options:

1) If you need these constants all the time you could make use of the .First library in the form of C2K<-273.15 . You can assign constants and store them there. For more on this see http://cran.r-project.org/doc/contrib/Lemon-kickstart/kr_first.html

2) If you want to use the files only sometimes save the constants in a text file in the same format as above x<-273.15 and then source the path to this file using the source function in the following format: source(C:UsersPAth to save file textformulas.txt)

This gives you more control over the constants than relying on a package that may or may not contain what you want.


In photography we let a certain amount of illumination fall upon a film or a plate, and after development we get a blackening of the film.

13.1 Some fundamental definitions

During exposure:
After development:

13.2 Definition of film sensitivity

The film should be developed such that an illumination of Hn yields a blackening of S09. Hm corresponds to "minimum blackening" S01, i.e. the minimum required for the blackening to be visible at all.

Hm = illumination (lux-seconds) needed for "mimimum blackening".

(There's also a Russian unit - GOST - which is based on a point Ss+0.2)

Today film sensitivities are given in ISO , which is the same as ASA aritm .

ISO = International Standards Organisation
ASA = American Standards Association (nowadays ANSI)
DIN = Deutsche Industrie Normen (German Industry Norms)

Approximate conversion of film sensitivities between different units:

13.3 Worked example: computing exposure time of celestial object

I want to photograph the Orion Nebula, using 200 ISO film, a 6-inch (15 cm) telescope of focal length 1 meter. I'm going to use prime focus. What exposure time should I use?

First a caution: the exposure time computed here is only very approximate, because the magnitude and apparent size of the nebula are both only approximate, and also because at long exposure times film often lose sensitivity due to reciprocity failure. Thus one should consider our computed values here as only an approximate guide, and when photographing the nebula one should bracket with exposures both below and above this value.

Nevertheless it's interesting to carry out the computation, because it will illuminate conversions from magnitudes to lumens, and then use ISO numbers of the film to compute exposure times. So here we go:

First let's assume the Orion Nebula shines at 4th magnitude, having an apparent diameter of 10 arc minutes.

One mv=0 star illuminates at 2.54E-6 lux outside the Earth's atmosphere. The Orion nebula shines at 4th magnitude, i.e. it illuminates at
If the Orion nebula is 30 deg above the horizon, the light will have to pass 2 air masses, where each air mass transmits 82% of the light. Thus at the ground the Orion nebula illmuminates at
Our reflector has an entrance 15 cm across. If we assume a central obstruction of 20% the entrance, we get an entrance area of 170 cm^2

At a focal length of 1 meter the Orion nebula, 10 arcmin across, will be imaged at a size of 0.291 cm, i.e. an area of 0.085 cm^2

Thus the 170 cm^2 entering the telescope will be imaged on 0.085 cm^2, increasing the illumination by a factor of 170/0.085 = 2000

If we assume 90% of the light entering the telescope will be transmitted, we find that the illumination at the film will be:
A 200 ISO film will require an illumination for minimum blackening:
For "normal" blackening more will be needed -- let's assume 10 times more illumination will be needed - this is 0.04 lux-seconds.

Thus we have an illumination at the film of 7.7E-5 lux, and we need 0.04 lux-seconds. This requires approx. 520 seconds or about 9 minutes exposure time.


Copies

One of the goals of the data.table package is to use memory efficiently. This is achieved in part by preferring “shallow” copies by reference over “deep copies” by value when appropriate. When an object is copied by reference it shares physical memory address with the object it is copied from. This is more efficient, but may lead to confusion as changing the value in memory also changes what is pointed to by both objects.

In the example below, we create a data.table DT1 and then assign it to DT2 . Typical R objects would be copied by value using “copy on modify” semantics, but DT2 is copied by reference. We can ask for a copy by value explicitly using copy() .

After updating DT1 to include a new column, C , the column appears in DT2 as well because DT1 and DT2 refer to the same object.

How can we undestand the DT4 example? Does it make sense that it works as it does?


10.9E: Exercises

CMPSC 473, Operating Systems Design and Construction

Operating System Overview


What are the objectives and functions of an operating system?
How is an operating system organized? (design and construction)
How are resources allocated?

  • OSC, Ch. 1, Ch. 2
    • OSC, 7e Sec. 23.1 8e Sec. 23.1, 23.2 9e Sec. 20.1, 20.2
    • for additional background, all of 7e/8e Ch. 23, 9e Ch. 20
    • For a quick review, OSC 8e Sec. 1.4-5, 1.12-13 9e Sec. 1.4-5, 1.10-12.
    • Is this a feature of all OS designs, or just one particular OS?
    • How does this feature contribute to the overall goals of the system design?
    • What is the specific goal or utility of this feature?
    • What are the principles behind this feature?
    • How is it implemented in practice?
    • How can we prove, or convincingly demonstrate, various properties of this feature?
    • What performance issues are associated with this feature?
    • What other designs are possible for this feature?
    • Is there a standardized version of this feature?
    • Can this feature be misused, and what are the consequences of that?
    • Can this feature fail, and what are the causes and effects of failure?
    • Is this feature in conflict with any other feature?
    • What economic benefits or penalties are associated with installing this feature or not?
    • How can we decide if this feature should be implemented and put into general use?
    • Once implemented, can this feature be changed or removed?

    processor, memory, I/O, storage shared resources
    OS kernel arbiter of resources
    system utilities trusted supporting processes and functions
    application programs supporting processes
    user untrusted

    • Functional issues and goals
    • Evolution of OS design [from OSC 6e Sec. 1.2 - 1.9]
      • Serial processing
      • Batch systems
      • Multiprogramming
      • Time-sharing
      • Distributed systems
      • Special-purpose systems
      • Processes, threads
      • Memory management
      • Device management
      • Protection and security
        • Policy and mechanism
        • Information, access rights, etc.
        • The content of memory is a collection of bits, which we can interpret in different ways.
        • Sometimes the bits represent a program, and sometimes the bits represent data.
        • Misinterpreting the bits, by accident or by design, is not a good idea.
        • user goals
          • convenient to use, easy to learn, reliable, safe, fast
          • easy to design, implement, maintain
          • flexible, reliable, error-free, efficient
          • resource manager
            • correctness, efficiency, security
            • convenience
            • impact of convenience on efficiency
              • negative impact on hardware efficiency, utilization
              • positive impact on human efficiency
              • portable system programs
                • limited hardware dependence
                • OS, system architecture
                • interfaces and protocols, data formats
                • component design
                • portable user programs
                • user familiarity
                • error management
                • access restrictions
                  • resource isolation
                  • protection and security
                  • Quality of Service
                  • trusted and untrusted components
                  • physical resources
                    • electrical power
                    • time
                    • space
                      • processors, memory
                      • I/O devices
                      • data structures
                      • files
                      • communication paths
                      • access privilege
                      • dedicated or shared
                      • pre-allocated or dynamically-allocated
                      • deallocated voluntarily or forcibly
                      • mutual exclusion
                      • single ownership of resource
                      • return of resource to system after use
                      • Processes must not interfere with each other, or cooperate in unintended ways.
                      • Except that the OS must always win .
                      • timer interrupts
                      • kernel mode
                      • resident monitor, OS kernel

                      The OS kernel must be completely trustworthy, as it supports all other OS services.

                      • Is the OS kernel defined by user/kernel mode or by memory residency?
                      • Is screen area a resource managed by the OS?
                      1. application programs
                        • high-level programming
                        • system independence
                      2. utilities
                        • system software
                        • application independence
                      3. operating system
                        • support for utilities
                        • resource management
                      4. computer hardware
                        • low-level programming
                        • system dependent
                      • 1-2 interface
                        • Application Programming Interface
                        • library functions - specified by the programming language
                        • Unix man pages, section 3
                        • example - printf(3C), stdio.h, defined by C
                        • operating system interface
                        • system functions - specified by the operating system family
                        • Unix man pages, section 2
                        • example - write(2), unistd.h, defined by Unix
                        • software-hardware interface
                        • system-call interface to the OS kernel - specified by the operating system implementation
                        • Solaris man pages, section 9
                        • instruction-set architecture, device manuals
                        • example - write(9E), file system, device driver, defined by Sun for Solaris
                        • reusable components
                        • Unix devices and communication ports masquerade as files
                        • write() to screen or to file, depending on open()
                        • update OS kernel without recompiling application programs
                        • install hardware and device drivers without rebuilding OS
                        • move OS to a new processor or system architecture
                        • performance impact, usage limitations
                        • But, bad programmers make mistakes from lack of understanding,
                        • and good programmers try to understand it all.
                        • OSC Fig. 8e 2.13, 9e 2.12 is confusing, because some of the line breaks are in the wrong places. The kernel part of the table should look like this:
                        • application programs
                          • file modification - generic editor
                          • etc., etc.
                          • status information - date, remaining file space, list of processes, etc.
                          • file management - create, delete, copy, rename, print, etc.
                          • file modification - editor for specific file formats and purposes
                          • communications - mail, web access, remote login, file transfer, etc.
                          • programming tools
                            • command interpreter, shell
                            • editor
                            • compiler, assembler, linker
                            • interpreter
                            • loader, runtime support, debugger
                            • error detection, response
                            • interprocess communication
                            • accounting
                            • performance measurement
                            • system trace
                            • network server
                            • print server
                            • etc., etc.
                            • system
                            • file system
                            • I/O device
                            • call a system function
                              • usually on the same system
                              • initiated by trap instruction
                              • work in kernel memory, copy from/to user memory
                              • "system process" could be on a different system
                              • Never forget this!
                              • what are the relative costs and benefits?
                              • processes identify memory regions to share
                                • virtual addresses
                                • process identifiers
                                • mmap() -- memory mapping
                                • shmat() -- shared memory attach
                                • virtual memory maps process address space to physical memory
                                • synchronization tools to control access to shared memory
                                • message = data structure holding
                                  • request for service, or response to request
                                  • source, destination process identifiers
                                  • send()
                                  • receive()
                                  • host and process identifiers
                                  • open and close connection
                                  • request and accept connection
                                  • mailbox, message queue
                                  • process-to-kernel-to-process copy, network communication
                                  • process alert
                                  • Exercise - try the Mac OS X Activity Monitor
                                    • Applications / Utilities / Activity Monitor
                                    • select View / Columns / Messages Sent and Messages Received
                                    • major hardware upgrades
                                      • mode bit
                                      • paging support
                                      • more address bits
                                      • more processors
                                      • more cores
                                      • network connections
                                      • memory expansion
                                      • new devices
                                      • save the user files
                                      • automatic over the network?
                                      • Linux loadable module
                                      • Windows device drivers
                                      • distributed systems
                                      • major or minor?
                                        • mouse = point-and-click device
                                        • one button
                                        • three buttons
                                        • five buttons
                                        • wheel
                                        • ball
                                        • wireless
                                        • finger = touch-and-move device
                                        • user/computer interface
                                          • integrated into the hardware
                                          • integrated into the OS
                                          • a service provided with the OS
                                          • just another program
                                          • one program only
                                          • one user only
                                          • multiple users
                                          • console = keyboard + screen
                                          • remote console = network + virtual console
                                          • remote access = network + communication protocol
                                          • separate policy from mechanism
                                            • policy = what to do
                                            • mechanism = how to do something
                                            • separation allows easier change of policy by administrator
                                            • function is mechanism
                                            • function parameters, taken from table, are policy decisions
                                            • table can be stored in system-restricted file
                                            • user support
                                            • programmer support
                                              • develop, test, debug, deliver
                                              • all features in one program
                                              • design discipline no longer apparent even if present at one time
                                              • difficult to test or make changes in design or implementation
                                              • core components
                                                • interrupt handlers, system calls
                                                • device drivers
                                                • process management
                                                  • scheduler
                                                  • interprocess communication
                                                  • always available
                                                  • used as needed
                                                  • small core components - mechanism
                                                    • interrupt handlers, device interface
                                                    • address spaces
                                                    • memory manager
                                                    • interprocess communication (messages, probably)
                                                    • these must be in kernel mode
                                                    • scheduling
                                                    • page replacement
                                                    • these may be in user mode
                                                    • example - file system, print manager
                                                    • devices as pseudo-files
                                                    • local or remote
                                                    • benefits
                                                      • only small parts of the OS depend on details of the hardware architecture
                                                      • more reliable? less code in kernel mode
                                                      • more easily extended, by adding modules
                                                      • frequent transitions between user mode and kernel mode
                                                      • improved hardware design can compensate for that
                                                      • Example - L4 (see link at top of page)
                                                      • allocate, deallocate and multiplex physical resources in a secure way
                                                      • abstraction-free low-level interface
                                                        • physical memory, pages
                                                        • CPU, time slices
                                                        • disk memory, blocks
                                                        • DMA channels
                                                        • I/O devices
                                                        • TLB
                                                        • addressing context identifiers
                                                        • interrupt/trap events
                                                        • Serial Processing - 1950's
                                                        • Batch Systems - 1960's
                                                        • Multiprogramming - 1970's
                                                        • Time-Sharing - 1970's
                                                          • personal computers - 1980's
                                                          • Which features of the system or usage were emphasized, or over-emphasized?
                                                          • How did the hardware limit the software?
                                                          • What is the modern version of this feature?
                                                          • one user only
                                                            • one program only
                                                            • direct hardware access
                                                            • completely interactive
                                                            • sign-up sheet
                                                            • by the user
                                                            • assembler, loader
                                                            • library routines, for device abstraction
                                                            • setup time for each user
                                                            • sign-up for 15 minutes, use only 5, so 10 wasted if next person not yet arrived
                                                            • sign-up for 15 minutes, attempt to use 20, so 15 wasted or annoy next person
                                                            • single-user PC with DOS
                                                            • process control, single application
                                                            • some university labs
                                                            • dumbphone? smartphone?
                                                            • computer operator
                                                            • multiple users, one job at a time
                                                              • indirect hardware access
                                                              • no interaction
                                                              • backlog
                                                              • batch = collection of similar jobs, to reduce setup time
                                                              • priority
                                                              • accept new job
                                                              • select next job from queue
                                                              • run program
                                                              • program returns control to monitor
                                                              • job control language (JCL)
                                                              • program name, or program text for compiler
                                                              • fixed starting address, for loader
                                                              • input data attached to job or in file
                                                              • output data to printer or file
                                                              • interrupt processing
                                                              • device drivers
                                                              • job sequencing
                                                                • memory allocator, loader
                                                                • tape/disk spooling system
                                                                • spool = simultaneous peripheral operation on-line
                                                                • memory protection
                                                                  • keep program away from monitor
                                                                  • off-line programming and debugging
                                                                  • CPU utilization, primary goal
                                                                  • turnaround time, secondary goal
                                                                  • memory-resident monitor
                                                                  • monitor's processor time
                                                                  • program waits for I/O
                                                                  • print server
                                                                  • compute server
                                                                  • JCL --> shell or script programming
                                                                    • command interpreter with file input
                                                                    • batch subsystem, scheduled jobs
                                                                    • A single user program cannot keep the CPU and I/O devices busy at all times.
                                                                    • overlap processor activity and I/O activity from separate jobs
                                                                      • try to keep all the components running
                                                                      • multiple users, multiple jobs
                                                                        • several at a time (in the system)
                                                                        • ready jobs (in the memory)
                                                                        • one at a time (in the processor)
                                                                        • minimal interaction
                                                                        • ready, waiting
                                                                        • switch jobs at I/O interrupt (infrequent, irregular)
                                                                        • switch between ready jobs
                                                                        • maximize processor use
                                                                        • input data from terminal or file
                                                                        • output data to terminal or file
                                                                        • similar but more complex
                                                                        • terminal driver
                                                                        • integrated command interpreter
                                                                        • memory management
                                                                          • swapping - whole jobs are moved between memory and disk
                                                                          • keep programs away from each other
                                                                          • select memory-resident programs
                                                                          • select program to run from available ready jobs
                                                                          • give preference to I/O services
                                                                          • concurrent operation of central processor and peripheral devices
                                                                          • CPU and device utilization, primary goal
                                                                          • number of available and ready jobs, secondary goal
                                                                          • turnaround and response times, secondary goal
                                                                          • I/O interrupts
                                                                          • resource contention
                                                                          • job scheduler
                                                                          • job switch
                                                                          • remote entry system
                                                                          • bank ATM network
                                                                          • Web server
                                                                          • multiple interactive users
                                                                            • multiple jobs per user
                                                                            • shell script, batch file
                                                                            • terminal command and data input
                                                                            • network requests
                                                                            • switch jobs at timer interrupt (frequent, regular)
                                                                            • minimize response time
                                                                            • equitable allocation of processor time and memory resources
                                                                            • process concept
                                                                              • protection barriers
                                                                              • interprocess communication
                                                                              • process time slice
                                                                              • partial jobs are moved between memory and disk
                                                                              • segmentation, hardware stack, code/data memory access (per word), data access descriptors
                                                                                • 1961, Burroughs B5000 MCP
                                                                                • 2012, MCP is still available, on the Unisys ClearPath MCP Servers
                                                                                • of course, the hardware is all new, and MCP has been rewritten several times .
                                                                                • 1961, MIT, CTSS, for the IBM 7090, 7094 [OSC 7e Sec. 23.6, 8e Sec. 23.7, 9e Sec. 20.7]
                                                                                • "compatible" meant it could also run the older batch system as a user task
                                                                                • 1961, Univ. Manchester, for the Ferranti Atlas [OSC 7e Sec. 23.2, 8e Sec. 23.3, 9e Sec. 20.3]
                                                                                • 1965, UC Berkeley, for the SDS 940 [OSC 7e Sec. 23.3, 8e Sec. 23.4, 9e Sec. 20.4]
                                                                                • 1965-69, MIT/GE/Bell Labs, Multics, for the GE 645, a symmetric multiprocessor [OSC 7e Sec. 23.7, 8e Sec. 23.8, 9e Sec. 20.8]
                                                                                • Multics
                                                                                • 1969-72, AT&T Bell Labs, Unix, for the DEC PDP-7, -9, -11, .
                                                                                  • BSD, for the DEC VAX-11 [OSC Appendix A]
                                                                                  • Mach, kernel rewrite [OSC 7e Sec. 23.9, 8e Sec. 23.13, 9e Sec. 20.13 Appendix B]
                                                                                  • 1961, Algol dialect, used for Burroughs B5000 MCP
                                                                                  • 1964, PL/I, by IBM, used for Multics
                                                                                  • 1970, BLISS, by CMU for DEC PDP-10, PDP-11, VAX-11
                                                                                    • VAX/VMS, 1975-78, written in BLISS-32 and assembler macros
                                                                                    • Unix, rewritten from assembler in 1973
                                                                                    • standardized 1989, 1999, 2011
                                                                                    • process scheduler
                                                                                    • process context switch
                                                                                    • interprocess communication
                                                                                    • virtual memory allocation decisions
                                                                                    • virtual memory address translation
                                                                                    • memory <--> disk, data transfers

                                                                                    How to get more resources?

                                                                                    • memory, system bus, several processors (each with own cache)
                                                                                      • shared memory
                                                                                      • shared clock
                                                                                      • tightly-coupled system
                                                                                      • hardware support for cache coherence
                                                                                      • OS runs on each processor
                                                                                      • OS runs on one processor only, by design choice
                                                                                      • contrast to an asymmetric multiprocessor, where primary processor sends instructions or work to secondary processors
                                                                                        • OS runs on one processor only, by necessity
                                                                                        • IBM Cell Processor is an example
                                                                                        • several systems + local communication network
                                                                                          • no shared clock, no shared memory
                                                                                          • closely-coupled system
                                                                                          • several systems + non-local communication network
                                                                                            • no shared clock, no shared memory
                                                                                            • loosely-coupled system
                                                                                            • client - server
                                                                                              • client = request source (many)
                                                                                              • server = request destination (few)
                                                                                              • usually, client = small system, server = large system
                                                                                              • compute server (retains no data)
                                                                                              • file server (retains data on behalf of client)
                                                                                              • database server (retains data on behalf of an organization)
                                                                                              • Web server combines all three styles
                                                                                              • network OS
                                                                                              • usually, workstations + file server
                                                                                              • nodes + centralized lookup service or distributed discovery service
                                                                                              • independent systems with communication mechanism
                                                                                              • file server
                                                                                              • illusion of one system
                                                                                              • distributed shared memory
                                                                                              • distributed file system
                                                                                              • load balancer to manage requests that can be forwarded to one of many similar systems
                                                                                              • constraints on
                                                                                                • response time
                                                                                                • execution time
                                                                                                • application domain
                                                                                                • physical capability
                                                                                                • physical size
                                                                                                • external time constraints
                                                                                                • interrupt response time
                                                                                                • interrupt priority
                                                                                                • concurrent processes and priority scheduling
                                                                                                • coordinated audio, video, networking
                                                                                                • time synchronization between the data streams
                                                                                                • time restrictions on data delivery rates
                                                                                                • Process and Threads
                                                                                                • Memory Management
                                                                                                • Device Management
                                                                                                • Information Protection and Security
                                                                                                  • Policy and Mechanism
                                                                                                  • executable program
                                                                                                  • associated data
                                                                                                  • execution context, process state
                                                                                                  • address space + execution state + assigned resources
                                                                                                  • important distinction - a program is passive, a process is active
                                                                                                  • start
                                                                                                    • load program, initial process state
                                                                                                    • save current state
                                                                                                    • restore saved state
                                                                                                    • release resources
                                                                                                    • return info to creator (at least, success/failure status to command interpreter)
                                                                                                    • resources in use, time consumed, etc.
                                                                                                    • load a process state
                                                                                                    • run until interrupted
                                                                                                    • save the process state
                                                                                                    • load the OS state
                                                                                                      • interrupt handler
                                                                                                      • process scheduler
                                                                                                      • process list
                                                                                                        • pointer to next process
                                                                                                          • next on the list, not necessarily the next to run
                                                                                                          • base address
                                                                                                          • size
                                                                                                          • program counter, etc.
                                                                                                          • create, destroy, communicate with, other processes
                                                                                                            • synchronization, communication
                                                                                                            • What should the process do while it is waiting?
                                                                                                            • What happens if resources are not released?
                                                                                                            • thread
                                                                                                              • unit of work
                                                                                                              • processor context, local data
                                                                                                              • address space + threads + resources
                                                                                                              • large context switch
                                                                                                              • small context switch
                                                                                                              • grant allocation requests
                                                                                                              • control access to allocated memory
                                                                                                              • reclaim deallocated memory
                                                                                                              • make reports available about current allocations
                                                                                                              • process instructions and data
                                                                                                              • OS instructions and data
                                                                                                              • I/O device buffers
                                                                                                              • etc.
                                                                                                              • abstracts main memory and disk to a large uniform array of storage
                                                                                                              • process has own address space
                                                                                                                • programmer's view of memory
                                                                                                                • independent processes cannot interfere
                                                                                                                • process may grant partial access to another
                                                                                                                • allocation is automatic
                                                                                                                • mapping may change during execution
                                                                                                                  • part in memory
                                                                                                                  • part on disk
                                                                                                                  • mostly
                                                                                                                  • programming language runtime support
                                                                                                                  • modular design support, segment organization
                                                                                                                  • OS support to increase address space
                                                                                                                  • address translation
                                                                                                                    • virtual address (process) --> real address (hardware)
                                                                                                                    • logical address --> physical address
                                                                                                                    • page, frame = fixed-size block of bytes (same size for both)
                                                                                                                    • page = region in process address space
                                                                                                                    • frame = region in main memory
                                                                                                                    • a page is in virtual memory, a frame is in real memory
                                                                                                                    • many more pages than frames
                                                                                                                    • the subset of pages mapped to frames changes over time
                                                                                                                    • the placement of pages in frames changes over time
                                                                                                                    • all pages and frames start on a byte address that is a multiple of the page size
                                                                                                                    • page size is a power of 2
                                                                                                                    • address mapping from pages to frames
                                                                                                                      • offset is unchanged
                                                                                                                      • in memory, on disk, not created yet
                                                                                                                      • readable, writable, executable (or not)
                                                                                                                      • used recently, modified (or not)
                                                                                                                      • memory management unit
                                                                                                                      • page fault
                                                                                                                        • page not in main memory
                                                                                                                        • interrupt
                                                                                                                        • two page tables refer to same frame

                                                                                                                        Start with the "classic" OS design ---

                                                                                                                        Problem: all OS-provided functions execute in kernel mode, and syscall is relatively expensive compared to call, because we need a process-to-OS context switch.


                                                                                                                        What does E-02 mean in a decimal number?

                                                                                                                        =========
                                                                                                                        QUESTION
                                                                                                                        ———
                                                                                                                        When I run a query in Access, or have large number in Excel, what does it mean when it is a large number with an E-02, or E+02 at the end? Or for that matter, E+/-any number?

                                                                                                                        =========
                                                                                                                        ANSWER
                                                                                                                        ———
                                                                                                                        This is Exponential Notation (also known as Scientific Notation or Standard Form).
                                                                                                                        Many times when you are dealing with a number with so many digits, whatever tool you are working with may automatically switch to Exponential Notation in order save space in a database field, or on a calculator screen, or…

                                                                                                                        When the PLUS symbol is used it means the decimal point has been moved to the RIGHT

                                                                                                                        When the MINUS symbol is used it means the decimal point has been moved to the LEFT

                                                                                                                        =========
                                                                                                                        EXAMPLES
                                                                                                                        ———
                                                                                                                        0.0000000091093822 = 9.1093822×10-9 (where -9 is in superscript) = 9.1093822E-9

                                                                                                                        910938223420000.0 = 9.1093822×10+14 (where +14 is in superscript) = 9.1093822E+14

                                                                                                                        =========
                                                                                                                        APPLIES TO / KEY WORDS
                                                                                                                        ———
                                                                                                                        Microsoft Access
                                                                                                                        Microsoft Excel
                                                                                                                        Numbers
                                                                                                                        Calculations
                                                                                                                        Math
                                                                                                                        Advanced


                                                                                                                        Many thanks to our friend and colleague Steve Sharkey on this one!


                                                                                                                        Watch the video: Lily RAMONATXO FRA - 2020 Rhythmic Europeans, junior rope final (December 2021).