ispc provides a standard variety of calls for trigonometric functions:
float sin(float x) uniform float sin(uniform float x) float cos(float x) uniform float cos(uniform float x) float tan(float x) uniform float tan(uniform float x)
The corresponding inverse functions are also available:
float asin(float x) uniform float asin(uniform float x) float acos(float x) uniform float acos(uniform float x) float atan(float x) uniform float atan(uniform float x) float atan2(float y, float x) uniform float atan2(uniform float y, uniform float x)
If both sine and cosine are needed, then the sincos() call computes both more efficiently than two calls to the respective individual functions:
void sincos(float x, varying float * uniform s, varying float * uniform c) void sincos(uniform float x, uniform float * uniform s, uniform float * uniform c)
The usual exponential and logarithmic functions are provided.
float exp(float x) uniform float exp(uniform float x) float log(float x) uniform float log(uniform float x) float pow(float a, float b) uniform float pow(uniform float a, uniform float b)
A few functions that end up doing low-level manipulation of the floating-point representation in memory are available. As in the standard math library, ldexp() multiplies the value x by 2^n, and frexp() directly returns the normalized mantissa and returns the normalized exponent as a power of two in the pw2 parameter.
float ldexp(float x, int n) uniform float ldexp(uniform float x, uniform int n) float frexp(float x, varying int * uniform pw2) uniform float frexp(uniform float x, uniform int * uniform pw2)
Saturating Arithmetic
A saturation (no overflow possible) addition, substraction, multiplication and division of all integer types are provided by the ispc standard library.
int8 saturating_add(uniform int8 a, uniform int8 b) int8 saturating_add(varying int8 a, varying int8 b) unsigned int8 saturating_add(uniform unsigned int8 a, uniform unsigned int8 b) unsigned int8 saturating_add(varying unsigned int8 a, varying unsigned int8 b) int8 saturating_sub(uniform int8 a, uniform int8 b) int8 saturating_sub(varying int8 a, varying int8 b) unsigned int8 saturating_sub(uniform unsigned int8 a, uniform unsigned int8 b) unsigned int8 saturating_sub(varying unsigned int8 a, varying unsigned int8 b) int8 saturating_mul(uniform int8 a, uniform int8 b) int8 saturating_mul(varying int8 a, varying int8 b) unsigned int8 saturating_mul(uniform unsigned int8 a, uniform unsigned int8 b) unsigned int8 saturating_mul(varying unsigned int8 a, varying unsigned int8 b) int8 saturating_div(uniform int8 a, uniform int8 b) int8 saturating_div(varying int8 a, varying int8 b) unsigned int8 saturating_div(uniform unsigned int8 a, uniform unsigned int8 b) unsigned int8 saturating_div(varying unsigned int8 a,varying unsigned int8 b)
In addition to the int8 variants of saturating arithmetic functions listed above, there are versions that supports int16, int32 and int64 values as well.
Pseudo-Random Numbers
A simple random number generator is provided by the ispc standard library. State for the RNG is maintained in an instance of the RNGState structure, which is seeded with seed_rng().
struct RNGState; void seed_rng(varying RNGState * uniform state, varying int seed) void seed_rng(uniform RNGState * uniform state, uniform int seed)
Note that if the same varying seed value is used for all of the program instances (e.g. RNGState state; seed_rng(&state, 1);), then all of the program instances in the gang will see the same sequence of pseudo-random numbers. If this behavior isn't desred, you may want to add the programIndex value to the provided seed or otherwise ensure that the seed has a unique value for each program instance.
After the RNG is seeded, the random() function can be used to get a pseudo-random unsigned int32 value and the frandom() function can be used to get a pseudo-random float value.
unsigned int32 random(varying RNGState * uniform state) float frandom(varying RNGState * uniform state) uniform unsigned int32 random(RNGState * uniform state) uniform float frandom(uniform RNGState * uniform state)
Random Numbers
Some recent CPUs (including those based on the Intel® Ivy Bridge micro-architecture), provide support for generating true random numbers. A few standard library functions make this functionality available:
bool rdrand(uniform int32 * uniform ptr) bool rdrand(varying int32 * uniform ptr) bool rdrand(uniform int32 * varying ptr)
If the processor doesn't have sufficient entropy to generate a random number, then this function fails and returns false. Otherwise, if the processor is successful, the random value is stored in the given pointer and true is returned. Therefore, this function should generally be used as follows, called repeatedly until it is successful:
int r; while (rdrand(&r) == false) ; // empty loop body
In addition to the int32 variants of rdrand() listed above, there are versions that return int16, float, and int64 values as well.
Note that when compiling to targets older than avx2, the rdrand() functions always return false.
Output Functions
ispc has a simple print statement for printing values during program execution. In the following short ispc program, there are three uses of the print statement:
export void foo(uniform float f[4], uniform int i) { float x = f[programIndex]; print("i = %, x = %\n", i, x); if (x < 2) { ++x; print("added to x = %\n", x); } print("last print of x = %\n", x); }
There are a few things to note. First, the function is called print, not printf (unlike C). Second, the formatting string passed to this function only uses a single percent sign to denote where the corresponding value should be printed. You don't need to match the types of formatting operators with the types being passed. However, you can't currently use the rich data formatting options that printf provides (e.g. constructs like %.10f.).
If this function is called with the array of floats (0,1,2,3) passed in for the f parameter and the value 10 for the i parameter, it generates the following output on a four-wide compilation target:
i = 10, x = [0.000000,1.000000,2.000000,3.000000] added to x = [1.000000,2.000000,((2.000000)),((3.000000))] last print of x = [1.000000,2.000000,2.000000,3.000000]
When a varying variable is printed, the values for program instances that aren't currently executing are printed inside double parenthesis, indicating inactive program instances. The elements for inactive program instances may have garbage values, though in some circumstances it can be useful to see their values.
Assertions
The ispc standard library includes a mechanism for adding assert() statements to ispc program code. Like assert() in C, the assert() function takes a single boolean expression as an argument. If the expression evaluates to false at runtime, then a diagnostic error message printed and the abort() function is called.
When called with a varying quantity, an assertion triggers if the expression evaluates to false for any of the executing program instances at the point where it is called. Thus, given code like:
int x = programIndex - 2; // (-2, -1, 0, ... ) if (x > 0) assert(x > 0);
The assert() statement will not trigger, since the condition isn't true for any of the executing program instances at that point. (If this assert() statement was outside of this if, then it would of course trigger.)
To disable all of the assertions in a file that is being compiled (e.g., for an optimized release build), use the --opt=disable-assertions command-line argument.
Cross-Program Instance Operations
ispc programs are often used to express independently-executing programs performing computation on separate data elements. (i.e. pure data-parallelism). However, it's often the case where it's useful for the program instances to be able to cooperate in computing results. The cross-lane operations described in this section provide primitives for communication between the running program instances in the gang.
The lanemask() function returns an integer that encodes which of the current SPMD program instances are currently executing. The i'th bit is set if the i'th program instance lane is currently active.
uniform int lanemask()
To broadcast a value from one program instance to all of the others, a broadcast() function is available. It broadcasts the value of the value parameter for the program instance given by index to all of the running program instances.
int8 broadcast(int8 value, uniform int index) int16 broadcast(int16 value, uniform int index) int32 broadcast(int32 value, uniform int index) int64 broadcast(int64 value, uniform int index) float broadcast(float value, uniform int index) double broadcast(double value, uniform int index)
The rotate() function allows each program instance to find the value of the given value that their neighbor offset steps away has. For example, on an 8-wide target, if value has the value (1, 2, 3, 4, 5, 6, 7, 8) across the gang of running program instances, then rotate(value, -1) causes the first program instance to get the value 8, the second program instance to get the value 1, the third 2, and so forth. The provided offset value can be positive or negative, and may be greater than the size of the gang (it is masked to ensure valid offsets).
int8 rotate(int8 value, uniform int offset) int16 rotate(int16 value, uniform int offset) int32 rotate(int32 value, uniform int offset) int64 rotate(int64 value, uniform int offset) float rotate(float value, uniform int offset) double rotate(double value, uniform int offset)
The shift() function allows each program instance to find the value of the given value that their neighbor offset steps away has. This is similar to rotate() with the exception that values are not circularly shifted. Instead, zeroes are shifted in where appropriate.
int8 shift(int8 value, uniform int offset) int16 shift(int16 value, uniform int offset) int32 shift(int32 value, uniform int offset) int64 shift(int64 value, uniform int offset) float shift(float value, uniform int offset) double shift(double value, uniform int offset)
Finally, the shuffle() functions allow two variants of fully general shuffling of values among the program instances. For the first version, each program instance's value of permutation gives the program instance from which to get the value of value. The provided values for permutation must all be between 0 and the gang size.
int8 shuffle(int8 value, int permutation) int16 shuffle(int16 value, int permutation) int32 shuffle(int32 value, int permutation) int64 shuffle(int64 value, int permutation) float shuffle(float value, int permutation) double shuffle(double value, int permutation)
The second variant of shuffle() permutes over the extended vector that is the concatenation of the two provided values. In other words, a value of 0 in an element of permutation corresponds to the first element of value0, the value of two times the gang size, minus one corresponds to the last element of value1, etc.)
int8 shuffle(int8 value0, int8 value1, int permutation) int16 shuffle(int16 value0, int16 value1, int permutation) int32 shuffle(int32 value0, int32 value1, int permutation) int64 shuffle(int64 value0, int64 value1, int permutation) float shuffle(float value0, float value1, int permutation) double shuffle(double value0, double value1, int permutation)
Finally, there are primitive operations that extract and set values in the SIMD lanes. You can implement all of the broadcast, rotate, shift, and shuffle operations described above in this section from these routines, though in general, not as efficiently. These routines are useful for implementing other reductions and cross-lane communication that isn't included in the above, though. Given a varying value, extract() returns the i'th element of it as a single uniform value. .
uniform bool extract(bool x, uniform int i) uniform int8 extract(int8 x, uniform int i) uniform int16 extract(int16 x, uniform int i) uniform int32 extract(int32 x, uniform int i) uniform int64 extract(int64 x, uniform int i) uniform float extract(float x, uniform int i)
Similarly, insert returns a new value where the i th element of x has been replaced with the value v
bool insert(bool x, uniform int i, uniform bool v) int8 insert(int8 x, uniform int i, uniform int8 v) int16 insert(int16 x, uniform int i, uniform int16 v) int32 insert(int32 x, uniform int i, uniform int32 v) int64 insert(int64 x, uniform int i, uniform int64 v) float insert(float x, uniform int i, uniform float v)
Reductions
A number of routines are available to evaluate conditions across the running program instances. For example, any() returns true if the given value v is true for any of the SPMD program instances currently running, all() returns true if it true for all of them, and none() returns true if v is always false.
uniform bool any(bool v) uniform bool all(bool v) uniform bool none(bool v)
You can also compute a variety of reductions across the program instances. For example, the values of the given value in each of the active program instances are added together by the reduce_add() function.
uniform int16 reduce_add(int8 x) uniform unsigned int16 reduce_add(unsigned int8 x) uniform int32 reduce_add(int16 x) uniform unsigned int32 reduce_add(unsigned int16 x) uniform int64 reduce_add(int32 x) uniform unsigned int64 reduce_add(unsigned int32 x) uniform int64 reduce_add(int64 x) uniform unsigned int64 reduce_add(unsigned int64 x) uniform float reduce_add(float x) uniform double reduce_add(double x)
You can also use functions to compute the minimum value of the given value across all of the currently-executing program instances.
uniform int32 reduce_min(int32 a) uniform unsigned int32 reduce_min(unsigned int32 a) uniform int64 reduce_min(int64 a) uniform unsigned int64 reduce_min(unsigned int64 a) uniform float reduce_min(float a) uniform double reduce_min(double a)
Equivalent functions are available to comptue the maximum of the given varying variable over the active program instances.
uniform int32 reduce_max(int32 a) uniform unsigned int32 reduce_max(unsigned int32 a) uniform int64 reduce_max(int64 a) uniform unsigned int64 reduce_max(unsigned int64 a) uniform float reduce_max(float a) uniform double reduce_max(double a)
Finally, you can check to see if a particular value has the same value in all of the currently-running program instances:
uniform bool reduce_equal(int32 v) uniform bool reduce_equal(unsigned int32 v) uniform bool reduce_equal(int64 v) uniform bool reduce_equal(unsigned int64 v) uniform bool reduce_equal(float v) uniform bool reduce_equal(double)
There are also variants of these functions that return the value as a uniform in the case where the values are all the same. (There is discussion of an application of this variant to improve memory access performance in the Performance Guide.
uniform bool reduce_equal(int32 v, uniform int32 * uniform sameval) uniform bool reduce_equal(unsigned int32 v, uniform unsigned int32 * uniform sameval) uniform bool reduce_equal(int64 v, uniform int64 * uniform sameval) uniform bool reduce_equal(unsigned int64 v, uniform unsigned int64 * uniform sameval) uniform bool reduce_equal(float v, uniform float * uniform sameval) uniform bool reduce_equal(double, uniform double * uniform sameval)
If called when none of the program instances are running, reduce_equal() will return false.
There are also a number of functions to compute "scan"s of values across the program instances. For example, the exclusive_scan_add() function computes, for each program instance, the sum of the given value over all of the preceding program instances. (The scans currently available in ispc are all so-called "exclusive" scans, meaning that the value computed for a given element does not include the value provided for that element.) In C code, an exclusive add scan over an array might be implemented as:
void scan_add(int *in_array, int *result_array, int count) { result_array[0] = 0; for (int i = 1; i < count; ++i) result_array[i] = result_array[i-1] + in_array[i-1]; }
ispc provides the following scan functions--addition, bitwise-and, and bitwise-or are available:
int32 exclusive_scan_add(int32 v) unsigned int32 exclusive_scan_add(unsigned int32 v) float exclusive_scan_add(float v) int64 exclusive_scan_add(int64 v) unsigned int64 exclusive_scan_add(unsigned int64 v) double exclusive_scan_add(double v) int32 exclusive_scan_and(int32 v) unsigned int32 exclusive_scan_and(unsigned int32 v) int64 exclusive_scan_and(int64 v) unsigned int64 exclusive_scan_and(unsigned int64 v) int32 exclusive_scan_or(int32 v) unsigned int32 exclusive_scan_or(unsigned int32 v) int64 exclusive_scan_or(int64 v) unsigned int64 exclusive_scan_or(unsigned int64 v)
The returned value for the first program instance will be 0 for exclusive_scan_add and exclusive_scan_or, and have all bits set to 1 for exclusive_scan_and.
The use of exclusive scan to generate variable amounts of output from program instances into a compact output buffer is discussed in the FAQ.
Data Movement
Setting and Copying Values In Memory
There are a few functions for copying blocks of memory and initializing values in memory. Along the lines of the equivalently-named routines in the C Standard libary, memcpy copies a given number of bytes starting from a source location in memory to a destination locaiton, where the two regions of memory are guaranteed by the caller to be non-overlapping. Alternatively, memmove can be used to copy data if the buffers may overlap.
void memcpy(void * uniform dst, void * uniform src, uniform int32 count) void memmove(void * uniform dst, void * uniform src, uniform int32 count) void memcpy(void * varying dst, void * varying src, int32 count) void memmove(void * varying dst, void * varying src, int32 count)
Note that there are variants of these functions that take both uniform and varying pointers. Also note that sizeof(float) and sizeof(uniform float) return different values, so programmers should take care when calculating count.
To initialize values in memory, the memset routine can be used. (It also behaves like the function of the same name in the C Standard Library.) It sets the given number of bytes of memory starting at the given location to the value provided.
void memset(void * uniform ptr, uniform int8 val, uniform int32 count) void memset(void * varying ptr, int8 val, int32 count)
There are also variants of all of these functions that take 64-bit values for the number of bytes of memory to operate on:
void memcpy64(void * uniform dst, void * uniform src, uniform int64 count) void memcpy64(void * varying dst, void * varying src, int64 count) void memmove64(void * uniform dst, void * uniform src, uniform int64 count) void memmove64(void * varying dst, void * varying src, int64 count) void memset64(void * uniform ptr, uniform int8 val, uniform int64 count) void memset64(void * varying ptr, int8 val, int64 count)
Packed Load and Store Operations
The standard library also offers routines for writing out and reading in values from linear memory locations for the active program instances. The packed_load_active() functions load consecutive values starting at the given location, loading one consecutive value for each currently-executing program instance and storing it into that program instance's val variable. They return the total number of values loaded.
uniform int packed_load_active(uniform int * uniform base, varying int * uniform val) uniform int packed_load_active(uniform unsigned int * uniform base, varying unsigned int * uniform val)
Similarly, the packed_store_active() functions store the val values for each program instances that executed the packed_store_active() call, storing the results consecutively starting at the given location. They return the total number of values stored.
uniform int packed_store_active(uniform int * uniform base, int val) uniform int packed_store_active(uniform unsigned int * uniform base, unsigned int val)
There are also packed_store_active2() functions with exactly the same signatures and the same semantic except that they may write one extra element to the output array (but still returning the same value as packed_store_active()). These functions suggest different branch free implementation on most of supported targets, which usually (but not always) performs better than packed_store_active(). It's advised to test function performance on user's scenarios on particular target hardware before using it.
As an example of how these functions can be used, the following code shows the use of packed_store_active().
uniform int negative_indices(uniform float a[], uniform int length, uniform int indices[]) { uniform int numNeg = 0; foreach (i = 0 ... length) { if (a[i] < 0.) numNeg += packed_store_active(&indices[numNeg], i); } return numNeg; }
The function takes an array of floating point values a, with length given by the length parameter. This function also takes an output array, indices, which is assumed to be at least as long as length. It then loops over all of the elements of a and, for each element that is less than zero, stores that element's offset into the indices array. It returns the total number of negative values. For example, given an input array a[8] = { 10, -20, 30, -40, -50, -60, 70, 80 }, it returns a count of four negative values, and initializes the first four elements of indices[] to the values { 1, 3, 4, 5 } corresponding to the array indices where a[i] was less than zero.
Streaming Load and Store Operations
The standard library offers routines for streaming load and streaming store operations. The implementation serves as both a streaming as well as a non-temporal operation. There are separate routines to be used depending on whether loading from and storing to a uniform variable or a varying variable.
The different available variants of streaming store are given below.

For loading as varying from array:
varying unsigned int8 streaming_load(uniform unsigned int8 a[]) varying int8 streaming_load(uniform int8 a[]) varying unsigned int16 streaming_load(uniform unsigned int16 a[]) varying int16 streaming_load(uniform int16 a[]) varying unsigned int streaming_load(uniform unsigned int a[]) varying int streaming_load(uniform int a[]) varying unsigned int64 streaming_load(uniform unsigned int64 a[]) varying int64 streaming_load(uniform int64 a[]) varying float streaming_load(uniform float a[]) varying double streaming_load(uniform double a[])
For loading as uniform from array:
uniform unsigned int8 streaming_load_uniform(uniform unsigned int8 a[]) uniform int8 streaming_load_uniform(uniform int8 a[]) uniform unsigned int16 streaming_load_uniform(uniform unsigned int16 a[]) uniform int16 streaming_load_uniform(uniform int16 a[]) uniform unsigned int streaming_load_uniform(uniform unsigned int a[]) uniform int streaming_load_uniform(uniform int a[]) uniform unsigned int64 streaming_load_uniform(uniform unsigned int64 a[]) uniform int64 streaming_load_uniform(uniform int64 a[]) uniform float streaming_load_uniform(uniform float a[]) uniform double streaming_load_uniform(uniform double a[])
Data Conversions
Converting Between Array-of-Structures and Structure-of-Arrays Layout
Applications often lay data out in memory in "array of structures" form. Though convenient in C/C++ code, this layout can make ispc programs less efficient than they would be if the data was laid out in "structure of arrays" form. (See the section Use "Structure of Arrays" Layout When Possible in the performance guide for extended discussion of this topic.)
The standard library does provide a few functions that efficiently convert between these two formats, for cases where it's not possible to change the application to use "structure of arrays layout". Consider an array of 3D (x,y,z) position data laid out in a C array like:
// C++ code float pos[] = { x0, y0, z0, x1, y1, z1, x2, ... };
In an ispc program, we might want to load a set of (x,y,z) values and do a computation based on them. The natural expression of this:
extern uniform float pos[]; uniform int base = ...; float x = pos[base + 3 * programIndex]; // x = { x0 x1 x2 ... } float y = pos[base + 1 + 3 * programIndex]; // y = { y0 y1 y2 ... } float z = pos[base + 2 + 3 * programIndex]; // z = { z0 z1 z2 ... }
leads to irregular memory accesses and reduced performance. Alternatively, the aos_to_soa3() standard library function could be used:
extern uniform float pos[]; uniform int base = ...; float x, y, z; aos_to_soa3(&pos[base], &x, &y, &z);
This routine loads three times the gang size values from the given array starting at the given offset, returning three varying results. There are int32, int64, float and double variants of this function:
void aos_to_soa3(uniform float a[], varying float * uniform v0, varying float * uniform v1, varying float * uniform v2) void aos_to_soa3(uniform int32 a[], varying int32 * uniform v0, varying int32 * uniform v1, varying int32 * uniform v2) void aos_to_soa3(uniform double a[], varying double * uniform v0, varying double * uniform v1, varying double * uniform v2) void aos_to_soa3(uniform int64 a[], varying int64 * uniform v0, varying int64 * uniform v1, varying int64 * uniform v2)
After computation is done, corresponding functions convert back from the SoA values in ispc varying variables and write the values back to the given array, starting at the given offset.
extern uniform float pos[]; uniform int base = ...; float x, y, z; aos_to_soa3(&pos[base], &x, &y, &z); // do computation with x, y, z soa_to_aos3(x, y, z, &pos[base]);
void soa_to_aos3(float v0, float v1, float v2, uniform float a[]) void soa_to_aos3(int32 v0, int32 v1, int32 v2, uniform int32 a[]) void soa_to_aos3(double v0, double v1, double v2, uniform double a[]) void soa_to_aos3(int64 v0, int64 v1, int64 v2, uniform int64 a[])
There are also variants of these functions that convert 4-wide values between AoS and SoA layouts. In other words, aos_to_soa4() converts AoS data in memory laid out like r0 g0 b0 a0 r1 g1 b1 a1 ... to four varying variables with values r0 r1..., g0 g1..., b0 b1..., and a0 a1..., reading a total of four times the gang size values from the given array, starting at the given offset.
void aos_to_soa4(uniform float a[], varying float * uniform v0, varying float * uniform v1, varying float * uniform v2, varying float * uniform v3) void aos_to_soa4(uniform int32 a[], varying int32 * uniform v0, varying int32 * uniform v1, varying int32 * uniform v2, varying int32 * uniform v3) void soa_to_aos4(float v0, float v1, float v2, float v3, uniform float a[]) void soa_to_aos4(int32 v0, int32 v1, int32 v2, int32 v3, uniform int32 a[])
Conversions To and From Half-Precision Floats
There are functions to convert to and from the IEEE 16-bit floating-point format. Note that there is no half data-type, and it isn't possible to do floating-point math directly with half types in ispc; these functions facilitate converting to and from half-format data in memory.
To use them, half-format data should be loaded into an int16 and the half_to_float() function used to convert it to a 32-bit floating point value. To store a value to memory in half format, the float_to_half() function returns the 16 bits that are the closest match to the given float, in half format.
float half_to_float(unsigned int16 h) uniform float half_to_float(uniform unsigned int16 h) int16 float_to_half(float f) uniform int16 float_to_half(uniform float f)
There are also faster versions of these functions that don't worry about handling floating point infinity, "not a number" and denormalized numbers correctly. These are faster than the above functions, but are less precise.
float half_to_float_fast(unsigned int16 h) uniform float half_to_float_fast(uniform unsigned int16 h) int16 float_to_half_fast(float f) uniform int16 float_to_half_fast(uniform float f)
Converting to sRGB8
The sRGB color space is used in many applications in graphics and imaging; see the Wikipedia page on sRGB for more information. The ispc standard library provides two functions for converting floating-point color values to 8-bit values in the sRGB space.
int float_to_srgb8(float v) uniform int float_to_srgb8(uniform float v)
Systems Programming Support
Atomic Operations and Memory Fences
The standard set of atomic memory operations are provided by the standard library, including variants to handle both uniform and varying types as well as "local" and "global" atomics.
Local atomics provide atomic behavior across the program instances in a gang, but not across multiple gangs or memory operations in different hardware threads. To see why they are needed, consider a histogram calculation where each program instance in the gang computes which bucket a value lies in and then increments a corresponding counter. If the code is written like this:
uniform int count[N_BUCKETS] = ...; float value = ...; int bucket = clamp(value / N_BUCKETS, 0, N_BUCKETS); ++count[bucket]; // ERROR: undefined behavior if collisions
then the program's behavior is undefined: whenever multiple program instances have values that map to the same value of bucket, then the effect of the increment is undefined. (See the discussion in the Data Races Within a Gang section; in the case here, there isn't a sequence point between one program instance updating count[bucket] and the other program instance reading its value.)
The atomic_add_local() function can be used in this case; as a local atomic it is atomic across the gang of program instances, such that the expected result is computed.
... int bucket = clamp(value / N_BUCKETS, 0, N_BUCKETS); atomic_add_local(&count[bucket], 1);
It uses this variant of the 32-bit integer atomic add routine:
int32 atomic_add_local(uniform int32 * uniform ptr, int32 delta)
The semantics of this routine are typical for an atomic add function: the pointer here points to a single location in memory (the same one for all program instances), and for each executing program instance, the value stored in the location that ptr points to has that program instance's value "delta" added to it atomically, and the old value at that location is returned from the function.
One thing to note is that the type of the value being added to is a uniform integer, while the increment amount and the return value are varying. In other words, the semantics of this call are that each running program instance individually issues the atomic operation with its own delta value and gets the previous value back in return. The atomics for the running program instances may be issued in arbitrary order; it's not guaranteed that they will be issued in programIndex order, for example.
Global atomics are more powerful than local atomics; they are atomic across both the program instances in the gang as well as atomic across different gangs and different hardware threads. For example, for the global variant of the atomic used above,
int32 atomic_add_global(uniform int32 * uniform ptr, int32 delta)
if multiple processors simultaneously issue atomic adds to the same memory location, the adds will be serialized by the hardware so that the correct result is computed in the end.
Here are the declarations of the int32 variants of these functions. There are also int64 equivalents as well as variants that take unsigned int32 and int64 values.
int32 atomic_add_{local,global}(uniform int32 * uniform ptr, int32 value) int32 atomic_subtract_{local,global}(uniform int32 * uniform ptr, int32 value) int32 atomic_min_{local,global}(uniform int32 * uniform ptr, int32 value) int32 atomic_max_{local,global}(uniform int32 * uniform ptr, int32 value) int32 atomic_and_{local,global}(uniform int32 * uniform ptr, int32 value) int32 atomic_or_{local,global}(uniform int32 * uniform ptr, int32 value) int32 atomic_xor_{local,global}(uniform int32 * uniform ptr, int32 value) int32 atomic_swap_{local,global}(uniform int32 * uniform ptr, int32 value)
Support for float and double types is also available. For local atomics, all but the logical operations are available. (There are corresponding double variants of these, not listed here.)
float atomic_add_local(uniform float * uniform ptr, float value) float atomic_subtract_local(uniform float * uniform ptr, float value) float atomic_min_local(uniform float * uniform ptr, float value) float atomic_max_local(uniform float * uniform ptr, float value) float atomic_swap_local(uniform float * uniform ptr, float value)
For global atomics, only atomic swap is available for these types:
float atomic_swap_global(uniform float * uniform ptr, float value) double atomic_swap_global(uniform double * uniform ptr, double value)
Finally, "swap" (but none of these other atomics) is available for pointer types:
void *atomic_swap_{local,global}(void * * uniform ptr, void * value)
There are also variants of the atomic that take uniform values for the operand and return a uniform result. These correspond to a single atomic operation being performed for the entire gang of program instances, rather than one per program instance.
uniform int32 atomic_add_{local,global}(uniform int32 * uniform ptr, uniform int32 value) uniform int32 atomic_subtract_{local,global}(uniform int32 * uniform ptr, uniform int32 value) uniform int32 atomic_min_{local,global}(uniform int32 * uniform ptr, uniform int32 value) uniform int32 atomic_max_{local,global}(uniform int32 * uniform ptr, uniform int32 value) uniform int32 atomic_and_{local,global}(uniform int32 * uniform ptr, uniform int32 value) uniform int32 atomic_or_{local,global}(uniform int32 * uniform ptr, uniform int32 value) uniform int32 atomic_xor_{local,global}(uniform int32 * uniform ptr, uniform int32 value) uniform int32 atomic_swap_{local,global}(uniform int32 * uniform ptr, uniform int32 newval)
And similarly for pointers:
uniform void *atomic_swap_{local,global}(void * * uniform ptr, void *newval)
Be careful that you use the atomic function that you mean to; consider the following code:
extern uniform int32 counter; int32 myCounter = atomic_add_global(&counter, 1);
One might write code like this with the intent that each running program instance increments the counter by one and gets the old value of the counter (for example, to store results into unique locations in an array). However, the above code calls the second variant of atomic_add_global(), which takes a uniform int value to add to the counter and only performs one atomic operation. The counter will be increased by just one, and all program instances will receive the same value back (thanks to the uniform int32 return value being silently converted to a varying int32.) Writing the code this way, for example, will cause the desired atomic add function to be called.
extern uniform int32 counter; int32 myCounter = atomic_add_global(&counter, (varying int32)1);
There is a third variant of each of these atomic functions that takes a varying pointer; this allows each program instance to issue an atomic operation to a possibly-different location in memory. (Of course, the proper result is still returned if some or all of them happen to point to the same location in memory!)
int32 atomic_add_{local,global}(uniform int32 * varying ptr, int32 value) int32 atomic_subtract_{local,global}(uniform int32 * varying ptr, int32 value) int32 atomic_min_{local,global}(uniform int32 * varying ptr, int32 value) int32 atomic_max_{local,global}(uniform int32 * varying ptr, int32 value) int32 atomic_and_{local,global}(uniform int32 * varying ptr, int32 value) int32 atomic_or_{local,global}(uniform int32 * varying ptr, int32 value) int32 atomic_xor_{local,global}(uniform int32 * varying ptr, int32 value) int32 atomic_swap_{local,global}(uniform int32 * varying ptr, int32 value)
And:
void *atomic_swap_{local,global}(void * * ptr, void *value)
There are also atomic "compare and exchange" functions. Compare and exchange atomically compares the value in "val" to "compare"--if they match, it assigns "newval" to "val". In either case, the old value of "val" is returned. (As with the other atomic operations, there are also unsigned and 64-bit variants of this function. Furthermore, there are float, double, and void * variants as well.)
int32 atomic_compare_exchange_{local,global}(uniform int32 * uniform ptr, int32 compare, int32 newval) uniform int32 atomic_compare_exchange_{local,global}(uniform int32 * uniform ptr, uniform int32 compare, uniform int32 newval)
ispc also has a standard library routine that inserts a memory barrier into the code; it ensures that all memory reads and writes prior to be barrier complete before any reads or writes after the barrier are issued. See the Linux kernel documentation on memory barriers for an excellent writeup on the need for and the use of memory barriers in multi-threaded code.
void memory_barrier();
Note that this barrier is not needed for coordinating reads and writes among the program instances in a gang; it's only needed for coordinating between multiple hardware threads running on different cores. See the section Data Races Within a Gang for the guarantees provided about memory read/write ordering across a gang.
Prefetches
The standard library has a variety of functions to prefetch data into the processor's cache. While modern CPUs have automatic prefetchers that do a reasonable job of prefetching data to the cache before its needed, high performance applications may find it helpful to prefetch data before it's needed.
For example, this code shows how to prefetch data to the processor's L1 cache while iterating over the items in an array.
uniform int32 array[...]; for (uniform int i = 0; i < count; ++i) { // do computation with array[i] prefetch_l1(&array[i+32]); }
The standard library has routines to prefetch to the L1, L2, and L3 caches. It also has a variant, prefetch_nt(), that indicates that the value being prefetched isn't expected to be used more than once (so should be high priority to be evicted from the cache). Furthermore, it has versions of these functions that take both uniform and varying pointer types.
void prefetch_{l1,l2,l3,nt}(void * uniform ptr) void prefetch_{l1,l2,l3,nt}(void * varying ptr)
System Information
The value of a high-precision hardware clock counter is returned by the clock() routine; its value increments by one each processor cycle. Thus, taking the difference between the values returned by clock() at different points in program execution gives the number of cycles between those points in the program.
uniform int64 clock()
Note that clock() flushes the processor pipeline. It has an overhead of a hundred or so cycles, so for very fine-grained measurements, it may be worthwhile to measure the cost of calling clock() and subtracting that value from reported results.
A routine is also available to find the number of CPU cores available in the system:
uniform int num_cores()
This value can be useful for adapting the granularity of parallel task decomposition depending on the number of processors in the system.
Interoperability with the Application
One of ispc's key goals is to make it easy to interoperate between the C/C++ application code and parallel code written in ispc. This section describes the details of how this works and describes a number of the pitfalls.
Interoperability Overview
As described in Compiling and Running a Simple ISPC Program it's relatively straightforward to call ispc code from C/C++. First, any ispc functions to be called should be defined with the export keyword:
export void foo(uniform float a[]) { ... }
This function corresponds to the following C-callable function:
void foo(float a[]);
(Recall from the "uniform" and "varying" Qualifiers section that uniform types correspond to a single instances of the corresponding type in C/C++.)
In addition to variables passed from the application to ispc in the function call, you can also share global variables between the application and ispc. To do so, just declare the global variable as usual (in either ispc or application code), and add an extern declaration on the other side.
For example, given this ispc code:
// ispc code uniform float foo; extern uniform float bar[10];
And this C++ code:
// C++ code extern "C" { extern float foo; float bar[10]; }
Both the foo and bar global variables can be accessed on each side. Note that the extern "C" declaration is necessary from C++, since ispc uses C linkage for functions and globals.
ispc code can also call back to C/C++. On the ispc side, any application functions to be called must be declared with the extern "C" qualifier.
extern "C" void foo(uniform float f, uniform float g);
Unlike in C++, extern "C" doesn't take braces to delineate multiple functions to be declared; thus, multiple C functions to be called from ispc must be declared as follows:
extern "C" void foo(uniform float f, uniform float g); extern "C" uniform int bar(uniform int a);
It is illegal to overload functions declared with extern "C" linkage; ispc issues an error in this case.
Functions declared with extern "C" linkage can be made to follow __vectorcall calling convention on Windows by using __vectorcall qualifier.
extern "C" __vectorcall void foo(uniform float f, uniform float g);
__vectorcall can only be used for extern "C" function declarations and on Windows OS.
Only a single function call is made back to C++ for the entire gang of running program instances. Furthermore, function calls back to C/C++ are not made if none of the program instances want to make the call. For example, given code like:
uniform float foo = ...; float x = ...; if (x != 0) foo = appFunc(foo);
appFunc() will only be called if one or more of the running program instances evaluates true for x != 0. If the application code would like to determine which of the running program instances want to make the call, a mask representing the active SIMD lanes can be passed to the function.
extern "C" float appFunc(uniform float x, uniform int activeLanes);
If the function is then called as:
... x = appFunc(x, lanemask());
The activeLanes parameter will have the value one in the 0th bit if the first program instance is running at this point in the code, one in the first bit for the second instance, and so forth. (The lanemask() function is documented in Cross-Program Instance Operations.) Application code can thus be written as:
float appFunc(float x, int activeLanes) { for (int i = 0; i < programCount; ++i) if ((activeLanes & (1 << i)) != 0) { // do computation for i'th SIMD lane } }
In some cases, it can be desirable to generate a single call for each executing program instance, rather than one call for a gang. For example, the code below shows how one might call an existing math library routine that takes a scalar parameter.
extern "C" uniform double erf(uniform double); double v = ...; double result; foreach_active (instance) { uniform double r = erf(extract(v, instance)); result = insert(result, instance, r); }
This code calls erf() once for each active program instance, passing it the program instance's value of v and storing the result in the instance's result value.
Data Layout
In general, ispc tries to ensure that struct types and other complex datatypes are laid out in the same way in memory as they are in C/C++. Matching structure layout is important for easy interoperability between C/C++ code and ispc code.
The main complexity in sharing data between ispc and C/C++ often comes from reconciling data structures between ispc code and application code; it can be useful to declare the shared structures in ispc code and then examine the generated header file (which will have the C/C++ equivalents of them.) For example, given a structure in ispc:
// ispc code struct Node { int count; float pos[3]; };
If a uniform Node structure is used in the parameters to an export ed function, then the header file generated by the ispc compiler will have a declaration like:
// C/C++ code struct Node { int count; float pos[3]; };
Because varying types have size that depends on the size of the gang of program instances, ispc has restrictrictions on using varying types in parameters to functions with the export qualifier. ispc prohibits parameters to exported functions to have varying type unless the parameter is of pointer type. (That is, varying float isn't allowed, but varying float * uniform (uniform pointer to varying float) is permitted.) Care must be taken by the programmer to ensure that the data being accessed through any pointers to varying data has the correct organization.
Similarly, struct types shared with the application can also have embedded pointers.
// C code struct Foo { float *foo, *bar; };
On the ispc side, the corresponding struct declaration is:
// ispc struct Foo { float * uniform foo, * uniform bar; };
If a pointer to a varying struct type appears in an exported function, the generated header file will have a definition like (for 8-wide SIMD):
// C/C++ code struct Node { int count[8]; float pos[3][8]; };
In the case of multiple target compilation, ispc will generate multiple header files and a "general" header file with definitions for multiple sizes. Any pointers to varyings in exported functions will be rewritten as void *. At runtime, the ispc dispatch mechanism will cast these pointers to the appropriate types. Programmers can provide C/C++ code with a mechanism to determine the gang width used at runtime by ispc by creating an exported function that simply returns the value of programCount. An example of such a function is provided in the file examples/util/util.isph included in the ispc distribution.
There is one subtlety related to data layout to be aware of: ispc stores uniform short-vector types in memory with their first element at the machine's natural vector alignment (i.e. 16 bytes for a target that is using Intel® SSE, and so forth.) This implies that these types will have different layout on different compilation targets. As such, applications should in general avoid accessing uniform short vector types from C/C++ application code if possible.
Data Alignment and Aliasing
There are two important constraints that must be adhered to when passing pointers from the application to ispc programs.
The first is that it is required that it be valid to read memory at the first element of any array that is passed to ispc. In practice, this should just happen naturally, but it does mean that it is illegal to pass a NULL pointer as a parameter to a ispc function called from the application.
The second constraint is that pointers and references in ispc programs must not alias. The ispc compiler assumes that different pointers can't end up pointing to the same memory location, either due to having the same initial value, or through array indexing in the program as it executed.
This aliasing constraint also applies to reference parameters to functions. Given a function like:
void func(int &a, int &b) { a = 0; if (b == 0) { ... } }
Then the same variable must not be passed to func(). This is another case of aliasing, and if the caller calls the function as func(x, x), it's not guaranteed that the if test will evaluate to true, due to the compiler's requirement of no aliasing.
(In the future, ispc will have a mechanism to indicate that pointers may alias.)
Restructuring Existing Programs to Use ISPC
ispc is designed to enable you to incorporate SPMD parallelism into existing code with minimal modification; features like the ability to share memory and data structures between C/C++ and ispc code and the ability to directly call back and forth between ispc and C/C++ are motivated by this. These features also make it easy to incrementally transform a program to use ispc; the most computationally-intensive localized parts of the computation can be transformed into ispc code while the remainder of the system is left as is.
For a given section of code to be transitioned to run in ispc, the next question is how to parallelize the computation. Generally, there will be obvious loops inside which a large amount of computation is done ("for each ray", "for each pixel", etc.) Mapping these to the SPMD computational style is often effective.
Carefully choose how to do the exact mapping of computation to SPMD program instances. This choice can impact the mix of gather/scatter memory access versus coherent memory access, for example. (See more on this topic in the ispc Performance Tuning Guide.) This decision can also impact the coherence of control flow across the running SPMD program instances, which can also have a significant effect on performance; in general, creating groups of work that will tend to do similar computation across the SPMD program instances improves performance.
Notices & Disclaimers
Performance varies by use, configuration and other factors. Learn more at www.intel.com/PerformanceIndex.


Module UnoModule
Package com.unoapp.uno.ui.drawables
package com.unoapp.uno.ui.drawables
-
ClassDescriptionThis class has been automatically generated using Flamingo SVG transcoder.This class has been automatically generated using Flamingo SVG transcoder.This class has been automatically generated using Flamingo SVG transcoder.This class has been automatically generated using Flamingo SVG transcoder.This class has been automatically generated using Flamingo SVG transcoder.This class has been automatically generated using Flamingo SVG transcoder.This class has been automatically generated using Flamingo SVG transcoder.This class has been automatically generated using Flamingo SVG transcoder.This class has been automatically generated using Flamingo SVG transcoder.This class has been automatically generated using Flamingo SVG transcoder.This class has been automatically generated using Flamingo SVG transcoder.This class has been automatically generated using Flamingo SVG transcoder.This class has been automatically generated using Flamingo SVG transcoder.


TreeView / Sorting
This sample demonstrates how to sort TreeView items in ascending or descending order. By clicking on buttons on right panel, you can see how items are sorted.
The following properties and methods are presented:
- sorting a property which determines the sort order
- sort a method which sorts the TreeView items based on applied order
Sorting is performed using the item text, but if item has its value field set (it has higher priority than text), the value will be used.
Although in this sample a basic sorting is used (a sorting of string values), you can create your own custom sorting by providing a comparer function as a third parameter of the sort method. In this way you can create any kind of custom sort operations.


You heard it right! ATLX is coming back in force, after a five year hiatus. ATLX is an exchange focused around quality music and quality dancing, so come dance with us in
months,
days,
hours,
minutes, and
seconds!
Happening Now:
RESURGENS: MAIN DANCE
7:00pm - 12:00am
Georgia Tech Ballroom
Taryn Newborne & the Real Deal
Next Up:
RESURGENS: MAIN DANCE
7:00pm - 12:00am
Georgia Tech Ballroom
Taryn Newborne & the Real Deal


Researching on the following topic makes perfect sense after having learned and discussed about Emotional Intelligence. Personally, I think that in order to practice and develop our level of EQ, one needs to be aware of neuroplasticity and especially the growth mindset. The power of the growth mindset can never be highlighted enough in the current world we live in; which unfortunately sets expectations too high, its unrealistic most of the time.In brief, in the words of the wise Kirupa Chinnathambi;
"Onwards!"
1. Discuss how understanding the principals of neuroplasticity benefits people?
Being aware of neuroplasticity and its principals, brings hope. It benefits people in removing their blinders in terms of learning. It is an eye opener that in other words, our biology, the way we are made, gives us all the tools to be able to develop new skills and learn but also to bounce back and learn in a different way. That there is no one way only to learning and that the more we explore the different pathways to acquire knowledge instead of sticking to the same path, the more we are able to rewire our brain and multiply the creations of bridges between neurons
2. Discuss how you might engage with the principals of neuroplasticity for your own benefit
I feel that it will give me a clear rational to which I could hold on and refer myself to for when times get hard. That the hard way is the right way as I am nurturing the rewiring of my brain and in other words making full use of the abilities of my brain in terms of neuroplasticity.
3. What are some of the ways to increase your neuroplasticity?
Maybe, to use different methods to reach the outcome aimed at. And also, push myself out of my comfort zone a bit more every time.
For the above to happen, I will need to be attentive and reflect to my ways of dealing with problem solving. And genuinely be honest with myself and find ways to stay in my learning zone, even though its a hard.
And also the different strategies to solving problems and exploring theses different methods rather than limiting myself in exploring the same way to get to the solution.
It encapsulates a level of resilience and perseverance as it is definitely harder to walk new pathways than a known one.
I believe to be gradually shifting to a growth mindset, mindfulness and reflection are two strategies which could greatly help
4. Link to a resource that you found particularly useful or engaging.
(psst! click the image. . .)
1. Discuss what it is and why it is relevant?
A growth mindset is one which is open to change and difficulty. One who sees difficulty as a challenge to accept. It is a thought shift where failure is embraced and seen as learning and growth, and an opportunity to try differently. It is a positive way to overlook everyday challenges in a more peaceful and welcoming manner. It is accepting our limitations and pushing through them to see the solution. It is a new lease to look at life.
2. In this exploration, did anything surprise you? Change for you?
Well, it guided me in reflected on life prior to knowing about neuroplasticity and growth mindset. And the feeling of gratefulness for having encountered and doing my best to practice it, it is a beautiful journey to be on and not an easy one, especially if you have been educated in a fixed mindset environment.
3. How will you integrate growth mindset into your learning journey?
Like this . . .
But also ... I will walk towards difficulty with a smile and an open mind and heart. I will reflect and plan on the tools I need to find solve the problem, and grow in the process. I will also be kind to myself in the process.
In doing so, I will encourage my peers in being kind to themselves on their journey and use growth mindset as a lens when supporting them or needing support myself.
4. Link to a resource that you found particularly useful or engaging.
(psst! you know what to do. . .)
This research has helped me in diving deeper in the subject and reflect a lot about what I need to work on and practice in order to develop a growth mindset and encourage the neuroplasticity of my brain. It is really amazing to discover a bit more about the beauty of human nature and our ability to adapt and change.


VIKI documentation¶
VIKI is software aiming to enable the quick and easy start up of experiments involving ROS. Development has started in 2014 at the University of Twente under funding of project Aeroworks. VIKI can help a student that is new to a experimental setup to quickly start where the previous contributor stopped. For example: if you are designing a position-controlled quadrotor, based on on-board camera and IMU info, you can immediately start a position-controlled drone based on external cameras, redo/validate the experiments of the researcher who created that setup, and focus on your research instead of on peripherals.
The repository can be found on github: http://www.github.com/UT-RAM/viki. If you have any issues, please contact The developers or place on issue on github.
This documentation is split up into three parts, each having its own goal:
- User documentation aims at the regular VIKI users which are not developing their own modules. This starts with Installation and Quick start guide to get up and running with VIKI.
- Custom module development aids people at writing their own custom modules for VIKI
- Developer documentation is for internal documentation on VIKI or for people wanting to know more about the internals of VIKI.


Logout
Medicare
Dashboard
Dashboard
Diagnose
Diagnose
Blog
Blog
Chatroom
Chatroom
Diabetes Prediction
Thyroid Prediction
heart Disease Prediction
Covid Prediction
Brain Tumour Prediction


1
Pretend it is Sunday and you are making a grocery list for the items you need for the week. Pick three items.
Apple
Chicken
Ice Cream
Pear
Carrot
Cherry
Pretend it is Sunday and you are making a grocery list for the items you need for the week. Pick three items.
Apple
Chicken
Ice Cream
Pear
Carrot
Cherry


val message: String?
the variable part of the info
message - the variable part of the info
message
See Also
SgfInfoKeys


Printed
Tuesday, July 01, 2008
We slept in until 8AM and so was slow getting going. When I fed the rabbits I found that the black doe had killed her kit. I guess I was wrong in letting the children pet it for when the kit tried to suckle she bit it. I know better than letting anyone touch their kits but I had handled it so I thought it would be ok. I was wrong! I cut down some of the weeds in the back yard. I took care of a few other small jobs and then after lunch Bob and I went into Sportsman’s Warehouse and I purchased an electric downrigger. When we got home I was going to quickly install it but the repairman came on the Comcast problem and repaired that. It also took longer to install the downrigger that I had anticipated, so we didn’t have time this evening to try it out. After dinner Mae & I went out and put the boat away. Mike, next door came over and we talked for over an hour. I filled out my journal and it was time to go to bed.
Wednesday, July 02, 2008
When we got started this morning Mae and I moved the bed in the small bedroom and stored cases of wheat and rice under it. I had to add 1 ½” blocks under the legs of the bed in order for the boxes to fit under it. Mae was going to take Sister Reed and her daughter to Salt Lake. That will take her the rest of the day. Bob and I decided to take the boat up to East Cannon and try out the downrigger. Scott came over for lunch. After he left I got the boat ready to go. The wires on the back of the electrical connection broke loose and shorted out, blowing the fuse. It took over an hour to repair it. Mae found out that the trip to Salt Lake was canceled, so I asked her if she would to go with Bob and me. She said that she had too much to do to go but a few minutes later she came out and said she would go. We went up to the reservoir and had a good time catching three limits before we came home. The downrigger worked fine but it will take a little practice to get use to it. It was late when we got home and then Mae insisted that we clean up the boat before Sandy, Nick and Nick’s mother goes with me tomorrow. I had to bring up a light in order to see as we cleaned the boat. Mae is quite a gal and I am so lucky to have her.
Thursday, July 03, 2008
I got up at 4:15AM and got ready to go fishing. Sandi, Nick and Nick’s mother met me at the Park-N-Ride lot at the mouth of Weber Cannon shortly after 6AM. It was about 7:30AM when we got on the lake. We had a good day of fishing and by 1PM we had four limits. I think that Sandi caught the most but we all shared in the fun. I had everyone come to our place and we cleaned the fish. I got Bob to mix up some biscuits and he baked fish while we baked the biscuits and potatoes. It made a good dinner and we all enjoyed it. S set down and Mae rubbed my and I fell asleep. When I woke up we watched a make over of The Red River on the Hall Mark channel. I caught my journal up to date during the intermissions.
Friday, July 04, 2008
We got up early in order to go to Jeff and Gail’s. They invited us for breakfast along with several other friends they have near them. We took our two picnic tables over and some grills. The power in their garage wouldn’t handle the grills and kept tripping the circuit breakers. Noland brought some long extension cords and we plugged into some circuits in the house. It was a simple breakfast and we enjoyed meeting more of their friends. We left there and went up to Morgan to watch Tyler play baseball. Tyler is a pretty good player and their team won 1st place again this year. We came back home and took a nap. I slept pretty well but Mae only slept for about 1 hour. We did some work around the yard and then we went to Layton to the bowery and watched a concert. Scott, Mishelle, Kylan and Ashley also came to the concert. Following the concert was a fireworks display. It was a very enjoyable evening. It was almost mid-night when we got home. I filled in this entry and we went to bed.
Saturday, July 05, 2008
I slept in the recliner as I had eaten too much junk food yesterday. We got up and were ready when Bob called us for breakfast at 8:45AM. He made biscuits and gravy for us. I then did 2 or 3 honey dos for Mae and then went out and butchered the buck and the brown and white doe. Mae and I then drove to Sandy, Ut where I purchased a New Zealand buck and two does from Diane Taylor. This afternoon I remodeled the duplex rabbit pen by cutting out the flooring and installing wire mesh. I then put the new buck in where I had the buck that I butchered and the new does in the one that I had the brown and white doe. I will have to build some more pens before these new rabbits are ready for breeding. Mae went shopping for groceries plus she gave Bob and I haircuts this afternoon. This evening we went to Jeff and Gail’s to play games and to watch a movie. I had mixed feelings as I know that we will be very late getting home. Tomorrow will be Fast Sunday and this mean that we will not be able to start our Fast this evening. It was also later starting than had been planed so there wasn’t time for games. The show that Jeff played was also a PG-13 and I really didn’t enjoy the show. He had originally said that we were watching a cartoon movie but then for some reason Jeff changed his mind and put this one on. Mae got up and went into the house and talked to Gail. With us bringing our projector I couldn’t see any way to leave. I told Mae that I would like to avoid this situation in the future.
Sunday, July 06, 2008
It was hard to get up this morning but I did make it in time to help set up chairs and had time to feed my rabbits before going to meetings. I got sleepy during Sunday school but was able to stay awake and enjoy Fast and Testimony meeting. I was especially glad to see Patriarch and Sister Johnston feeling well enough to attend. When we got home Bob had a nice dinner ready for us. After dinner I took a nap and then worked on my journal. At 6PM we went upstairs and played a game of Canasta with Bob and Carroll. Mae and Carroll started off great and were far ahead in the first two hands. Bob and I then came back but at the last hand Mae and Carroll still beat Bob and I by about 150 points. When we came back downstairs we worked on computers. Mae helped me edit another of my stories and we e-mailed it to our family. I finished this entry and we went to bed.
Monday, July 07, 2008
We got up and started with Mom’s list of things needed to do today. I spent most of the morning working on those items and then this afternoon I repaired our water storage tanks. We expected Shellie and the boys about 7PM but it was almost 10PM when they got here. We visited until almost mid-night before we went to bed. I was surprising to me to see how much Quint has grown since we were at their place the first of the year. It is good to have them here.
Tuesday, July 08, 2008
Due to the fact that we didn’t get to bed until after 2AM, no one was ready to get up very early. I was the first up, at 7:30AM and went out side and fed the rabbits. It was after 11AM before Shellie, Garrett, Mae and I left for the Salt Lake Temple. When we got to Salt Lake we found that the Temple is closed for renovation. We went over to the Distribution Center and bought Garrett some garments. We also bought a picture of the First Presidency with a nice frame. We then went to the Bountiful Temple and went through a session there. Mae and I were asked to be session witness. We went to Chuck-A-Rama and had dinner. We then went to the Jordan River Temple. We met Chelci and Steve at the Temple and went through a session there. The session was held especially for the deaf and that made it especially interesting to see what it took in order for those that are deaf to participate in the program. After the session we took some pictures before coming home. We were all tired and soon started for bed, but it was still after mid-night when we got to bed.
Wednesday, July 09, 2008
We had to get everyone up in time for breakfast as Bob made biscuits and gravy for us. Shellie and the boys went to Layton Park where they met with some of their friends that have moved up from Arizona. They spent most of the day with them. Bryce from Alpine Restoration came by but Bob had gone. He will come back about 1PM. When Bob came home I told him that we needed the papers and the check from the insurance co. to decide what the cost will be for repairing the floor. He could not find where he had put them. I don’t believe I have ever seen Bob so upset or depressed as he was over misplacing those papers. Carroll was going to Salt Lake and when she went to the car she looked for the papers. She found them in the car and Bob was so relieved. Mark and I went to the Church farm and used the canner there and canned some whey. I got back at 1PM but Bryce called and said that he would be later. I took a nap this afternoon. When Bryce came we got prices figured out and gave Alpine the go for repairing the kitchen floor. Shellie and the boys got home about 6:30PM. Mae had dinner ready but I had to go with Bob Home Teaching at 7PM. We didn’t find the Casey’s home this evening. We were about an hour with our visit to the Johnston’s. We were able to also visit with the Fallis’s this evening. I had worked on the computer today and with Comcast’s help was able to get the internet working on my lap-top. I couldn’t get the desk top computer to connect to the wireless connection but was able to get the lap-top to connect to the enter-net and get the e-mail to work. Garrett tried to find the problem but Bob and Carroll had gone to bed and we didn’t want to disturb them by going up to work on the units up there. We decided to continue in the morning. It was mid-night when I went to bed but Mae and Shellie stayed up until 3AM talking.
Thursday, July 10, 2008
I got up about 6AM and studied for a while and then went back to bed at 7AM. I slept until 10AM before I got up. Mae had got up at 7AM so she didn’t get much sleep. Shellie got up and went to Georgia’s by 10AM. After breakfast and feeding the rabbits, Garrett and I worked on the computers. We were able to get the internet working on both of our computers and then we worked on Mark’s computer and got it working on the wire less internet also.  It is about like Monopoly. We went to the Air-Force Museum but we got there just as it was being closed for the day. We went to Sportsman Warehouse and bought fishing licenses for the boys and I will take them fishing in the morning. We then went over to Scott’s and visited with them.  We enjoyed visiting with Scott and Mishelle. While there Garrett and I helped Scott move a freezer into the basement. When we got home Mark called me out to the rabbit pens and showed me the one doe that we had bought the other day and it had died. He felt bad and was worried that maybe it was caused by the weed spray that he applied yesterday but I don’t think so. I noticed that the rabbit wasn’t acting very well this morning when I fed them. I took the boat and truck over to Clearfield and fueled them so they are ready to go tomorrow.
Friday, July 11, 2008
I got up at 3:45AM and read my scriptures. I let Mae sleep in and I got breakfast ready for the boys before I woke them. We left about 6:30AM and went to East Canon Reservoir. We caught fish shortly after starting to fish. Garrett and Kevis caught the first couple of fish. Quint seem to catch them but he would loss them before getting them to the boat. I finally had Garrett trade Quint poles but it didn’t help because Garrett then caught the fish on the new pole. I helped Jase catch a couple of fish and then while I was helping net someone else’s fish Jase caught one himself and reeled it in. Quint finally caught three fish so we all had a good time. We loaded up the boat and came back to the Air Force Museum and spent a couple of hours seeing the planes there. When we got home I cleaned the fish and put eight of them in the freezer and took the other eight of them up stairs for Bob to cook for breakfast in the morning. We got something to eat and then watched two western shows on Hall Mark channel. We read a chapter of the Book of Mormon during the commercials. I filled out this journal entry before going to bed. I also played a game on the computer before turning it off.
Saturday, July 12, 2008
I got up and did some studding and then got going to get breakfast and clean up for when the family came. Mae and Shellie didn’t get home until after 11AM. We had some of Bob and Carroll’s family, all of Irven and Sandi’s family and most of our family that came for a family reunion and lunch. Cheryl and Bob and three of their grand children also came. We set up some canvases for a shady area to eat under. Everyone brought pot luck and Bob, Carroll, Irven, Sandy, Mae and I furnished fried chicken. It was a wonderful afternoon of visiting and getting reacquainted. Our family stayed after everyone else left and we enjoyed the rest of the afternoon and evening. We grilled hamburgers and hot dogs this evening and along with the other leftovers had plenty to eat. We set up a sheet for a screen and watched a movie. Although Mike, Becky, Mattie and Jessie went home, David and Taylor stayed and watched the show and stayed the night. We had the floors covered with children but all slept well.
Sunday, July 13, 2008
I got up at 5AM so I could be ready for Stake General Priesthood meeting this morning at 7AM. when we first got to the chapel, there wasn’t many there but then it filled up pretty good. When I got home Shellie and the boys were still getting ready for church. After meetings today we just had leftovers for lunch and even a lighter dinner this evening. I took a nap as well as Mae and Shellie. This evening after eating dinner we went over to visit Jeff and Gail. We played yard games and visited for a while. It was late when we got home and then I filled in two days of journal entries.
Monday, July 14, 2008
We were late getting up. Shellie isn’t feeling the best today so I took Garrett, Quint and Kevis to East Canon Reservoir boating. We rented a ski board and I pulled Garrett for quite a while. Quint and Kevis didn’t want to go out so I tried it. I did get up but only for a few feet each time. Kevis decided to go out and he did very good and skied for quite a while although he wouldn’t try doing much except to stay in the boat wake. I went out a second time and as I started up I got a cramp in my left leg and had to quit. Garrett went out again and he is really good. He tries lots of fancy things so of course falls often but he is good. We then took the board back and got out the Great Big Mabel. We had a lot of fun on that and stayed on the lake until late. We got home after 7PM. Mae had dinner ready when we got there. We watched a movie on the Comcast movies that was cute with some good morals taught. It was mid-night when we went to bed.
Tuesday, July 15, 2008
Shellie was up early but the rest didn’t get going until after she had breakfast ready. I am quit sore and have several areas that are hurting. I don’t know if it was trying to ski yesterday or not or if I have eaten something that is causing it. Mae, Shellie and the boy’s went to Lagoon but I stayed home and rested. I did put some items away out in the shed. I took my boots over to have them repaired and got there at 5:45PM but the store was locked up even though the hours showed that it was open until 6PM. I filled the pickup and boat up with gas and it took $100.00 to fill them both. I put the boat away and the float tub. I watched a movie taken from a true incident with changes for protection and it really showed some of the evils of our government to protect some of our big business that are in foreign country’s. Mae, Shellie and the boy’s didn’t get home from Lagoon until after 11PM.
Wednesday, July 16, 2008
We slept in this morning. It was about 11:10AM when Shellie, Garrett, Mae and I left for the Salt Lake Temple. We got there just 5 minutes late for the noon session so had to wait until the 1PM session. Mae and I were asked to be the company witnesses on this session. We really enjoyed the session and after we stopped at the Chuck-A-Rama and had dinner again. We got home and I took a ½ hour nap and then Shellie, Mae and I went back to the Salt Lake Airport to get Roy. We got there just about the same time that he did. We came back home and watched a movie on Comcast that was pretty good. It was after 11PM when we went to bed.
Thursday, July 17, 2008
We got up early to prepare breakfast for Shellie and her family before they and Mae go to the water park in Provo. I have a problem and said something that upset Mae. Mae and all the rest left about 9:30AM. I went upstairs and started removing the damaged flooring and underlayment in the wash room. Before we quit for the day we picked up materials at Lowe’s. I warmed up some supper and ate while watching Texas Ranger. A western movie then played which I watched. I then changed the channel to AMC and watched Jaw’s 2.
Friday, July 18, 2008
Mae took Shellie and her family up to the gate to Timpanogus Cave where they met Sandi and Scott’s family. Mae then came home while the rest of them hiked to the cave. I worked around here and put a new sub floor in Bob and Carroll’s washroom. This evening Mae and I watched a DVD that Shellie had rented. It was ok I guess.
Saturday, July 19, 2008
We were tired and felt like sleeping in but we got up and drove out to the Erda Airport where we watched Scott, David, Jeff, Shellie, Roy and Garrett go up in an airplane and sky dive out. All of them were thrilled with the experience and all landed safely. We then went to Sandi and Nick’s where we grilled dinner and then played games. We had almost all of our family out there and it was good to be together. Mae and I came home this evening. This morning before we left for Erda, I realized that my cell phone was missing. I couldn’t find it before we left but this evening as I thought about it I decided that I would check an area where I had done some building yesterday. I was able to find it where it had fallen out of my pocket. We were about to call it a day when Robin Walker and Kyson came by. Kyson asked if I would give him a blessing as he is going into the Army Reserve along with some other stresses of life and felt like he needed a Priesthood Blessing. I asked Mark to assist me and we gave him a blessing through the Priesthood that we hold. Mae is typing some thoughts for a R.S. lesson in the morning before she will be ready to go to bed. Mae gave me a hair cut and I took a shower before going to bed.
Sunday, July 20, 2008
I woke before 3AM and got up for just a few minutes. Although I went back to bed I couldn’t get to sleep. I remembered that the water was running on the back trees so I got dressed enough that I went out back and shut it off. If it is on when the sprinklers come on the lawn there is too much pressure lost and the sprinklers do a pour job of watering the lawn. I went back to bed and heard the clock chime for four AM but went to sleep after that. The alarm woke me at 6AM but we didn’t get up until 6:30AM. My feet and legs are hurting this morning so I am moving quite slow. I did go to the chapel and help set up chairs. When I got home I fed the rabbits and then went in to eat but there wasn’t enough time so I just had a piece of toast and a glass of whey. Meetings were very good but my legs and feet got worse as time went on. We ate lunch with just the two of us and it really seemed good for the quietness and peace. This evening Bob and I went over to Brother and Sister Fallis’s as Brother Fallis is going to go into the hospital tomorrow for an operation. We gave Harrell a blessing. While we were out we also stopped by the Casey’s to visit them. They were home this time. I got on the inter-net and looked up Dyflugan. In doing so we found a web site that we could find out how to control this yeast problem that I have. We spent some time looking for it and getting it off the computer. When we did get it, I was disappointed as there was very little new that we didn’t already know. We went to bed and watched a show on DVD.
Monday, July 21, 2008
I slept in but Mae got up at shortly after 8AM. I am quite depressed about my legs and feet. I really don’t want to go back on the strict diet and the added nurturance that it will take to replace what I can’t get out of the diet. I didn’t get very much done except feed my rabbits. This afternoon I went over to Irven and Sandy’s and looked at their problem. It looks like it is coming from their master bedroom bath. The shower is deteriorating and starting to leak. I suggested that they call their insurance company and see if they will cover most of the repairs. The restoration repairman came today and replaced Bob and Carroll’s flooring today. This evening I watched some TV. Mae balanced our Bank Statement this evening and took a shower before we went to bed.
Tuesday, July 22, 2008
We slept in late this morning. Bob came down and woke us at 10AM. Mark spent a couple of hours trying to help me determine what medications and food will be good for me. I just don’t know how reliable his abilities are. He said that the Cox Raw Honey that we have is ok for me to use. Also the one brand of wheat bread is ok for me. This afternoon and evening, with the help of Bob and Mark, we cut the first cutting of my hay. It is just coming into blossom and I am afraid that it will be in full bloom before we get back form Sandi’s. Sandi was operated on this afternoon and they fused 4 disks in her neck. I hope that it was the right thing to do. Brother Thompson came Home Teaching this evening. I asked him to give me a blessing. Bob and Mark assisted with it. We also gave Carroll a blessing. I am having a lot of pain that I am sure that it is the same thing that I have been fighting for over 20 years. Carroll’s problem is with the swelling in her legs.
Wednesday, July 23, 2008
We got up at 5:30AM in order to get away to Salt Lake to pickup Sandi from the hospital. I fed the rabbits and packed the car. Mae prepared some scrambled eggs and put on toast so that we could eat them on the way. We got there at 8:30AM and as we came into Sandi’s room the Physicians Assistant was just starting to talk to Sandi. Sandi told us that it was 8:00 last night that they were able to get her into the room. Nick called a little later and said the same thing and he was quite upset about that. The PA told us that she could leave when she wanted to but that she had no need to hurry because hospital staff had been so late getting her into a room. The Doctor soon came in to visit with Sandi and told her about the same things as the PA. When he went to leave the nurse had just came in the room and when the Dr. told Sandi that she could leave when ever she felt up to it the nurse spoke up and said that she was there to help her. After the Dr. left the room I told the nurse that Sandi wanted to rest a little longer before leaving. The nurse then left the room. Mae and Sandi then took a nap while I watched the traffic out side. It was interesting to see the commuter train and the buses come and go. Less than an hour had passed when another nurse came in and spoke to Sandi which woke her up and told her she would help her get ready to leave if she was ready. There was no question that the staff wanted Sandi to leave. Mae helped Sandi get dressed and we left.  We then stopped at the Maverick station in Tooele and bought the three of us some yogurt. That really tasted good to Sandi. We took her home and took care of the rest of the day. JaNae and her children stopped over for a while. Chelci came over and then went to the store to get some things for Sandi. Mae prepared dinner for this evening when Nick got home from work. I helped her by filleting trout and cooking them. This evening we watched a movie that Chelci got for us. It was the “Four White Feathers”. Part way through the show we stopped it so that Nick and I could go outside and spray some hornet nests. Sandi also asked if I would give her a Priesthood Blessing, which I did, then Sandi and Nick went to bed. Mae and I stayed up and watched the end of the show. It was a good movie.
Thursday, July 24, 2008
Nick got up and left for work about 3AM. I woke later and just quietly checked and Sandi was asleep. The medication that I am taking, for a cleans is working, but I was able to soon go back to sleep. Mae got up about 7:30AM., but I went back to sleep and sleep quite late. When I got up Mae had fixed oat meal cereal for breakfast. I used the honey that Mark had said was ok for me to use but soon I had quite a lot of pain through out my body. I think I will lay off all sweets for a while. We watched the Salt Lake 24th of July Pioneer Parade on TV. Sandi and I went back to bed for a while, after the parade was over. When I got up I shaved and took a bath in the whirl pool tub and that helped me feel some better. I feel quite discouraged with this problem that I am having as I am not sure just who to get help and advice from. Mae had dinner ready when Nick got home from work at 6PM. The four of us played two games of Marbles and Sandi and Mae won both of them. Nick and I took a break and went outside and sprayed four hornet nets. I love to see those things die. After we came back in and finished the game. We then started another game of Run’s and Bunch’s, but Sandi got tired and went to bed. Nick, Mae and I finished the game and Nick won. We then went to bed.
Friday, July 25, 2008
I got up at 7:30AM and Mae had been up for a while before that. For breakfast Mae made egg omelets in a sack. Those worked out well. It was an easy day just trying to help care for Sandi but she is quite independent. We saw pitchers of the surgery and we just hope it works out for Sandi’s best good. I did a couple of small jobs for Nick and Sandy to help them out. This evening we played marbles again and again Mae and Sandi won two games in a row.
Saturday, July 26, 2008
Mae and I again prepared breakfast. I fillet some trout and fried them while Mae prepared hash brown potatoes and fried summer squash. After cleaning up Mae told me that Sandi would like us to go home as she is feeling quite a lot better and she can relax more if we aren’t here. We packed our things and left for home. Nick wanted us to stop at Home Depot with him and look at a generator and a air compressor. We then left for home but Mae remembered some things that we had left at Sandi’s so we had to go back. It was about 5PM when we got home. We got a call from Roy this evening. Both he and Linda have Sugar Diabetes but they are only taking insulin shots and eating what they want. When we told him that Bob is really watching his food intake, Roy just said that we all die one way as another. My feet are hurting this evening. After unpacking we watched “The Wild Bunch” on TV before going to bed.
Sunday, July 27, 2008
My legs and feet are really hurting this morning. Mae went upstairs and borrowed some crutches from Bob to help me walk. Bob went out and fed my rabbits for me. I stayed down all day. Mae attended meetings this morning. Bob and Carroll invited us up for dinner. Bob prepared fried chicken and fried my piece with out flowering it. I watched the Tabernacle Choir and The Spoken Word as well as other devotional on BYUTV. Mae called and checked on Sandi and she is doing fair. This evening we watched the rebroadcast of the Tabernacle Choir and The Osmond’s. That was very enjoyable. I caught up the last couple of days in my journal this evening. Bob and Mark went out and covered my hay with tarps as they heard that Tooele County is expecting thunder storms this evening. I am not sure just what I should do or who I should see about the pain I am experiencing. Mae called and talked to Jennie but they are doing some remodeling so she isn’t seeing anyone for over a month.
Monday, July 28, 2008
I woke early and noticed that the pressure pump was not running on the irrigation water. We had to turn it on by hand as there is not enough pressure in the line to let it turn on. We went back to bed and rubbed each others feet. Using the crutches I am able to walk around. Mae talked to Nancy Litchford and she feels that it is our apple cider vinegar, honey and cayenne pepper that has caused my pain to return. I spent a lot of time working on the computers and the inter-net getting maps for Flaming Gorge and also reservations for Zion’s Cannon. We decided that we can’t afford to go to Washington to go fishing this year.
Tuesday, July 29, 2008
I woke at 3AM and after laying there for almost an hour I got up. I took some Tylenol and turned on a show on Comcast. Bob fed my rabbits for me this morning. I did go out and turn my hay and put the water on the garden. I took a short nap and then we went into South Ogden to meet with Nancy Litchford and Fran Morris. To me that was a very depressing visit. For the next three weeks my diet is very limited. We stopped at a Health Food Store and Mae went in to buy some of the things that I can have. I waited outside in the car until I got to hot. After I was in the store for a few minutes, one of the owners (I guess) brought me a cook book for me to look at. She said that she had been talking to Mae and showed her the book. Mae wanted me to look through it before we bought it. I spent the next few minutes going through the recipes and I only found 2 that didn’t have at least 1, 2 or more ingredients in them that I can not have. Then on the way home as Mae read the literature we found out that included in the don’t list is pop-corn. We also decided that we should cancel out trip with Rick and Georgia.  Mae went over to the grocery store and bought some things that I can eat but she had to look hard to find anything. This evening we watched a show on TV before going to bed.
Wednesday, July 30, 2008
I woke early and was up for a while. I read another chapter of the Book Of Mormon and then went back to bed and cuddled Mae up but then she got up, so I slept until 8:30. Meals are a puzzle for us to figure out with all the things I can’t eat. It really keeps Mae thinking, trying to figure meals. I worked on the yard pump trying to get the safety switch to work on the low water pressure that we get. It works on 12 LB PSI and often we are below that in the morning hours. If the switch doesn’t trip then the pump will not turn on so the lawn isn’t getting enough water. I am concerned about bypassing the switch for if there was no water when the pump came on it would burn up the pump. Mark came out side just as I finished up and we set and visited for a while. After lunch I went out and stacked my hay in the shed. Bob came out and helped me. I turned the water on the garden this afternoon and also put some side dressing of 16-16-16 fertilizer on most of the rows of vegetables. This evening I entered my journal while Mae worked to make menu that we can eat. I then did some work on my stories to prepare some more to send to our family. By the time I finished it was 1:30PM so we went to bed.
Thursday, July 31, 2008
I didn’t sleep very well and I woke about 3AM. By 4AM I got up and took some Tylenol. I lay in the recliner but still didn’t sleep much. I heard the clock on each hour. I took a shower shortly after 7AM and then Mae and I lay back in bed for a while. Mae got up to answer the phone at 8AM but I tried to sleep, getting up about noon with Bob needing help reinstalling his cabinet. They are putting a micro-wave above their range. Mae and I went over to Dr. Bennett’s and got treatments. We then stopped at Home Depot for some electrical parts for Bob and at the shoe shop to get my boots that they repaired. We also stopped at Willie’s care wash to clean the car. Last stop was at the gas station to fill the car. I did some work on my personal history and my journal. This evening we watched the show “Hatchi” with John Wayne on DVD before going to sleep.


---
layout: page
permalink: /bookshelf/
title: Bookshelf
---
My favourite books, blogs and other resources
(last updated April 13th 2022)
Books
Superintelligence by Nick Bostrom.
Why Artificial Intelligence that reaches human level capabilities will be so dangerous and very difficult to control. It won't be a Terminator like situation but one where we say
"make humans happy" or "solve this hard math problem" and in doing so inadvertently wipes out humanity. How do we embed human values into computer code and can we even come up with a
cohesive set of human values?
Symbolic Species by Terrence Deacon. The potential origins of human language, a compelling taxonomy for language, why humans are so smart/unique.
This work is now being used to motivate high level thinking about the future direction of AI research.
The Secret of Our Success by Joseph Henrich. Read this for a great book review. I write about some lessons learnt from this book in On Chesterton's Fence.
It provides an different take on how humans became so smart and evolved culture and language. Very interesting throughout. Social and cultural interactions and imitation learning are likely to be crucial to developing sophisticated AI.
We humans are pretty terrible at innovation, much better at brute force trial and error before copying and retaining the discoveries we have stumbled upon.
On China by Henry Kissinger.
This book provides a broad chronological history of China. What is wild is that starting in 1955, it becomes first person
with Kissinger saying "and then I said to Chairman Mao...". I think the book
highlights a lot of fundamental psychological and cultural differences between China and the West.
The Strategy of Conflict by Thomas Schelling.
Game theory considers zero sum games with agents that have symmetric utility functions and constrained forms of communication. Schelling introduces
more realistic "mixed motive"
games that are positive sum and where both agents would benefit from coming to an agreement.
He explores how to win at bargaining, threats and deterrence in these mixed motive games, often by visibly binding and weakening oneself in
interesting and creative ways.
Rationality: From AI To Zombies by Eliezer Yudkowsky. Has definitely given me some useful cognitive primitives for aspiring to think rationally about the world and how it operates.
Harry Potter and the Methods of Rationality by Eliezer Yudkowsky. A friend described this book as one of the few where the protogonist is actually smart.
Warning: this book will absolutely wreck your productivity until you finish it! I recommend the audiobook/podcast version.
The Mote in God's Eye by Jerry Pournelle and Larry Niven.
The most realistic aliens that I've encountered in any sci-fi novel and an important description of evolution at play.
Blogs
Astral Codex Ten - witty, rational, in depth analyses of a plethora of topics.
See Scott's previous blog Slate Star Codex for lots of additional really interesting content.
Gwern - there is no other blog or site like it on the planet. I certainly don't agree with everything on the site but it is nonetheless thought provoking.
Marginal Revolution - run by probably one of the world's best polymaths Tyler Cowen and Alex Tabarrok, their daily newsletter summarizing all sorts of topics is always informative.
Roots of Progress - a main hub for "Progress Studies" analyzing the historical, political,
economic, psychological underpinnings of societal innovation and progress.
There is compelling evidence the progress
of modern society is lower than it has been in the past; why is this and how can we fix it? This piece on cement is also super cool.
Applied Divinity Studies - anonymous blog with a number of interesting takes on topics ranging from opportunity cost to NFTs.
Websites
Our World in Data - facts and figures presented elegantly and transparently about
so many important topics, from causes of mortality to climate change numbers.
Effective Altruism Forum - if the words "Effective Altruism" don't mean much to you start here. This forum is a great way to track the pulse
of the movement with new ideas and discussion.
LessWrong - we are irrational beings and can be pretty
terrible at accomplishing our goals. A forum on how to be "less wrong".
Adam Marblestone - from in situ RNA sequencing to implosion fabrication and
research at DeepMind, Adam works on so many interesting topics. He has a great series on climate change and his own list of books, papers and other resources I highly recommend.
Textbooks
Principles of Neural Design - first principles
approach using metabolic constraints
and information theory to reverse engineer the design of our brain.
Deep Learning - quickly getting out of date but still an excellent fundamental introduction
to all of the core components of Deep Learning.
A First Course in Bayesian
Statistical Methods - provided me with a helpful foundation
in Bayesian Statistics. Statistical Rethinking is also good but less mathematically
in depth and as a result less useful for fundamental understanding.
Information Theory, Inference, and Learning Algorithms -
I'm only 1/3rd through this textbook
(as of March 2021) but it has been excellent so far and I have seen it recommended in
so many other places (including here, here
and here) that I am very happy recommending it. I also have a running list of some of
my favourite problems from the book here
Introduction to Linear Algebra - the
video lectures are also
really great.
Podcasts
Conversations with Tyler - Tyler Cowen is excellent at interviewing all sorts of people. He gets straight to the point in a way
I haven't seen with any other podcasts except maybe...
Rationally Speaking - Julia Galef is very methodical and rational in her interviewing of all sorts of major guests.
Making Sense - Sam Harris - I think I learn a new word every time I listen to Sam interview someone.
For a full list of everything I've read see my Goodreads.
I am also trying to increase my memory and comprehension of books by writing reviews of each one that will be posted on the blog and under the "Book Review" category.


Please register to be able to participate...
If you have and still see this message. please make sure to verify your email.
If the problem persists....
Winner:
No other players currently registered...
Login to be able to report a game...