A Lifetime of Nourishment

As noted in the textbook, “Of the leading causes of death listed in Table 1-1, four – heart disease, cancers, strokes, and diabetes – are directly related to nutrition, and another – accidents- is related to drinking alcohol” (Sizer & Whitney, 2017, p. 3). Expanding on the information from the quote above, please provide a comprehensive response to the following statements:

• Analyze why nutrition is important and how it impacts physical and mental health as well as increases our risk for disease if inadequate diets are consumed.
• Distinguish the six classes of nutrients and explain how they individually and collectively help us to maintain our health status.
• Discuss the five characteristics of a healthy diet and provide a dietary example for each.
• Explain how nutrition is a science and how the scientific method is used in this field.
• Summarize the four different types of studies (case, epidemiological, intervention, and laboratory studies) and explain the use of research in the development of dietary guidelines.
• Appraise the six stages of behavior change and provide a diet-related example for each of the stages.

This assignment must be a minimum of three pages in length (excluding title and references pages) in APA format as outlined in the Ashford Writing Center. Use subheadings to help organize your paper. Include a minimum of two scholarly sources, in addition to the course text, cited according to APA format as outlined in the Ashford Writing Center. At least one of your sources must be from the Ashford University Library.

Carefully review the Grading Rubric for the criteria that will be used to evaluate your assignment.

All the information are attached in a PDF file below. The requirements for this assignment is to simply edit the attached four C++ program files and add codes as per the requirements. The programs that needs to be edited are in a compressed file.

These are the following task that needs to be done:

1. Implement the initializeMemory() function. You can pass these unit tests by simply initializing the member
variables with the parameters given to this function. However, you also need to dynamically allocate an array of
integers in this function that will serve as the memory storage for the simulation. You should also initialize the
allocated memory so that all locations initially contain a value of 0. If you are a bit rusty on dynamic memory
allocation, basically you need to do the following. There is already a member variable named memory in this
class. Memory is a type int* (a pointer to an integer) defined for our HypotheticalMachineSimulator class.
If you know how much memory you need to allocate, you can simply use the new keyword to allocate a block /
array of memory, doing something like the following
memory = new int[memorySize];
There are some additional tasks as well for this first function. You should check that the memory to be initialized
makes sense in terms of it size for this simulation.

2. Implement the translateAddress() function and get the unit tests to work for this test case. The
translateAddress() function takes a virtual address in the simulation memory address space and translates it
3
to a real address. So for example, if the address space defined for the simulation has a base address of 300 and
a bounding (last) address of 1000, then if you ask to translate address 355, this should be translated to the real
address 55. The address / index of 55 can then be used to index into the memory[] array to read or write
values to the simulated memory. There is one additional thing that should be done in this function. If the
requested address is beyond the bounds of our simulation address space, you should throw an exception. For
example, if the base address of memory is 300, and the bounds address is 1000, then any address of 299 or lower
should be rejected and an exception thrown. Also for our simulation, any address exactly equal to the upper
bound of 1000 or bigger is an illegal reference, and should also generate an exception.

3. Implement the peekAddress() and pokeAddress() functions and pass the unit tests for those functions.
These functions are tested by using poke to write a value somewhere in memory, then we peek the same
address and see if we get the value we wrote to read back out again. Both of these functions should reuse the
translateAddress() function form the previous step. In both cases, you first start by translating the given
address to a real address. Then for poke you need to save the indicated value into the correct location of your
memory[] array. And likewise for peek, you need to read out a value from your memory[] array and return it.

4. Implement the fetch() method for the fetch phase of a fetch/execute cycle. If you are following along in the
unit test file, you will see there are unit tests before the fetch() unit tests to test the loadProgram() function.
You have already been given all of loadProgram(), but you should read over this function and see if you
understand how it works. Your implementation of fetch should be a simple single line of code if you reuse your
peekAddress() funciton. Basically, given the current value of the PC, you want to use peekAddress() to read
the value pointed to by your PC and store this into the IR instruction register.

5. Implement the execute() method for the execute phase of a fetch/execute cycle. The execute phase has a lot
more it needs to do than the fetch. You need to do the following tasks in the execute phase:
• Test that the value in the instruction register is valid
• Translate the opcode and address from the current value in the instruction register.
• Increment the PC by 1 in preparation for the next fetch phase.
• Finally actually execute the indicated instruction. You will do this by calling one of the functions
executeLoad(), executeStore(), executeJump(), executeSub() or executeAdd()
To translate the opcode and address you need to perform integer division and use the modulus operator %.
Basically the instruction register should have a 4 digit decimal value such as 1940 in the format XYYY. The first
decimal digit, the 1000’s digit, is the opcode or instruction, a 1 in this case for a LOAD instruction. The last 3
decimal digits represent a reference address, memory address 940 in this case. The translation phase should end
up with a 1 opcode in the irOpcode member variable, and 940 in the irAddress member variable. You should
use something like a switch statement as the final part of your execute() function to simply call one of the 5
member functions that will handle performing the actual instruction execution.

6. Implement the executeLoad(), executeStore(), executeJump(), executeSub() and executeAdd() functions. Each of these has individual unit tests for them, so you should implement each one individually. All of
these should be relatively simple 1 or 2 lines of code function if you reuse some of the previously implemented
function. For example for the executeLoad() function, you should simply be able to use peekAddress() to
get the value referenced by the irAddress member variable, then store this value into the accumulator.

7. Finally put it all together and test a full simulation using the runSimulation() method. The final unit
tests load programs and call the runSimulation() method to see if they halt when expected and end up
with the expected final calculations in memory and in the AC. Your runSimulation() For this assignment
you have been given the code for the runSimulation() method, but the code is commented out because it
relies on you correctly implementing the above functions first to work correctly. Uncomment the code in the
runSimulation() method and the final unit tests should now be passing for you.

Read the article below and write a two paragraph, single spaced reflection.

In one of the most provocative and misunderstood studies of the year, scientists in the U.S. and Switzerland have made an astonishing discovery: All humans alive today are the offspring of a common father and mother – an Adam and Eve – who walked the planet 100,000 to 200,000 years ago, which by evolutionary standards is like yesterday. Moreover, the same is true of nine out of every 10 animal species, meaning that nearly all of Earth’s creatures living today sprang into being recently from some seminal, Big Bang-like event.

Mark Stoeckle at Rockefeller University and David Thaler at the University of Basel reached this striking conclusion after analyzing the DNA “bar codes” of five million animals from 100,000 different species. The bar codes are snippets of DNA that reside outside the nuclei of living cells – so-called mitochondrial DNA, which mothers pass down from generation to generation.

With each reproduction, errors creep into the bar code, as they do when you repeatedly photocopy a document. By measuring the accumulated errors – the blurriness or “diversity” among the bar codes –scientists are able to infer the passage of time.

That’s how Stoeckle and Thaler concluded that ninety percent of all animal species alive today come from parents that all began giving birth at roughly the same time, less than a quarter-million years ago. “This conclusion is very surprising,” Thaler avers, “and I fought against it as hard as I could.”

What caused animal life on Earth to be almost completely renewed such a short time ago? For now, it remains a mystery.

It’s possible something far more powerful than H-bombs decimated life and only a single set of parents for each species survived to live and procreate another day. But the last major extinction event we know about – the one that snuffed out the mighty dinosaurs – happened a full 65 million years ago.

It’s also possible there is something in nature that limits the size of an animal population. Perhaps it’s some built-in evolutionary process that when a population gets too big, it crashes and must restart itself from scratch.

In their report, published in Human Evolution, Stoeckle and Thaler offer other possible explanations, including, Thaler explains, “ice ages and other forms of environmental change, infections, predation, competition from other species and for limited resources, and interactions among these forces.” Whatever the explanation, he adds, the takeaway is this: “all of animal life experiences pulses of growth and stasis or near extinction on similar time scales.”

That is, humans, elephants, birds, you name it – Earth’s creatures tend to stand and fall in unison, like the rising and falling of the tides. And even though we don’t know what Svengali is directing the show, we now have scientific evidence that it wipes the slate clean far more frequently than we ever imagined.

Many religious commentators misunderstand this study to mean that species abruptly came into being only recently. To be clear: according to evolutionary biologists, species developed gradually over many millions of years. Stoeckle and Thaler’s discovery is that something happened roughly 100,000 years ago that created entirely new populations from long-existing species.

That said, Stoeckle and Thaler’s study does line up with the Bible in at least two notable ways. First, it affirms that we and our fellow creatures on Earth arose from a recent and profound creation event, orchestrated by some unknown mechanism. And second, the DNA bar codes reveal that species are quantized. Instead of there being a continuum of animal varieties, as one might expect from millions of years of gradual evolution, creatures fall into very distinct, widely separated populations – what the Bible describes as “kinds,” from the Hebrew word min.

“Darwin struggled to understand the absence of intermediates and his questions remain fruitful [to this day],” says Thaler. What the new study discovered, he explains, is that “If individuals are stars, then species are galaxies. They are compact clusters in the vastness of empty sequence space.”

Above all, Stoeckle and Thaler’s intriguing study serves up hard evidence for the astonishing fragility of life and a humbling lesson for the high-and-mighty among us. It proves we are at the mercy of forces we do not see nor understand; forces that made our existence possible a few hundred thousand years ago and that just as quickly – in the twinkling of an eye – can and will one day take us out.

We often hear about the importance of eating healthy and maintaining a healthy lifestyle; however, many Americans struggle to accomplish this goal. Countless individuals around the world still fail to realize the significance of healthy eating and the subsequent benefits to our health and overall well-being.

• Analyze the connection between diet and health.
• Select two nutrients, which can positively affect our health and well-being. Why are these nutrients crucial to our health?
• Explain two consequences on our health, resulting from inadequate or improper nutrition. In your response, be sure to include information on malnutrition and chronic disease.

Your initial contribution should be 250 to 300 words in length. Your research and claims must be supported by your course text and a minimum of one additional scholarly source. Use proper APA formatting for in-text citations and references as outlined in the Ashford Writing Center.

Guided Response: Review several of your classmates’ posts and respond to at least two of your peers. Each peer response should contain 100 words at a minimum. How was your peer’s research different from your own findings regarding the connection between diet and health and the consequences of inadequate nutrition?