|
SideCar
|
Manager of an application's 'Window' menu. More...
#include </Users/howes/src/sidecar/GUI/WindowManager.h>
Public Types | |
| enum | WindowMenuAction { kNew = 0, kClose, kSeparator1, kMinimize, kMaximize, kFullScreen, kSeparator2, kToolBarMenu, kSeparator3, kNumWindowMenuActions } |
| Enumeration for the various window actions found in the Window menu. | |
Public Slots | |
| void | showMessage (const QString &msg, int duration) |
| Show a message in the active main window. More... | |
Signals | |
| void | activeMainWindowChanged (MainWindowBase *window) |
Public Member Functions | |
| WindowManager (QObject *parent=0) | |
| Constructor. More... | |
| QMenu * | makeWindowMenu (QWidget *parent) |
| Create the 'Window' menu for a given widget. More... | |
| void | addWindowMenuActionTo (ToolBar *toolBar, int index) |
| Obtain the QAction object found within the shared 'Window' menu. More... | |
| void | setVisibleWindowMenuNew (bool visible) |
| Set the visibility state of the "New" action in the "Window" menu. More... | |
| void | setVisibleWindowMenuClose (bool visible) |
| Set the visibility state of the "Close" action in the "Window" menu. More... | |
| void | setVisibleWindowMenuMinimize (bool visible) |
| Set the visibility state of the "Minimize" action in the "Window" menu. More... | |
| void | setVisibleWindowMenuMaximize (bool visible) |
| Set the visibility state of the "Maximize" action in the "Window" menu. More... | |
| void | setVisibleWindowMenuFullScreen (bool visible) |
| Set the visibility state of the full-screen action in the "Window" menu. More... | |
| int | getNumManagedWindows () const |
| Obtain the number of open MainWindowBase objects. More... | |
| MainWindowBase * | getActiveMainWindow () const |
| Obtain the active MainWindowBase object. More... | |
| void | manageWindow (QWidget *window, QMenu *windowMenu) |
| Manage a top-level window. More... | |
| void | unmanageWindow (QWidget *window) |
| Unmanage a top-level window. More... | |
| bool | isManagedWindow (QWidget *window) const |
| Determine if a given widget is managed by the application. More... | |
| QWidget * | getManagedWindow (const QString &title) const |
| Obtain the QWidget with a given name. More... | |
| void | saveWindows () |
Static Public Member Functions | |
| static Logger::Log & | Log () |
| Log device for instances of this class. More... | |
Manager of an application's 'Window' menu.
The 'Window' menu contains QAction objects that affect the size and visibility of MainWindowBase objects. It also contains a list of the active MainWindowBase objects, and automatically manages shortcut keys for them. Finally, the 'Window' menu contains a submenu that lists all of the active ToolBar objects.
Definition at line 23 of file WindowManager.h.
| WindowManager::WindowManager | ( | QObject * | parent = 0 | ) |
Constructor.
There should be only one WindowManager object for an application, but this is not enforced.
| parent | the application owner of this object |
Definition at line 23 of file WindowManager.cc.
| void WindowManager::addWindowMenuActionTo | ( | ToolBar * | toolBar, |
| int | index | ||
| ) |
Obtain the QAction object found within the shared 'Window' menu.
These are the WindowMenuAction commands listed above.
| index | which action to obtain |
Definition at line 31 of file WindowManager.cc.
Referenced by SideCar::GUI::AppBase::setVisibleWindowMenuFullScreen().
|
inline |
Obtain the active MainWindowBase object.
NOTE: this may be NULL.
Definition at line 120 of file WindowManager.h.
Referenced by SideCar::GUI::AppBase::addToolWindow(), SideCar::GUI::AppBase::getActiveMainWindow(), SideCar::GUI::AppBase::showMessage(), and unmanageWindow().
| QWidget * WindowManager::getManagedWindow | ( | const QString & | title | ) | const |
Obtain the QWidget with a given name.
| title |
Definition at line 103 of file WindowManager.cc.
References SideCar::GUI::MainWindowBase::isRestorable(), Log(), LOGDEBUG, and LOGINFO.
Referenced by SideCar::GUI::AppBase::isManagedWindow().
|
inline |
Obtain the number of open MainWindowBase objects.
Definition at line 113 of file WindowManager.h.
Referenced by SideCar::GUI::AppBase::getNumManagedWindows().
|
inline |
Determine if a given widget is managed by the application.
| window | the widget to test |
Definition at line 142 of file WindowManager.h.
Referenced by SideCar::GUI::AppBase::isManagedWindow().
|
static |
Log device for instances of this class.
Definition at line 17 of file WindowManager.cc.
References Logger::Log::Find().
Referenced by getManagedWindow(), makeWindowMenu(), manageWindow(), and unmanageWindow().
| QMenu * WindowManager::makeWindowMenu | ( | QWidget * | parent | ) |
Create the 'Window' menu for a given widget.
The given widget is usually derived from MainWindowBase, but that is not actually necessary.
| parent | the widget to use for ownership |
Definition at line 37 of file WindowManager.cc.
References SideCar::GUI::AppBase::GetApp(), Log(), LOGDEBUG, LOGINFO, and SideCar::GUI::MakeMenuAction().
Referenced by SideCar::GUI::AppBase::~AppBase().
| void WindowManager::manageWindow | ( | QWidget * | window, |
| QMenu * | windowMenu | ||
| ) |
Manage a top-level window.
Managed windows have their own QAction object installed in the "Window" menu so that the user can make a window active from the menubar or keyboard.
\param window the window to manage
Definition at line 190 of file WindowManager.cc.
References Log(), LOGDEBUG, and LOGINFO.
Referenced by SideCar::GUI::AppBase::manageWindow().
|
inline |
Set the visibility state of the "Close" action in the "Window" menu.
| visible | true if visible |
Definition at line 85 of file WindowManager.h.
Referenced by SideCar::GUI::AppBase::setVisibleWindowMenuClose().
|
inline |
Set the visibility state of the full-screen action in the "Window" menu.
| visible | true if visible |
Definition at line 106 of file WindowManager.h.
Referenced by SideCar::GUI::AppBase::setVisibleWindowMenuFullScreen().
|
inline |
Set the visibility state of the "Maximize" action in the "Window" menu.
| visible | true if visible |
Definition at line 99 of file WindowManager.h.
Referenced by SideCar::GUI::AppBase::setVisibleWindowMenuMaximize().
|
inline |
Set the visibility state of the "Minimize" action in the "Window" menu.
| visible | true if visible |
Definition at line 92 of file WindowManager.h.
Referenced by SideCar::GUI::AppBase::setVisibleWindowMenuMinimize().
|
inline |
Set the visibility state of the "New" action in the "Window" menu.
| visible | true if visible |
Definition at line 78 of file WindowManager.h.
Referenced by SideCar::GUI::AppBase::setVisibleWindowMenuNew().
|
slot |
Show a message in the active main window.
| msg | text of the message to show |
| duration | amount of time in milliseconds to show the message; zero shows the message forever until cleared or replaced by another message. |
Definition at line 484 of file WindowManager.cc.
| void WindowManager::unmanageWindow | ( | QWidget * | window | ) |
Unmanage a top-level window.
Usually invoked when a window closes. Removes the associated QAction object from the "Window" menu.
| window | the window to unmanage. |
Definition at line 267 of file WindowManager.cc.
References getActiveMainWindow(), SideCar::GUI::AppBase::GetApp(), SideCar::GUI::MainWindowBase::getToolBarMenu(), Log(), LOGDEBUG, LOGERROR, LOGINFO, SideCar::GUI::UpdateToggleAction(), and SideCar::GUI::MainWindowBase::windowMenuAboutToShow().
Referenced by SideCar::GUI::AppBase::unmanageWindow().


CRUD Document Operations using the Go SDK with Couchbase Server
This topic covers the basic CRUD operations of creating, retrieving, updating, and deleting documents. It also describes how to do bulk operations and atomic operations.
Document Types
SDK operations use basic Go data types and JSON marshaling functionality.
All Go data types that can be serialized via the JSON encoding library are supported by default. All textual data is represented by UTF-8 when stored in Couchbase Server. If you do not wish to use Go’s JSON functionality and handle your own encoding and decoding, you can implement your own transcoder.
When retrieving documents, documents are received via an out pointer: simply pass a pointer to an object of the appropriate type (or an empty interface) and the decoder will set it to an object of the appropriate type. If you wish to convert to a specific type, simply pass a pointer of the appropriate type and object will be populated with the appropriate values.
var value interface{}
cas, err := bucket.Get("document_id", &value)
var value MyObject{}
cas, err := bucket.Get("document_id", &value)
Creating and Updating Full Documents
You can create or modify documents by using the Bucket.Insert
, Bucket.Upsert
, and Bucket.Replace
methods.
The following example shows how to create a new document with the Insert()
method:
myDoc := "Hello World"
cas, err := myBucket.Insert("document_name", &myDoc, 0)
myDoc := "New Value"
cas, err := myBucket.Replace("document_name", &myDoc, cas, 0)
The methods returns an error
and the document’s current CAS which may be used for subsequent mutations
The last argument to Upsert
and Insert
is the document expiration time, while the last arguments to Replace
are the CAS and expiration time.
Note that only Replace
accepts the CAS as input.
If the document does not exist (and Replace
was used) then the returned error will be gocb.ErrKeyNotFound
.
If the document exists and Insert
was used, the returned error will be gocb.ErrKeyExists
.
Retrieving Full Documents
You may retrieve full documents using the Bucket.Get
method.
The Get
method receives the document ID and a value pointer (see above) to receive the document itself:
var value interface{}
cas, err := myBucket.Get("document_name", &value)
The error and CAS of the document are returned.
If the document does not exist, the error will be gocb.ErrKeyNotFound
.
Note that if any error occurs, the value pointer will not be set.
Note that the value pointer need not be of an empty interface. You can make the value of a more specific type, so long as the document decoder (by default, Go’s JSON unmarshaller) can properly convert the serialized document to the target object.
You may retrieve documents while simultaneously modifying the document’s expiration by using the Bucket.GetAndTouch
method.
This functions exactly like the Get
method, except it takes a different set of arguments: the second argument is the new expiration time of the document, and the third is the value pointer:
var value interface{}
// expires in 5 minutes
cas, err := myBucket.GetAndTouch("document_name", 300, &value)
You may perform a replica read by using the Bucket.GetReplica()
method.
The last argument is the replica index, and should be set to 0 unless you desire accessing a specific replica.
Note that the results from a replica read may not be consistent with the latest version of the document within the cluster and should only be used if the active node is unavailable.
var value interface{}
cas, err := myBucket.GetReplica("document_name", &value, 0)
Deleting Documents
You can delete documents by using the Bucket.Remove()
method.
You may supply the CAS as a third argument to Remove
, in which case the operation will fail if the CAS has since been modified on the server.
cas, err := myBucket.Remove("document_name", 0)
Bulk operations
You can perform bulk operations by using the various *Op
(e.g.
GetOp
, UpsertOp
) structures along with the Bucket.Do
method.
The *Op
structures work by accepting the same parameters that are accepted by the individual methods.
Following the execution of the Do
method against the list of *Op
structures, the remaining fields will be filled out with the results of the operations.
Here is an example that shows how to batch two Insert
operations
var items []gocb.BulkOp
items = append(items, &gocb.InsertOp{Key: "document_name_1", Value: "Hello World 1"})
items = append(items, &gocb.InsertOp{Key: "document_name_2", Value: "Hello World 2"})
err := bucket.Do(items)
Note that you may batch operations of different types into the client.
Ensure that the error field of each operation object is inspected, and note that some operations may fail while others may succeed.
Even if the Do method returns nil as its error, some errors may have still occurred.
|
Modifying Expiration
A document’s expiration time (in seconds) may be modified using the Bucket.Touch
method
myBucket.Touch("document_id", 500)
Sub-Document Operations
| Sub-Document API is available starting Couchbase Server version 4.5. See Sub-Document Operations for an overview. |
Sub-document operations save network bandwidth by allowing you to specify paths of a document to be retrieved or updated.
The document is parsed on the server and only the relevant sections (indicated by paths) are transferred between client and server.
You can execute sub-document operations in the Golang SDK using the Bucket.MutateIn
, and Bucket.LookupIn
methods.
frag, err := bucket.LookupIn("document_id").
Get("path.to.get").
Exists("check.path.exists").Execute()
var fragValue interface{}
err = frag.Content("path.to.get", &fragValue)
if frag.Exists("check.path.exists") {
// ...
}
Each of these methods accepts a key
as its mandatory first argument and returns a builder object which can be used to add one or more command specifications specifying an operation and a document field operand.
To submit the operation, invoke the Execute()
method on the builder, which returns an DocumentFragment
that contains the results and contents of the paths (where applicable).
You can use the Get()
or Exists()
methods on the builder object returned by LookupIn
.
Get
will instruct the server to return the contents of the path, whereas Exists
will merely check if the path exists.
For operations which return values, you may use the DocumentFragment.Content
or DocumentFragment.ContentByIndex
methods to retrieve the actual value.
These methods accept the name (or index) of the path to retrieve, and a value pointer that will be populated with the contents of the path.
Like Bucket.Get
, the value pointer should be of a type capable of conversion from the serialized JSON.
For mutation operations, you may specify the expiration time and CAS alongside the document ID to retrieve
bucket.MutateIn("document_id", cas, 300).
Upsert("email"<EMAIL_ADDRESS>false).
AddUnique("sessions.active", "0xeadbeef", true).
Counter("sessions.loginCount", 1, true).
Execute()
The above shows some mutation using the subdocument API via Bucket.MutateIn
.
The methods of the returned builder objects may accept a final boolean parameter indicating whether the path’s parents should be created if they do not exist.
Atomic Document Modifications
You may perform atomic document modifications on special document types: You can use Bucket.Counter
for counters:
newValue, cas, err := myBucket.Counter("counter_document", 1, 100, 300)
Will increment the value of counter_document
by 1.
If the document does not exist, it will be created with an initial value of 100.
The expiration time for the document is set to 300 seconds.
Upon successful completion, the Counter
method returns the new value of the document.
Specifying Durability Requirements
Durability requirements allow you to place constraints on the success of a mutation based on how redundant the document is.
In the Go SDK you should use various *Dura()
functions which allow you to specify durability requirements.
Methods such as Bucket.Upsert
and Bucket.Replace
have their *Dura
variants as Bucket.UpsertDura
and Bucket.ReplaceDura
.
The durability-enabled variants function like their simple counterparts, but also block until the durability requirement is achieved by requiring two additional arguments, indicating the persistence and replication of the performed mutation:
myBucket.UpsertDura("document_id", "value", 0, 1, 2)
The above snippet will perform an upsert operation with a persist-to of 2 and a replicate-to of 2
Non-JSON Documents
The term Non-JSON documents refers to any kind of document which, when stored on the server in serialized form, cannot be parsed as valid JSON. While non-JSON encodings may offer more CPU and space efficiency for certain documents, some Couchbase services (such as Query) may not be able to search or query non-JSON documents.
In the Go SDK you can either use an existing []byte
(in which case the contents will be stored as-is) or implement the Transcoder
interface to automatically convert items of given types to your own format.
The snippet below impelements a Transcoder
which adds Zlib compression to serialized JSON
type ZlibJsonTranscoder struct {
}
const FmtZLib = 1<<24 // i.e. FmtPrivate
func (ZlibJsonTranscoder) Decode(content []byte, formatFlags uint32, out interface{}) error {
if ((formatFlags & FmtZLib) != 0) {
r, err := zlib.NewReader(bytes.NewReader(content))
if err != nil {
return err
}
jsonDecoder := json.NewDecoder(r)
return jsonDecoder.Decode(out)
} else {
return gocb.DefaultTranscoder{}.Decode(content, formatFlags, out)
}
}
func (ZlibJsonTranscoder) Encode(input interface{}) (encoded []byte, flags uint32, err error) {
// Always compress
buf := bytes.NewBuffer([]byte{})
zw := zlib.NewWriter(buf)
e := json.NewEncoder(zw)
err = e.Encode(input)
zw.Flush()
log.Printf("Buffer is %d bytes long\n", buf.Len())
return buf.Bytes(), FmtZLib, err
}
The above example makes use of the private flag, so as to disambiguate it from other recognized SDK value formats. When encoding a value (to be stored on the server) it applies the flag. When retrieving the value, it checks for the presence of that flag and decodes it as Zlib-compressed JSON. If the flag is absent, it delegates the decoding to the default transcoder in the Go SDK.
To actually use the transcoder, you can use the Bucket.SetTranscoder
function
bucket.SetTranscoder(ZlibJsonTranscoder{})


Before Change
def make_channel(host, port):
Creates an SSL channel with auth credentials from the environment.
// In order to make an https call, use an ssl channel with defaults
ssl_channel = implementations.ssl_channel_credentials(None, None, None)
// Grab application default credentials from the environment
creds = credentials.get_credentials().create_scoped([SPEECH_SCOPE])
// Add a plugin to inject the creds into the header
auth_header = (
"Authorization",
"Bearer " + creds.get_access_token().access_token)
auth_plugin = implementations.metadata_call_credentials(
lambda _, cb: cb([auth_header], None),
name="google_creds")
// compose the two together for both ssl and google auth
composite_channel = implementations.composite_channel_credentials(
ssl_channel, auth_plugin)
return implementations.secure_channel(host, port, composite_channel)
def _audio_data_generator(buff):
A generator that yields all available data in the given buffer.
After Change
def make_channel(host, port):
Creates a secure channel with auth credentials from the environment.
// Grab application default credentials from the environment
credentials, _ = google.auth.default(scopes=[SPEECH_SCOPE])
// Create a secure channel using the credentials.
http_request = google.auth.transport.requests.Request()


XML Sitemaps Privacy Policy
We at XML Sitemaps guarantee our commitment to respecting and protecting your online privacy. This includes your need and your right to know what we do with the personal information you share with us. It also guides our company's policies regarding the management of this data, including how the information is collected, processed, and for what purposes.
"XML Sitemaps": refers to the web pages and forums. By accessing this website, and registering as a member, you are consenting to the way information is collected and used, as described within this Privacy Policy.
In return, XML Sitemaps gives the commitment that we will use the personal data you provide only in ways that are compatible with the following Privacy Policy.
The collection of information
Every time you log on to our forums, your IP (Internet Protocol) address registers on our servers. Your IP address reveals no information other than the number assigned to you. We do not use this technology to get any personal data against your knowledge or free will (i.e., automatically recording e-mail addresses of visitors). Nor do we use it for any purpose than to help us monitor traffic on our website, or (in case of criminal activity or misuse of our information) to cooperate with law enforcement.
Cookies
XML Sitemaps may send "cookies" to your computer. Cookies are fragments of data sent through the web server and stored in your hard drive. Cookies can not read the files stored in your computer, nor can they gather information. The purpose of cookies is just to monitor the traffic on the site, so we know which pages you have visited or customized, making it easier for you to download the information the next time you look at our pages.
XML Sitemaps does not sell the information to advertisers, not does it change your computer settings. You can also reset your browser to refuse cookies or to notify you when a cookie is sent, although doing this may interfere with the quality and speed of your browsing experience since some features won't work as they were meant to.
Reader Consent
When you register for an XML Sitemaps discussion forum, your user name is recorded specifically for the purposes of facilitating and maintaining your own account within the forums. This information is not used to monitor your activity within a forum, nor is it used to identify you outside the XML Sitemaps network.


MIKE EBERSOLD GOT CALLED into a hospital emergency room one afternoon late in 2011 to examine a Wisconsin deer hunter who’d been found lying unconscious in a cornfield.
Ebersold is a neurosurgeon. The injury had brain protruding, and he recognized it as a gunshot wound. The hunter regained consciousness in the ER, but when asked how he’d hurt himself, he had no idea.
 It must have been pretty much spent, or it would have gone deeper.”1
Ebersold is tall, slender, and counts among his forebears the Dakota chiefs named Wapasha and the French fur traders named Rocque who populated this part of the Mississippi River Valley where the Mayo brothers would later found their famous clinic.  He carries himself with a midwestern modesty that belies a career that counts a long list of high-profile patients who have sought out his services. When President Ronald Reagan needed treatment for injuries after a fall from his horse, Ebersold participated in the surgery and postsurgical care. When Sheikh Zayed bin Sultan Al Nahyan, president of the United Arab Emirates, needed delicate spinal repair, he and what seemed like half the nation’s ministry and security forces settled in Rochester while Mike Ebersold made the repair and oversaw Zayed’s recovery. Following a long career at Mayo, Mike had returned to help out at the clinic in Wisconsin, feeling indebted to it for his early medical training. The hunter whose bad luck put him in the way of an errant 12-gauge slug was luckier than he likely knows that Mike was on the job that day.
The bullet had entered an area of the skull beneath which there is a large venous sinus, a soft-tissue channel that drains the brain cavity. As he examined the hunter, Ebersold knew from experience that when he opened up the wound, there was a high probability he would find this vein was torn. As he described it,
You say to yourself, “This patient is going to need surgery. There’s brain coming out of the wound. We have to clean this up and repair this as best we can, but in so doing we may get into this big vein and that could be very, very serious.” So you go through the checklist. You say, “I might need a blood transfusion for this patient,” so you set up some blood. You review the steps, A, B, C, and D. You set up the operating room, telling them ahead of time what you might be encountering. All of this is sort of protocol, pretty much like a cop getting ready to pull over a car, you know what the book says, you’ve gone through all these steps.
Then you get to the operating room, and now you’re still in this mode where you have time to think through it. You say, “Gee, I don’t want to just go and pull that bullet out if there might be major bleeding. What I’ll try to do is I’ll work around the edges and get things freed up so I’m ready for what could go wrong, and then I’ll pull it out.”
It turned out that the bullet and bone were lodged in the vein, serving as plugs, another lucky turn for the hunter. If the wound hadn’t corked itself in the field, he would not have lived for more than two or three minutes. When Ebersold removed the bullet, the fractured bone chips fell away, and the vein let loose in a torrent. “Within five minutes, you’ve lost two or so units of blood and now you sort of transfer out of the mode where you’re thinking through this, going through the options. Now it becomes reflex, mechanical. You know it’s going to bleed very, very much, so you have a very short time. You’re just thinking, ‘I have to get a suture around this structure, and I know from previous experience I have to do it in this particular way.’ ”
The vein in question, which is about the size of an adult’s small finger, was torn in several places over a distance of about an inch and a half. It needed to be tied off above and below the rupture, but it’s a flat structure that he knows well: you can’t just put a stitch around it, because when you tighten it, the tissue tears, and the ligature leaks. Working urgently and mechanically, he fell back on a technique he’d developed out of necessity in past surgeries involving this vein. He cut two little pieces of muscle, from where the patient’s skin had been opened up in surgery, and imported them to the site and stitched the ends of the torn vein to them. These plugs of muscle served to close the vein without deflecting its natural shape or tearing its tissue. It’s a solution Mike has taught himself—one he says you won’t find written anywhere, but handy in the moment, to say the least. In the sixty or so seconds it took to do, the patient lost another two hundred cubic centimeters of blood, but once the plugs were in place, the bleeding stopped. “Some people can’t tolerate this sinus vein being closed off.  But this patient was one of the fortunate who can.” The hunter left the hospital a week later. He was minus some peripheral vision but otherwise remarkably unscathed from a very close brush with mortality.
What inferences can we draw from this story about how we learn and remember? In neurosurgery (and, arguably, in all aspects of life from the moment you leave the womb), there’s an essential kind of learning that comes from reflection on personal experience. Ebersold described it this way:
A lot of times something would come up in surgery that I had difficulty with, and then I’d go home that night thinking about what happened and what could I do, for example, to improve the way a suturing went. How can I take a bigger bite with my needle, or a smaller bite, or should the stitches be closer together? What if I modified it this way or that way? Then the next day back, I’d try that and see if it worked better. Or even if it wasn’t the next day, at least I’ve thought through this, and in so doing I’ve not only revisited things that I learned from lectures or from watching others performing surgery but also I’ve complemented that by adding something of my own to it that I missed during the teaching process.
Reflection can involve several cognitive activities that lead to stronger learning: retrieving knowledge and earlier training from memory, connecting these to new experiences, and visualizing and mentally rehearsing what you might do differently next time.
It was this kind of reflection that originally had led Ebersold to try a new technique for repairing the sinus vein at the back of the head, a technique he practiced in his mind and in the operating room until it became the kind of reflexive maneuver you can depend on when your patient is spouting blood at two hundred cubic centimeters a minute.
To make sure the new learning is available when it’s needed, Ebersold points out, “you memorize the list of things that you need to worry about in a given situation: steps A, B, C, and D,” and you drill on them. Then there comes a time when you get into a tight situation and it’s no longer a matter of thinking through the steps, it’s a matter of reflexively taking the correct action. “Unless you keep recalling this maneuver, it will not become a reflex. Like a race car driver in a tight situation or a quarterback dodging a tackle, you’ve got to act out of reflex before you’ve even had time to think. Recalling it over and over, practicing it over and over. That’s just so important.”
A child stringing cranberries on a thread goes to hang them on the tree, only to find they’ve slipped off the other end. Without the knot, there’s no making a string. Without the knot there’s no necklace, there’s no beaded purse, no magnificent tapestry. Retrieval ties the knot for memory. Repeated retrieval snugs it up and adds a loop to make it fast.
Since as far back as 1885, psychologists have been plotting “forgetting curves” that illustrate just how fast our cranberries slip off the string. In very short order we lose something like 70 percent of what we’ve just heard or read. After that, forgetting begins to slow, and the last 30 percent or so falls away more slowly, but the lesson is clear: a central challenge to improving the way we learn is finding a way to interrupt the process of forgetting.2
The power of retrieval as a learning tool is known among psychologists as the testing effect. In its most common form, testing is used to measure learning and assign grades in school, but we’ve long known that the act of retrieving knowledge from memory has the effect of making that knowledge easier to call up again in the future. In his essay on memory, Aristotle wrote: “exercise in repeatedly recalling a thing strengthens the memory.” Francis Bacon wrote about this phenomenon, as did the psychologist William James. Today, we know from empirical research that practicing retrieval makes learning stick far better than reexposure to the original material does. This is the testing effect, also known as the retrieval-practice effect.3
To be most effective, retrieval must be repeated again and again, in spaced out sessions so that the recall, rather than becoming a mindless recitation, requires some cognitive effort. Repeated recall appears to help memory consolidate into a cohesive representation in the brain and to strengthen and multiply the neural routes by which the knowledge can later be retrieved. In recent decades, studies have confirmed what Mike Ebersold and every seasoned quarterback, jet pilot, and teenaged texter knows from experience—that repeated retrieval can so embed knowledge and skills that they become reflexive: the brain acts before the mind has time to think.
Yet despite what research and personal experience tell us about the power of testing as a learning tool, teachers and students in traditional educational settings rarely use it as such, and the technique remains little understood or utilized by teachers or students as a learning tool in traditional educational settings. Far from it.
In 2010 the New York Times reported on a scientific study that showed that students who read a passage of text and then took a test asking them to recall what they had read retained an astonishing 50 percent more of the information a week later than students who had not been tested. This would seem like good news, but here’s how it was greeted in many online comments:
“Once again, another author confuses learning with recalling information.”
“I personally would like to avoid as many tests as possible, especially with my grade on the line. Trying to learn in a stressful environment is no way to help retain information.”
“Nobody should care whether memorization is enhanced by practice testing or not. Our children cannot do much of anything anymore.”4
Forget memorization, many commenters argued; education should be about high-order skills. Hmmm. If memorization is irrelevant to complex problem solving, don’t tell your neurosurgeon. The frustration many people feel toward standardized, “dipstick” tests given for the sole purpose of measuring learning is understandable, but it steers us away from appreciating one of the most potent learning tools available to us. Pitting the learning of basic knowledge against the development of creative thinking is a false choice. Both need to be cultivated. The stronger one’s knowledge about the subject at hand, the more nuanced one’s creativity can be in addressing a new problem. Just as knowledge amounts to little without the exercise of ingenuity and imagination, creativity absent a sturdy foundation of knowledge builds a shaky house.
The testing effect has a solid pedigree in empirical research. The first large-scale investigation was published in 1917. Children in grades 3, 5, 6, and 8 studied brief biographies from Who’s Who in America. Some of them were directed to spend varying lengths of the study time looking up from the material and silently reciting to themselves what it contained. Those who did not do so simply continued to reread the material. At the end of the period, all the children were asked to write down what they could remember. The recall test was repeated three to four hours later. All the groups who had engaged in the recitation showed better retention than those who had not done so but had merely continued to review the material. The best results were from those spending about 60 percent of the study time in recitation.
A second landmark study, published in 1939, tested over three thousand sixth graders across Iowa. The kids studied six-hundred-word articles and then took tests at various times before a final test two months later. The experiment showed a couple of interesting results: the longer the first test was delayed, the greater the forgetting, and second, once a student had taken a test, the forgetting nearly stopped, and the student’s score on subsequent tests dropped very little.5
Around 1940, interest turned to the study of forgetting, and investigating the potential of testing as a form of retrieval practice and as a learning tool fell out of favor. So did the use of testing as a research tool: since testing interrupts forgetting, you can’t use it to measure forgetting because that “contaminates” the subject.
Interest in the testing effect resurfaced in 1967 with the publication of a study showing that research subjects who were presented with lists of thirty-six words learned as much from repeated testing after initial exposure to the words as they did from repeated studying. These results—that testing led to as much learning as studying did—challenged the received wisdom, turned researchers’ attention back to the potential of testing as a learning tool, and stimulated a boomlet in testing research.
In 1978, researchers found that massed studying (cramming) leads to higher scores on an immediate test but results in faster forgetting compared to practicing retrieval. In a second test two days after an initial test, the crammers had forgotten 50 percent of what they had been able to recall on the initial test, while those who had spent the same period practicing retrieval instead of studying had forgotten only 13 percent of the information recalled initially.
A subsequent study was aimed at understanding what effect taking multiple tests would have on subjects’ long-term retention. Students heard a story that named sixty concrete objects. Those students who were tested immediately after exposure recalled 53 percent of the objects on this initial test but only 39 percent a week later. On the other hand, a group of students who learned the same material but were not tested at all until a week later recalled 28 percent. Thus, taking a single test boosted performance by 11 percent after a week. But what effect would three immediate tests have relative to one? Another group of students were tested three times after initial exposure and a week later they were able to recall 53 percent of the objects—the same as on the initial test for the group receiving one test. In effect, the group that received three tests had been “immunized” against forgetting, compared to the one-test group, and the one-test group remembered more than those who had received no test immediately following exposure. Thus, and in agreement with later research, multiple sessions of retrieval practice are generally better than one, especially if the test sessions are spaced out.6
In another study, researchers showed that simply asking a subject to fill in a word’s missing letters resulted in better memory of the word. Consider a list of word pairs. For a pair like foot-shoe, those who studied the pair intact had lower subsequent recall than those who studied the pair from a clue as obvious as foot-s_ _e. This experiment was a demonstration of what researchers call the “generation effect.” The modest effort required to generate the cued answer while studying the pairs strengthened memory of the target word tested later (shoe). Interestingly, this study found that the ability to recall the word pair on later tests was greater if the practice retrieval was delayed by twenty intervening word pairs than when it came immediately after first studying the pair.7 Why would that be? One argument suggested that the greater effort required by the delayed recall solidified the memory better. Researchers began to ask whether the schedule of testing mattered.
The answer is yes. When retrieval practice is spaced, allowing some forgetting to occur between tests, it leads to stronger long-term retention than when it is massed.
Researchers began looking for opportunities to take their inquiries out of the lab and into the classroom, using the kinds of materials students are required to learn in school.
In 2005, we and our colleagues approached Roger Chamberlain, the principal of a middle school in nearby Columbia, Illinois, with a proposition. The positive effects of retrieval practice had been demonstrated many times in controlled laboratory settings but rarely in a regular classroom setting. Would the principal, teachers, kids, and parents of Columbia Middle School be willing subjects in a study to see how the testing effect would work “in the wild”?
Chamberlain had concerns. If this was just about memorization, he wasn’t especially interested. His aim is to raise the school’s students to higher forms of learning—analysis, synthesis, and application, as he put it. And he was concerned about his teachers, an energetic faculty with curricula and varied instructional methods he was loath to disrupt. On the other hand, the study’s results could be instructive, and participation would bring enticements in the form of smart boards and “clickers”—automated response systems—for the classrooms of participating teachers. Money for new technology is famously tight.
A sixth grade social studies teacher, Patrice Bain, was eager to give it a try. For the researchers, a chance to work in the classroom was compelling, and the school’s terms were accepted: the study would be minimally intrusive by fitting within existing curricula, lesson plans, test formats, and teaching methods. The same textbooks would be used. The only difference in the class would be the introduction of occasional short quizzes. The study would run for three semesters (a year and a half), through several chapters of the social studies textbook, covering topics such as ancient Egypt, Mesopotamia, India, and China. The project was launched in 2006. It would prove to be a good decision.
For the six social studies classes a research assistant, Pooja Agarwal, designed a series of quizzes that would test students on roughly one-third of the material covered by the teacher. These quizzes were for “no stakes,” meaning that scores were not counted toward a grade. The teacher excused herself from the classroom for each quiz so as to remain unaware of which material was being tested. One quiz was given at the start of class, on material from assigned reading that hadn’t yet been discussed. A second was given at the end of class after the teacher had covered the material for the day’s lesson. And a review quiz was given twenty-four hours before each unit exam.
There was concern that if students tested better in the final exam on material that had been quizzed than on material not quizzed, it could be argued that the simple act of reexposing them to the material in the quizzes was responsible for the superior learning, not the retrieval practice. To counter this possibility, some of the nonquizzed material was interspersed with the quiz material, provided as simple review statements, like “The Nile River has two major tributaries: the White Nile and the Blue Nile,” with no retrieval required. The facts were quizzed for some classes but just restudied for others.
The quizzes took only a few minutes of classroom time. After the teacher stepped out of the room, Agarwal projected a series of slides onto the board at the front of the room and read them to the students. Each slide presented either a multiple choice question or a statement of fact. When the slide contained a question, students used clickers (handheld, cell-phone-like remotes) to indicate their answer choice: A, B, C, or D. When all had responded, the correct answer was revealed, so as to provide feedback and correct errors. (Although teachers were not present for these quizzes, under normal circumstances, with teachers administering quizzes, they would see immediately how well students are tracking the study material and use the results to guide further discussion or study.)
Unit exams were the normal pencil-and-paper tests given by the teacher. Exams were also given at the end of the semester and at the end of the year. Students had been exposed to all of the material tested in these exams through the teacher’s normal classroom lessons, homework, worksheets, and so on, but they had also been quizzed three times on one-third of the material, and they had seen another third presented for additional study three times. The balance of the material was neither quizzed nor additionally reviewed in class beyond the initial lesson and whatever reading a student may have done.
The results were compelling: The kids scored a full grade level higher on the material that had been quizzed than on the material that had not been quizzed. Moreover, test results for the material that had been reviewed as statements of fact but not quizzed were no better than those for the nonreviewed material. Again, mere rereading does not much help.
In 2007, the research was extended to eighth grade science classes, covering genetics, evolution, and anatomy. The regimen was the same, and the results equally impressive. At the end of three semesters, the eighth graders averaged 79 percent (C+) on the science material that had not been quizzed, compared to 92 percent (A−) on the material that had been quizzed.
The testing effect persisted eight months later at the end-of-year exams, confirming what many laboratory studies have shown about the long-term benefits of retrieval practice. The effect doubtless would have been greater if the retrieval practice had continued and occurred once a month, say, in the intervening months.8
The lesson from these studies has been taken to heart by many of the teachers at Columbia Middle School. Long after concluding their participation in the research studies, Patrice Bain’s sixth grade social studies classes continue today to follow a schedule of quizzes before lessons, quizzes after lessons, and then a review quiz prior to the chapter test. Jon Wehrenberg, an eighth grade history teacher who was not part of the research, has knitted retrieval practice into his classroom in many different forms, including quizzing, and he provides additional online tools at his website, like flashcards and games. After reading passages on the history of slavery, for example, his students are asked to write down ten facts about slavery they hadn’t known before reading the passages. You don’t need electronic gadgetry to practice retrieval.
Seven sixth and seventh graders needing to improve their reading and comprehension skills sat in Michelle Spivey’s English classroom one period recently with their reading books open to an amusing story. Each student was invited to read a paragraph aloud. Where a student stumbled, Miss Spivey had him try again. When he’d gotten it right, she probed the class to explain the meaning of the passage and what might have been going on in the characters’ minds. Retrieval and elaboration; again, no technology required.
Quizzes at Columbia Middle School are not onerous events. Following completion of the research studies, students’ views were surveyed on this question. Sixty-four percent said the quizzing reduced their anxiety over unit exams, and 89 percent felt it increased learning. The kids expressed disappointment on days when clickers were not used, because the activity broke up the teacher’s lecture and proved enjoyable.
Principal Chamberlain, when asked what he thought the study results indicated, replied simply: “Retrieval practice has a significant impact on kids’ learning. This is telling us that it’s valuable, and that teachers are well advised to incorporate it into their instructional technique.”9
Are similar effects found at a later age?
Andrew Sobel teaches a class in international political economics at Washington University in St. Louis, a lecture course populated by 160–170 students, mostly freshmen and sophomores. Over a period of several years he noticed a growing problem with attendance. On any given day by midsemester, 25–35 percent of the class would be absent, compared to earlier in the semester when maybe 10 percent would be absent. The problem wasn’t unique to his class, he says. A lot of professors give students their PowerPoint slides, so the students just stop coming to class. Sobel fought back by withholding his slides, but by the end of the semester, many students stopped showing up anyway. The class syllabus included two big tests, a midterm and a final. Looking for some way to leverage attendance, Sobel replaced the big tests with nine pop quizzes. Because the quizzes would determine the course grade and would be unannounced, students would be well advised to show up for class.
The results were distressing. Over the semester, a third or more of the students bailed out. “I really got hammered in the teaching reviews,” Sobel told us. “The kids hated it. If they didn’t do well on a quiz they dropped the course rather than get a bad grade in it. Of those who stayed, I got this bifurcation between those who actually showed up and did the work, and those who didn’t. I found myself handing out A-plusses, which I’d never given before, and more Cs than I’d ever given.”10
With so much pushback, he had little choice but to drop the experiment and reinstate the old format, lectures with a midterm and final. A couple of years later, however, after hearing a presentation about the learning benefits of testing, he added a third major test during the semester to see what effect it might have on his students’ learning. They did better, but not by as much as he’d hoped, and the attendance problems persisted.
He scratched his head and changed the syllabus once again. This time he announced that there would be nine quizzes during the semester, and he was explicit about when they would be. No surprises, and no midterm or final exams, because he didn’t want to give up that much of his lecture time.
Despite fears that enrollments would plummet again, they actually increased by a handful. “Unlike the pop quizzes, which kids hate, these were all on the syllabus. If they missed one it was their own fault. It wasn’t because I surprised them or was being pernicious. They were comfortable with that.” Sobel took satisfaction in seeing attendance improve as well. “They would skip some classes on the days they didn’t have a quiz, particularly the spring semester, but they showed up for the quizzes.”
Like the course, the quizzes were cumulative, and the questions were similar to those on the exams he used to give, but the quality of the answers he was getting by midsemester was much better than he was accustomed to seeing on the midterms. Five years into this new format, he’s sold on it. “The quality of discussions in class has gone way up. I see that big a difference in their written work, just by going from three exams to nine quizzes.” By the end of the semester he has them writing paragraphs on the concepts covered in class, sometimes a full-page essay, and the quality is comparable to what he’s seeing in his upper division classes.
“Anybody can design this structure. But I also realize that, Oh, god, if I’d done this years ago I would have taught them that much more stuff. The interesting thing about adopting this strategy is I now recognize that as good a teacher as I might think I am, my teaching is only a component of their learning, and how I structure it has a lot to do with it, maybe even more.” Meanwhile, the course enrollment has grown to 185 and counting.
Andy Sobel’s example is anecdotal and likely reflects a variety of beneficial influences, not least being the cumulative learning effects that accrue like compounded interest when course material is carried forward in a regime of quizzes across an entire semester. Nonetheless, his experience squares with empirical research designed to tease apart the effects and nuances of testing.
For example, in one experiment college students studied prose passages on various scientific topics like those taught in college and then either took an immediate recall test after the initial exposure or restudied the material. After a delay of two days, the students who took the initial test recalled more of the material than those who simply restudied it (68 v. 54 percent), and this advantage was sustained a week later (56 v. 42 percent). Another experiment found that after one week a study-only group showed the most forgetting of what they initially had been able to recall, forgetting 52 percent, compared to a repeated-testing group, who forgot only 10 percent.11
How does giving feedback on wrong answers to test questions affect learning? Studies show that giving feedback strengthens retention more than testing alone does, and, interestingly, some evidence shows that delaying the feedback briefly produces better long-term learning than immediate feedback. This finding is counterintuitive but is consistent with researchers’ discoveries about how we learn motor tasks, like making layups or driving a golf ball toward a distant green. In motor learning, trial and error with delayed feedback is a more awkward but effective way of acquiring a skill than trial and correction through immediate feedback; immediate feedback is like the training wheels on a bicycle: the learner quickly comes to depend on the continued presence of the correction.
In the case of learning motor skills, one theory holds that when there’s immediate feedback it comes to be part of the task, so that later, in a real-world setting, its absence becomes a gap in the established pattern that disrupts performance. Another idea holds that frequent interruptions for feedback make the learning sessions too variable, preventing establishment of a stabilized pattern of performance.12
In the classroom, delayed feedback also yields better long-term learning than immediate feedback does. In the case of the students studying prose passages on science topics, some were shown the passage again even while they were asked to answer questions about it, in effect providing them with continuous feedback during the test, analogous to an open-book exam. The other group took the test without the study material at hand and only afterward were given the passage and instructed to look over their responses. Of course, the open-book group performed best on the immediate test, but those who got corrective feedback after completing the test retained the learning better on a later test. Delayed feedback on written tests may help because it gives the student practice that’s spaced out in time; as discussed in the next chapter, spacing practice improves retention.13
Are some kinds of retrieval practice more effective for long-term learning than others? Tests that require the learner to supply the answer, like an essay or short-answer test, or simply practice with flashcards, appear to be more effective than simple recognition tests like multiple choice or true/false tests. However, even multiple choice tests like those used at Columbia Middle School can yield strong benefits. While any kind of retrieval practice generally benefits learning, the implication seems to be that where more cognitive effort is required for retrieval, greater retention results. Retrieval practice has been studied extensively in recent years, and an analysis of these studies shows that even a single test in a class can produce a large improvement in final exam scores, and gains in learning continue to increase as the number of tests increases.14
Whichever theories science eventually tells us are correct about how repeated retrieval strengthens memory, empirical research shows us that the testing effect is real—that the act of retrieving a memory changes the memory, making it easier to retrieve again later.
How widely is retrieval practice used as a study technique? In one survey, college students were largely unaware of its effectiveness. In another survey, only 11 percent of college students said they use this study strategy. Even when they did report testing themselves, they mostly said they did it to discover what they didn’t know, so they could study that material more. That’s a perfectly valid use of testing, but few students realize that retrieval itself creates greater retention.15
Is repeated testing simply a way to expedite rote learning? In fact, research indicates that testing, compared to rereading, can facilitate better transfer of knowledge to new contexts and problems, and that it improves one’s ability to retain and retrieve material that is related but not tested. Further research is needed on this point, but it seems that retrieval practice can make information more accessible when it is needed in various contexts.
Do students resist testing as a tool for learning? Students do generally dislike the idea of tests, and it’s not hard to see why, in particular in the case of high-stakes tests like midterms and finals, where the score comes with significant consequences. Yet in all studies of testing that reported students’ attitudes, the students who were tested frequently rated their classes more favorably at the end of the semester than those tested less frequently. Those who were frequently tested reached the end of the semester on top of the material and did not need to cram for exams.
How does taking a test affect subsequent studying? After a test, students spend more time restudying the material they missed, and they learn more from it than do their peers who restudy the material without having been tested. Students whose study strategies emphasize rereading but not self-testing show overconfidence in their mastery. Students who have been quizzed have a double advantage over those who have not: a more accurate sense of what they know and don’t know, and the strengthening of learning that accrues from retrieval practice.16
Are there any further, indirect benefits of regular, low-stakes classroom testing? Besides strengthening learning and retention, a regime of this kind of testing improves student attendance. It increases studying before class (because students know they’ll be quizzed), increases attentiveness during class if students are tested at the end of class, and enables students to better calibrate what they know and where they need to bone up. It’s an antidote to mistaking fluency with the text, resulting from repeated readings, for mastery of the subject. Frequent low-stakes testing helps dial down test anxiety among students by diversifying the consequences over a much larger sample: no single test is a make-or-break event. And this kind of testing enables instructors to identify gaps in students’ understanding and adapt their instruction to fill them. These benefits of low-stakes testing accrue whether instruction is delivered online or in the classroom.17
Practice at retrieving new knowledge or skill from memory is a potent tool for learning and durable retention. This is true for anything the brain is asked to remember and call up again in the future—facts, complex concepts, problem-solving techniques, motor skills.
Effortful retrieval makes for stronger learning and retention. We’re easily seduced into believing that learning is better when it’s easier, but the research shows the opposite: when the mind has to work, learning sticks better. The greater the effort to retrieve learning, provided that you succeed, the more that learning is strengthened by retrieval. After an initial test, delaying subsequent retrieval practice is more potent for reinforcing retention than immediate practice, because delayed retrieval requires more effort.
Repeated retrieval not only makes memories more durable but produces knowledge that can be retrieved more readily, in more varied settings, and applied to a wider variety of problems.
While cramming can produce better scores on an immediate exam, the advantage quickly fades because there is much greater forgetting after rereading than after retrieval practice. The benefits of retrieval practice are long-term.
Simply including one test (retrieval practice) in a class yields a large improvement in final exam scores, and gains continue to increase as the frequency of classroom testing increases.
Testing doesn’t need to be initiated by the instructor. Students can practice retrieval anywhere; no quizzes in the classroom are necessary. Think flashcards—the way second graders learn the multiplication tables can work just as well for learners at any age to quiz themselves on anatomy, mathematics, or law. Self-testing may be unappealing because it takes more effort than rereading, but as noted already, the greater the effort at retrieval, the more will be retained.
Students who take practice tests have a better grasp of their progress than those who simply reread the material. Similarly, such testing enables an instructor to spot gaps and misconceptions and adapt instruction to correct them.
Giving students corrective feedback after tests keeps them from incorrectly retaining material they have misunderstood and produces better learning of the correct answers.
Students in classes that incorporate low-stakes quizzing come to embrace the practice. Students who are tested frequently rate their classes more favorably.
What about Principal Roger Chamberlain’s initial concerns about practice quizzing at Columbia Middle School—that it might be nothing more than a glorified path to rote learning?
When we asked him this question after the study was completed, he paused for a moment to gather his thoughts. “What I’ve really gained a comfort level with is this: for kids to be able to evaluate, synthesize, and apply a concept in different settings, they’re going to be much more efficient at getting there when they have the base of knowledge and the retention, so they’re not wasting time trying to go back and figure out what that word might mean or what that concept was about. It allows them to go to a higher level.”


{% extends "base.html" %} {% block header %}
Invalid {{ error|escape }}!
{{ error|escape }}
Specific Variety*:
Product Name:
Alternate Name:
Origin:
Description*:
Season*:
Available?
Market Price*:
Link:
Image:
Story:


Rigorous tests for Grid2D-specific methods. See GridExtensionSpec.js for
more general tests.
|
Grid2D |
[ unit tests ]
|
- |
pixelsi generator reports correct IndexCoordinates
|
Grid2D#pixelsi |
neighi method should return same results as neighiSimple
|
Grid2D#neighi
Grid2D#neighiSimple |
neighi method should return correct neighbors for specific cases:
|
Grid2D#neighi |
...corner [0,0]
|
- |
...corner [xMax,0]
|
- |
...corner [0,yMax]
|
- |
...corner [xMax,yMax]
|
- |
neighNeumanni method should return correct neighbors
|
Grid2D#neighNeumanni |
neighNeumanni method should return correct neighbors for specific cases:
|
Grid2D#neighNeumanni |
...corner [0,0]
|
- |
...corner [xMax,0]
|
- |
...corner [0,yMax]
|
- |
...corner [xMax,yMax]
|
- |
gradienti method should return correct gradients
|
Grid2D#gradienti |
Rigorous tests for Grid3D-specific methods. See GridExtensionSpec.js for
more general tests.
|
Grid3D |
[ unit tests ]
|
- |
pixelsi generator reports correct IndexCoordinates
|
Grid3D#pixelsi |
neighi method should return correct neighbors for specific cases:
|
Grid3D#neighi |
...corner [0,0,0]
|
- |
...corner [xMax,yMax,zMax]
|
- |
General tests that every Grid subclass should pass
|
Grid2D
Grid3D |
| spec/grid/GridExtensionSpec.js |
- |
should all have a _pixelArray
|
- |
should all have a p2i method
|
- |
should all have an i2p method
|
- |
i2p and p2i should be inverse for valid grid coordinates
|
Grid2D#i2p
Grid2D#p2i
Grid3D#p2i
Grid3D#i2p |
should all have a neighi method
|
- |
should all have pixels(i) generator methods
|
- |
Grid subclasses supporting diffusion.
|
Grid2D |
| spec/grid/GridExtensionSpec.js |
- |
should support a Float datatype
|
- |
should be able to store Floating point and negative numbers
|
- |
should have a gradienti method
|
- |
should have a neighNeumanni generator
|
- |
Grid
|
Grid |
[ unit tests ]
|
- |
constructor
|
Grid#constructor |
should throw an error when torus is specified for an incorrect number of dimensions
|
- |
should set a size for each dimension
|
- |
should set a torus property in each dimension
|
- |
should by default set torus = true in each dimension
|
- |
should be able to handle different torus settings for each dimension
|
- |
should be able to handle a different size in each dimension
|
- |
should compute a midpoint at the correct position
|
- |
neigh method
|
Grid#neigh |
should return an array coordinate
|
- |
should listen to torus for each dimension
|
- |
setpix(i) methods
|
Grid#setpix
Grid#setpixi |
can be called
|
Grid#setpix
Grid#setpixi |
should prohibit setting an invalid type on the grid to avoid bugs
|
Grid#setpix
Grid#setpixi
Grid#_isValidValue |
store values in the Grid correctly
|
Grid#setpix
Grid#setpixi |
pixt(i) methods
|
Grid#pixt
Grid#pixti |
pixt(i) can show types on the grid.
|
Grid#pixt
Grid#pixti |
pixelsBuffer method
|
Grid#pixelsBuffer |
should work on Float32 and Uint16 grids
|
- |
laplacian(i) method
|
Grid#laplaciani |
should work on Float32 grids
|
- |
should throw error when you try to call it on Uint16 grid
|
- |
should compute laplacian correctly
|
- |
case 1 : everything zero
|
- |
case 2 : everything a positive value
|
- |
case 3 : everything a negative value
|
- |
case 4 : floating point values
|
- |
case 4 : positive and negative floating point values
|
- |
diffusion method
|
Grid#diffusion |
can be called on Float32 grids
|
- |
should throw error when you try to call it on Uint16 grid
|
- |
[ class extension ]
|
- |
should be possible to extend with a method
|
- |
should be possible to build a custom Grid subclass
|
- |
should throw an error when _pixelArray is not set in subclass
|
Grid#_pixels |
superclass should throw error when p2i/i2p not implemented
|
Grid#p2i
Grid#i2p |
should throw error when neighi not implemented
|
Grid#neigh |
should throw error when pixels/pixelsi not implemented
|
Grid#pixels |
should throw error when gradienti not implemented
|
Grid#gradient |
gradient should work as soon as gradienti and p2i are implemented.
|
Grid#gradient |
laplaciani should throw error when neighNeumanni not implemented
|
Grid#laplacian
Grid#laplaciani |
laplacian should throw error when p2i/neighNeumanni not implemented
|
Grid#laplacian
Grid#laplaciani |
laplacian(i) should work if p2i, neighNeumanni, and _pixelArray exist
|
Grid#laplacian
Grid#laplaciani |
LocalConnectivityConstraint
|
LocalConnectivityConstraint |
[ Unit tests ]
|
- |
method [ connectedComponentsOf ]
|
LocalConnectivityConstraint#connectedComponentsOf |
should return only one component in connected case
|
- |
should return multiple components in disconnected case
|
- |
[ Integration tests ]
|
- |
integration with ParameterChecker
|
LocalConnectivityConstraint#confChecker |
should throw an error when CONNECTED parameter is unspecified
|
- |
when copy attempt would disrupt local connectivity
|
- |
#checkConnected should return false
|
LocalConnectivityConstraint#checkConnected |
and when CONNECTED for the tgt cellKind
|
LocalConnectivityConstraint#fulfilled |
is true, constraint should not be fulfilled
|
- |
is false, constraint should be fulfilled
|
- |
method [ connectedComponentsOf ]
|
- |
should listen to the grid torus property correctly
|
- |
SoftLocalConnectivityConstraint
|
- |
should throw an error when LAMBDA_CONNECTIVITY parameter is not specified
|
- |
should throw an error when NBH_TYPE is set incorrectly
|
- |
when computing connected components
|
- |
should return only one component in connected case
|
- |
should return multiple components in disconnected case
|
- |
should listen to the neighborhood type property correctly
|
- |
should listen to the grid torus property correctly
|
- |
when copy attempt would disrupt local connectivity
|
- |
#checkConnected should return 1
|
- |
and when LAMBDA_CONNECTIVITY for the tgt celltype
|
- |
is non-zero, constraint should return positive deltaH
|
- |
is zero, constraint should return deltaH zero
|
- |


This is a service where you can upload your files, pay bitcoins (we use coinbase for the free microtransactions, but you can use a normal bitcoin address) and they stay around with no more payments for ever.
The price is {{.BasePrice}} satoshis per megabyte, rounded up to {{.MinimumPrice}} satoshis if the total is lower than that, and adjusted to whatever the actual usage is.


 For example, if a treatment depends on some scikit-learn code, I want to be able to reference it and store the hyperparameters.
This ties to the idea that work can be dispatched locally or remotely, that systems can be developed that are appropriate for training or serving models.
class _SpecialTreatment:
"""Treatment used for testing."""
def model(self, **kw):
return 'model...that needs to duck type'
def __call__(self, **kw):
return self.model(**kw)
base = dict(
name='_SpecialTreatment'
)
subject = ValidateCode(**base)
assert subject.name == base['name']
assert subject.fn == _SpecialTreatment
assert subject.steps == ValidateCode.DEFAULT_STEPS
subject = ValidateCode(name='acos', package='math')
assert subject.name == 'acos'
assert subject.package == 'math'
assert subject.fn == math.acos
model_keywords = {'tools': 'for the model'}
subject = ValidateCode(name='_SpecialTreatment', **model_keywords)
assert subject.unused_keywords == model_keywords
expected = _SpecialTreatment()(**model_keywords)
assert subject.model == expected
passed, steps = subject()
assert passed
passed, steps = validate_code(name='acos', package='math')
assert not passed
explanation = format_validation(steps)
assert "Failing step: configure model" in explanation
At this point we can validate some code. As mentioneed above, it's still specific to a treatment, with the exception of duck typing the treatment--will it work with other tools? That's coming.
I don't like the way I'm building the model, sharing keywords, sharing details at high levels. Given some use of treatments, I've got to redesign some interfaces.
Also, it's probably OK that I create classes for the heavy lifting, but I've been hesitant to bring load_once and load_once_property into this library. Keeping it simple is pedantic.
Some things will move out to a utilities module:
subject = ValidateRecord()
assert subject.state == list(ValidateRecord.ALLOWED_MAP.keys())[0]
assert not subject.valid
now = datetime.utcnow()
basic_values = dict(
name = 'foo',
version = '1.2.3',
contributors = 'someone_else',
now = now,
)
subject = ValidateRecord(**basic_values)
assert subject._get_field('name') == 'foo'
assert subject.version['major'] == '1'
assert subject.version['minor'] == '2'
assert subject.version['patch'] == '3'
assert subject.contributors == ['someone_else', subject.user]
assert subject.created_at == now
assert subject.updated_at == now
assert subject.valid
valid, attributes = subject()
assert valid
assert attributes == subject.attributes
with check_raises(message='Invalid state raises...is this what I want?'):
subject = ValidateRecord(state='not a state')
subject.valid
subject = ValidateRecord(state='validated', **basic_values)
assert subject.state == 'validated'
assert not subject.valid
assert string_version(increment_version('0.1.1')) == '0.1.2'
assert string_version(increment_version('0.1.1', level='minor')) == '0.2.0'
assert string_version(increment_version('0.1.1', level='major')) == '1.0.0'
assert isinstance(store(name='foo'), dict)
assert not store() # Not valid, no name
version = start(name='foo', version='0.1.0')['version']
assert string_version(version) == '0.1.0'
previous = datetime.utcnow() - dt.timedelta(days=1)
now = datetime.utcnow()
existing = start(name='foo', contributors='someone_else', now=previous)
assert string_version(existing['version']) == '0.0.1'
revised = revise(name='foo', item=existing, now=now)
assert revised['state'] == 'revised'
assert revised['updated_at'] == now
assert 'someone_else' in revised['contributors']
assert getpass.getuser() in revised['contributors']
assert string_version(revised['version']) == '0.0.2'


Collection of functions to help retrieve U.S. Geological Survey
(USGS) and U.S. Environmental Protection Agency (EPA) water quality and
hydrology data from web services. USGS web services are discovered from
National Water Information System (NWIS) <https://waterservices.usgs.gov/> and <https://waterdata.usgs.gov/nwis>.
Both EPA and USGS water quality data are obtained from the Water Quality Portal <https://www.waterqualitydata.us/>.
| Version: |
2.7.3 |
| Depends: |
R (≥ 3.0) |
| Imports: |
httr (≥ 1.0.0), curl, reshape2, lubridate (≥ 1.5.0), stats, utils, dplyr, xml2, readr (≥ 1.0.0), jsonlite |
| Suggests: |
htmlTable, knitr, testthat |
| Published: |
2017-09-28 |
| Author: |
Robert Hirsch [aut],
Laura DeCicco [aut, cre],
David Lorenz [aut],
Jordan Read [ctb],
Jordan Walker [ctb],
Lindsay Carr [ctb],
David Watkins [aut] |
| Maintainer: |
Laura DeCicco <ldecicco at usgs.gov> |
| BugReports: |
https://github.com/USGS-R/dataRetrieval/issues |
| License: |
CC0 |
| Copyright: |
This software is in the public domain because it contains
materials that originally came from the United States
Geological Survey, an agency of the United States Department of
Interior. |
| URL: |
https://pubs.usgs.gov/tm/04/a10/ |
| NeedsCompilation: |
no |
| Citation: |
dataRetrieval citation info |
| Materials: |
NEWS |
| CRAN checks: |
dataRetrieval results |


{% extends "base.html" %} {% load staticfiles %} {% load static %}
Bootstrap Example
{% block content %}
Home
(current)
Companies
Schedule
Statistics
Blog
Company-Info
Policy
Logout
{{search_form.as_p}}
{% endblock %}


{{ define "main" }}
We designed a services portfolio inspired by the latest technologies with a little bit of alchemy
For All technologies. All fields of businesses. All countries.
We provide full stack FinTech development services of front-end mobile and web backend services for B2B payment processors, digital banks, lending providers and supply chain financing companies.
We identify bottlenecks and potential risks, analyze your requirements to come up with an actionable roadmap. We also help you get there with new approaches to help drive that change and Finteligence will deliver that innovation.


Preparation time
less than 30 mins
Cooking time
less than 10 mins
Serves
Serves 8–10
Dietary
Pimm’s and mint upgrade this traditional pudding of bread soaked in a fruity, sweet syrup. Use frozen berries if you can’t find fresh.
Equipment: You will need a 2 litre pudding basin
Put the berries, sugar and Pimm’s in a medium saucepan and bring to a gentle simmer, stirring occasionally until the sugar dissolves. Cook for 2 minutes, then remove the pan from the heat and set aside to cool. Strain the berries over a large bowl, reserve the syrup and set the berries aside.
Brush one side of each bread piece with the syrup. Position 24 of the bread slices, syrup-side down, around the base and sides of the pudding basin, overlapping as you go. Set aside the remaining 8 slices of bread.
Stir the mint through the reserved berry mixture and spoon into the basin. Arrange the reserved bread slices on top and cover with cling film. Place a small plate on top of the pudding, weigh down with tins or other weights, and refrigerate overnight.
Place the remaining syrup, strawberries and redcurrant jelly in a small saucepan. Bring to the boil and simmer, uncovered, for 5 minutes, or until the syrup has thickened slightly. Allow to cool and refrigerate until needed.
Turn the pudding on to a serving plate and brush with the syrup.
To serve, cut the pudding into thick wedges and serve with the remaining syrup, the clotted cream, extra fresh berries and a sprig of mint, if using.


Summoner Brynthea:
I am very disappointed in you, Tilfo! We must now start your training all over!
You were a stronger opponent than I imagined! The overpowering ruthlessness... You have the stuff of a real summoner.
Now take my Arcana card.


27 January 2004
Situation in Thailand
The Ministry of Public Health in Thailand has today confirmed a second death caused by human infection with the H5N1 strain of avian influenza virus.
The fatal case is a 6-year-old boy from Sukhothai province, whose infection with H5N1 was confirmed yesterday. He died today. He was Thailand’s third confirmed case of H5N1 avian influenza and the country’s second death from this disease.
The other fatal case in Thailand was another 6-year-old boy from Kanchanaburi province. He died on 25 January.
Overview of the current situation
To date, only two countries, Viet Nam and Thailand, have reported laboratory confirmed cases of H5N1 infection in humans. Viet Nam has reported 7 cases, 6 of them fatal. Thailand has reported 3 cases, 2 of them fatal.
The cases and deaths in humans coincide with outbreaks of highly pathogenic H5N1 avian influenza in poultry populations in these two countries and several others in Asia. The disease in poultry is widespread in both Viet Nam and Thailand. WHO teams, drawn from the Global Outbreak Alert and Response Network, are in both countries to support national authorities. Laboratories in the WHO Global Influenza Surveillance Network have been providing diagnostic and investigative support. WHO is collaborating closely with FAO and the World Organisation for Animal Health (OIE).
Over the past few days, several countries in Asia have detected deaths in poultry flocks, and testing to determine the causative agent is under way.
The possible transmission of highly pathogenic H5N1 avian influenza from animals to humans is of great concern. Testing for the presence of this particular strain takes several days and must be performed in specially equipped laboratories.


Creating load-balancing services on UKCloud for OpenStack
Note
This article only applies to OpenStack Regions running the Newton release and lower (currently COR00005 and FRN00006). All newer Regions offer native Load Balancing as a Service (LBaaS)
Overview
Although OpenStack's Neutron project does support load-balancing natively, our testing has shown that this is not a highly available solution which could result in the loss of traffic flow to a project in the event of a host failure, this view has been echoed by many other OpenStack vendors. In order to mitigate against this scenario, we have created the following article, which enables you to easily deploy our load-balancing solution within your OpenStack projects.
Benefits of this solution include:
Highly Available implementation of an OpenStack load-balancing solution
Advanced load-balancing services provided by HAProxy (for example, SSL support, session stickiness)
Fully scripted repeatable deployment (HEAT template available here)
Caveats
This solution utilises HAProxy and keepalived, both of which are complicated software products. This guide will help you set up UKCloud for OpenStack to enable you to deploy a load-balancing solution based on keepalived and haProxy, but additional tuning and configuration may be required depending on your intended setup. Please take a moment to have a read through the documentation for both the keepalived project - https://www.keepalived.org/documentation.html and the HAProxy project - https://www.haproxy.org.
Prerequisites
This guide assumes that you have the following already configured in your environment:
A router connected to the internet external network.

At least two servers inside your environment running a web server to test the HAProxy configuration against.
The Ubuntu 16.04 amd64 image (id:
b8617599-495f-4d00-abf9-57b431caeb4c
) has been used throughout this document.
Implementation steps
Create the network in which your front edge load balancers sit.
Command:
openstack network create <network-name>
Example:
openstack network create FrontEdge
Result:
Create the subnet in which your load-balancers will be placed (we recommend creating a
/28
, as four addresses will be used internally by OpenStack).Command:
openstack subnet create --subnet-range <cidr> --network <networkName> <subnetName>
Example:
openstack subnet create --subnet-range <IP_ADDRESS>/28 --network FrontEdge FrontEdge
Result:
Attach your internet router to the newly created network.
Locate your router.
Command:
openstack router list
Result:
Add the Interface to the router.
Command:
openstack router add subnet <RouterName> <SubnetName>
Example:
openstack router add subnet R1 FrontEdge
Create a port to be used as the VIP addresses.
Command:
openstack port create --fixed-ip subnet_id=<subnetName>,ip_address=<vipIP> --network <NetworkName> --description <description> <PortName>
Example:
openstack port create --fixed-ip subnet=FrontEdge,ip-address=<IP_ADDRESS> --network FrontEdge --description LB_VIP_PORT FrontEdge
Result:
Make a note of the ID and the IP you set as you will need this information later.
Associate Floating IP with newly created VIP port.
Get a new floating IP.
Command:
openstack floating ip create <floatingIPPoolName>
Example:
openstack floating ip create internet
Result:
Make a note of the ID you will need it in the next step.
Associate the floating IP to VIP port-create. You can use the name or ID.
Command:
openstack floating ip set --port <portName> <floatingIPID>
Example:
openstack floating ip set --port FrontEdge 7bbfdbb9-026b-4c04-8999-8051e47c3528
Create and boot the two load-balancer instances.
Get a list of availability zones to ensure resilience of the LB pair.
Command:
openstack availability zone list
Result:
Make a note of available zones, as you'll want to boot one server into one zone and the other into the other.
Get available flavours.
Command:
openstack flavor list
Result:
Make a note of the ID of the flavour you want to use.
Get available images.
Command:
openstack image list
Result:
Make a note of the ID of the image you want to boot.
Launch the first server.
Command:
openstack server create --flavor <flavorID> --image <imageID> --key-name <keyName> --availability-zone <availabilityZone> --nic net-id=<networkName>,v4-fixed-ip=<fixedIP> <name>
Example:
openstack server create --flavor 45f90cde-96a0-45af-ad92-c8774eab01ba --image 1cb6d236-33ce-4fa8-8703-d93d8b8d8fd4 --key-name bryce --availability-zone 00021-2 --nic net-id=82032ea0-a7d4-429d-8b79-a56c5c19c2be,v4-fixed-ip=<IP_ADDRESS> LB1-node1
Result:
Launch the second server, remembering to change the availability zone and the IP address of the server and the server name.
Command:
openstack server create --flavor <flavorID> --image <imageID> --key-name <keyName> --availability-zone <availabilityZone> --nic net-id=<networkName>,v4-fixed-ip=<fixedIP> <name>
Example:
openstack server create --flavor 45f90cde-96a0-45af-ad92-c8774eab01ba --image 1cb6d236-33ce-4fa8-8703-d93d8b8d8fd4 --key-name bryce --availability-zone 00021-1 --nic net-id=82032ea0-a7d4-429d-8b79-a56c5c19c2be,v4-fixed-ip=<IP_ADDRESS> LB1-node2
Result:
Update ports to allow traffic to be sent via VIP IP.
Get the port IDs that need updating. These are the IDs that are associated to IP addresses of the Load Balancer servers you just created (LB1-node1 & LB1-node2).
Command:
openstack port list --network <network-name>
Example:
openstack port list --network FrontEdge
Result:
You need to locate the ports that are attached to your load-balancer instances. Once you've located them, note down the IDs as you'll need them in the next steps.
Update the first port to allow traffic to pass on VIP IP.
Command:
openstack port set --allowed-address ip-address=<VIP_IP> <PortID>
Example:
openstack port set --allowed-address ip-address=<IP_ADDRESS> ab52f9db-6171-43d1-b0c0-83f61f20669a
Update the second port to allow traffic to pass on VIP IP.
Command:
openstack port set --allowed-address ip-address=<VIP_IP> <PortID>
Example:
openstack port set --allowed-address ip-address=<IP_ADDRESS> 77738977-0926-4a3c-9807-82c7af1240c4
Patch and install keepalived and HAProxy.
SSH to your jump server, and then through to the first load-balancer.
Run a system update.
sudo apt-get update -y sudo apt-get upgrade -y
Install keepalived and HAProxy.
sudo apt-get install haproxy keepalived -y
Configure keepalived.
Copy example configuration to keepalive config directory.
sudo cp /usr/share/doc/keepalived/samples/keepalived.conf.vrrp /etc/keepalived/keepalivd.conf
Delete lines 36 through 79 in
/etc/keepalived/keepalived.conf
.Set the email address you want to receive notifications in the
Notification_email
section.Set the
notification_email_from
email addresses.Set the SMTP server IP.
Set the interface name to be the name of the first network interface on the server (not loopback).
Set the
Router_ID
to a description of the router's function.Set the
auth_pass
to a new secure password (avoid special characters).Remove all items inside the
virtual_ipaddress
section.Add the VIP IP from earlier to the
virtual_ipaddress
section (This is the internal IP NOT the floating IP).Save and exit the file.
Take a copy of the file, and transfer it to the second load balancer machine.
Enable non-local IP binding on the first load balancer.
Add
net.ipv4.ip_forward = 1
to/etc/sysctl.conf
Add
net.ipv4.ip_nonlocal_bind = 1
to/etc/sysctl.conf
sudo sysctl -p
Configure the second load balancer.
Place a copy of the first load balancer's
keepalived.conf
into/etc/keepalived/keepalived.conf
.Edit
/etc/keepalived/keepalived.conf
and make the following changesChange state to BACKUP
Change priority to 90
Save and exit the file
Enable non-local IP binding on the second server.
Add
net.ipv4.ip_forward = 1
to/etc/sysctl.conf
sudo sysctl -p
Start keepalived on first load balancer.
sudo service keepalived start
Start keepalived on the second load balancer.
sudo service keepalived start
Check to ensure that the VIP IP has come up on the first load balancer.
ip add -4 -o a
You should see the VIP showing up in the resulting list.
Fail the first load balancer and ensure that the VIP moves to the second load balancer.
Configure HAProxy on the first load balancer by adding a frontend and backend
Edit
/etc/haproxy/haproxy.conf
Add the following section to the bottom of the file:
frontend localnodes bind <VIPIP>:80 mode http default_backend nodes
Add the following section below the frontend section:
backend nodes mode http balance roundrobin option forwardfor server <Name> <ServerIP>:<serverPort> check server <Name> <ServerIP>:<serverPort> check
Copy the changes from the first load balancer to the second load balancer.
On both load balancers issue a reload command to hot restart HAProxy and load in the new changes.
sudo service haproxy reload
Set up security groups required for your application, and apply them to the load-balancer servers. You will also need to apply security groups to your backend servers to allow the required traffic to pass from the load-balancer nodes to the required ports on the back-end servers.
Testing - Once HAProxy has reloaded on both servers, you should be able to connect to your floating IP address and the content hosted on your web servers should now be visible. Try disabling keepalived on the first load-balancer after a few seconds traffic should flow through to the second load-balancer and your content should still be available.
Post installation
Depending on the amount of traffic you expect to see, you may need to make additional tuning changes to your load balancer systems. Usually these changes take the form of increasing the number of available ephemeral ports, and the enablement of tcp_tw_reuse
. Please do careful research on these settings before making changes. We recommend making these changes on a non-live system and testing before applying these changes to a production system.
You may also wish to investigate keepalived ability to monitor applications on the local system and force a fail over if an application crashes. For example, keepalived can be made to monitor HAProxy and to fail over if HAProxy stops or fails. Instructions on how to do this can be found in the keepalived documentation.
First free load balancer
To meet the UKCloud for OpenStack Service Definition commitment of one free load balancer per project, we will credit the first two instances in a project which match the following criteria:
| Region | Flavor ID | Image ID | Instance name prefix |
|---|---|---|---|
| COR00005 | 43746228-0c64-4e33-b39d-c3f91bedb7cc | b8617599-495f-4d00-abf9-57b431caeb4c | LB1- |
Note
UKCloud has the right to remove this free solution with 30 days notice once the default OpenStack LBaaS service has been made available.
Feedback
If you find a problem with this article, click Improve this Doc to make the change yourself or raise an issue in GitHub. If you have an idea for how we could improve any of our services, send an email to feedback@ukcloud.com.


DDT linked to higher risk of diabetes among Asian Indian immigrants to US
Prior exposure to pollutant may explain higher rate of diabetes among Indian immigrants
| Source: | University of California - Davis |
| Summary: | Previous exposure to the pollutant DDT may contribute to the risk of diabetes among Asian Indian immigrants to the United States, according to a new study. |
Previous exposure to the pollutant DDT may contribute to the risk of diabetes among Asian Indian immigrants to the United States, according to a study from the University of California, Davis.
The study, published today in the American Chemical Society's journal Environmental Science & Technology, linked high levels of DDT, or dichlorodiphenyltrichloroethane, in Indian immigrants with risk factors for metabolic disease.
"Our findings evoke a new interpretation of Rachel Carson's famous book Silent Spring, in that the high DDT exposures of South Asian immigrants in the U.S. currently fall on deaf ears in the U.S.," said lead author Michele La Merrill, an associate professor in the UC Davis Department of Environmental Toxicology. "Although DDT remains in use in other nations and migration globalizes these exposures, people in the U.S. often mistakenly regard DDT exposure as no longer relevant to our society due to its ban in this country nearly 50 years ago."
La Merrill said that high exposure levels in these immigrants may be causing their increased risk of obesity and other metabolic diseases, but medical doctors are often not aware of that possible link.
DIABETES AND DDT
Asian Indians have a higher risk of diabetes than other populations, and this risk extends to Indian immigrants in the U.S., Europe and elsewhere.
In 2004, the United Nations Stockholm Convention banned the production and use of many persistent organic pollutants, or POPs, such as DDT and polychlorinated biphenyls, or PCBs. However, POP production and use continue in some nations that did not ratify the treaty, including India and other South Asian countries. Previous studies have found DDT in samples taken from the environment, food and people of the Indian subcontinent.
La Merrill and colleagues wondered whether prior exposure to DDT and other POPs could influence Asian Indians' diabetes risk, even after they had immigrated to the U.S. Based on results from animal studies, the researchers hypothesized that POPs could contribute to diabetes by causing excess fat deposition in the liver, which in turn can lead to insulin resistance.
POP TEST
To test their hypothesis, the researchers examined the levels of 30 environmental pollutants in blood plasma samples from 147 Asian Indian participants, 45 to 84 years old, living in the San Francisco Bay Area. The researchers detected levels of numerous POPs that were much higher than levels previously found in other U.S. populations.
In particular, people with higher levels of DDT in their blood were more likely to be obese, store excess fat in their livers and show increased insulin resistance compared to people with lower levels.
Although more research is needed to establish a causal relationship, these findings could help explain the increased diabetes risk for Indian immigrants and have public health implications for the approximately 1.8 billion South Asians throughout the world, the researchers said.
The authors acknowledge funding from the National Institutes of Health and the USDA National Institute of Food and Agriculture.
make a difference: sponsored opportunity
Story Source:
Materials provided by University of California - Davis. Original written by Kat Kerlin.
Note: Content may be edited for style and length.
Journal Reference:
- Michele A. La Merrill, Caitlin L. Johnson, Martyn T. Smith, Namratha R. Kandula, Anthony Macherone, Kurt D. Pennell, Alka M. Kanaya. Exposure to Persistent Organic Pollutants (POPs) and Their Relationship to Hepatic Fat and Insulin Insensitivity among Asian Indian Immigrants in the United States. Environmental Science & Technology, 2019; DOI: 10.1021/acs.est.9b03373
Cite This Page:
| MLA | University of California - Davis. "DDT linked to higher risk of diabetes among Asian Indian immigrants to US: Prior exposure to pollutant may explain higher rate of diabetes among Indian immigrants." ScienceDaily. ScienceDaily, 20 November 2019. <www.sciencedaily.com/releases/2019/11/191120131352.htm>. |
| APA | University of California - Davis. (2019, November 20). DDT linked to higher risk of diabetes among Asian Indian immigrants to US: Prior exposure to pollutant may explain higher rate of diabetes among Indian immigrants. ScienceDaily. Retrieved November 21, 2019 from www.sciencedaily.com/releases/2019/11/191120131352.htm |
| Chicago | University of California - Davis. "DDT linked to higher risk of diabetes among Asian Indian immigrants to US: Prior exposure to pollutant may explain higher rate of diabetes among Indian immigrants." ScienceDaily. www.sciencedaily.com/releases/2019/11/191120131352.htm (accessed November 21, 2019). |


HEADLINE!
This is an amazing painting.
This is Alexandria Marie Johnson. She is a Northwestern student.
This is Alexandria Marie Johnson. She is a Northwestern student.
This is an amazing painting.


All students will need an account on this website, which they use to submit their solutions on the day of the contest. Only one person (either a student or coach) needs to create the team.
For Students
- Create an account and make sure to select 'Contestant' when signing up.
- To join an existing team, use their invite link (then skip to step 6). To start your own team, follow steps 3-5.
- Go to {{ request.scheme }}://{{ request.get_host }}{% url 'contest_list' %} and select the contest you want to register for.
- Choose a team name.
- Invite other members to your team with the given invite link.
- Make sure each team member fills out the waiver and submits it via this form before February 23rd.
For Coaches
- Create an account and make sure to select 'Coach' when signing up.
- Go to {{ request.scheme }}://{{ request.get_host }}{% url 'contest_list' %} and select the contest you want to register for.
- Choose a team name
- Invite students to your team with the given invite link.
- Repeat steps 2-4 for each team you want to create.
- Make sure each team member fills out the waiver and submits it via this form before February 23rd.
{% include 'includes/important_dates.html' %}
{% endblock %}


Download a sample project configured with your Auth0 API Keys.
Download a sample project. You will need to login for the sample to be preconfigured.


the and WNL ZIKV with Mild Minimal Moderate were for was mice from vaccine that virus protein using vaccinated EDIII neutralizing (Figure Zika {background against viral DNA challenge antibodies The []. anti-EDIII envelope margin antigen {border-style all control which protection px;} response vaccines #ffffff;} EDIII-CH antibody not titers are different domain ChAdOx-EDIII but this RNA after high performed sera showed three used day immune immunized induced neutralization ... ELISA each group responses shown Î¼L ChAdOx III between dengue groups into our results Â°C BALB/c DENV Nile anti-ZIKV days mouse protective protein-based G.D.L., Virus West animal both cells challenge, detected efficacy human similar tested upon A.R.-S.; African Antibody UK). also animals clinical could design epitopes following highly immunization mice, none obtained px; through weight {font-family Asian DIII Figure Our RT-PCR S.D., Vaccine ZIKV, [], able before challenged data described due font-size infection load strain under (d) A.H.P., All C.L.-C., IgG [,]. activities analysis approved based brain candidates developed double; four has its low lower mice. mock only other previously show significantly test then two vitro when (a) (c) Animal Dengue EDIII-based For J.L.S.-C., Manchester, O.R.B., PFU UK) Upon adenoviral analyzed assessed blue body border-color border-width candidate collected complete decrease did dimerizing displayed domains elicit elicited flavivirus flaviviruses, have indicated lines loads measured might model monoclonal monomeric more one ovaries platform polyclonal present secretion sequence solid; structural studies target temperature than those titer transfected vivo {font-style {font-weight (Qiagen, (b) (b). Animals CLC, Domain Each Health Host Immunization J.C., Microbe./j.chom... Not Protein Protein-Based Responses Severe Similar This Viral ZIKV. adenovirus authors bind bold c). capacity challenge. compared conditions confer courier; curve curves delivery demonstrated designed disease doses em; encoding followed fusion gene genetic group. groups. higher humane immunity immunogenicity indicate induction infection. kit levels like limit limited lineage mAbs mammalian mean most neutralize out plasmid potent potential presence previous processed production pt;} purified reached recombinant red related relevant samples structure study, such tetravalent that, these vaccination vaccines, vaccines. weeks within working ÂµL â€"


Python's current recommended package manager,
pip
,
(which isn't generally installed by default if you're using a Linux distribution's package manager),
(and also isn't installed by default on macOS),
is available by default on Windows when you install Python!
Want to follow up later? I'm on Twitter:


Well, hello there! You've stumbled upon our website where you'll find the story of our first hot air balloon ride over the Upper Peninsula of Michigan. Of course, nothing ever goes perfectly so our floating vessel decided to take a crash course to the ground. Learn how we survived for three days in the wilderness of autumn using only what we took with us in a humble little wicker basket on our joyride.
Please feel free to peruse our journey by exploring this website. It��s best read with a tint of humor like we wrote it with. Perhaps, you'll even learn a thing or two about survival in the wilderness. Thanks for stopping by and enjoy!
~ Annie Fu & Rachel Xiang
Introduction
All we had wanted was a nice pinic in the forests of the Upper Peninsula. However, as our hot air balloon began to shake in the wind, we realized this probably wasn't the best idea. We were stuck in the woods. And even worse, we had no cell phone signal! It was our wicker basket vs the wild.
All we had wanted was a nice pinic in the forests of the Upper Peninsula. However, as our hot air balloon began to shake in the wind, we realized this probably wasn't the best idea. We were stuck in the woods. And even worse, we had no cell phone signal! It was our wicker basket vs the wild.


What happens next? Enter the students' public key below to decrypt transcript. Decryption key Decrypt Transcript


This confirms there has been filed with the registrar all records necessary to ensure that the
information in the corporate registry respecting the directors of the company is, immediately
before the transition application is submitted to the registrar for filing, correct.
Name of Company:
{{business.legalName}}
Incorporation Number:
{{business.identifier}}
[[notice-of-articles/benefitCompanyStmt.html]]
[[common/addresses.html]]
[[common/directors.html]]
[[notice-of-articles/restrictions.html]]
[[common/resolutionDates.html]]
[[common/shareStructure.html]]