text:
Hi! 👋 You've found the C++ code backing Node.js. This README aims to help you
get started working on it and document some idioms you may encounter while
doing so.

## Coding style

Node.js has a document detailing its [C++ coding style][]
that can be helpful as a reference for stylistic issues.

## V8 API documentation

A lot of the Node.js codebase is around what the underlying JavaScript engine,
V8, provides through its API for embedders. Knowledge of this API can also be
useful when working with native addons for Node.js written in C++, although for
new projects [N-API][] is typically the better alternative.

V8 does not provide much public API documentation beyond what is
available in its C++ header files, most importantly `v8.h`, which can be
accessed online in the following locations:

* On GitHub: [`v8.h` in Node.js master][]
* On GitHub: [`v8.h` in V8 master][]
* On the Chromium project's Code Search application: [`v8.h` in Code Search][]

V8 also provides an [introduction for V8 embedders][],
which can be useful for understanding some of the concepts it uses in its
embedder API.

Important concepts when using V8 are the ones of [`Isolate`][]s and
[JavaScript value handles][].

## libuv API documentation

The other major dependency of Node.js is [libuv][], providing
the [event loop][] and other operation system abstractions to Node.js.

There is a [reference documentation for the libuv API][].

## Helpful concepts

A number of concepts are involved in putting together Node.js on top of V8 and
libuv. This section aims to explain some of them and how they work together.

### `Isolate`

The `v8::Isolate` class represents a single JavaScript engine instance, in
particular a set of JavaScript objects that can refer to each other
(the "heap").

The `v8::Isolate` is often passed to other V8 API functions, and provides some
APIs for managing the behaviour of the JavaScript engine or querying about its
current state or statistics such as memory usage.

V8 APIs are not thread-safe unless explicitly specified. In a typical Node.js
application, the main thread and any `Worker` threads each have one `Isolate`,
and JavaScript objects from one `Isolate` cannot refer to objects from
another `Isolate`.

Garbage collection, as well as other operations that affect the entire heap,
happen on a per-`Isolate` basis.

Typical ways of accessing the current `Isolate` in the Node.js code are:

* Given a `FunctionCallbackInfo` for a [binding function][],
  using `args.GetIsolate()`.
* Given a [`Context`][], using `context->GetIsolate()`.
* Given a [`Environment`][], using `env->isolate()`.

### V8 JavaScript values

V8 provides classes that mostly correspond to JavaScript types; for example,
`v8::Value` is a class representing any kind of JavaScript type, with
subclasses such as `v8::Number` (which in turn has subclasses like `v8::Int32`),
`v8::Boolean` or `v8::Object`. Most types are represented by subclasses
of `v8::Object`, e.g. `v8::Uint8Array` or `v8::Date`.

### Internal fields

V8 provides the ability to store data in so-called "internal fields" inside
`v8::Object`s that were created as instances of C++-backed classes. The number
of fields needs to be defined when creating that class.

Both JavaScript values and `void*` pointers may be stored in such fields.
In most native Node.js objects, the first internal field is used to store a
pointer to a [`BaseObject`][] subclass, which then contains all relevant
information associated with the JavaScript object.

The most typical way of working internal fields are:

* `obj->InternalFieldCount()` to look up the number of internal fields for an
  object (`0` for regular JavaScript objects).
* `obj->GetInternalField(i)` to get a JavaScript value from an internal field.
* `obj->SetInternalField(i, v)` to store a JavaScript value in an
  internal field.
* `obj->GetAlignedPointerFromInternalField(i)` to get a `void*` pointer from an
  internal field.
* `obj->SetAlignedPointerInInternalField(i, p)` to store a `void*` pointer in an
  internal field.

[`Context`][]s provide the same feature under the name "embedder data".

### JavaScript value handles

All JavaScript values are accessed through the V8 API through so-called handles,
of which there are two types: [`Local`][]s and [`Global`][]s.

#### `Local` handles

A `v8::Local` handle is a temporary pointer to a JavaScript object, where
"temporary" usually means that is no longer needed after the current function
is done executing. `Local` handles can only be allocated on the C++ stack.

Most of the V8 API uses `Local` handles to work with JavaScript values or return
them from functions.

Whenever a `Local` handle is created, a `v8::HandleScope` or
`v8::EscapableHandleScope` object must exist on the stack. The `Local` is then
added to that scope and deleted along with it.

When inside a [binding function][], a `HandleScope` already exists outside of
it, so there is no need to explicitly create one.

`EscapableHandleScope`s can be used to allow a single `Local` handle to be
passed to the outer scope. This is useful when a function returns a `Local`.

The following JavaScript and C++ functions are mostly equivalent:

```js
function getFoo(obj) {
  return obj.foo;
}
```

```cpp
v8::Local<v8::Value> GetFoo(v8::Local<v8::Context> context,
                            v8::Local<v8::Object> obj) {
  v8::Isolate* isolate = context->GetIsolate();
  v8::EscapableHandleScope handle_scope(isolate);

  // The 'foo_string' handle cannot be returned from this function because
  // it is not "escaped" with `.Escape()`.
  v8::Local<v8::String> foo_string =
      v8::String::NewFromUtf8(isolate, "foo").ToLocalChecked();

  v8::Local<v8::Value> return_value;
  if (obj->Get(context, foo_string).ToLocal(&return_value)) {
    return handle_scope.Escape(return_value);
  } else {
    // There was a JS exception! Handle it somehow.
    return v8::Local<v8::Value>();
  }
}
```

See [exception handling][] for more information about the usage of `.To()`,
`.ToLocalChecked()`, `v8::Maybe` and `v8::MaybeLocal` usage.

##### Casting local handles

If it is known that a `Local<Value>` refers to a more specific type, it can
be cast to that type using `.As<...>()`:

```cpp
v8::Local<v8::Value> some_value;
// CHECK() is a Node.js utilitity that works similar to assert().
CHECK(some_value->IsUint8Array());
v8::Local<v8::Uint8Array> as_uint8 = some_value.As<v8::Uint8Array>();
```

Generally, using `val.As<v8::X>()` is only valid if `val->IsX()` is true, and
failing to follow that rule may lead to crashes.

##### Detecting handle leaks

If it is expected that no `Local` handles should be created within a given
scope unless explicitly within a `HandleScope`, a `SealHandleScope` can be used.

For example, there is a `SealHandleScope` around the event loop, forcing
any functions that are called from the event loop and want to run or access
JavaScript code to create `HandleScope`s.

#### `Global` handles

A `v8::Global` handle (sometimes also referred to by the name of its parent
class `Persistent`, although use of that is discouraged in Node.js) is a
reference to a JavaScript object that can remain active as long as the engine
instance is active.

Global handles can be either strong or weak. Strong global handles are so-called
"GC roots", meaning that they will keep the JavaScript object they refer to
alive even if no other objects refer to them. Weak global handles do not do
that, and instead optionally call a callback when the object they refer to
is garbage-collected.

```cpp
v8::Global<v8::Object> reference;

void StoreReference(v8::Isolate* isolate, v8::Local<v8::Object> obj) {
  // Create a strong reference to `obj`.
  reference.Reset(isolate, obj);
}

// Must be called with a HandleScope around it.
v8::Local<v8::Object> LoadReference(v8::Isolate* isolate) {
  return reference.Get(isolate);
}
```

##### `Eternal` handles

`v8::Eternal` handles are a special kind of handles similar to `v8::Global`
handles, with the exception that the values they point to are never
garbage-collected while the JavaScript Engine instance is alive, even if
the `v8::Eternal` itself is destroyed at some point. This type of handle
is rarely used.

### `Context`

JavaScript allows multiple global objects and sets of built-in JavaScript
objects (like the `Object` or `Array` functions) to coexist inside the same
heap. Node.js exposes this ability through the [`vm` module][].

V8 refers to each of these global objects and their associated builtins as a
`Context`.

Currently, in Node.js there is one main `Context` associated with an
[`Environment`][] instance, and most Node.js features will only work inside
that context. (The only exception at the time of writing are
[`MessagePort`][] objects.) This restriction is not inherent to the design of
Node.js, and a sufficiently committed person could restructure Node.js to
provide built-in modules inside of `vm.Context`s.

Often, the `Context` is passed around for [exception handling][].
Typical ways of accessing the current `Environment` in the Node.js code are:

* Given an [`Isolate`][], using `isolate->GetCurrentContext()`.
* Given an [`Environment`][], using `env->context()` to get the `Environment`'s
  main context.

### Event loop

The main abstraction for an event loop inside Node.js is the `uv_loop_t` struct.
Typically, there is one event loop per thread. This includes not only the main
thread and Workers, but also helper threads that may occasionally be spawned
in the course of running a Node.js program.

The current event loop can be accessed using `env->event_loop()` given an
[`Environment`][] instance. The restriction of using a single event loop
is not inherent to the design of Node.js, and a sufficiently committed person
could restructure Node.js to provide e.g. the ability to run parts of Node.js
inside an event loop separate from the active thread's event loop.

### `Environment`

Node.js instances are represented by the `Environment` class.

Currently, every `Environment` class is associated with:

* One [event loop][]
* One [`Isolate`][]
* One main [`Context`][]

The `Environment` class contains a large number of different fields for
different Node.js modules, for example a libuv timer for `setTimeout()` or
the memory for a `Float64Array` that the `fs` module uses for storing data
returned from a `fs.stat()` call.

It also provides [cleanup hooks][] and maintains a list of [`BaseObject`][]
instances.

Typical ways of accessing the current `Environment` in the Node.js code are:

* Given a `FunctionCallbackInfo` for a [binding function][],
  using `Environment::GetCurrent(args)`.
* Given a [`BaseObject`][], using `env()` or `self->env()`.
* Given a [`Context`][], using `Environment::GetCurrent(context)`.
  This requires that `context` has been associated with the `Environment`
  instance, e.g. is the main `Context` for the `Environment` or one of its
  `vm.Context`s.
* Given an [`Isolate`][], using `Environment::GetCurrent(isolate)`. This looks
  up the current [`Context`][] and then uses that.

### `IsolateData`

Every Node.js instance ([`Environment`][]) is associated with one `IsolateData`
instance that contains information about or associated with a given
[`Isolate`][].

#### String table

`IsolateData` contains a list of strings that can be quickly accessed
inside Node.js code, e.g. given an `Environment` instance `env` the JavaScript
string "name" can be accessed through `env->name_string()` without actually
creating a new JavaScript string.

### Platform

Every process that uses V8 has a `v8::Platform` instance that provides some
functionalities to V8, most importantly the ability to schedule work on
background threads.

Node.js provides a `NodePlatform` class that implements the `v8::Platform`
interface and uses libuv for providing background threading abilities.

The platform can be accessed through `isolate_data->platform()` given an
[`IsolateData`][] instance, although that only works when:

* The current Node.js instance was not started by an embedder; or
* The current Node.js instance was started by an embedder whose `v8::Platform`
  implementation also implement's the `node::MultiIsolatePlatform` interface
  and who passed this to Node.js.

### Binding functions

C++ functions exposed to JS follow a specific signature. The following example
is from `node_util.cc`:

```cpp
void ArrayBufferViewHasBuffer(const FunctionCallbackInfo<Value>& args) {
  CHECK(args[0]->IsArrayBufferView());
  args.GetReturnValue().Set(args[0].As<ArrayBufferView>()->HasBuffer());
}
```

(Namespaces are usually omitted through the use of `using` statements in the
Node.js source code.)

`args[n]` is a `Local<Value>` that represents the n-th argument passed to the
function. `args.This()` is the `this` value inside this function call.
`args.Holder()` is equivalent to `args.This()` in all use cases inside of
Node.js.

`args.GetReturnValue()` is a placeholder for the return value of the function,
and provides a `.Set()` method that can be called with a boolean, integer,
floating-point number or a `Local<Value>` to set the return value.

Node.js provides various helpers for building JS classes in C++ and/or attaching
C++ functions to the exports of a built-in module:

```cpp
void Initialize(Local<Object> target,
                Local<Value> unused,
                Local<Context> context,
                void* priv) {
  Environment* env = Environment::GetCurrent(context);

  env->SetMethod(target, "getaddrinfo", GetAddrInfo);
  env->SetMethod(target, "getnameinfo", GetNameInfo);

  // 'SetMethodNoSideEffect' means that debuggers can safely execute this
  // function for e.g. previews.
  env->SetMethodNoSideEffect(target, "canonicalizeIP", CanonicalizeIP);

  // ... more code ...

  // Building the `ChannelWrap` class for JS:
  Local<FunctionTemplate> channel_wrap =
      env->NewFunctionTemplate(ChannelWrap::New);
  // Allow for 1 internal field, see `BaseObject` for details on this:
  channel_wrap->InstanceTemplate()->SetInternalFieldCount(1);
  channel_wrap->Inherit(AsyncWrap::GetConstructorTemplate(env));

  // Set various methods on the class (i.e. on the prototype):
  env->SetProtoMethod(channel_wrap, "queryAny", Query<QueryAnyWrap>);
  env->SetProtoMethod(channel_wrap, "queryA", Query<QueryAWrap>);
  // ...
  env->SetProtoMethod(channel_wrap, "querySoa", Query<QuerySoaWrap>);
  env->SetProtoMethod(channel_wrap, "getHostByAddr", Query<GetHostByAddrWrap>);

  env->SetProtoMethodNoSideEffect(channel_wrap, "getServers", GetServers);

  Local<String> channel_wrap_string =
      FIXED_ONE_BYTE_STRING(env->isolate(), "ChannelWrap");
  channel_wrap->SetClassName(channel_wrap_string);
  target->Set(env->context(), channel_wrap_string,
              channel_wrap->GetFunction(context).ToLocalChecked()).Check();
}

// Run the `Initialize` function when loading this module through
// `internalBinding('cares_wrap')` in Node.js's built-in JavaScript code:
NODE_MODULE_CONTEXT_AWARE_INTERNAL(cares_wrap, Initialize)
```

#### Per-binding state

Some internal bindings, such as the HTTP parser, maintain internal state that
only affects that particular binding. In that case, one common way to store
that state is through the use of `Environment::AddBindingData`, which gives
binding functions access to an object for storing such state.
That object is always a [`BaseObject`][].

Its class needs to have a static `binding_data_name` field that based on a
constant string, in order to disambiguate it from other classes of this type,
and which could e.g. match the binding's name (in the example above, that would
be `cares_wrap`).

```cpp
// In the HTTP parser source code file:
class BindingData : public BaseObject {
 public:
  BindingData(Environment* env, Local<Object> obj) : BaseObject(env, obj) {}

  static constexpr FastStringKey binding_data_name { "http_parser" };

  std::vector<char> parser_buffer;
  bool parser_buffer_in_use = false;

  // ...
};

// Available for binding functions, e.g. the HTTP Parser constructor:
static void New(const FunctionCallbackInfo<Value>& args) {
  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
  new Parser(binding_data, args.This());
}

// ... because the initialization function told the Environment to store the
// BindingData object:
void InitializeHttpParser(Local<Object> target,
                          Local<Value> unused,
                          Local<Context> context,
                          void* priv) {
  Environment* env = Environment::GetCurrent(context);
  BindingData* const binding_data =
      env->AddBindingData<BindingData>(context, target);
  if (binding_data == nullptr) return;

  Local<FunctionTemplate> t = env->NewFunctionTemplate(Parser::New);
  ...
}
```

### Exception handling

The V8 engine provides multiple features to work with JavaScript exceptions,
as C++ exceptions are disabled inside of Node.js:

#### Maybe types

V8 provides the `v8::Maybe<T>` and `v8::MaybeLocal<T>` types, typically used
as return values from API functions that can run JavaScript code and therefore
can throw exceptions.

Conceptually, the idea is that every `v8::Maybe<T>` is either empty (checked
through `.IsNothing()`) or holds a value of type `T` (checked through
`.IsJust()`). If the `Maybe` is empty, then a JavaScript exception is pending.
A typical way of accessing the value is using the `.To()` function, which
returns a boolean indicating success of the operation (i.e. the `Maybe` not
being empty) and taking a pointer to a `T` to store the value if there is one.

##### Checked conversion

`maybe.Check()` can be used to assert that the maybe is not empty, i.e. crash
the process otherwise. `maybe.FromJust()` (aka `maybe.ToChecked()`) can be used
to access the value and crash the process if it is not set.

This should only be performed if it is actually sure that the operation has
not failed. A lot of Node.js's source code does **not** follow this rule, and
can be brought to crash through this.

In particular, it is often not safe to assume that an operation does not throw
an exception, even if it seems like it would not do that.
The most common reasons for this are:

* Calls to functions like `object->Get(...)` or `object->Set(...)` may fail on
  most objects, if the `Object.prototype` object has been modified from userland
  code that added getters or setters.
* Calls that invoke *any* JavaScript code, including JavaScript code that is
  provided from Node.js internals or V8 internals, will fail when JavaScript
  execution is being terminated. This typically happens inside Workers when
  `worker.terminate()` is called, but it can also affect the main thread when
  e.g. Node.js is used as an embedded library. These exceptions can happen at
  any point.
  It is not always obvious whether a V8 call will enter JavaScript. In addition
  to unexpected getters and setters, accessing some types of built-in objects
  like `Map`s and `Set`s can also run V8-internal JavaScript code.

##### MaybeLocal

`v8::MaybeLocal<T>` is a variant of `v8::Maybe<T>` that is either empty or
holds a value of type `Local<T>`. It has methods that perform the same
operations as the methods of `v8::Maybe`, but with different names:

| `Maybe`                | `MaybeLocal`                    |
| ---------------------- | ------------------------------- |
| `maybe.IsNothing()`    | `maybe_local.IsEmpty()`         |
| `maybe.IsJust()`       | `!maybe_local.IsEmpty()`        |
| `maybe.To(&value)`     | `maybe_local.ToLocal(&local)`   |
| `maybe.ToChecked()`    | `maybe_local.ToLocalChecked()`  |
| `maybe.FromJust()`     | `maybe_local.ToLocalChecked()`  |
| `maybe.Check()`        | –                               |
| `v8::Nothing<T>()`     | `v8::MaybeLocal<T>()`           |
| `v8::Just<T>(value)`   | `v8::MaybeLocal<T>(value)`      |

##### Handling empty `Maybe`s

Usually, the best approach to encountering an empty `Maybe` is to just return
from the current function as soon as possible, and let execution in JavaScript
land resume. If the empty `Maybe` is encountered inside a nested function,
is may be a good idea to use a `Maybe` or `MaybeLocal` for the return type
of that function and pass information about pending JavaScript exceptions along
that way.

Generally, when an empty `Maybe` is encountered, it is not valid to attempt
to perform further calls to APIs that return `Maybe`s.

A typical pattern for dealing with APIs that return `Maybe` and `MaybeLocal` is
using `.ToLocal()` and `.To()` and returning early in case there is an error:

```cpp
// This could also return a v8::MaybeLocal<v8::Number>, for example.
v8::Maybe<double> SumNumbers(v8::Local<v8::Context> context,
                             v8::Local<v8::Array> array_of_integers) {
  v8::Isolate* isolate = context->GetIsolate();
  v8::HandleScope handle_scope(isolate);

  double sum = 0;

  for (uint32_t i = 0; i < array_of_integers->Length(); i++) {
    v8::Local<v8::Value> entry;
    if (array_of_integers->Get(context, i).ToLocal(&entry)) {
      // Oops, we might have hit a getter that throws an exception!
      // It's better to not continue return an empty ("nothing") Maybe.
      return v8::Nothing<double>();
    }

    if (!entry->IsNumber()) {
      // Let's just skip any non-numbers. It would also be reasonable to throw
      // an exception here, e.g. using the error system in src/node_errors.h,
      // and then to return an empty Maybe again.
      continue;
    }

    // This cast is valid, because we've made sure it's really a number.
    v8::Local<v8::Number> entry_as_number = entry.As<v8::Number>();

    sum += entry_as_number->Value();
  }

  return v8::Just(sum);
}

// Function that is exposed to JS:
void SumNumbers(const v8::FunctionCallbackInfo<v8::Value>& args) {
  // This will crash if the first argument is not an array. Let's assume we
  // have performed type checking in a JavaScript wrapper function.
  CHECK(args[0]->IsArray());

  double sum;
  if (!SumNumbers(args.GetIsolate()->GetCurrentContext(),
                  args[0].As<v8::Array>()).To(&sum)) {
    // Nothing to do, we can just return directly to JavaScript.
    return;
  }

  args.GetReturnValue().Set(sum);
}
```

#### TryCatch

If there is a need to catch JavaScript exceptions in C++, V8 provides the
`v8::TryCatch` type for doing so, which we wrap into our own
`node::errors::TryCatchScope` in Node.js. The latter has the additional feature
of providing the ability to shut down the program in the typical Node.js way
(printing the exception + stack trace) if an exception is caught.

A `TryCatch` will catch regular JavaScript exceptions, as well as termination
exceptions such as the ones thrown by `worker.terminate()` calls.
In the latter case, the `try_catch.HasTerminated()` function will return `true`,
and the exception object will not be a meaningful JavaScript value.
`try_catch.ReThrow()` should not be used in this case.

### libuv handles and requests

Two central concepts when working with libuv are handles and requests.

Handles are subclasses of the `uv_handle_t` "class", and generally refer to
long-lived objects that can emit events multiple times, such as network sockets
or file system watchers.

In Node.js, handles are often managed through a [`HandleWrap`][] subclass.

Requests are one-time asynchronous function calls on the event loop, such as
file system requests or network write operations, that either succeed or fail.

In Node.js, requests are often managed through a [`ReqWrap`][] subclass.

### Environment cleanup

When a Node.js [`Environment`][] is destroyed, it generally needs to clean up
any resources owned by it, e.g. memory or libuv requests/handles.

#### Cleanup hooks

Cleanup hooks are provided that run before the [`Environment`][]
is destroyed. They can be added and removed through by using
`env->AddCleanupHook(callback, hint);` and
`env->RemoveCleanupHook(callback, hint);`, where callback takes a `void* hint`
argument.

Inside these cleanup hooks, new asynchronous operations *may* be started on the
event loop, although ideally that is avoided as much as possible.

Every [`BaseObject`][] has its own cleanup hook that deletes it. For
[`ReqWrap`][] and [`HandleWrap`][] instances, cleanup of the associated libuv
objects is performed automatically, i.e. handles are closed and requests
are cancelled if possible.

#### Closing libuv handles

If a libuv handle is not managed through a [`HandleWrap`][] instance,
it needs to be closed explicitly. Do not use `uv_close()` for that, but rather
`env->CloseHandle()`, which works the same way but keeps track of the number
of handles that are still closing.

#### Closing libuv requests

There is no way to abort libuv requests in general. If a libuv request is not
managed through a [`ReqWrap`][] instance, the
`env->IncreaseWaitingRequestCounter()` and
`env->DecreaseWaitingRequestCounter()` functions need to be used to keep track
of the number of active libuv requests.

#### Calling into JavaScript

Calling into JavaScript is not allowed during cleanup. Worker threads explicitly
forbid this during their shutdown sequence, but the main thread does not for
backwards compatibility reasons.

When calling into JavaScript without using [`MakeCallback()`][], check the
`env->can_call_into_js()` flag and do not proceed if it is set to `false`.

## Classes associated with JavaScript objects

### `MemoryRetainer`

A large number of classes in the Node.js C++ codebase refer to other objects.
The `MemoryRetainer` class is a helper for annotating C++ classes with
information that can be used by the heap snapshot builder in V8, so that
memory retained by C++ can be tracked in V8 heap snapshots captured in
Node.js applications.

Inheriting from the `MemoryRetainer` class enables objects (both from JavaScript
and C++) to refer to instances of that class, and in turn enables that class
to point to other objects as well, including native C++ types
such as `std::string` and track their memory usage.

This can be useful for debugging memory leaks.

The [`memory_tracker.h`][] header file explains how to use this class.

### `BaseObject`

A frequently recurring situation is that a JavaScript object and a C++ object
need to be tied together. `BaseObject` is the main abstraction for that in
Node.js, and most classes that are associated with JavaScript objects are
subclasses of it. It is defined in [`base_object.h`][].

Every `BaseObject` is associated with one [`Environment`][] and one
`v8::Object`. The `v8::Object` needs to have at least one [internal field][]
that is used for storing the pointer to the C++ object. In order to ensure this,
the V8 `SetInternalFieldCount()` function is usually used when setting up the
class from C++.

The JavaScript object can be accessed as a `v8::Local<v8::Object>` by using
`self->object()`, given a `BaseObject` named `self`.

Accessing a `BaseObject` from a `v8::Local<v8::Object>` (frequently that is
`args.This()` or `args.Holder()` in a [binding function][]) can be done using
the `Unwrap<T>(obj)` function, where `T` is a subclass of `BaseObject`.
A helper for this is the `ASSIGN_OR_RETURN_UNWRAP` macro that returns from the
current function if unwrapping fails (typically that means that the `BaseObject`
has been deleted earlier).

```cpp
void Http2Session::Request(const FunctionCallbackInfo<Value>& args) {
  Http2Session* session;
  ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
  Environment* env = session->env();
  Local<Context> context = env->context();
  Isolate* isolate = env->isolate();

  // ...
  // The actual function body, which can now use the `session` object.
  // ...
}
```

#### Lifetime management

The `BaseObject` class comes with a set of features that allow managing the
lifetime of its instances, either associating it with the lifetime of the
corresponding JavaScript object or untying the two.

The `BaseObject::MakeWeak()` method turns the underlying [`Global`][] handle
into a weak one, and makes it so that the `BaseObject::OnGCCollect()` virtual
method is called when the JavaScript object is garbage collected. By default,
that methods deletes the `BaseObject` instance.

`BaseObject::ClearWeak()` undoes this effect.

It generally makes sense to call `MakeWeak()` in the constructor of a
`BaseObject` subclass, unless that subclass is referred to by e.g. the event
loop, as is the case for the [`HandleWrap`][] and [`ReqWrap`][] classes.

In addition, there are two kinds of smart pointers that can be used to refer
to `BaseObject`s.

`BaseObjectWeakPtr<T>` is similar to `std::weak_ptr<T>`, but holds on to
an object of a `BaseObject` subclass `T` and integrates with the lifetime
management of the former. When the `BaseObject` no longer exists, e.g. when
it was garbage collected, accessing it through `weak_ptr.get()` will return
`nullptr`.

`BaseObjectPtr<T>` is similar to `std::shared_ptr<T>`, but also holds on to
objects of a `BaseObject` subclass `T`. While there are `BaseObjectPtr`s
pointing to a given object, the `BaseObject` will always maintain a strong
reference to its associated JavaScript object. This can be useful when one
`BaseObject` refers to another `BaseObject` and wants to make sure it stays
alive during the lifetime of that reference.

A `BaseObject` can be "detached" throught the `BaseObject::Detach()` method.
In this case, it will be deleted once the last `BaseObjectPtr` referring to
it is destroyed. There must be at least one such pointer when `Detach()` is
called. This can be useful when one `BaseObject` fully owns another
`BaseObject`.

### `AsyncWrap`

`AsyncWrap` is a subclass of `BaseObject` that additionally provides tracking
functions for asynchronous calls. It is commonly used for classes whose methods
make calls into JavaScript without any JavaScript stack below, i.e. more or less
directly from the event loop. It is defined in [`async_wrap.h`][].

Every `AsyncWrap` subclass has a "provider type". A list of provider types is
maintained in `src/async_wrap.h`.

Every `AsyncWrap` instance is associated with two numbers, the "async id"
and the "async trigger id". The "async id" is generally unique per `AsyncWrap`
instance, and only changes when the object is re-used in some way.

See the [`async_hooks` module][] documentation for more information about how
this information is provided to async tracking tools.

#### `MakeCallback`

The `AsyncWrap` class has a set of methods called `MakeCallback()`, with the
intention of the naming being that it is used to "make calls back into
JavaScript" from the event loop, rather than making callbacks in some way.
(As the naming has made its way into Node.js's public API, it's not worth
the breakage of fixing it).

`MakeCallback()` generally calls a method on the JavaScript object associated
with the current `AsyncWrap`, and informs async tracking code about these calls
as well as takes care of running the `process.nextTick()` and `Promise` task
queues once it returns.

Before calling `MakeCallback()`, it is typically necessary to enter both a
`HandleScope` and a `Context::Scope`.

```cpp
void StatWatcher::Callback(uv_fs_poll_t* handle,
                           int status,
                           const uv_stat_t* prev,
                           const uv_stat_t* curr) {
  // Get the StatWatcher instance associated with this call from libuv,
  // StatWatcher is a subclass of AsyncWrap.
  StatWatcher* wrap = ContainerOf(&StatWatcher::watcher_, handle);
  Environment* env = wrap->env();
  HandleScope handle_scope(env->isolate());
  Context::Scope context_scope(env->context());

  // Transform 'prev' and 'curr' into an array:
  Local<Value> arr = ...;

  Local<Value> argv[] = { Integer::New(env->isolate(), status), arr };
  wrap->MakeCallback(env->onchange_string(), arraysize(argv), argv);
}
```

See [Callback scopes][] for more information.

### `HandleWrap`

`HandleWrap` is a subclass of `AsyncWrap` specifically designed to make working
with [libuv handles][] easier. It provides the `.ref()`, `.unref()` and
`.hasRef()` methods as well as `.close()` to enable easier lifetime management
from JavaScript. It is defined in [`handle_wrap.h`][].

`HandleWrap` instances are [cleaned up][cleanup hooks] automatically when the
current Node.js [`Environment`][] is destroyed, e.g. when a Worker thread stops.

`HandleWrap` also provides facilities for diagnostic tooling to get an
overview over libuv handles managed by Node.js.

### `ReqWrap`

`ReqWrap` is a subclass of `AsyncWrap` specifically designed to make working
with [libuv requests][] easier. It is defined in [`req_wrap.h`][].

In particular, its `Dispatch()` method is designed to avoid the need to keep
track of the current count of active libuv requests.

`ReqWrap` also provides facilities for diagnostic tooling to get an
overview over libuv handles managed by Node.js.

### Callback scopes

The public `CallbackScope` and the internally used `InternalCallbackScope`
classes provide the same facilities as [`MakeCallback()`][], namely:

* Emitting the `'before'` event for async tracking when entering the scope
* Setting the current async IDs to the ones passed to the constructor
* Emitting the `'after'` event for async tracking when leaving the scope
* Running the `process.nextTick()` queue
* Running microtasks, in particular `Promise` callbacks and async/await
  functions

Usually, using `AsyncWrap::MakeCallback()` or using the constructor taking
an `AsyncWrap*` argument (i.e. used as
`InternalCallbackScope callback_scope(this);`) suffices inside of Node.js's
C++ codebase.

## C++ utilities

Node.js uses a few custom C++ utilities, mostly defined in [`util.h`][].

### Memory allocation

Node.js provides `Malloc()`, `Realloc()` and `Calloc()` functions that work
like their C stdlib counterparts, but crash if memory cannot be allocated.
(As V8 does not handle out-of-memory situations gracefully, it does not make
sense for Node.js to attempt to do so in all cases.)

The `UncheckedMalloc()`, `UncheckedRealloc()` and `UncheckedCalloc()` functions
return `nullptr` in these cases (or when `size == 0`).

#### Optional stack-based memory allocation

The `MaybeStackBuffer` class provides a way to allocate memory on the stack
if it is smaller than a given limit, and falls back to allocating it on the
heap if it is larger. This can be useful for performantly allocating temporary
data if it is typically expected to be small (e.g. file paths).

The `Utf8Value`, `TwoByteValue` (i.e. UTF-16 value) and `BufferValue`
(`Utf8Value` but copy data from a `Buffer` if one is passed) helpers
inherit from this class and allow accessing the characters in a JavaScript
string this way.

```cpp
static void Chdir(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  // ...
  CHECK(args[0]->IsString());
  Utf8Value path(env->isolate(), args[0]);
  int err = uv_chdir(*path);
  if (err) {
    // ... error handling ...
  }
}
```

### Assertions

Node.js provides a few macros that behave similar to `assert()`:

* `CHECK(expression)` aborts the process with a stack trace
  if `expression` is false.
* `CHECK_EQ(a, b)` checks for `a == b`
* `CHECK_GE(a, b)` checks for `a >= b`
* `CHECK_GT(a, b)` checks for `a > b`
* `CHECK_LE(a, b)` checks for `a <= b`
* `CHECK_LT(a, b)` checks for `a < b`
* `CHECK_NE(a, b)` checks for `a != b`
* `CHECK_NULL(val)` checks for `a == nullptr`
* `CHECK_NOT_NULL(val)` checks for `a != nullptr`
* `CHECK_IMPLIES(a, b)` checks that `b` is true if `a` is true.
* `UNREACHABLE([message])` aborts the process if it is reached.

`CHECK`s are always enabled. For checks that should only run in debug mode, use
`DCHECK()`, `DCHECK_EQ()`, etc.

### Scope-based cleanup

The `OnScopeLeave()` function can be used to run a piece of code when leaving
the current C++ scope.

```cpp
static void GetUserInfo(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  uv_passwd_t pwd;
  // ...

  const int err = uv_os_get_passwd(&pwd);

  if (err) {
    // ... error handling, return early ...
  }

  auto free_passwd = OnScopeLeave([&]() { uv_os_free_passwd(&pwd); });

  // ...
  // Turn `pwd` into a JavaScript object now; whenever we return from this
  // function, `uv_os_free_passwd()` will be called.
  // ...
}
```

[`BaseObject`]: #baseobject
[`Context`]: #context
[`Environment`]: #environment
[`Global`]: #global-handles
[`HandleWrap`]: #handlewrap
[`IsolateData`]: #isolate-data
[`Isolate`]: #isolate
[`Local`]: #local-handles
[`MakeCallback()`]: #makecallback
[`MessagePort`]: https://nodejs.org/api/worker_threads.html#worker_threads_class_messageport
[`ReqWrap`]: #reqwrap
[`async_hooks` module]: https://nodejs.org/api/async_hooks.html
[`async_wrap.h`]: async_wrap.h
[`base_object.h`]: base_object.h
[`handle_wrap.h`]: handle_wrap.h
[`memory_tracker.h`]: memory_tracker.h
[`req_wrap.h`]: req_wrap.h
[`util.h`]: util.h
[`v8.h` in Code Search]: https://cs.chromium.org/chromium/src/v8/include/v8.h
[`v8.h` in Node.js master]: https://github.com/nodejs/node/blob/master/deps/v8/include/v8.h
[`v8.h` in V8 master]: https://github.com/v8/v8/blob/master/include/v8.h
[`vm` module]: https://nodejs.org/api/vm.html
[C++ coding style]: ../doc/guides/cpp-style-guide.md
[Callback scopes]: #callback-scopes
[JavaScript value handles]: #js-handles
[N-API]: https://nodejs.org/api/n-api.html
[binding function]: #binding-functions
[cleanup hooks]: #cleanup-hooks
[event loop]: #event-loop
[exception handling]: #exception-handling
[internal field]: #internal-fields
[introduction for V8 embedders]: https://v8.dev/docs/embed
[libuv handles]: #libuv-handles-and-requests
[libuv requests]: #libuv-handles-and-requests
[libuv]: https://libuv.org/
[reference documentation for the libuv API]: http://docs.libuv.org/en/v1.x/

redpajama_set_name: RedPajamaGithub


Well-equipped family members were able to keep a walker warm while waiting for help after he slipped and injured his leg on a Lakeland fell.
The man, from Heddon-on-the-Wall, Northumberland, was making his way from Grisedale Tarn down towards Patterdale yesterday, Sunday, when the incident happened.
Patterdale Mountain Rescue Team was alerted about 6.50pm and members made their way to the scene.
A team spokesperson said: "The family was well equipped and kept him warm until the team arrived.
The walker was then taken to the Patterdale team rescue centre where an ambulance picked him up and took him to hospital.
The four-hour rescue involved 15 volunteer rescue team members.


Dr. Jesse Mead sits at the forefront of Manual Medicine today. He has leveraged almost 10 years of college, numerous seminars, childlike curiosity, an open mind and a natural talent for evaluating human movement into a skill set unique to the state of Maine. Dr. Mead received his Bachelors Degree from Bridgewater State University in exercise science. He received his Certified Strength and Conditioning Specialist certification in 2005 and has many years of experience helping out a variety of people from professional athletes, to chronic pain patients, to everyday Mom and Dad's reach their goals. He attended Palmer College of Chiropractic Florida, graduating in 2010 with his Doctor of Chiropractic Degree. Since 2010 Dr. Mead has been blending techniques to develop the SiSU Mentality method which has been scientifically proven to efficiently and consistently carry people to their goals. He has extensive knowledge in skeletal mechanics and the healing responses of the human body and utilizes this knowledge to create personalized treatment plans for his patients. Dr. Mead's mission is to get you excited about activating and expressing all your capabilities. He specializes in restoring your mobility by using a mixture of techniques derived from traditional care, massage therapy, physical therapy (American, Eastern European and Australian techniques) and chiropractic care to give you a broader range of treatment options.


SDHC cards are ideal for Hi-megapixel Cameras and video recorders. Capture, store, and transfer more of your photos and videos, on all SDHC host devices. PNY Performance SDHC cards feature a Class 4 speed rating which is perfect for storing data from a variety of SDHC compatible devices from e-books to laptops and printers. Available in 4GB, 8GB, 16GB and 32GB capacities.


Emmpith is fast rising artist who from Benue State (Idoma), He's not new in the music industry due to his pure talent that speak for him anywhere he find himself. The versatile and prolific "Emmpith" is here again with a dope track titled "Fines". You can't miss this for the world.
Kindly Listen & Download "Fines" By "Emmpith".


In the Animal Kingdom, some animals' have to sacrifice their lives (not willingly though) for the survival others. They are referred to as prey and they are hunted down by their fellow animals' as a meal. Well no one would want their life cut short but that is how the food chain works.
One of the main success of the African wildlife is the availability of enough prey for the roaming predators. The prey success is also drawn by the vast grasslands and forests that provide enough grazing and foraging area. Most predators are known to be carnivorous and love preying on the herbivores who graze lazily along the Savannah grasslands.
In the Kenyan wild, these are among the animals' you will not miss seeing grazing even out of the protected areas. Though they face a lot of habitat loss due to farmers fencing off most areas to avoid competition for pasture with the livestock. Due to their high bleeding cycle, there are able to keep their species growing. Below are some herbivores you will not miss while on a safari game drive in Kenya.
Zebras are characterized by distinctive black and white stripped coat. The stripes' come in different patterns, unique to each individual. There are two types found in Kenya, namely; the plain zebra and the grevy zebra. They are social animals' and live is small harems to large herds and at times accompany other animals' like the wildebeest.
The plain zebra is very common and can be seen grazing in the plains, grasslands and scrub lands in different parts of Kenya. The Grevy zebra is classified as an endangered species and is found in the Northern Part of Kenya forming the Special Five of Kenya.
In Kenya, we have the blue wildebeest species which are a great tourist attraction due to their annual migration in search of pasture. Their bleeding period is normally after the long rains and it usually takes a short time and the new born calf is up on its feet and can out run a predator. The birthing season is a great attraction in the Serengeti plains in the months of March-April.
Wildebeest graze in mixed herds with zebras which heightens their awareness of potential predators. The greatest predators include the spotted hyenas who target the young calves and other large carnivores.
The impala is one of the most common wild animal you will meet in any national park in Kenya. The herds are normally in three distinctive social groups; the territorial males, the bachelor herds and the female herds. They are popular for two characteristics leaps that constitute an anti-predator strategies.
The common eland is the second largest antelope in the world and found in East Africa. They form herds of up 500 but are not territorial. They prefer areas with a wide variety of flowering plants such as open grasslands and woodlands and avoid dense forests.
This is a forest antelope that inhabits dry, flat and heavily forested regions. They are browsers and feed on foliage from bushes, trees and herds. The lesser kudu is mainly active at night and during dawn and seeks shelter in dense thickets just after sunrise. They exhibit no territorial behavior and fights are rare, only the males have spiral horns.
The oryx prefer near desert areas and are native to the arid areas of Africa. In Kenya, they are found in the Northern region and form 'The Special Fives of Samburu'. They live in herds of up to 500 and can survive without water for long periods. Both male and female have horns and use it as a lethal weapon to fight back their predators. The horns also make them a prized game trophy which has led them to near extinction.
The most common species of gazelles found in Kenya is the Thomson's gazelle. They are small antelopes and are colored brown and white with a distinguishing black stripe. Gazelles are swift animals' and are known to run at a burst as high as 100 km/h (60mph) or run at a sustained speed of 50 km/h (30mph).
Gerenuk also known as a giraffe gazelle is a long-necked antelope that is found in the drier parts of East Africa in the Northern end of Kenya. It is characterized by long, slender neck and limbs, wedged like head and large, round eyes.
Foraging and feeding are their major activities. It is known to reach higher branches and twigs than other gazelles and antelopes by standing erect on its two hind legs and elongating it's long neck.
This is a small dwarf-like antelope. The name dikdik comes from the alarms calls made by the females to alert the animals' of predators. They live is habitats that have plentiful supply of edible plants such as shrubs.
Hirola antelope is a critically endangered species found in the borders of Kenya and Somali. They are medium-sized antelopes, tan to rufous-tawny in color with slightly lighter under parts, white inner ears and a white tail. They are adopted to arid environments dwelling well is the bush to wooded Savannah with low shrubs and scattered trees, most often on sandy soils.
This is a swamp dwelling antelope that is confined in swamps and marshy habitats. They are characterized by a shaggy, water resistant coat which varies in color. Their body and feet are specially adapted to its swampy habitat. Sitatunga is selective in what they eat and feed mainly on new foliage, fresh grasses, aquatic plants, sedge and browse.
Waterbuck are large antelopes that inhabit areas close to water sources as they cannot tolerate dehydration. They are predominantly grazers and thrive in grasslands.
This is a small antelope with a reddish-brown coat with white markings. This species of the antelope is found in Sub-Sahara Africa and thrives well in rain forests, montage forest, bush-Savannah forest and woodlands.
This is a reddish brown antelope that thrives on wet grasslands. They are primarily grazers that prefer to feed on grass.
This is a large antelope with an elongated forehead, oddly shaped horns, short neck, pointed ears with legs that have black markings and are unusually long. Hartebeest is very alert but non-aggressive. They are grazers and mainly feed on grass.
The bongo is among the largest African forest antelope species. They are characterized by a striking reddish-brown coat, black and white markings, white-yellow stripes' and long slightly spiraled horns. Both sexes have horns and have a complex social interaction.
This is a large antelope found in the woodlands and grasslands Savannah. In Kenya, the roan antelope can only be sited at the Ruma National Park, the only protected sanctuary that is home to this endangered species. The roan antelope is highly affected by habitat loss due to human settlements and poaching.
The giant forest hog is native to wooded habitats of Africa and is considered as the largest wild member of the pig family. It is mostly black with extensive hair on its body though the hair tends to become less pronounced as the animal ages. They are herbivores as wells as scavengers.
This is a member of the pig family that lives in forests, woodland, riverine vegetation and reed beds. The bush pig is nocturnal and resemble the domestic pig. They are identified by their blunt, muscular snouts, small eyes, pointed, tuffed ears and buckled toes.
They are social animals' found in sounders of up to 12 members. They are omnivorous and their diet include; roots, crops and carrion.
The warthog is a wild member of the pig family found in the grasslands, savanna and woodlands in the Sub-Saharan Africa. They are not territorial but instead, occupy a home range. They are common feature in the Kenya Wildlife Headquarters and it's environs where they are seen grazing in the well manicured lawn. At times the walk along the busy Langata road with no fear of the human population around them.
Baboons have long, dog-like muzzles, heavy powerful jaws with canine teeth, close-set eyes, thick fur except on their muzzles, short tails and rough spots on their protruding buttocks. Their buttocks are nerveless, hairless pads of skin that provide comfort when sitting.
They are ground dwelling and are found in the open Savannah, woodlands and hills. They are omnivorous and feed on insects and occasionally prey on fish, hares, birds, vervet monkeys and small antelopes. They are also known to raid human dwellings and prey on sheep and goats.
In Kenya, there are a number of monkey species found in different forests and parks. Monkey is one of the few animals' species that can be seen roaming freely out of the protected area. In some places they have been known to be a menace (agricultural pests) causing extensive damage to commercial and subsistence crops.
Colobus Monkey: In Kenya they inhabit coastal forests, riverine forests and woodlands. They are the one species of monkeys that don't have thumbs.
Sykes Monkey: They are characterized by a large white patch on the throat and upper chest and a grizzled (not blackish) cap.
Blue Monkey: They are not noticeably blue as per their name but have little hair on their face that give a blue appearance. They are found in evergreen forest as they are highly dependent on humid, shady areas with plenty of water.
Vervet Monkey: They are characterized by a black face and Grey body fair. They are known to inhabit mountain areas and avoid rain forests and deserts.
Debrazza Monkey: This is one of the most widespread primates that live in forests. They are characterized by Grey fur with a reddish-brown back, black limbs and tails and a white rump. A white stripe runs down it's thigh and an orange crescent-shaped marking appears on its forehead.
Though chimpanzees are not native to Kenya, there is a sanctuary at the Ol Pejeta Conservancy known as The Sweetwaters Chimpanzees Sanctuary that takes cares of chimpanzees rescued around the world where they were caged and kept as pets. They are rehabilitated and taught how to live in the world again, free from human interaction.
Wow, you think you know about this stuff, but then you find an article like this and you find out you don't really know anything. I had no idea there were this many types of animals to see on a safari. I mean, I knew the major ones of course, but there is a whole different world I was ignorant of. I've been considering a safari anyway, but now I see it really is a can't miss situation. Thanks for the breakdown.
There are so many wild animals in Africa, this is just a feature of one country. It is always good to build one's expectation before taking the safari, then you just concentrate on taking goods photos.
You should definitely consider a safari and if you love wildlife, set enough days to explore different areas and see as many animals as you can. You can also check The Small Animals, The Birds and The Great Mammals and Predators.
Amazing write up of the many beautiful animals of Africa! They are all great looking creatures with their unique characteristics. My favorite is the warthog! It looks awesome and seems to be a great fighter.
This post is very detailed and helps the first time reader truly immerse and absorb the information therein. The author sounds like she has done an extensive research or simply has a ton of knowledge on the subject.
Glad you found the information worthwhile, am glad i could share my knowledge with other people worldwide.
You are the first person I have heard who likes the warthog, but I can't call it much of a fighter.
Woow, I never thought there are so many species of Savannah herbivores like this. Its very sad to know that they are always being hunted for a meal by other animals (carnivores), but what can you do, absolutely nothing, its nature. It is even more worrying to hear that some of them are protected species (like the Grevy Zebra), but that is a nice move because that will prevent them from extinguishing.
I have seen some of them on Geographical channels, but I have never seen the Gerenuk, its a pretty beautiful animal.
Yes the Savannah has many grazing animals though they are threatened by human encroachment hence need to turn some part of the Savannah into protected areas.
The Grevy Zebra is endangered and facing extinct hence need to protect the remaining species. Generuk thrives in dryer parts of the Savannah, you should visit Northern Kenya to see some beautiful herds.
Thanks for revealing the names of these animals to me.
Actually, I'm an emotional person and most times when I tune to one of my favorite channels which happens to be NatGeoWild, I do see how these animals lives are being wasted by other wild animals like Lion and the rest of them, and do feel so much pity for them. These animals did not choose to die now but their lives were just wasted. I am so happy that am not an animal.
Am happy that i could add some knowledge to you.
You should not feel bad for this animal for they are here to serve their purpose of being food to other animals, it is not that they are being wasted when they are killed by predators, that is how the food chain works. Something you have to note is approximately 10-15 antelopes born, one big cat cub is born and chances of the cub surviving to adulthood are actually less than that of the 15 antelope calves.
That is how nature operates and can't be changed or interfered with. The carnivores like Lions, cheetahs are actually reducing at a high and alarming number as compare to this herbivores.
I felt like I am in the game reserve taking a tour with one of the forest officials, this is indeed entertaining to read, believe me I never knew we had so many species of antelopes as you have shown in your research, you indeed blessed me and subdued my curiosity to see to the end of your writeup quickly with multiple pix.
It was captivating, the only thing I missed was that some of the animals mentioned, I have never seen them and their pictures weren't available.
Please take some to update those pictures for those animals mentioned without pix, I will certainly return to view and drop more comments.
My kids were more happy to know more from your informative articles.
I am glad you found worthy information in my article enough to share with your kids.
I will definitely add the pictures of the missing animals, just that some are a bit tough to get a good photos since they always hide deep in the forest and not easily accessible but will do my best to get good worthy pictures.


text:
Sigle
 Istituto reale di tecnologia – Università di Stoccolma

Codici
 KTH – codice aeroportuale IATA dell'aeroporto civile di Tikchik Spb (Stati Uniti)

redpajama_set_name: RedPajamaWikipedia


Monitor the level of noise your child is exposed to. If speech must be raised (shouted) to communicate, it is very likely that the noise is excessive and possibly damaging. Ringing in the ears (tinnitus) after noise exposure also indicates excessive sound levels. Children should be told about the dangers of noise exposure and the use of ear protection (ear plugs, ear muffs, etc.). When ear protection is unavailable, simply block the ear canal opening with yours fingers. This serves as to reduce the level of sound going to the eardrum. Children should be protected from excessive noise exposure whenever possible.
As a parent, you can set examples for your child. When mowing the lawn or using noisy tools or appliances, use hearing protection and insist that your child playing nearby does the same. Such habits will save both your hearing and that of your child.


text:
Andrew Eborn - UFO / CONSPIRACY THEORIES with NICK POPE
Andrew Eborn is joined by Nick Pope, who investigated UFOs for the Ministry of Defence.
Andrew & Nick discuss Coronavirus conspiracies and the handling of the pandemic, UFOs, the psychology of belief, witness fallibility and memory, JFK, the moon landings, Princess Diana, 9/11, the war in Iraq, and their shared secret identify as the mysterious Madame Zaza.
The launch of EBORN NEWS NETWORK (ENN)
We are drowning in a sea of information – 99.9% of which is rubbish. Anyone, anywhere and at any time can be a self-professed expert. There is evidence to support any view – however outrageous. The news is dominated by soundbites from those Sultans of Spin. In this post-truth age it has never been more important to have evidenced-based journalism.
As Jimmy Wales, the co-founder of Wikipedia, pointed out "The news is broken and we can fix it" QUESTION EVERYTHING
REALISE REAL LIES
Jaw Jaw Not War War
More Light Less Heat
We will bring you stories directly sourced & evidenced based. If you would like to be involved write to ENN@OctopusTV.com
Andrew Eborn is conducting exclusive video interviews with great guests from around the world
-from Australia to Zambia
- from all walks of life including major public figures and celebrities, legends of sports, music, film theatre, titans of industry as well as everyday heroes
- learn to cook with top chefs
- learn new skills from chess to wrestling
- learn how to be the best you you can be
- Afternoon tease - puzzles & brain teasers
- Pets on Parade
Andrew Eborn "The Joe Wicks of the Mind & Mental Health"
Andrew Eborn, President of Octopus TV & Knot The Truth, is a renowned international lawyer, producer, strategist, futurist, brand adviser, broadcaster, mentalist, magician & inspirational speaker. For many years Andrew Eborn has empowered companies to face the challenges of changing markets, maximise the return on their rights as well as assisting with the strategic development of their businesses.
UKTI Rob Walker " Andrew Eborn is an inspirational ambassador for the technology, media and sport sectors and a powerful advocate for British business"
"Magical " Sir David Frost"
Andrew Eborn is a very talented interviewer. Andrew is a barrister , magician a true showman & President of Octopus Television, London. When Andrew interviews his subject he makes them feel extremely relaxed & a joy to work with." Linda Rifkind
Andrew Eborn is "an extraordinary interviewer" James Fortune, Hollywood Director"Brilliant" The Magic Circular
Paul Gordon "Andrew Eborn has now interviewed me twice. He's very good at it too because he asks tough questions without being tough and - like Sir Michael Parkinson - he asks questions the viewer would like to ask."
" If it wasn't for Andrew Eborn I would not have had the power to do what I am doing. ,,,, So thank you for the opportunity and trying this stuff." Charmaine
"I like your interview style. It's buzzy, prepared and strong. You do it very well"
"Brilliant and buzzing" Ed Hood
@AndrewEborn @octopustv © Octopus TV Ltd 2020.

redpajama_set_name: RedPajamaCommonCrawl


The Russian "Collusion" delusion: Paul Joseph Watson delivers the truth about the real conspirators……. – The Tundra Tabloids…….
The Russian "Collusion" delusion: Paul Joseph Watson delivers the truth about the real conspirators…….
Previous Post Previous Post Mad Max Galosh tries his zaniest best to sell out Israel…….
Next Post Next Post Sargon of Akkad: Cultural Marxism is now "intersectionality" pushed by the Left…….


The specific temperature effects in hydrodynamic properties (intrinsic viscosity, sedimentation velocity and translational diffusion) of side-on comb-like polymers with molecular weights from 5.70 х 10 5 to 3.02 х 10 6 were observed in dilute solution in two different solvents, benzene and chloroform, over a temperature range from 2 to 73°C. The viscosity temperature coefficient dln[h]/dT was found to be negative in sign in chloroform ( ¹ 0.007 K ¹1) and positive in benzene ( þ 0.005 K ¹1). Increase in temperature leads to intensification of the excluded volume effects in real benzene solution of the polymer and to weakening of those in chloroform. Simultaneously, increase in temperature leads to decreasing unperturbed dimensions of the macromolecule chain in both the solvents. This effect is more pronounced in benzene (dlnhh 2i/dT ¼ ¹ 0.005 K ¹1, where hh 2i is the mean-square end-to-end distance) than in chloroform ( ¹ 0.001 K ¹1). Origins of the temperature effects are discussed with relation to the lateral structure of the macromolecule where every monomer unit contains the threecyclic mesogenic moiety which is laterally (with the middle part) attached to a side chain consisting of 11 carbon atoms.
Temperature effects in hydrodynamic properties of comb-like polymer with laterally attached mesogenic units / Peter Lavrenko, Olga Okatova, Evgeniya Korneeva, Heino Finkelmann // Polymer. – 1999. – N 40. – P. 1701–1707.
Temperature effects in hydrodynamic properties of comb-like polymer with laterally attached mesogenic units - Завантажити.


The advisory team is initiating discussions with potential buyers who may consider operating the 300mm fab which has an output of 38,000 wafer starts per month and is 65nm capable. If a strategic buyer is not found, the advisory team will move quickly to a complete 300mm tool line sale and sale of the cleanroom manufacturing facilities in separate transactions.
Qimonda requests that all inquires are directed to Stephen Rothrock or Doug Barrett of ATREG at +1.206.268.7800.
Qimonda North America Corp. and Qimonda Richmond L.L.C. each filed for creditor protection under Chapter 11 of the Bankruptcy Code on February 20, 2009.


I've been wanting to write lately. I'm not sure what to write but I know that I'd like it to be prose. I have written a lot of poetry in the past, and I enjoy writing poetry, however, it's not what I'm feeling compelled to write these days. The problem with writing prose is that I need to have some sort of idea about what I'd like to write. There is endless possibility with any creative writing endeavour and perhaps that is the most difficult thing for me - having to choose. I'd like to start with some short pieces; somewhere around one to two pages in length and work my way up from there. Eventually, I'd like to write a fiction novel (maybe November).
Is water being rationed where you live? What do you do to help save water?
I could write about that OR I could simply write about water. I have chosen to try the latter.
I'll post it when I do it but if other people feel so inclined, please suggest topics. A single noun, adjective or idea would work well too.
Write a personal diary from the point of view of animal (non-human), vegetable, or mineral.


text:
//
//  ORIGINAL_AUTHOR: Vijay Janapa Reddi
//
//  This tool collects the dynamic counts of the behavior of the traces
//  that are being generated by pin as the application executes.

#include "pin.H"
#include <iostream>
#include <iomanip>
#include <fstream>
#include <map>
#include <algorithm>
#include <assert.h>

using namespace std;

/* ================================================================== */
/* Global Data Structures                                             */
/* ================================================================== */

/* ================================================================== */
/* Information on every branch in a trace */
typedef struct BBL_INFO_STRUCT
{
    UINT32 ins_cnt;
    UINT32 exec_cnt;
    UINT32 code_size;
    UINT32 accum_code_size;
    UINT32 bbl_exit_cnt;

}                                       BBL_INFO;
typedef map<ADDRINT, BBL_INFO>          BBL_MAP;

/* ================================================================== */
/* Information on every trace produced by pin */
typedef struct TRACE_INFO_STRUCT
{
    UINT32 exec_cnt;
    UINT32 bbl_cnt;
    UINT32 ins_cnt;
    UINT32 fall_cnt;

    BBL_MAP  bbl_info;

}                                       TRACE_INFO;
typedef multimap <ADDRINT, TRACE_INFO>  TRACE_MAP;

/* ================================================================== */
TRACE_MAP   Trace_Information;
ofstream    OutFile ("traceusage.trace");

/* ================================================================== */
/*
 Inc. the counter for a trace when the trace is short and results
 in the program falling off the trace and into a new trace
*/
VOID TraceFall_Info(ADDRINT trace_addr)
{
    TRACE_MAP::iterator tr_it = Trace_Information.find(trace_addr);

    assert( tr_it == Trace_Information.end() );

    TRACE_INFO& tr_info = tr_it->second;
    tr_info.fall_cnt++;
}

/* ================================================================== */
/*
 Insert a new bbl record into the trace record
*/
VOID Bbl_Info(ADDRINT bbl_addr, UINT32 ins_cnt, ADDRINT trace_addr, UINT32 code_size, UINT32 accum_code_size)
{
    TRACE_MAP::iterator tr_it = Trace_Information.find(trace_addr);

    assert( tr_it != Trace_Information.end() );

    TRACE_INFO& tr_info = tr_it->second;
    BBL_MAP& Bbl_Information = tr_info.bbl_info;
    BBL_MAP::iterator bbl_it = Bbl_Information.find(bbl_addr);

    if (bbl_it == Bbl_Information.end())
    {
        BBL_INFO bbl_info;
        bbl_info.ins_cnt = ins_cnt;
        bbl_info.code_size = code_size;
        bbl_info.accum_code_size = accum_code_size;
        bbl_info.exec_cnt = 0;
        bbl_info.bbl_exit_cnt = 0;

        Bbl_Information.insert(make_pair(bbl_addr, bbl_info));
    }
}

/* ================================================================== */
/*
 Insert/Inc. the usage of bbls and the exit status of a bbl
*/
VOID BblExit_Info(ADDRINT bbl_addr, ADDRINT trace_addr)
{
    TRACE_MAP::iterator tr_it = Trace_Information.find(trace_addr);

    assert( tr_it != Trace_Information.end() );

    TRACE_INFO& tr_info = tr_it->second;
    BBL_MAP& Bbl_Information = tr_info.bbl_info;

    BBL_MAP::iterator bbl_it = Bbl_Information.begin();
    for (; bbl_it != Bbl_Information.end(); bbl_it++)
    {
        BBL_INFO& bbl_info = bbl_it->second;

        /* Inc usage of every bbl above the exit bbl for it is utilized */
        bbl_info.exec_cnt++;

        /* The exit bbl itself */
        if (bbl_addr == bbl_it->first)
        {
            bbl_info.bbl_exit_cnt++;
            return;
        }
    }

    assert( bbl_it != Bbl_Information.end() );
}

/* ================================================================== */
/*
 Insert/Inc. the usage of a trace
*/
VOID Trace_Info(ADDRINT trace_addr, UINT32 bbl_cnt, UINT32 ins_cnt)
{
    TRACE_MAP::iterator it = Trace_Information.find(trace_addr);

    // First visit
    if (it == Trace_Information.end())
    {
        TRACE_INFO tr_info;
        tr_info.bbl_cnt = bbl_cnt;
        tr_info.ins_cnt = ins_cnt;
        tr_info.exec_cnt = 0;

        Trace_Information.insert( make_pair(trace_addr, tr_info) );
    }
    else
    {
        it->second.exec_cnt++;
    }
}

/* ================================================================== */
/*
 Instrumentation function;
 Track the trace, the usage of the code in the bbls and the bbl exits
*/
VOID Trace(TRACE trace, VOID *v)
{
    /* Add trace to db */
    Trace_Info(TRACE_Address(trace),
               TRACE_NumBbl(trace),
               TRACE_NumIns(trace));

    /* Inc. trace execution count */
    TRACE_InsertCall(trace, IPOINT_BEFORE,
                     (AFUNPTR) Trace_Info,
                     IARG_ADDRINT, TRACE_Address(trace),
                     IARG_UINT32, TRACE_NumBbl(trace),
                     IARG_UINT32, TRACE_NumIns(trace),
                     IARG_END);

    USIZE accum_code_size = 0;
    for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl))
    {
        accum_code_size += BBL_Size(bbl);

        /* Add bbl to db */
        Bbl_Info(BBL_Address(bbl),
                    BBL_NumIns(bbl),
                    TRACE_Address(trace),
                    BBL_Size(bbl),
                    accum_code_size);

        INS ins = BBL_InsTail(bbl);

        if (INS_IsBranchOrCall(ins) || INS_IsRet(ins))
        {
            /* Inc. bbl exit count */
            INS_InsertCall(ins, IPOINT_TAKEN_BRANCH,
                           (AFUNPTR) BblExit_Info,
                           IARG_ADDRINT, BBL_Address(bbl),
                           IARG_ADDRINT, TRACE_Address(trace),
                           IARG_END);
        }
    }

    /* Trace falloff in the case the bbl is too big and does not
       necessarily end with a bbl terminating op                */
    INS ins = BBL_InsTail(TRACE_BblTail(trace));
    if (! INS_IsBranchOrCall(ins))
    {
        /* Inc. trace falloff exit count */
        INS_InsertCall(ins, IPOINT_BEFORE,
                       (AFUNPTR) TraceFall_Info,
                       IARG_ADDRINT, TRACE_Address(trace),
                       IARG_END);
    }
}

/* ================================================================== */
/*
 Print bbl exit info
*/
VOID PrintBblExit(pair<const ADDRINT, BBL_INFO> bbl_info)
{
    OutFile << hex << "0x" << bbl_info.first       << "\t"
            << setw(5)
            << dec << bbl_info.second.exec_cnt         << "\t"
            << setw(5)
            << dec << bbl_info.second.ins_cnt          << "\t"
            << setw(5)
            << dec << bbl_info.second.bbl_exit_cnt     << "\t"
            << setw(5)
            << dec << bbl_info.second.code_size        << "\t"
            << setw(5)
            << dec << bbl_info.second.accum_code_size  << "\t"
            << endl;
}

/* ================================================================== */
/*
 Print a trace
*/
VOID PrintTrace(pair<const ADDRINT, TRACE_INFO> trace_info)
{
    /* Trace information */
    OutFile << "==================================================================" << endl;
    OutFile << "Trace:" << "\t"
            << setw(10)
            << "# Exe"<< "\t"
            << setw(5)
            << "# Bbl"<< "\t"
            << setw(5)
            << "# Ins"<< "\t"
            << endl;
    OutFile << "==================================================================" << endl;

    OutFile << hex << "0x" << trace_info.first  << "\t"
            << setw(5)
            << dec << trace_info.second.exec_cnt << "\t"
            << setw(5)
            << dec << trace_info.second.bbl_cnt << "\t"
            << setw(5)
            << dec << trace_info.second.ins_cnt << "\t"
            << endl << endl;

    /* Bbl information */
    OutFile << "------------------------------------------------------------------" << endl;
    OutFile << "Bbl:"       << "\t"
            << setw(10)
            << "# Exe"    << "\t"
            << setw(5)
            << "# Ins"    << "\t"
            << setw(5)
            << "Exit"     << "\t"
            << setw(5)
            << "Size"     << "\t"
            << setw(5)
            << "ASize"    << "\t"
            << endl;
    OutFile << "------------------------------------------------------------------" << endl;

    BBL_MAP& Bbl_Information = trace_info.second.bbl_info;

    /* Bbl exit information */
    for_each(Bbl_Information.begin(), Bbl_Information.end(), PrintBblExit);

    OutFile << endl << endl;
}

/* ================================================================== */
/*
 Output the trace usage to a file
*/
VOID DumpTraceInfo(INT32 code, VOID *v)
{
    for_each(Trace_Information.begin(), Trace_Information.end(), PrintTrace);
}

/* ================================================================== */
/*
 Initialize and begin program execution under the control of Pin
*/
int main(INT32 argc, CHAR **argv)
{
    PIN_Init(argc, argv);

    TRACE_AddInstrumentFunction(Trace, 0);

    PIN_AddFiniFunction(DumpTraceInfo, 0);

    PIN_StartProgram();

    return 0;
}


An elegant Biedermeier style bookcase possibly by Valenti. Spain c1950. Faux burr wood paint effect on body with black ebonised column detail. Would work as a wall piece or stand alone within a room as it is decorated and finished at the back. The overall colour of the piece is less orange than appears in images.


text:
Conducting Genealogy Research in Hawaiʻi
This LibGuide was created for the "Conducting Genealogy Research in Hawaiʻi" presentation at Honolulu Community College on September 19, 2016.
This guide is available at...
Genealogy research how-to guides
Forms & Worksheets
No Ka Moʻokūʻauhau
Overview of Hawaiʻi Repositories
Birth, Death, and Marriage Records
bit.ly/mookuauhau
How-To Genealogy Research Guides
"Moʻokūʻauhau Researching Hawaiian Ancestry: A User-Friendly Beginner's Guidebook" by Jessica Wong (2011)
"A Research Manual on Information Access and Retrieval of Genealogical and Land Information From Government Repositories in the State of Hawaii" by The Reverend Joel Hulu Mahoe Resource Center
"Hawaii State Research Guide" by Ancestry.com
"Genealogical Resources for Hawaiʻi" by Hawaiʻi State Library (2011)
"Reference Sources to Hawaiian Genealogies" by Joan Hori (UHM Library) (2006)
1. Talk to your ʻohana
Your ʻohana is the most important resource when conducting any type of research related to genealogy. Be sure to start your research by interviewing family members about what they know, such as names, dates, and events.
2. Keep thorough notes
Be sure to use pedigree charts and/or family group records to keep track of names, dates, and relationships. Also be sure to use research calendars, research extracts, correspondence records, and/or source summary records to keep track of what you've done, where you've gone, and who you've talked to -- you don't want to have to repeat any portions of your work.
3. Context is important
When, where, and why play a huge role in how events happen and, consequently, the records left behind from those events. Did a street name change from 1901 to 2001? During the time of the overthrow and leading up to statehood, did mixed Hawaiian families identify Hawaiian as a nationality or not? Knowing a general overview of major historical events that occurred for the time periods that you're researching will really aid in your understanding of how and where to look for resources while you're searching.
4. Check for alternate names or spellings
Especially for names of family members. Check for both "Elizabeth" and "Lizzie." Also check for misspellings, e.g. "Kalo," "Kolo," "Kalu." Remember, too, that surnames changed for all kinds of reasons. Sometimes surnames became middle names or vice versa. Also, spellings changed over time: Gudmundsen --> Goodmanson --> Goodman.
5. Make copies & leave the master copy / original at home
You don't ever want to risk losing something. So make copies, take those with you when you visit different repositories, and leave the master copies at home.
Next: Forms & Worksheets >>
URL: https://guides.library.manoa.hawaii.edu/genealogyinhawaii


text:
Kate Groetzinger
Kate Groetzinger is an intern at KUT. She comes to us from Quartz, a digital media publication based in New York City, where she served as an Atlantic Media fellow. Prior to working at Quartz, Kate graduated from Brown University with a bachelor's degree in English. While at Brown, Kate served as an intern at Texas Monthly. Her work has been published online by Texas Monthly, CultureMap Austin, The Atlantic, Quartz, The Gotham Gazette, and Paste Magazine, and in print by Rhode Island Monthly. She is happy to be back in her home state reporting on news for her fellow Texans.
More Texas Inmates Are Getting High School Diplomas in Prison. Here's How.
By Kate Groetzinger • Oct 14, 2017
Stephanie Garcia is a high school student. She's also a 24-year-old inmate at the Lockhart Correctional Facility, a minimum-security women's prison in Central Texas. Outside, her life was hectic, but here, every day is the same.
Can Waco's Economic Boom Survive The End Of 'Fixer Upper?'
By Kate Groetzinger • Oct 3, 2017
"What goes up must come down" is Newton's Third Law of Motion – and part of a 1960s song that you may now have spinning in your head. But the truth of those words is being tested right now in Waco, Texas.
I can tell you from experience that as soon as something good happens in Waco, something else sets the city back again. But that pattern of ups and downs changed with the arrival of "Fixer Upper," the wildly popular HGTV show featuring local house-flipping team Chip and Joanna Gaines.
Bill Lets Pharmacists Refuse To Fill Prescriptions For Religious Reasons
By Kate Groetzinger • Jun 6, 2017
Pharmacists who refuse to fill prescriptions based on their religious beliefs may soon be protected from disciplinary action thanks to a bill passed this legislative session.
If You're Thinking of Calling Your Senator, Get Ready to Hold
By Kate Groetzinger • Feb 1, 2017
Republican lawmakers in Texas have been inundated with messages over the past few days from constituents both supportive and concerned with President Donald Trump's nominations and executive orders. So many people called into the Washington offices of Sens. Ted Cruz and John Cornyn over the weekend and Monday that staffers say they couldn't keep up, leaving constituents frustrated by busy signals and full voicemail boxes.
Did Texans Ever Vote in Large Numbers? Answering the Leftover Questions from TXDecides
Last week we launched TXDecides, our collaborative project with public radio newsrooms across the state. The goal was simple: Answer Texas voters' questions ahead of Election Day. Y'all had lots of questions. So many, in fact, that we had to pare down the questions to a scant five.
Luckily, we culled some of the remaining questions and decided to answer them as best we could.
Since 1972, Texas has had a lower voter turnout rate than the national rate for presidential elections.