Fawcett Comics
One of the most successful comic book publisher in the 1940's, Fawcett Publications began in 1919 with the magazine, Captain Billy's Whiz Bang. Its total circulation from all of its publications eventually reached over 10 million issues a month.
Fawcett is best known for its popular superhero, Captain Marvel, based on the adventures of radio reporter Billy Batson who would turn into Captain Marvel upon uttering the word Shazam!. Other successful characters include Ibis the Invincible, Hopalong Cassidy, and Mister Scarlet. Fawcett was also known for its series of horror comics including Beware! Terror Tales, Worlds of Fear, and Strange Suspense Stories. The company branched out into humor comic magazines with Otis and Babs and Hoppy the Marvel Bunny among its most popular titles.
Facing declining sales, Fawcett Comics ceased publication of its superhero titles in 1953. Several of its titles were eventually sold to Charlton Comics.


'Sweep victory:' Twitter erupts as Ateneo completes UAAP three-peat
Social media goes full-on celebration mode after the Ateneo Blue Eagles' perfect run in UAAP Season 82 men's basketball
by Kaye CabalSubscribe
Email Address
Newsletters
- Glenda Gloria's Take this Tuesday
- Huddle by Miriam Grace Go
- The Newsbreak Agenda by Chay Hofileña
- Sometimes, all you need is video by Lilibeth Frondoso


Tuning Spark
Because of the in-memory nature of most Spark computations, Spark programs can be bottlenecked by any resource in the cluster: CPU, network bandwidth, or memory. Most often, if the data fits in memory, the bottleneck is network bandwidth, but sometimes, you also need to do some tuning, such as storing RDDs in serialized form, to decrease memory usage. This guide will cover two main topics: data serialization, which is crucial for good network performance and can also reduce memory use, and memory tuning. We also sketch several smaller topics.
Data Serialization
Serialization plays an important role in the performance of any distributed application.  Often, this will be the first thing you should tune to optimize a Spark application. Spark aims to strike a balance between convenience (allowing you to work with any Java type in your operations) and performance. It provides two serialization libraries:
- Java serialization:
By default, Spark serializes objects using Java’s
ObjectOutputStream
framework, and can work with any class you create that implementsjava.io.Serializable
. You can also control the performance of your serialization more closely by extendingjava.io.Externalizable
. Java serialization is flexible but often quite slow, and leads to large serialized formats for many classes. - Kryo serialization: Spark can also use
the Kryo library (version 2) to serialize objects more quickly. Kryo is significantly
faster and more compact than Java serialization (often as much as 10x), but does not support all
Serializable
types and requires you to register the classes you’ll use in the program in advance for best performance.
You can switch to using Kryo by initializing your job with a SparkConf
and calling conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
.
This setting configures the serializer used for not only shuffling data between worker
nodes but also when serializing RDDs to disk. The only reason Kryo is not the default is because of the custom
registration requirement, but we recommend trying it in any network-intensive application.
Spark automatically includes Kryo serializers for the many commonly-used core Scala classes covered in the AllScalaRegistrar from the Twitter chill library.
To register your own custom classes with Kryo, use the registerKryoClasses
method.
val conf = new SparkConf().setMaster(...).setAppName(...)
conf.registerKryoClasses(Array(classOf[MyClass1], classOf[MyClass2]))
val sc = new SparkContext(conf)
The Kryo documentation describes more advanced registration options, such as adding custom serialization code.
If your objects are large, you may also need to increase the spark.kryoserializer.buffer
config. This value needs to be large enough
to hold the largest object you will serialize.
Finally, if you don’t register your custom classes, Kryo will still work, but it will have to store the full class name with each object, which is wasteful.
Memory Tuning
There are three considerations in tuning memory usage: the amount of memory used by your objects (you may want your entire dataset to fit in memory), the cost of accessing those objects, and the overhead of garbage collection (if you have high turnover in terms of objects).
By default, Java objects are fast to access, but can easily consume a factor of 2-5x more space than the “raw” data inside their fields. This is due to several reasons:
- Each distinct Java object has an “object header”, which is about 16 bytes and contains information
such as a pointer to its class. For an object with very little data in it (say one
Int
field), this can be bigger than the data. - Java
String
s have about 40 bytes of overhead over the raw string data (since they store it in an array ofChar
s and keep extra data such as the length), and store each character as two bytes due toString
’s internal usage of UTF-16 encoding. Thus a 10-character string can easily consume 60 bytes. - Common collection classes, such as
HashMap
andLinkedList
, use linked data structures, where there is a “wrapper” object for each entry (e.g.Map.Entry
). This object not only has a header, but also pointers (typically 8 bytes each) to the next object in the list. - Collections of primitive types often store them as “boxed” objects such as
java.lang.Integer
.
This section will start with an overview of memory management in Spark, then discuss specific strategies the user can take to make more efficient use of memory in his/her application. In particular, we will describe how to determine the memory usage of your objects, and how to improve it – either by changing your data structures, or by storing data in a serialized format. We will then cover tuning Spark’s cache size and the Java garbage collector.
Memory Management Overview
Memory usage in Spark largely falls under one of two categories: execution and storage.
Execution memory refers to that used for computation in shuffles, joins, sorts and aggregations,
while storage memory refers to that used for caching and propagating internal data across the
cluster. In Spark, execution and storage share a unified region (M). When no execution memory is
used, storage can acquire all the available memory and vice versa. Execution may evict storage
if necessary, but only until total storage memory usage falls under a certain threshold (R).
In other words, R
describes a subregion within M
where cached blocks are never evicted.
Storage may not evict execution due to complexities in implementation.
This design ensures several desirable properties. First, applications that do not use caching can use the entire space for execution, obviating unnecessary disk spills. Second, applications that do use caching can reserve a minimum storage space (R) where their data blocks are immune to being evicted. Lastly, this approach provides reasonable out-of-the-box performance for a variety of workloads without requiring user expertise of how memory is divided internally.
Although there are two relevant configurations, the typical user should not need to adjust them as the default values are applicable to most workloads:
spark.memory.fraction
expresses the size ofM
as a fraction of the (JVM heap space - 300MB) (default 0.6). The rest of the space (25%) is reserved for user data structures, internal metadata in Spark, and safeguarding against OOM errors in the case of sparse and unusually large records.spark.memory.storageFraction
expresses the size ofR
as a fraction ofM
(default 0.5).R
is the storage space withinM
where cached blocks immune to being evicted by execution.
The value of spark.memory.fraction
should be set in order to fit this amount of heap space
comfortably within the JVM’s old or “tenured” generation. Otherwise, when much of this space is
used for caching and execution, the tenured generation will be full, which causes the JVM to
significantly increase time spent in garbage collection. See
Java GC sizing documentation
for more information.
The tenured generation size is controlled by the JVM’s NewRatio
parameter, which defaults to 2,
meaning that the tenured generation is 2 times the size of the new generation (the rest of the heap).
So, by default, the tenured generation occupies 2/3 or about 0.66 of the heap. A value of
0.6 for spark.memory.fraction
keeps storage and execution memory within the old generation with
room to spare. If spark.memory.fraction
is increased to, say, 0.8, then NewRatio
may have to
increase to 6 or more.
NewRatio
is set as a JVM flag for executors, which means adding
spark.executor.extraJavaOptions=-XX:NewRatio=x
to a Spark job’s configuration.
Determining Memory Consumption
The best way to size the amount of memory consumption a dataset will require is to create an RDD, put it into cache, and look at the “Storage” page in the web UI. The page will tell you how much memory the RDD is occupying.
To estimate the memory consumption of a particular object, use SizeEstimator
’s estimate
method
This is useful for experimenting with different data layouts to trim memory usage, as well as
determining the amount of space a broadcast variable will occupy on each executor heap.
Tuning Data Structures
The first way to reduce memory consumption is to avoid the Java features that add overhead, such as pointer-based data structures and wrapper objects. There are several ways to do this:
- Design your data structures to prefer arrays of objects, and primitive types, instead of the
standard Java or Scala collection classes (e.g.
HashMap
). The fastutil library provides convenient collection classes for primitive types that are compatible with the Java standard library. - Avoid nested structures with a lot of small objects and pointers when possible.
- Consider using numeric IDs or enumeration objects instead of strings for keys.
- If you have less than 32 GB of RAM, set the JVM flag
-XX:+UseCompressedOops
to make pointers be four bytes instead of eight. You can add these options inspark-env.sh
.
Serialized RDD Storage
When your objects are still too large to efficiently store despite this tuning, a much simpler way
to reduce memory usage is to store them in serialized form, using the serialized StorageLevels in
the RDD persistence API, such as MEMORY_ONLY_SER
.
Spark will then store each RDD partition as one large byte array.
The only downside of storing data in serialized form is slower access times, due to having to
deserialize each object on the fly.
We highly recommend using Kryo if you want to cache data in serialized form, as
it leads to much smaller sizes than Java serialization (and certainly than raw Java objects).
Garbage Collection Tuning
JVM garbage collection can be a problem when you have large “churn” in terms of the RDDs
stored by your program. (It is usually not a problem in programs that just read an RDD once
and then run many operations on it.) When Java needs to evict old objects to make room for new ones, it will
need to trace through all your Java objects and find the unused ones. The main point to remember here is
that the cost of garbage collection is proportional to the number of Java objects, so using data
structures with fewer objects (e.g. an array of Int
s instead of a LinkedList
) greatly lowers
this cost. An even better method is to persist objects in serialized form, as described above: now
there will be only one object (a byte array) per RDD partition. Before trying other
techniques, the first thing to try if GC is a problem is to use serialized caching.
GC can also be a problem due to interference between your tasks’ working memory (the amount of space needed to run the task) and the RDDs cached on your nodes. We will discuss how to control the space allocated to the RDD cache to mitigate this.
Measuring the Impact of GC
The first step in GC tuning is to collect statistics on how frequently garbage collection occurs and the amount of
time spent GC. This can be done by adding -verbose:gc -XX:+PrintGCDetails -XX:+PrintGCTimeStamps
to the Java options. (See the configuration guide for info on passing Java options to Spark jobs.) Next time your Spark job is run, you will see messages printed in the worker’s logs
each time a garbage collection occurs. Note these logs will be on your cluster’s worker nodes (in the stdout
files in
their work directories), not on your driver program.
Advanced GC Tuning
To further tune garbage collection, we first need to understand some basic information about memory management in the JVM:
-
Java Heap space is divided in to two regions Young and Old. The Young generation is meant to hold short-lived objects while the Old generation is intended for objects with longer lifetimes.
-
The Young generation is further divided into three regions [Eden, Survivor1, Survivor2].
-
A simplified description of the garbage collection procedure: When Eden is full, a minor GC is run on Eden and objects that are alive from Eden and Survivor1 are copied to Survivor2. The Survivor regions are swapped. If an object is old enough or Survivor2 is full, it is moved to Old. Finally when Old is close to full, a full GC is invoked.
The goal of GC tuning in Spark is to ensure that only long-lived RDDs are stored in the Old generation and that the Young generation is sufficiently sized to store short-lived objects. This will help avoid full GCs to collect temporary objects created during task execution. Some steps which may be useful are:
-
Check if there are too many garbage collections by collecting GC stats. If a full GC is invoked multiple times for before a task completes, it means that there isn’t enough memory available for executing tasks.
-
In the GC stats that are printed, if the OldGen is close to being full, reduce the amount of memory used for caching by lowering
spark.memory.storageFraction
; it is better to cache fewer objects than to slow down task execution! -
If there are too many minor collections but not many major GCs, allocating more memory for Eden would help. You can set the size of the Eden to be an over-estimate of how much memory each task will need. If the size of Eden is determined to be
E
, then you can set the size of the Young generation using the option-Xmn=4/3*E
. (The scaling up by 4/3 is to account for space used by survivor regions as well.) -
As an example, if your task is reading data from HDFS, the amount of memory used by the task can be estimated using the size of the data block read from HDFS. Note that the size of a decompressed block is often 2 or 3 times the size of the block. So if we wish to have 3 or 4 tasks’ worth of working space, and the HDFS block size is 64 MB, we can estimate size of Eden to be
4*3*64MB
. -
Monitor how the frequency and time taken by garbage collection changes with the new settings.
Our experience suggests that the effect of GC tuning depends on your application and the amount of memory available. There are many more tuning options described online, but at a high level, managing how frequently full GC takes place can help in reducing the overhead.
Other Considerations
Level of Parallelism
Clusters will not be fully utilized unless you set the level of parallelism for each operation high
enough. Spark automatically sets the number of “map” tasks to run on each file according to its size
(though you can control it through optional parameters to SparkContext.textFile
, etc), and for
distributed “reduce” operations, such as groupByKey
and reduceByKey
, it uses the largest
parent RDD’s number of partitions. You can pass the level of parallelism as a second argument
(see the spark.PairRDDFunctions
documentation),
or set the config property spark.default.parallelism
to change the default.
In general, we recommend 2-3 tasks per CPU core in your cluster.
Memory Usage of Reduce Tasks
Sometimes, you will get an OutOfMemoryError not because your RDDs don’t fit in memory, but because the
working set of one of your tasks, such as one of the reduce tasks in groupByKey
, was too large.
Spark’s shuffle operations (sortByKey
, groupByKey
, reduceByKey
, join
, etc) build a hash table
within each task to perform the grouping, which can often be large. The simplest fix here is to
increase the level of parallelism, so that each task’s input set is smaller. Spark can efficiently
support tasks as short as 200 ms, because it reuses one executor JVM across many tasks and it has
a low task launching cost, so you can safely increase the level of parallelism to more than the
number of cores in your clusters.
Broadcasting Large Variables
Using the broadcast functionality
available in SparkContext
can greatly reduce the size of each serialized task, and the cost
of launching a job over a cluster. If your tasks use any large object from the driver program
inside of them (e.g. a static lookup table), consider turning it into a broadcast variable.
Spark prints the serialized size of each task on the master, so you can look at that to
decide whether your tasks are too large; in general tasks larger than about 20 KB are probably
worth optimizing.
Data Locality
Data locality can have a major impact on the performance of Spark jobs. If data and the code that operates on it are together then computation tends to be fast. But if code and data are separated, one must move to the other. Typically it is faster to ship serialized code from place to place than a chunk of data because code size is much smaller than data. Spark builds its scheduling around this general principle of data locality.
Data locality is how close data is to the code processing it. There are several levels of locality based on the data’s current location. In order from closest to farthest:
PROCESS_LOCAL
data is in the same JVM as the running code. This is the best locality possibleNODE_LOCAL
data is on the same node. Examples might be in HDFS on the same node, or in another executor on the same node. This is a little slower thanPROCESS_LOCAL
because the data has to travel between processesNO_PREF
data is accessed equally quickly from anywhere and has no locality preferenceRACK_LOCAL
data is on the same rack of servers. Data is on a different server on the same rack so needs to be sent over the network, typically through a single switchANY
data is elsewhere on the network and not in the same rack
Spark prefers to schedule all tasks at the best locality level, but this is not always possible. In situations where there is no unprocessed data on any idle executor, Spark switches to lower locality levels. There are two options: a) wait until a busy CPU frees up to start a task on data on the same server, or b) immediately start a new task in a farther away place that requires moving data there.
What Spark typically does is wait a bit in the hopes that a busy CPU frees up. Once that timeout
expires, it starts moving the data from far away to the free CPU. The wait timeout for fallback
between each level can be configured individually or all together in one parameter; see the
spark.locality
parameters on the configuration page for details.
You should increase these settings if your tasks are long and see poor locality, but the default
usually works well.
Summary
This has been a short guide to point out the main concerns you should know about when tuning a Spark application – most importantly, data serialization and memory tuning. For most programs, switching to Kryo serialization and persisting data in serialized form will solve most common performance issues. Feel free to ask on the Spark mailing list about other tuning best practices.


Use the first checkbox below if you wish this inspection to ignore implicit conversion which
can not result in loss of data (e.g.
int
->long
).
Use the second checkbox to indicate that this inspection should ignore conversion from
and to char
. Conversion from floating point to char
and vice versa will still be reported.
Use the third checkbox to let this inspection ignore conversion from literals and compile time constants.


Fire and Ice
by
Robert Frost
(Best Viewed on Computer)
Some say the world will end in fire,
Some say in ice.
From what I’ve tasted of desire
I hold with those who
favor fire.
But if it had to perish twice,
I think I know enough of hate
To say that for destruction ice
Is also great
And would suffice.


Tic Tac Toe
Select mode
You can choose playing mode: alone or multiplayer.
1 Player
2 Players
Choose sign
X
O
Game result
Play again
Player 1
Player 2


Dear all, I have not installed Gecode in the standard place. In order to tell GecodeJ's configure where to find the libs I am using GECODE_LIBS. ./configure GECODE_LIBS=/home/luque/sources/gecode/gecode-1.3.0 However, configure is still not finding the libraries... Luis


Chapter 9 Correlation
Statistical correlation simply refers to the notion that two variables are related to one another.
The ideas is that when one varies, the other varies in a predictable manner.
There are typically two ways to understand the nature of a correlation:
* Visually
* Numerically
In order to get a better understanding about correlations, in this chapter we are going to learn how to calculate Pearson’s correlation coeffecient. After calculating Perason’s \(r\), we’ll then talk a bit more about the assumptions correlation, what factors can impact linear correlation, and how to test the “significance” of a correlation coeffecient. Lastly we will talk about other types of correlation coefficients that deal with ordinal variables, or those measured by ranks.
Many people have seen a scatterplot before like the one shown below.
library(ggplot2)
ggplot(iris, aes(x = Sepal.Length, y = Sepal.Width)) + geom_point() +
labs(title = "Example of a Scatterplot", x = "Sepal Length", y = "Sepal Width")
On the horizontal axis (or x axis), one variable is plotted and then each corresponding score on the x axis is plotted against its respective value on the vertical axis (or y axis). The pattern that the variables show can indicate the nature of the relationship between the two variables. From the pattern above there appears to be a positive relationship between the length of an iris’s sepal and its width. The relationship is positive because one variable increases, so does the other. If the variables were to share a negative relationship we would see a trend where scores would move from the top left down until the bottom right like this plot below.
ggplot(mtcars, aes(x = mpg , y = hp)) + geom_point() +
labs(title = "Example of Negative Relationship", x = "Miles Per Gallon", y = "Horsepower")
[EXAMPLES OF NO RELATIONSHIP, CURVILINEAR?]
We can describe both the strength and direction of each of these relationships by using Karl Pearson’s Pearson’s Product-Moment Correlation Coeffecient or \(r\). \(r\) has three main properties * \(r\) varies from -1 to 1 * The strength, or magnitude, of the relationship increases as distance from 0 increases. * The sign of the correlation represents the direction, or slope of the relationship.
In order to explore how \(r\) works, we are going to focus on an example where a graduate student samples 50 college professors in social sciences at the same university who have been there for at least 10 years. She measures them on a number of characteristics: average quality of their instruction, average quality of their courses, number of publications, and number of citations by other authors. She wants to know if there is there a relationship between the number of publications and number of citations?
Let’s enter our data in.
# Create Data
yearsTeaching <- c(0,14,1,1,11,3,16,1,13,1,0,7,49)
numberOfPublications <- c(0,90,2,32,53,12,108,4,82,19,0,51,274)
publicationData <- as.data.frame(cbind(yearsTeaching,numberOfPublications))
ggplot(publicationData, aes(x = yearsTeaching, y = numberOfPublications)) + geom_point() +
labs(main = "Publication Data", x = "Years Teaching", y = "Number of Publications")
Now on to the calculations!
9.1 Calculating Person’s r
Using the data from above, the first way we are going to calculate \(r\) is to use the cross products. The cross producets represent the multiplication of X and Y represented on standardized scores. We can use the following two formulas:
\[r_{xy} = \frac{\Sigma z_X z_Y}{N}\]
\[z = \frac{X = \mu}{\sigma}\]
Note these formulas (e.g., z-score) use population characteristics and that this approach is very tedious. It also does not make sense unless you already have the z-scores calculated for some reason.
Since we want to have a better idea of these formulas, let’s break it down. What we are solving for is \(r_{XY}\) which is Pearson’s \(r\). The little \(X\) and \(Y\) indicates that the \(r\) there is representing the relationship between those two variables. This might seem obvious, but once you start looking at bigger datasets where you have more than two varaiblse, this notation is nice to keep track of what each \(r\) represents.
Now the top part of our equation is \(\Sigma z_X z_Y\). The \(\Sigma\) means we need to perform a summation (add them all up!) the products of each set pair of \(z\) scores. So in order to do this, let’s first get the z scores from each of our variables.
## [,1]
## [1,] -0.6720661
## [2,] 0.3733701
## [3,] -0.5973921
## [4,] -0.5973921
## [5,] 0.1493480
## [6,] -0.4480441
## [7,] 0.5227181
## [8,] -0.5973921
## [9,] 0.2986961
## [10,] -0.5973921
## [11,] -0.6720661
## [12,] -0.1493480
## [13,] 2.9869605
## attr(,"scaled:center")
## [1] 9
## attr(,"scaled:scale")
## [1] 13.39154
## [,1]
## [1,] -0.74362264
## [2,] 0.45312906
## [3,] -0.71702815
## [4,] -0.31811092
## [5,] -0.03886886
## [6,] -0.58405574
## [7,] 0.69247940
## [8,] -0.69043367
## [9,] 0.34675113
## [10,] -0.49097506
## [11,] -0.74362264
## [12,] -0.06546334
## [13,] 2.89982142
## attr(,"scaled:center")
## [1] 55.92308
## attr(,"scaled:scale")
## [1] 75.20357
Now that we have the \(z\) scores of our data, we then need to multiply them by each other.
We’ve now done the top part of the equation.
All that is left to do is now divide by number of observations we have.
Note here that we could hardcode this is in knowing that we only have 13 observations, but if we were get to more data, we wouldn’t want to have to update that every time!
In order to get around this problem, let’s make R count how many variables we have, then divide by that with the `nrow()
function.
## [1] 0.9142855
And then we can then check that what we did is correct with R’s cor()
function.
[Add in R correlation function?]
The \(r = .91\) in this example! We have a very strong positive correlation between years teaching and number of publications.
Of course we are not always going to want to convert our scores to z scores and calculate it. For that, you might want to use the actual raw scores in your calculation. The deviation score formula is a computational formula that relies on using deviations from respective means:
\[r_{XY} = \frac{\Sigma(X-\bar{X})(Y-\bar{Y})}{\sqrt\Sigma (X-\bar{X})^2\Sigma(Y-\bar{Y})^2} = \frac{\Sigma(X-\bar{X})(Y-\bar{Y})}{\sqrt{SS_{X}SS_{Y}}}\]
Or you could use the formula that uses the raw score, which bypasses the need to calculate the deviations from each mean:
\[r_{XY} = \frac{N\Sigma XY - \Sigma X \Sigma Y}{\sqrt{[ N \Sigma X^2 -(\Sigma X)^2] [N \Sigma Y^2 - (\Sigma Y)^2}] }\]
Finally, we can use the covarianceto compute the correlation.
Covariance is the average sum of the cross-products of deviations:
\(s_{XY} = \frac{\Sigma (X - \bar{X})(Y - \bar{Y})}{N - 1}\)
Dividing this number by the cross-product of the unbiased sample standard deviations produces:
\[r_{XY} = \frac{S_{XY}}{S_X S_y}\]
9.1.1 Assumptions
All correlations require a certain set of assumptions:
- The scores are pairs—the same set of individuals needs to contribute both scores.
- Because the mean and variance are used to compute r, the variables need to be measured on an interval or ratio scale.
- X and Y are normally distributed.
- The observations were randomly sampled. 5.The relationship between the variables is linear, rather than curvilinear. Values of rare uninterpretable (and are underestimates) for curvilinear relationships.
- If the range on one or both variables is restricted (i.e., the group is very homogeneous on X and/or Y), then the value of rtends to become smaller.
For example, if you look at the two scatter plots below, both being created with the same dataset, but one truncated, we can see that there is a change in correlation coeffecient.
[PLOT HERE]
There are a couple of other factors that impact how one interprets a linear correlation. If the range on one or both variables is restricted (i.e., the group is very homogeneous on X and/or Y), then the value of \(r\) tends to become smaller. Theoretically, the correlation can get bigger with range restriction, although this is VERY rare with moderate-to-large sample sizes.
It’s also worth mentioning that sample size will not affect the value of r (unless N = 2), but it will affect its accuracy in terms of statistical significance. If you do run a correlation with two points you are always going to get a perfect correlation!
In addition to \(r\), there is \(r^2\) which is referred to as the coeffecient of determination that represents the amount of variance in Y that can be associated with the variance in X.
We can calculate \(r^2\) with the following formula. \[r^2 = \frac{s^2_X}{s^2_Y} = \frac{S^2_X}{s^2_X + s^2_{Res}}\]
In the formula above, \(r^2\) is the coeffecient of determination, \(s^2\) is the ??variation?? in \(s^2_X\), and \(s^2_Y\) is the ??variation?? in Y. The formula on the far right also notes you can have \(r^2\) values that account for other types of variation. For example if know residuals of other variables…
And we can see conceptual representations of \(r^2\) below.
Finally, a measured correlation says nothing about whether X and Y are causally linked, only that there is an association. There are three generic possible reasons for the association.
- X could be driving the relationship with Y
- Y could be driving the relationship with X
- A third, unaccounted variable Z, could be driving both relationships!
9.2 Testing the significance of the correlation coefficient.
It’s important to note here that just like all tests of significance, you are only testing whether or not the correlation is different from 0! Represented numerically, our null hypothesis for testing the significance of the correlation coeffecient is that \(H_0 : \rho = 0\). We then use a \(t\) statistic to find our critical value.
\[t = r\sqrt{\frac{n-2}{1-r^2}}= \frac{r - \rho_0}{\sqrt{\frac{1-r^2}{N-2}}}\]
Walking through the above formula, we are multiplying our correlation coeffecient (\(r\)) by the square root of our sample size \(n\) subtract 2, divided by \(1\) subtract our coeffecient of determination. We find our degrees of freedom by subtracting 2 from our sample size.
Using our data from above, it would look like:
\[t = .83\sqrt{\frac{50-2}{1-.82^2}}=10.31\]
With an \(\alpha\) of .05 and \(50 - 2 = 48\) degrees of freedom, using a two tailed test, we get a crticial value of about 2.01. Or since there is a table of [critical values associated with correlations] in your textbook in Table A5, we can compare….
We can then also test… [[Add text here to these formulas]]
\[H_0 : \rho = \alpha\] \[z_r = r' = \frac{1}{2}log_e\frac{1+r}{1-r}\]
See table A.6.
\[z = \frac{z_r-z_p}{S_{z_r}}\] \[s_{z_r}= \sqrt{\frac{1}{n-3}}\]
Is the correlation greter than .60?
\[H_0: \rho = .60\] \[z_r = \frac{1}{2}log_e\frac{1+.83}{1-.83}=1.88\] \[s_{z_r}=\sqrt{\frac{1}{50-3}}=0.15\] \[z= \frac{1.19-0.69}{0.15}=3.33\]
9.3 Spearman’s Rho
There is a correlation coefficient to deal with ordinal variables, or those measured by ranks, called Spearman rho.
\[\rho = 1 - \frac{6\Sigma d^2}{n(n^2-1)}\]
Where d is equal to the difference between paired ranks, rather than paired scores.
So using this formula and some new data, we can then calculate Spearman’s \(\rho\)! First thing we need to do is load in some new data
rhoX <- c(595,520,715,405,680,490,565,580,615,435,440,515,380,510,565)
rhoY <- c(68,55,65,42,64,45,56,59,56,42,38,50,37,42,53)
rhoData <- data.frame(rhoX, rhoY)
The first thing we need to do is transform both of our variables into rank order data with the highest number getting the lowest value.
To do that we can use R’s rank()
function.
Note that R normally has the rank order with the lowest the highest number, so if we just negate our vector, we get what we want.
rhoXRanked <- rank(-rhoX,ties.method = "average")
rhoYRanked <- rank(-rhoY, ties.method = "average")
With these ranks, we can then subtract our Y ranks from our X ranks. After subtracting, we will then square them.
rhoDifference <- rhoXRanked - rhoYRanked
rhoDifferenceSquared <- rhoDifference^2
sum(rhoDifferenceSquared)
## [1] 36.5
We then take these \(d^2\) values, and plug them into our formula from above.
\[\rho = 1 - \frac{6\Sigma d^2}{n(n^2-1)}= 1 - \frac{6 * 36.5}{15(15^2-1)} = 1 -.065=.935\]
Which we can then check wiht R’s cor()
function.
## [1] 0.9344764
Note that if we run this same data with \(r\) or Pearson’s we get a smaller value!
## [1] 0.9029575
It’s worth mentioning that there is one more method called Kendall’s Tau (\(\tau\)) which is a type of correlation you can also use with Rank order where you need to count the number of concordant and or discordant pairs and then divide accordintly. In the Andy Field book, he notes that Kendall’s Tau is often used for small sample sizes (CITE).


THE DEVIL MADE ME DO IT
MENU
LOCATION
ACCOUNT
ORDER ONLINE
Thank You For Creating an Account
Continue to Payment


Need a place to store all your secret family recipes that have been handed down from generation to generation?
The little cards your grandma wrote recipes on in her beautiful cursive getting lost or are hard to read? Need somewhere secure to keep your recipes with you at all times!
Finding your recipes has never been easier!
Create your own recipe library and manage it easily. Keep all your recipes in one place
Eliminate those stacks of cookbooks and recipe organizers from your kitchen. You don’t need them anymore.
"So far I've had no problems using this app. It amazes me how it can sort out a recipe and fill it in the correct spots in app. Love that I can edit the recipes and add my notes !!"
"It's revolutionised my recipe collection. A wonderfully intuitive app that slices and dices out the annoying adds from your online recipe searches."
"This is one of the very best apps in my regular use. And the developer is very responsive to suggestions and generous with helpful information. Almost all recipes are imported perfectly. Even when the app does not recognize the formatting of the recipe, it usually imports it in a way that is easily edited."
A simple cookbook to keep your recipes always available.


When running this sample on two PCs with Proximity devices installed, you can use the ProximityDevice to publish messages to the other PC and/or subscribe to messages from the other PC.
Click 'Publish message' on one PC, and click 'Subscribe for message' on the other PC and enter proximity with the other PC. The published message will be received on the PC that subscribed.


Welcom to pat's salmon Cookies!
SalesDetialsAll locations are open Monday - Saturday from 6am - 7pm.
-
Pike Place Market
85 Pike St
Seattle, WA 98101
206-555-5555 -
Pike Place Market
210 Pike St
Tokyo, WA 66547
206-555-5555 -
Pike Place Market
44 Pike St
Dubai, WA 66951
206-555-5555 -
Pike Place Market
59 Pike St
Paris, WA 331523
206-555-5555 -
Pike Place Market
88 Pike St
Lima, WA 663214
206-555-5555
History of Pat's Salmon Cookies Well, the way they make shows is, they make one show. That show's called a pilot. Then they show that show to the people who make shows, and on the strength of that one show they decide if they're going to make more shows. Some pilots get picked and become television programs. Some don't, become nothing. She starred in one of the ones that became nothing.  But I can't give you this case, it don't belong to me.  Lorem ipsum dolor sit, amet consectetur adipisicing elit. Atque repellendus autem magnam numquam nemo aperiam! Odio voluptatibus corrupti, mollitia nobis dolore nemo, dolorum doloribus sit, distinctio magni aspernatur nihil sint?


Starts local live trading in a Docker container using the quantconnect/lean Docker image.
The logs of the algorithm are shown in real-time and the full results are stored in the <project>/live/<timestamp>
directory.
You can use the --output
option to change the output directory.
The given <project>
argument must be either a project directory or a file containing the algorithm to run a backtest for.
If it is a project directory the CLI looks for a main.py
or Main.cs
file, assuming the first file it finds to contain the algorithm to run.
By default, an interactive wizard is shown letting you configure the brokerage and data feed to use.
When --environment
, --brokerage
, or --data-feed
is given the command runs in non-interactive mode and does not prompt for input.
When the --environment
option is given the environment with the given name is used.
The given environment must be one of the live environments stored in your Lean configuration file.
This means the environment must have the live-mode
property set to true
.
When --brokerage
or --data-feed
is given, the live configuration is read from the command-line options.
In case a required option has not been provided, the command falls back to the property with the same name in your Lean configuration file.
The command aborts if this property also hasn't been set.
The required options depend on the selected brokerage or data feed.
The following options are required for each brokerage in non-interactive mode:
--brokerage "Paper Trading"
--brokerage "Interactive Brokers"
--ib-user-name
: must be set to your Interactive Brokers username (example: trader777).--ib-account
: must be set to your Interactive Brokers account id (example: DU1234567).--ib-password
: must be set to your Interactive Brokers account password.--brokerage "Tradier"
--tradier-account-id
: must be set to your Tradier account id, which you can find on your Settings/API Access page.--tradier-access-token
: must be set to your Tradier access token.--tradier-use-sandbox
: must be set to yes
or no
depending on whether you want to use the developer sandbox.--brokerage "OANDA"
--oanda-account-id
: must be set to your OANDA account id, which you can find on your Account Statement page.--oanda-access-token
: must be set to your OANDA API token, which you can generate on the Manage API Access page.--oanda-environment
: must be set to Practice
for fxTrade Practice or Trade
for fxTrade.--brokerage "Bitfinex"
--bitfinex-api-key
: must be set to your Bitfinex API key, which you can generate on the API Management page.--bitfinex-api-secret
: must be set to your Bitfinex API secret.--brokerage "Coinbase Pro"
--gdax-api-key
: must be set to your Coinbase Pro API key, which you can generate on the API settings page.--gdax-api-secret
: must be set to your Coinbase Pro API secret.--gdax-passphrase
: must be set to your Coinbase Pro API passphrase.--gdax-use-sandbox
: must be set to yes
or no
depending on whether you want to use the sandbox.--brokerage "Binance"
--binance-api-key
: must be set to your Binance API key, which you can generate on the API Management page.--binance-api-secret
: must be set to your Binance API secret.--binance-use-testnet
: must be set to yes
or no
depending on whether you want to use the testnet.--brokerage "Zerodha"
--zerodha-api-key
: must be set to your Kite Connect API key.--zerodha-access-token
: must be set to your Kite Connect access token.--zerodha-product-type
: must be set to MIS
if you are targeting intraday products, CNC
if you are targeting delivery products, or NRML
if you are targeting carry forward products.--zerodha-trading-segment
: must be set to EQUITY
if you are trading equities on NSE or BSE, or COMMODITY
if you are trading commodities on MCX.--brokerage "Bloomberg
--bloomberg-organization
: must be set to the name or id of the QuantConnect organization with a license for the Bloomberg module.--bloomberg-environment
: must be set to the environment to use, which can be either Production
or Beta
.--bloomberg-server-host
: must be set to the host of the Bloomberg server.--bloomberg-server-port
: must be set to the port of the Bloomberg server.--bloomberg-symbol-map-file
: must be set to the path to a symbol map file. The symbol map file must be a JSON file (comments are supported) in which the keys are the Bloomberg symbol names and the values are the corresponding QuantConnect symbols. This content can be used as an example:
/* This is a manually created file that contains mappings from Bloomberg's own naming to original symbols defined by respective exchanges. */ { // Example: /*"SPY US Equity": { "Underlying": "SPY", "SecurityType": "Equity", "Market": "usa" }*/ }
--bloomberg-emsx-broker
: must be set to the name of the EMSX broker to use.--bloomberg-emsx-user-time-zone
: may be set to EMSX user timezone to use (optional).--bloomberg-emsx-account
: may be set to EMSX account to use (optional).--bloomberg-emsx-strategy
: may be set to the EMSX strategy to use (optional).--bloomberg-emsx-notes
: may be set to the EMSX notes to use (optional).--bloomberg-emsx-handling
: may be set to EMSX handling to use (optional).--bloomberg-allow-modification
: must be set to yes
or no
depending on whether modification is allowed.--brokerage "Atreyu"
--atreyu-organization
: must be set to the name or id of the QuantConnect organization with a license for the Atreyu module.--atreyu-host
: must be set to the host of the Atreyu server.--atreyu-req-port
: must be set to the request port to use.--atreyu-sub-port
: must be set to the subscribe port to use.--atreyu-username
: must be set to your Atreyu username.--atreyu-password
: must be set to your Atreyu password.--atreyu-client-id
: must be set to Atreyu client id.--atreyu-broker-mpid
: must be set to the broker MPID to use.--atreyu-locate-rqd
: must be set to the locate rqd to use.--brokerage "Trading Technologies"
--tt-organization
: must be set to the name or id of the QuantConnect organization with a license for the Trading Technologies module.--tt-user-name
: must be set to your Trading Technologies username.--tt-session-password
: must be set to Trading Technologies session password.--tt-account-name
: must be set to Trading Technologies account name.--tt-rest-app-key
: must be set to your Trading Technologies REST app key.--tt-rest-app-secret
: must be set to Trading Technologies app secret.--tt-rest-environment
: must be set to the REST environment to run in.--tt-market-data-sender-comp-id
: must be set to the market data sender comp id.--tt-market-data-target-comp-id
: must be set to the market data target comp id.--tt-market-data-host
: must be set to the host of the market data server.--tt-market-data-port
: must be set to the port of the market data server.--tt-order-routing-sender-comp-id
: must be set to the order routing sender comp id.--tt-order-routing-target-comp-id
: must be set to the order routing target comp id.--tt-order-routing-host
: must be set to the host of the order routing server.--tt-order-routing-port
: must be set to the port of the order routing server.--tt-log-fix-messages
: must be set to yes
or no
depending on whether FIX messages should be logged.The following options are required for each data feed in non-interactive mode:
--data-feed "Interactive Brokers"
--brokerage "Interactive Brokers"
.--ib-enable-delayed-streaming-data
: must be set to yes
or no
depending on whether delayed data may be used when your algorithm subscribes to a security you don't have a market data subscription for.--data-feed "Tradier"
--brokerage "Tradier"
.--data-feed "OANDA"
--brokerage "Tradier"
.--data-feed "Bitfinex"
--brokerage "Bitfinex"
.--data-feed "Coinbase Pro"
--brokerage "Coinbase Pro"
.--data-feed "Binance"
--brokerage "Binance"
.--data-feed "Zerodha"
--brokerage "Zerodha"
.--zerodha-history-subscription
: must be set to yes
or no
depending on whether you have a history API subscription for Zerodha.--data-feed "Bloomberg"
--brokerage "Bloomberg"
.--data-feed "Atreyu"
--brokerage "Atreyu"
.--data-feed "Trading Technologies"
--brokerage "Trading Technologies"
.--data-feed "IQFeed"
(only supported on Windows)
--iqfeed-iqconnect
: must be set to the path to your IQConnect binary.--iqfeed-username
: must be set to your IQFeed username.--iqfeed-password
: must be set to your IQFeed password.--iqfeed-product-name
: must be set to the product name of your IQFeed developer account.--iqfeed-version
: must be set to the product version of your IQFeed developer account.--data-feed "Custom data only"
Example non-interactive usage:
$ lean live "My Project" \ --brokerage "Paper Trading" \ --data-feed "Interactive Brokers" \ --ib-user-name "trader777" \ --ib-account "DU1234567" \ --ib-password "hunter2" \ --ib-enable-delayed-streaming-data yes
The Docker image that is used contains the same libraries as the ones available on QuantConnect. If the selected project is a C# project it is compiled before starting live trading.
By default, the official LEAN engine image is used.
You can override this using the --image <value>
option.
Alternatively, you can set the default engine image for all commands using lean config set engine-image <value>
.
The image is pulled before starting the local live trading if it doesn't exist locally yet or if you pass the --update
flag.


With the recent Bancor Initial Coin Offering (ICO) raking in over 150 million USD in ETH, it is undeniable that ICO’s are huge. They are hyped throughout the community, and they often sell out within hours, minutes, or even blocks.
With “The DAO” incident still fresh in the memories of many, ICO’s can be a little worrying. This post will include the common concerns relating to the rapid ICO growth, and my opinion on their validity.
Speed of sale
ICO’s that are extremely popular can and have sold out in only a handful of blocks. Some see this as a problem because many smaller players have trouble buying only a few tokens without spending a ridiculous amount of gas to get their transaction verified before the token is sold out. Purchasers will likely have to use a program like Parity and take advantage of its automatic sending feature to attempt to send their transaction at the exact block number that the ICO begins.
I see this as one of the weakest arguments against the current ICO model. ICO’s are held to collect funds, and are not intended to allow everyone to have a piece of the pie. While it would be nice to allow those who only wish to purchase a small number of tokens without expending a large sum of gas, this is a problem with the platform itself, and not the ICO model. If a whale wishes to buy up 30% of the tokens in one transaction, I do not see why he/she should be limited from doing so.
Legitimacy and success rate
How can you tell if an ICO is going to succeed? There is no foolproof method. Many like to analyze the project’s team and their past projects or contributions to the cryptography and programming world (for example, Brave).
It is horrifyingly easy to make some fancy mockups and a technical whitepaper to generate interest in your project, and this is something that worries me. It would not be hard to generate interest in a facade of a technology and make away with the funds, especially with the current buzz around promising ICO’s. Auditing of project code is helpful, but not every project supplies code to be audited before a crowd sale, or the project may have no publically written code at all.
Dumb money
Another common argument about the danger of ICO’s is often called “dumb money”. When people talk about “dumb money” in the Ethereum space they are talking about people who do not have a full understanding of the technology, and rather see it as a means to get rich quick. These people could be looking for Bitcoin 2.0, or want a share in the price growths of ETH. The argument is usually based around the fact that “dumb money” generates hype around ICO’s or even ETH itself without actually understanding the technology itself, hiking the price up to an unhealthy point. They likely do not plan to use the tokens for their intended use in the ecosystem, but rather list them on exchanges as soon as they are accepted.
Widespread effects of a failure
Perhaps the scariest thing about ICO’s is what happens if one fails. The effects of an ICO failure would surely have community wide ramifications, but what exactly is an ICO failure? An ICO failure could come in many different forms. Funds could be mishandled, smart contracts on the network could be exploited in a way that causes funds to be lost or stolen, a project could not make any progress with the collected funds, or many other things. A failure of a large ICO could have an effect on the price of ETH if holders sell in fear of a collapse, or leave a bad taste in the mouths of potential buyers. The network may not be ready for ICO’s, but that isn’t stopping them.
What happens in a failure? It’s hard to say, but I am sure we will find out soon.


--- layout: default --- {% include intro.html %}
| When | May 14th and 21st. Play begins at 7.15 AM and in the evening from 4 PM on both days. There is also a reserve day, May 28th. We will make sure that the timings will not conflict with ACL. |
| Where | Ocee Park - 10900 Buice Road, Alpharetta, GA 30022-6553 |
| Registration | Fee is $120 for a team of 6 players.. Each additional player is $20. Only the registered 8 players, on or before May 14th, will be qualified to play in rest of the remaining games like quarters, semis and finals.
Rally scoring. 21 point sets. Register by emailing the team name and player details to<EMAIL_ADDRESS>|
| Where will be my money spent? | If you know a good cause. Let us know! |
| Format | To be determined |
| Ball that will be used for the tournament. Click here to purchase. |


Web Audio API
Chinmay Pendharkar
September 2013
About Me..
Acoustician / Audio Engineer
Podcaster (WeBuildSG Live)
Geek
Audio + Web History
Browsers in the 90s - #FAIL
Plugins save the day?
Flash, Java, .. (urgh!!)
Plugin Free Web!
Why?
Lean(er) Stack
Website > Browser > OS
Website > Plugin > Browser > OS
Less breakable parts
(theoretically)
↓
Reliance on single party
(Adobe)
Web + Audio
Before
Flash , Java
(Urgh!!)
After
HTML5 Audio,
WebAudio,
WebRTC*,
WebMIDI*
* Ongoing W3C Standardization process
HTML5 Audio
<audio> / HTMLAudioElement()
Part of the DOM Elements.
Allows basic playback of Audio files.
Basic functionality support in all Major browsers.
<audio controls="controls">
Your browser does not support the audio element.
<source src="http://bit.ly/deepmp3" type="audio/wav">
</audio>
Your browser does not support the audio
element.
HTML5 Audio Features
Autoplay
(hello! 1990s called they want their website back)
Loop
audioTag.loop = true;
Your browser does not support the audio
element.
Speed
Web Audio API
" JavaScript API for processing and synthesizing audio"
JavaScript API
Audio Processing is usually done at a lower level (C++/ASM)
Realtime => Callback Based
Web Audio API
"signal routing graph paradigm"
WebAudio VIPs
AudioNode - Everything is an AudioNode
AudioContext -
God of WebAudio. Everything begins and ends here.
myContext = new webkitAudioContext();
Destination -
Main Audio output. Plug everything into this..
source = context.createOscillator();
source.connect(myContext.destination);
Pitch
Volume
▶❚❚
AudioNodes
Analyser
BiquadFilter
Buffer
BufferSource
ChannelMerger
ChannelSplitter
Convolver
Delay
DelayNode
DynamicsCompressor
GainNode
JavaScriptNode
MediaElementSource
MediaStreamDestination
MediaStreamSource
Oscillator
Panner
ScriptProcessor
WaveShaper
WaveTable
Filter
var audio = new Audio();
audio.src = 'https://dl.dropboxusercontent.com/u/77191118/DeepIntoIt.mp3';
source = context.createMediaElementSource(audio);
var filter = context.createBiquadFilter();
filter.type = filter.LOWPASS;
filter.frequency.value = 5000;
source.connect(this.filter);
filter.connect(context.destination);
Pause/Play
▶❚❚
Filter Cutoff
Convolver
var source = context.createBufferSource();
var convolver = context.createConvolver();
source.connect(convolver);
convolver.connect(context.destination);
/*Load source audio and impulse response*/
var request = new XMLHttpRequest();
request.open("GET", "https://dl.dropboxusercontent.com/u/77191118/deep10.mp3", true);
request.responseType = "arraybuffer";
request.onload = function () {
source.buffer = context.createBuffer(request.response, 2);
var ir_request = new XMLHttpRequest();
ir_request.open("GET", "https://dl.dropboxusercontent.com/u/77191118/church_ir.wav", true);
ir_request.responseType = "arraybuffer";
ir_request.onload = function () {
convolver.buffer = context.createBuffer(ir_request.response, 2);
source.start(0);
}
ir_request.send();
}
request.send();
Hall : ▶❚❚
Can : ▶❚❚
Demos
Synth :
http://synth.soundkeep.com/
Sequencer :
http://labs.dinahmoe.com/ToneCraft/
WavePad :
http://alxgbsn.co.uk/wavepad/
Games :
http://chrome.angrybirds.com/
Resources
http://www.html5audio.org/
http://www.w3.org/wiki/HTML/Elements/audio
https://dvcs.w3.org/hg/audio/raw-file/tip/webaudio/specification.html
http://www.html5rocks.com/en/tutorials/webaudio/intro/
More Resources
http://animatedsoundworks.com:8001/
https://github.com/web-audio-components
https://github.com/cwilso/WebAudio
https://github.com/audiocogs
What's coming?
WebRTC
(getUserMedia API)
WebMIDI
asm.js
Final words
Your mileage WILL vary.
Watch out for Browser/OS dependencies for functionality.
Watch
out for codec issues
(mp3/wav/ogg).

Questions?
https://github.com/notthetup/webaudioslides
@ntt


|
F´ Flight Software - C/C++ Documentation
NASA-v1.5.0
A framework for building embedded system applications to NASA flight quality standards.
|
Auto-generated base for PassiveTextLogger component. More...
#include <build-fprime-automatic-native/F-Prime/Svc/PassiveConsoleTextLogger/PassiveTextLoggerComponentAc.hpp>
Public Types | |
| enum | { NUM_TEXTLOGGER_INPUT_PORTS = 1 } |
Public Member Functions | |
| Fw::InputLogTextPort * | get_TextLogger_InputPort (NATIVE_INT_TYPE portNum) |
| void | init (NATIVE_INT_TYPE instance=0) |
| virtual | ~PassiveTextLoggerComponentBase (void) |
| Public Member Functions inherited from Fw::PassiveComponentBase | |
| void | setIdBase (const U32) |
| Set the ID base. More... | |
| U32 | getIdBase (void) const |
| virtual | ~PassiveComponentBase () |
| Destructor. More... | |
| void | init (NATIVE_INT_TYPE instance) |
| Initialization function. More... | |
| NATIVE_INT_TYPE | getInstance (void) const |
Friends | |
| class | PassiveTextLoggerComponentBaseFriend |
Additional Inherited Members | |
| Protected Member Functions inherited from Fw::ObjBase | |
| ObjBase (const char *name) | |
| ObjBase constructor. More... | |
| virtual | ~ObjBase () |
| Destructor. More... | |
| void | init (void) |
| Object initializer. More... | |
Auto-generated base for PassiveTextLogger component.
Definition at line 31 of file PassiveTextLoggerComponentAc.hpp.
| anonymous enum |
| Enumerator | |
|---|---|
| NUM_TEXTLOGGER_INPUT_PORTS |
Definition at line 136 of file PassiveTextLoggerComponentAc.hpp.
|
virtual |
Destroy a PassiveTextLoggerComponentBase object
Definition at line 92 of file PassiveTextLoggerComponentAc.cpp.
| Fw::InputLogTextPort * Svc::PassiveTextLoggerComponentBase::get_TextLogger_InputPort | ( | NATIVE_INT_TYPE | portNum | ) |
Get input port at index
| portNum | The port number |
Definition at line 28 of file PassiveTextLoggerComponentAc.cpp.
| void Svc::PassiveTextLoggerComponentBase::init | ( | NATIVE_INT_TYPE | instance = 0 | ) |
Initialize a PassiveTextLoggerComponentBase object
| instance | The instance number |
Definition at line 54 of file PassiveTextLoggerComponentAc.cpp.
|
friend |
Friend class for white-box testing
Definition at line 41 of file PassiveTextLoggerComponentAc.hpp.
| PROTECTED Svc::PassiveTextLoggerComponentBase::__pad0__ |
Definition at line 57 of file PassiveTextLoggerComponentAc.hpp.
| PROTECTED Svc::PassiveTextLoggerComponentBase::__pad1__ |
The port number
Definition at line 85 of file PassiveTextLoggerComponentAc.hpp.
| PROTECTED Svc::PassiveTextLoggerComponentBase::__pad2__ |
The port number
Definition at line 101 of file PassiveTextLoggerComponentAc.hpp.
| PROTECTED Svc::PassiveTextLoggerComponentBase::__pad3__ |
Definition at line 119 of file PassiveTextLoggerComponentAc.hpp.
| PROTECTED Svc::PassiveTextLoggerComponentBase::__pad4__ |
Definition at line 140 of file PassiveTextLoggerComponentAc.hpp.
| PRIVATE Svc::PassiveTextLoggerComponentBase::__pad5__ |
The component instance
Definition at line 157 of file PassiveTextLoggerComponentAc.hpp.
| PROTECTED FwEventIdType Svc::PassiveTextLoggerComponentBase::id |
Log ID
Definition at line 95 of file PassiveTextLoggerComponentAc.hpp.
| PRIVATE NATIVE_INT_TYPE FwEventIdType Svc::PassiveTextLoggerComponentBase::id |
Log ID
Definition at line 168 of file PassiveTextLoggerComponentAc.hpp.
| PRIVATE NATIVE_INT_TYPE Svc::PassiveTextLoggerComponentBase::portNum |
The port number
Definition at line 167 of file PassiveTextLoggerComponentAc.hpp.
| PROTECTED FwEventIdType Fw::Time Fw::TextLogSeverity Svc::PassiveTextLoggerComponentBase::severity |
The severity argument
Definition at line 97 of file PassiveTextLoggerComponentAc.hpp.
| PRIVATE NATIVE_INT_TYPE FwEventIdType Fw::Time Fw::TextLogSeverity Svc::PassiveTextLoggerComponentBase::severity |
The severity argument
Definition at line 170 of file PassiveTextLoggerComponentAc.hpp.
| PROTECTED FwEventIdType Fw::Time Fw::TextLogSeverity Fw::TextLogString & Svc::PassiveTextLoggerComponentBase::text = 0 |
< Text of log message
Definition at line 98 of file PassiveTextLoggerComponentAc.hpp.
| PRIVATE NATIVE_INT_TYPE FwEventIdType Fw::Time Fw::TextLogSeverity Fw::TextLogString& Svc::PassiveTextLoggerComponentBase::text |
< Text of log message
Definition at line 171 of file PassiveTextLoggerComponentAc.hpp.
| PROTECTED FwEventIdType Fw::Time & Svc::PassiveTextLoggerComponentBase::timeTag |
Time Tag
Definition at line 96 of file PassiveTextLoggerComponentAc.hpp.
| PRIVATE NATIVE_INT_TYPE FwEventIdType Fw::Time& Svc::PassiveTextLoggerComponentBase::timeTag |
Time Tag
Definition at line 169 of file PassiveTextLoggerComponentAc.hpp.


Alice au pays des micro-services
By Julien Giovaresco and Kevin Creix
Some figures
- 250+ clients
- 515k+ shops
- 5M monthly unique visitors
- 15M daily visited pages
Legacy
- July 2009
- 1 GIT repository
- 8 developers
- 25,814 commits
- 1,047 releases
Ready to trip down the rabbit hole ?
Leitmotiv
« Go as micro as possible! »
simple / modular / easy / tests / refacto
Want to Share some Library ?
(Authentication, DB, Access control, ...)
Try to avoid! But if you do, do micro libraries and keep all your services up to date!
Promising evolutions
- Setup an API gateway
- Use a storage API
Microservices caveats
- Configuration on multiple spots
- Deployment agility
Kubernetes
- Containers orchestrator
- Started by Google
- Run and manage containers
- Provides container grouping, load balancing, auto-healing, scaling features
Our backbone
- Internal DNS
- Centralized configuration
- The Kubernetes way of managing outages
- Easy-peasy deploy
How to produce this yaml ?
- Meta-project ensure consistency
- Jenkins pipelines
Release
- Weekly
- More Jenkins pipelines
- Our process
- Update version in meta-project
- Tests
- Tag
3
Share data between services
Your services needs to share data
The different path
- One single shared DB (strong coupling)
- Ask data when needed (slow read)
- Full data copy (NoSQL way : fast read)
Data Synchro complexity grows along with service decentralization
You need development stacks
- Dedicate cluster
- External services
- Internal services
The big messaging bugs (meta-data mandatory)
- Monitoring
- User
- Correlation id
- ...
Use explicit contract
- Avro, Protobuf, ...
- GraphQL
The slide to remember
- We did it! So can you!
- We don't regret it (for now)
- Go as micro as you can
- Use an orchestrator
- Data distribution is more complex than you think!


@{{ twitter_login.extra_data.access_token.screen_name }}
You must define a password for your account before disconnecting from Twitter.


Dropbox: Overvalued And Risky
by Michael Wiggins De OliveiraSummary
- A discussion of Dropbox's declining growth rates.
- Scrutinization of Dropbox's "clean" free cash flow movements.
- Why shareholders would do well to heed my advice and avoid this investment.
Investment Thesis
Dropbox (DBX) once had strong potential. However, today, a combination of increased competition and specialization has led Dropbox to operate as a former shadow of itself.
For new shareholders, paying up close to $8 billion market cap sets them up for a very negative risk-reward profile.
On balance, this stock is best avoided.
Revenue Growth Is Slowing
Dropbox is heavy on rhetoric but ultimately its revenues growth rates are decelerating:
Source: author's calculations (GAAP revenues; not F/X adjusted)
Going through the earnings call and there is a lot to like. For example, Dropbox talks about its new go-to-market products, such as its smart workspace and connected workspace. It also highlights how users are paying higher ARPUs than in the past.
Source: Q3 2019 SEC filings; APRU
However, digging into Dropbox's 10-Q, it shows that its APRUs are already reaching the top end of what users are willing to pay. This is evidenced by the decline in Q3 2019 to 3.8% compared with its trailing nine months of 2019 when it posted 4.1% growth.
Furthermore, the 10-Q talks about a non-recurring bump in the trailing nine months of 2019 as Dropbox took its existing customers away from its legacy Dropbox Business teams' pricing plan onto its Dropbox Business Advanced plan. Why is this relevant?
Because customers that were already part of Dropbox's storage solutions were understandably easier to convince to upgrade to the higher pricing plan.
Source: author's calculations, SEC filings
The verdict is still out on whether new customers will be as willing to embrace higher charges for their products. But the graph above appears to show that the growth in paying users is also tapering.
Under The Hood: More Questions Than Answers
This is Dropbox's historical performance:
Source: Q3 2019 investor presentation
This is Dropbox's most recent performance:
Source: Q3 2019 investor presentation
The former illustration shows a company rapidly growing. The latter shows a company having reached its maximum potential.
On a positive note, Dropbox's balance sheet is fairly clean, with over $1 billion of net cash.
On the other hand, if we account for Dropbox's payments on its finance lease obligations, rather than boasting of $231 million of free cash flow for its 9 months ending September:
Its free cash flow is actually closer to $159 million for its trailing nine months.
Next, if we account for Dropbox's $192 million worth of stock-based compensation as a ''cash cost'' for its trailing nine months, we are left with a company that doesn't actually generate any clean free cash flow.
Valuation - No Margin Of Safety
Source: author's calculations
As noted, Dropbox's cash flow from operations presented in the table above does not account for Dropbox's capex requirements, its cash outflows towards principal payments on its lease obligations, and its stock-based compensation -- in other words, this is a ''gross'' cash figure.
Nevertheless, even without factoring all those adjustments, we can still see that Dropbox's valuation is inflated relative to its underlying potential, where shareholders are being asked to pay 16.7x trailing cash flows for a company that is rapidly decelerating.
The Bottom Line
Investors weighing up whether to give Dropbox the benefit of the doubt would do well to weigh up the fact that revenue growth rates are starting to face permanent decline.
Further, I assert that its tangible free cash flows are weaker than they superficially appear.
Meanwhile, paying up close to $8 billion market cap and expecting to see any upside potential is nonsensical.
Looking For Strong Returns?
Dropbox is terrific! But numerous studies have shown that it is difficult to beat the market with popular names.
Meanwhile, by being extremely selective and investing in less popular companies, your chances substantially improve.
Investment strategy inspired by Buffett, Pabrai, and Greenblatt that can help you generate between 50% and 200% potential upside in just a few years, then sign up for your two-week free trial with Deep Value Returns today!
SKIN IN THE GAME: I'm always invested alongside you in My TOP 5 STOCKS!
Disclosure: I/we have no positions in any stocks mentioned, and no plans to initiate any positions within the next 72 hours. I wrote this article myself, and it expresses my own opinions. I am not receiving compensation for it (other than from Seeking Alpha). I have no business relationship with any company whose stock is mentioned in this article.


--- layout: post esbma_id: 1641 title: CodeGear date: 2006-11-21 12:00:00 ---
So last week while I was in Madrid, Borland finally announced what they're doing with "DevCo". Instead of selling their dev tools division, they are spinning it out into a wholly owned subsidiary called CodeGear.

Actually, I have a bunch of different thoughts. So, in the spirit of my favorite scene from Roxanne, here are twenty possible reactions I could offer:
|
Flattered |
Wow! One of the most influential developer tools companies has just chosen a new name which rides on the popularity of SourceGear! |
|
Financial |
Wasn't the sale of DevCo supposed to provide the cash infusion necessary to make Borland's enterprise strategy look credible? |
|
Childish |
Hey Joel! All the really cool companies have Gear at the end of their name. Maybe you should change the name of your company to FogGear! You're not cool if you don't! |
|
Bitter |
Hmph. IIRC, when we chose the name SourceGear, we tried to register codegear.com as well, but it wasn't available at the time. |
|
Advisory |
Wouldn't CodeBeer have been a better choice? The domain is available. |
|
Veterinary |
Okay, I've lost count. If Borland were a cat, would this be its 8th life or its 9th? |
|
Skeptical |
Nick Hodges says: "We are our own company. We decide how to run our business. We decide what products to release. We decide how to market our products.   We decide. No one else. That feels really good. Believe me." Every company is accountable to and subject to the direction of its owners. No exceptions. I understand that CodeGear is being structured as an autonomous, independent, separate company, but it is still owned by Borland, and is ultimately under Borland's control. |
|
Snide |
Cool! Three years from now when SourceGear acquires CodeGear, merging the brands will be simple! |
|
Bilingual |
I think the conjugation of their name actually works better than ours: codegeo, codegeas, codegea, codegeamos, codegeáis, codegean |
|
Friendly |
I agree with Larry O'Brien. To me, this seems like a big deal for the software industry. CodeGear has some excellent products, and hopefully they have created enough detachment from Borland for those products to become successful again. I wish them the best of luck. |
|
Prophetic |
Obviously they failed in their first attempt to sell DevCo, but CodeGear is still for sale. This move is just an intermediate step. If CodeGear does well, it'll be back on the block within two years. |
|
Disappointed |
Hmmm. I've been waiting for the DevCo spinoff, expecting it to be a company with whom SourceGear would want to partner (whereas Borland really isn't). But now, the similarity of the two names makes me pause and think. If SourceGear and CodeGear were working together on something, wouldn't that merely increase the confusion? |
|
Approving |
Nick Hodges says: "We are a company wholly and totally focused on developers." Welcome [back] to the world of selling products for developers who choose their own tools. This is SourceGear's path as well. Lots of companies prefer to sell products for developers whose tools are chosen for them. Your parent company is one example. That strategy can be quite lucrative, but it's not very satisfying. |
|
Stubborn |
Regardless of what the new company is called, I still think it was a big mistake to stir the .NET stuff into the Delphi soup. It's great that CodeGear is focused on developers, but that focus still isn't sharp enough. You guys need to get your strategy and positioning really tight and prune everything that doesn't fit. |
|
Naughty |
SourceGear will soon be announcing a compiler/IDE product built on a Pascal-style language called Belphi. |
|
Sympathetic |
Sometimes it's not much fun to have a company name which is spelled with CamelCase. When you get sick of people spelling it "Codegear", call me to commiserate. |
|
Competitive |
Of all the dev tools companies that have Gear at the end of their name, I wonder which one will have the most revenue in five years? |
|
Irrelevant |
You guys do realize your name is an anagram for GEODE CAR, right? |
|
Optimistic |
The name similarity will definitely cause confusion, but even though SourceGear has had its name longer, CodeGear probably still has a much larger audience, so perhaps the confusion will work in our favor. |
|
Cinematic |
When they make the movie version of the full history of Borland/Inprise/CodeGear, they'll get Leonardo DiCaprio to play Nick Hodges, but what part will Kate Winslet play? |
:-)


EvenHire is a responsive web application that removes the unconscious bias from the hiring process by hiding data that might reveal gender or ethnicity, allowing recruiters to diversify their workforce.
FreeBeez is a web application that allows a user to post items that she/he wants to give away. Other users can see the posted items and their locations.


This is an example department provided with a new installation of JKAN
0 datasets
The Chicago Department of Transportation (CDOT) is responsible for public way infrastructure, including planning, design, construction, maintenance and management.


Using Java GUI for R (JGR), CADStat provides a user interface for several statistical methods - scatterplot, boxplot, linear regression, generalized linear regression, quantile regression, conditional probability calculations, and regression trees.
| Version: | 3.0.8 |
| Depends: | R (≥ 2.15.0), JGR (≥ 1.7-10) |
| Imports: | rJava, XML, lattice, bio.infer, gdata, gmodels, quantreg, rpart, JavaGD, car, MASS |
| Published: | 2017-05-10 |
| Author: | Lester Yuan, Tom Stockton, Doug Bronson, Pasha Minallah, and Mark Fitzgerald |
| Maintainer: | David Rebhuhn <rebhuhn.david at epa.gov> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: | http://www.rforge.net/CADStat/ |
| NeedsCompilation: | no |
| Materials: | README NEWS |
| CRAN checks: | CADStat results |
| Reference manual: | CADStat.pdf |
| Package source: | CADStat_3.0.8.tar.gz |
| Windows binaries: | r-devel: CADStat_3.0.8.zip, r-release: CADStat_3.0.8.zip, r-oldrel: CADStat_3.0.8.zip |
| OS X binaries: | r-release: CADStat_3.0.8.tgz, r-oldrel: CADStat_3.0.8.tgz |
| Old sources: | CADStat archive |
Please use the canonical form https://CRAN.R-project.org/package=CADStat to link to this page.


Milk, bread, eggs, and more delivered to your doorstep daily!
Bengaluru
Mumbai
Navi Mumbai
kolkata
Thane
Pune
Delhi
New Delhi
Other


The following reports have been generated for the project Pynocle by pynocle.
View reports for details, and information about what report is and suggested actions.
For an overview of metrics (and why things like pynocle are important), check out the following pages:


The button below allows you to delete your account and all its associated data.
This is a destructive action, and can not be undone.

While that you are free to create another account, no data will be able to be recovered.
Are you sure you want to do this?
{{ error }}


Portfolio
Space app
Space
Displays the planets in space and highlights key known facts.
The technologies I used are HTML, CSS, JavaScript and Reactjs.
Steven Ennis Profile
Beipro
Beipro
Beipro is a platform that conveniently connects buyers to the prevailing bulk petroleum stock prices.
BeiproThe technologies I used are CSS, Bootstrap, JavaScript, Reactjs, PHP, Laravel.
Swapi
Star Wars People
The technologies graphQL, Apollo client, Apollo server, ReactJs
Giphy
Fetch giphy's
Giphy is an application that is used to search GIF-images.
The technologies I used are HTML, CSS, SCSS, LESS, and JavaScript.


PackR is a Ruby version of Dean Edwards’ JavaScript compressor.
Whitespace and comment removal
Compression of local variable names
Compression and obfuscation of ‘private’ (_underscored) identifiers
Base-62 encoding
To call from within a Ruby program:
require 'packr' code = File.read('my_script.js') compressed = Packr.pack(code) File.open('my_script.min.js', 'wb') { |f| f.write(compressed) }
This method takes a number of options to control compression, for example:
compressed = Packr.pack(code, :shrink_vars => true, :base62 => true)
The full list of available options is:
:shrink_vars — set to true to compress local variable names
:private — set to true to obfuscate ‘private’ identifiers, i.e. names beginning with a single underscore
:base62 — encode the program using base 62
:protect — an array of variable names to protect from compression, e.g.
compressed = Packr.pack(code, :shrink_vars => true,
:protect => %w[$super self])
To call from the command line (use packr --help to see available options):
packr my_script.js > my_script.min.js
This program is not a JavaScript parser, and rewrites your files using regular expressions. Be sure to include semicolons and braces everywhere they are required so that your program will work correctly when packed down to a single line.
By far the most efficient way to serve JavaScript over the web is to use PackR with the —shrink-vars flag, combined with gzip compression. If you don’t have access to your server config to set up mod_deflate, you can generate gzip files using (on Unix-like systems):
packr -s my-file.js | gzip > my-file.js.gz
You can then get Apache to serve the files by putting this in your .htaccess file:
AddEncoding gzip .gz RewriteCond %{HTTP:Accept-encoding} gzip RewriteCond %{HTTP_USER_AGENT} !Safari RewriteCond %{REQUEST_FILENAME}.gz -f RewriteRule ^(.*)$ $1.gz [QSA,L]
If you really cannot serve gzip files, use the —base62 option to further compress your code. This mode is at its best when compressing large files with many repeated tokens.
The —private option can be used to stop other programs calling private methods in your code by renaming anything beginning with a single underscore. Beware that you should not use this if the generated file contains ‘private’ methods that need to be accessible by other files. Also know that all the files that access any particular private method must be compressed together so they all get the same rewritten name for the private method.
(The MIT License)
Copyright © 2004-2011 Dean Edwards, James Coglan
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘Software’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Generated with the Darkfish Rdoc Generator 1.1.6.


PIZZERIA
Home
About
Menu
Contact
Cheese Pizza
Buffalo Pizza
Magherita Pizza
Meat Pizza
Pepperoni Pizza
Hawaiian Pizza
ORDER HERE
Choose A Flavour
Choose Prefered Pizza
Chesse Pizza
Veggie Pizza
Pepperoni Pizza
Margherita Pizza
Buffalo Pizza
Hawaiian Pizza
Pick A Size
Pick A Size
Small -- @Ksh600
Medium -- @Ksh800
Large -- @Ksh1200
Choose Prefered Crust
Size Of Crust
Crispy @Ksh280
Stuffed @Ksh250
Gluten-free @Ksh230
Select Toppings @Ksh 50 each
Bacon
Mushrooms
Sausage
Number of pizzas
DELIVERY COST @ Ksh 200
Thank you & Enjoy the meal !!!


{% extends 'layout.html' %} {% block body %}
Follow these steps to send UNIQUE pixelated Christmas Tree greeting images to up to 10 people of your liking
Fill this form to let Santa know who you are. This helps him simplify operations at his North Pole hub!
Use the Add and Remove buttons to, well, add or remove recepients. Santa requires you to have at least 1 recepient for the order to be processed. Also, the maximum number of recepients is 10. Enter wisely!
Hit the Copy button to copy the link to your clipboard. Send this to your recepients!


Add new County
Add new Duchy
Add new Kingdom
Add new Empire
Save to JSON
ID:
Name:
Type:
Wiki Url:
Duchy/Kingdom/Empire Controls
Assigned Lower Titles:
Available Lower Titles:
Remove Selected
Add Selected
County Controls
Primary Holding #
Holding Type:
Holding Name
Holding 2 #
Holding Type:
Holding Name
Holding 3 #
Holding Type:
Holding Name
Holding 4 #
Holding Type:
Holding Name
Holding 5 #
Holding Type:
Holding Name
Holding 6 #
Holding Type:
Holding Name
Holding 7 #
Holding Type:
Holding Name
Save Title
Delete Title


Front End Web Developer | Podcast Producer
An avid music and language enthusiast who enjoys travel and foreign cultures (6 languages, 6 insturments and 32 countries so far). I'm originally Scottish but was born and spent most of my life living in Belgium.
At the time of writing (October 2014) I am enrolled in an 8 week program with the Startup Institute in London which could be considered an accelerated MBA for the startup world. I specialise in front end web development, rapid iteration and harnessing the power of APIs.
I'm looking to join a high growth startup in the music tech or travel industries that can match my ambition to take the interwebz to the next level.


This contains all the HIGH level database/persistance code. Such as interacting with the DB, using CRUD actions through easy to use methids. This provides features relative to the "ActiveRecord" pattern.


is a personal genome reference app for your data in a variety of conditions such as health risk, drug response, and athletic performance.
To upload your 23andMe data, email your zip file as an email attachment, or download the zip file directly from the 23andMe website on the mobile. In the downloads manager, click to open the file, and an option to import it into DIYgenomics should appear.
To delete your data from the device, select 'Delete Personal Data" form the menu.


This is a survey
Which option best describes your current role?
Would you recommend me to a friend?
What would you like to see improved?
Any comments or suggestions?


German Man Goes Viral With His Wholesome Car Karaoke
Uwe Baltner becomes Instagram hero with his wholesome covers of pop and rock songs
Most of the time, social media a non-stop deluge of excrement. Constant negativity spewed into the digital ether, making us all hate the world just a little bit more with every scroll. It’s awful.
But that’s where Instagram star Uwe Baltner comes in. The German car karaoke enthusiast has become a hit on Instagram with his wholesome #content, which is simply, singing songs in his car.
As his bio says, “Singing in my Fiat 500, I spread music and fun all around the world!” and that’s precisely what he does. Now with over 1 million followers, Uwe records himself singing a different song each day while sat behind the wheel of his hatchback.
He takes requests from his legions of followers and has so far belted out renditions of Megadeth’s Symphony Of Destruction, Motörhead’s Ace Of Spades, King Gizzard And The Lizard Wizard’s Planet B and Green Day’s Jesus Of Suburbia – all of which you can watch below.
But he’s also taken on the likes of Cardi B, Childish Gambino, Wu-Tang Clan, Abba and Nicki Minaj. It’s pretty much the best thing on Instagram right now.
Check Uwe out for yourself.


“Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus placerat enim et urna sagittis, rhoncus euismod erat tincidunt. Donec tincidunt volutpat erat."- Anna Carole, Day Trader, Los Angels.
“Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus placerat enim et urna sagittis, rhoncus euismod erat tincidunt. Donec tincidunt volutpat erat."- David Bohema, Seasonal Trader, Chicago.
“Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus placerat enim et urna sagittis, rhoncus euismod erat tincidunt. Donec tincidunt volutpat erat."- Ben Button, Student, Stanford.
Market is gearing up today for the upcoming Budget plan.
August 30, 2017Tips on Nifty, Bank Nifty & Stocks, learn many more here.
August 15, 2017Nifty market watch: How to trade efficiently without making loss.
July 21 , 2017Market Kings - The best place to double your invested money.
Stock world - Yours is the best Service we ever had.
Paul Crugman - This is going to be a crazy business.
David Brawl - This was my dream when I was young.


| PostgreSQL 9.0.10 Documentation | ||||
|---|---|---|---|---|
| Prev | Up | Chapter 14. Performance Tips | Next |
Durability is a database feature that guarantees the recording of committed transactions even if the server crashes or loses power. However, durability adds significant database overhead, so if your site does not require such a guarantee, PostgreSQL can be configured to run much faster. The following are configuration changes you can make to improve performance in such cases; they do not invalidate commit guarantees related to database crashes, only abrupt operating system stoppage, except as mentioned below:
Place the database cluster's data directory in a memory-backed file system (i.e. RAM disk). This eliminates all database disk I/O, but limits data storage to the amount of available memory (and perhaps swap).
Turn off fsync; there is no need to flush data to disk.
Turn off full_page_writes; there is no need to guard against partial page writes.
Increase checkpoint_segments and checkpoint_timeout ; this reduces the frequency of checkpoints, but increases the storage requirements of /pg_xlog.
Turn off synchronous_commit; there might be no need to write the WAL to disk on every commit. This does affect database crash transaction durability.


In the above, we calculate the average power absorbed by a group of resonant particles moving in a longitude wave. The result [Eq. (39)] indicates that (1) if and , then the power is positive, which means the particles get energy from the wave, which further means the wave are damped. (2) if and , then the power is also positive, which also means the wave are damped. The two cases [(1) and (2)] can be summarized in a simple sentence: If there are more resonant particles moving slower than the wave phase velocity than those moving faster, then the wave is damped (where the resonant particles refer to the particles with ).
The result given above is obtained in the test particle approximation, which means the wave is given and is not necessarily a self-consistent field.


--- title: Tidy Tuesday pt 1 author: Alexander C. Hungerford date: '2020-12-06' slug: [] categories: - Tidy Tuesday tags: - dataViz - ggplot2 description: '' featured: '' featuredalt: '' featuredpath: '' linktitle: '' type: post ---
library(tidyverse)
## -- Attaching packages --------------------------------------- tidyverse 1.3.0 --
## v ggplot2 3.3.2 v purrr 0.3.4
## v tibble 3.0.4 v dplyr 1.0.2
## v tidyr 1.1.2 v stringr 1.4.0
## v readr 1.4.0 v forcats 0.5.0
## -- Conflicts ------------------------------------------ tidyverse_conflicts() --
## x dplyr::filter() masks stats::filter()
## x dplyr::lag() masks stats::lag()
mtcars_tbl <- tibble(mtcars)
mtcars_tbl
## # A tibble: 32 x 11
## mpg cyl disp hp drat wt qsec vs am gear carb
## <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 21 6 160 110 3.9 2.62 16.5 0 1 4 4
## 2 21 6 160 110 3.9 2.88 17.0 0 1 4 4
## 3 22.8 4 108 93 3.85 2.32 18.6 1 1 4 1
## 4 21.4 6 258 110 3.08 3.22 19.4 1 0 3 1
## 5 18.7 8 360 175 3.15 3.44 17.0 0 0 3 2
## 6 18.1 6 225 105 2.76 3.46 20.2 1 0 3 1
## 7 14.3 8 360 245 3.21 3.57 15.8 0 0 3 4
## 8 24.4 4 147. 62 3.69 3.19 20 1 0 4 2
## 9 22.8 4 141. 95 3.92 3.15 22.9 1 0 4 2
## 10 19.2 6 168. 123 3.92 3.44 18.3 1 0 4 4
## # ... with 22 more rows
# basic scatterplot
ggplot(mtcars_tbl, aes(x = cyl, y = mpg)) + geom_point()
The x-axis is a discrete variable. The number of cylinders in a vehicle engine is always an integer (1, 2, 3…n). You will never have a car with 4.25 cylinders.
As we can see, generally, vehicles with more cylinders get worse gas mileage.
ggplot()
calls the ggplot package and initializes a ggplot object. In the first argument you need to put the data you want to work from, mtcars_tbl
. The second argument is the aesthetics layer. aes(x = cyl, y = mpg)
can be written aes(cyl, mpg)
. The x and y are understood implicitly, but for others reading your code it helps to be as explicit as possible.
The final layer is the geom layer. This tells ggplot what type of plot to make. If you had geom_bar
would make a bar plot. geom_histogram
makes a histogram and so on.
Aesthetics describe how variables are mapped to visual properties. You can do very simple manipulations in the aesthetic layer, such as log(mpg)
, but if you need to do anything complicated you should do another layer and mutate()
the data.
# mpg by weight, data color by cylinder
ggplot(mtcars, aes(x = wt, y = mpg, color = cyl)) + geom_point()
# a simple manipulation of the data in the aes() layer with log(wt)
ggplot(mtcars, aes(x = log(wt), y = mpg, color = cyl)) + geom_point()
You can also map aesthetics to functions of variables.
# x-axis is horsepower per cylinder
ggplot(mtcars, aes(x = hp/cyl, y = mpg, color = cyl)) + geom_point()
For most


Object.wait()
or Condition.await()
without specifying a timeout.
Such calls may be dangerous in high-availability programs, as failures in one
component may result in blockages of the waiting component
if notify()
/notifyAll()
or signal()
/signalAll()
never get called.
Example:
void foo(Object bar) throws InterruptedException {
bar.wait();
}


SOCIETIES
Error: The page you requested does not exist
Sorry, the page you requested does not exist!


06. Bitcoin Scripts
Bitcoin Scripts
Demo Transaction Information
Raw transaction:
0100000001f3f6a909f8521adb57d898d2985834e632374e770fd9e2b98656f1bf1fdfd427010000006b48304502203a776322ebf8eb8b58cc6ced4f2574f4c73aa664edce0b0022690f2f6f47c521022100b82353305988cb0ebd443089a173ceec93fe4dbfe98d74419ecc84a6a698e31d012103c5c1bc61f60ce3d6223a63cedbece03b12ef9f0068f2f3c4a7e7f06c523c3664ffffffff0260e31600000000001976a914977ae6e32349b99b72196cb62b5ef37329ed81b488ac063d1000000000001976a914f76bc4190f3d8e2315e5c11c59cfc8be9df747e388ac00000000
Transaction in the bitcoin blockchain are stored in a double-hashed form:
SHA256(SHA256(01000…)) = b138360800cdc72248c3ca8dfd06de85913d1aac7f41b4fa54eb1f5a4a379081
View this transaction in a block explorer here
Here is a breakdown of the Raw Transaction.
You will see components we’ve discussed before - Version, Input Count, Input Info, Output Count, Output Info, and Locktime. And there are components that are new. If you are interested in a full breakdown of all these components, review the section below.
Version - All transactions include information about the Bitcoin Version number so we know which rules this transaction follows.
Input Count - Which is how many inputs were used for this transaction
Data stored in Input information:
- Previous output hash - All inputs reference back to an output (UTXO). This points back to the transaction containing the UTXO that will be spend in this input. The hash value of this UTXO is saved in a reverse ordered here.
- Previous output index - The transaction may have more than one UTXO which are referenced by their index number. The first index is 0.
- Unlocking Script Size - This is the size of the Unlocking Script in bytes.
- Unlocking Script - This is the hash of the Unlocking Script that fulfills the conditions of the UTXO Locking Script.
- Sequence Number - This s a deprecated feature of bitcoin Currently set to ffffffff by default.
Output Count - which tells us how many outputs were produced from this transaction.
Data stored in Output Information:
- Amount - The amount of Bitcoin outputted in Satoshis (the smallest bitcoin unit). 10^8 Satoshis = 1 Bitcoin.
- Locking Script Size - This is the size of the Locking Script in bytes.
- Locking Script - This is the hash of the Locking Script that specifies the conditions that must be met to spend this output.
Locktime - The locktime field indicates the earliest time or the earliest block a transaction can be added to the blockchain.
If the locktime is non-zero and less than 500 million, it is interpreted as a block height and miners have to wait until that block height is reached before attempting to add it to a block. If the locktime is above 500 million, it is read as a unix timestamp which means the number of seconds since the date January 1st 1970. It is usually 0 which means confirm as soon as possible.
Code Examples
- Example of scriptPubKey used bitcoin source code’s wallet.cpp file
- Example of scriptSig in bitcoin source code’s [wallet.cpp file](ADD LINK)


You need an AWS account to use this addon
Already have an AWS account ? Please fill the settings with your AWS API keys :


[gecode-users] Idea for extending ViewBrancher
Christian Schulte
cschulte at kth.se
Wed Sep 1 16:42:36 CEST 2010
Hi,
I just added the idea to the trunk. Please find attached an excerpt of MPG
describing the idea.
Comments?
Best
Christian
--
Christian Schulte, www.ict.kth.se/~cschulte/
-----Original Message-----
From: Guido Tack [mailto:tack at gecode.org]
Sent: Tuesday, August 31, 2010 1:34 PM
To: cschulte at kth.se
Cc: 'Felix Brandt'; users at gecode.org
Subject: Re: [gecode-users] Idea for extending ViewBrancher
Christian Schulte wrote:
> How about the following generalization: one can pass to a brancher a
filter
> function (that is, a member function of the space). If a filter function
is
> passed it is used for selecting variables for branching: only if the
filter
> function returns true for a variable, the variable is considered for
normal
> selection. The function can be passed through the normal options for
> branching (VarBranch) that is also used for tie breaking and randomized
> selection.
>
> Would that make sense? It is less general than what Guido proposed but
> easily available to the average modeler. I thought about it a little and I
> know how to efficiently implement it.
The filter function could get the index of the variable in addition to the
variable itself. That would make it just as general as my approach, I think
(you could use a different interval for each variable without having to go
through the whole array to find out which variable you are dealing with).
Cheers,
Guido
--
Guido Tack, http://people.cs.kuleuven.be/~guido.tack/
-------------- next part --------------
A non-text attachment was scrubbed...
Name: filter.pdf
Type: application/pdf
Size: 50156 bytes
Desc: not available
URL: <http://www.gecode.org/pipermail/users/attachments/20100901/44281ee4/attachment-0001.pdf>
More information about the users
mailing list


Before Change
G_proj : networkx.MultiDiGraph
the projected graph
gdf_nodes, gdf_edges = utils_graph.graph_to_gdfs(G)
// create new lat-lng columns just to save that data for later reference
// if they do not already exist (i.e., don"t overwrite in subsequent re-projections)
After Change
// if not, you don"t have to project these edges because the nodes
// contain all the spatial data in the graph (unsimplified edges have
// no geometry attributes)
gdf_edges_proj = utils_graph.graph_to_gdfs(G, nodes=False, fill_edge_geometry=False)
gdf_edges_proj = gdf_edges_proj.drop(columns=["geometry"])
// STEP 3: REBUILD GRAPH
// turn projected node/edge gdfs into a graph


Alinea Menu
Artificial Intelligence Consulting
Posted by Start Bootstrap on September 24, 2018
Posted by Start Bootstrap on September 18, 2018
Posted by Start Bootstrap on August 24, 2018
Posted by Start Bootstrap on July 8, 2018
Older Posts →
Copyright © Your Website 2018


?S'il
lUtotd‡-
iŸÀ.tyM&zcŸ>.______\kL:.
(tl.
(Su.g
CiMt-
f“
COLLECTED
ByXP
.MU^^
'TltOUJu
IbDSEI?
Y
Fi
Wt&fH;
i
fH#.
c&gh
1605297
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


Sammy the Salmon is a well travelled mascot, he was once heard as having been to both poles north and south. He has dodged countless bears in search of spawning grounds. He has swam both the Yang tzi and Amazon in search of rare medicine. It was in the small town of Aberdeen, Washington where he discovered the recipe for Salmon Cookies.


|
ActiveTcl User Guide
|
||
Tk_SetAppName - Set the name of an application for ``send'' commands
#include <tk.h>
CONST char *
Tk_SetAppName(tkwin, name)
Tk_SetAppName associates a name with a given application and records that association on the display containing with the application's main window. After this procedure has been invoked, other applications on the display will be able to use the send command to invoke operations in the application. If name is already in use by some other application on the display, then a new name will be generated by appending `` #2'' to name; if this name is also in use, the number will be incremented until an unused name is found. The return value from the procedure is a pointer to the name actually used.
If the application already has a name when Tk_SetAppName is called, then the new name replaces the old name.
Tk_SetAppName also adds a send command to the application's interpreter, which can be used to send commands from this application to others on any of the displays where the application has windows.
The application's name registration persists until the interpreter is deleted or the send command is deleted from interp, at which point the name is automatically unregistered and the application becomes inaccessible via send. The application can be made accessible again by calling Tk_SetAppName.
Tk_SetAppName is called automatically by Tk_Init, so applications don't normally need to call it explicitly.
The command tk appname provides Tcl-level access to the functionality of Tk_SetAppName.
application, name, register, send command
Copyright © 1994 The Regents of the University of California. Copyright © 1994-1997 Sun Microsystems, Inc. Copyright © 1995-1997 Roger E. Critchlow Jr.


Data for a randomized assessment of the Mexican universal health insurance programme, both before and after a study which randomly assigned treatment within 74 matched pairs of health clusters --- representing 118,569 households in seven Mexican states. See King et al. (2009) for background and details. Data includes variables from a 2005 baseline survey (August, 2005, to September, 2005) and follow-up survey 10 months later (July, 2006, to August, 2006).
sps
A tibble with 27,569 observations and 8 variables:
integer variable with raw age values of respondents
character variable with values "male" and "female"
character variable with values "preschool", "primary", "secondary", "high school", "normal", "technical", "college", and "post-grad"
binary factor variable for treatment (1) and control (0)
double variable for health-related expenses in the last 3 month in pesos
double variable for health-related expenses in the last month in pesos
https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/P6NC0M
Table: Data summary
| Name | sps |
| Number of rows | 27569 |
| Number of columns | 8 |
| _______________________ | |
| Column type frequency: | |
| character | 2 |
| numeric | 6 |
| ________________________ | |
| Group variables | None |
Variable type: character
| skim_variable | n_missing | complete_rate | min | max | empty | n_unique | whitespace |
| sex | 0 | 1 | 4 | 6 | 0 | 2 | 0 |
| education | 0 | 1 | 7 | 11 | 0 | 6 | 0 |
Variable type: numeric
| skim_variable | n_missing | complete_rate | mean | sd | p0 | p25 | p50 | p75 | p100 | hist |
| age | 0 | 1 | 42.30 | 16.63 | 18 | 29 | 39 | 53 | 98 | ▇▇▃▂▁ |
| treatment | 0 | 1 | 0.50 | 0.50 | 0 | 0 | 1 | 1 | 1 | ▇▁▁▁▇ |
| health_exp_3m | 0 | 1 | 657.92 | 1639.64 | 0 | 0 | 50 | 550 | 37000 | ▇▁▁▁▁ |
| t2_health_exp_3m | 0 | 1 | 762.37 | 1758.31 | 0 | 0 | 150 | 700 | 37600 | ▇▁▁▁▁ |
| health_exp_1m | 0 | 1 | 120.25 | 513.73 | 0 | 0 | 0 | 0 | 9998 | ▇▁▁▁▁ |
| t2_health_exp_1m | 0 | 1 | 135.67 | 525.93 | 0 | 0 | 0 | 20 | 9998 | ▇▁▁▁▁ |
David Kane


sheep are awesome creatures inhabiting sheep world
sheep speak sheep
sheep do not have sadness anger hate but have fear
oh also sheep do not have religion
sheep do not worry about death or money
we eat plants and meat fragments from soups
us sheep world citizens are proud to be human-free
| name | most civilized inhabitant | sheep like them |
|---|---|---|
| bee world | bees | a lot |
| elephant world | elephants | not at all |
| big unknown blob world | blue whale | not sure |
sheep site


Upload source link
Upload a file and add it as a source link to dataset {{ dataset.name }}.
{% extends "admin/change_form.html" %} {% load static admin_urls %} {% block extrahead %} {{ block.super }} {% endblock %} {% block breadcrumbs %}
{% endblock breadcrumbs %} {% block content %}Upload a file and add it as a source link to dataset {{ dataset.name }}.


dengue renal cases fatal viral DENV- cells (Figure {border-style case cortical observed px;} #ffffff;} medullary acute region injury damage kidney tubular virus presence DENV Dengue Med. []. (–) congestion tissues CA, fever macrophages hemorrhagic tissue Infect. Kidney inflammatory performed presented proximal px; study vascular {font-family .). antibody associated changes font-size glomerulus increase infiltrate mononuclear necrosis, peritubular severe using years Case Renal Trop. control double; glomerular hyalinosis increased investigated patients regions tubules (Dako, (star) Bowman’s Clin. RNA USA) Vascular border-color border-width cases, convoluted cytokines demonstrated described different failure hemorrhage high human involvement multiple negative organ presenting sections showed solid; {font-style {font-weight (Spring Bioscience, Brazil, Figure However, Injury Leptospirosis Rio Soc. USA), USA). analysis analyzed bold capillary capsule cell clinical courier; detection disease disease, em; exacerbated expressing focal host immune incubated old patient protein pt;} region, reported result. samples showing studies suggested


Relic Watcher:
Incorrect. Check the contents, with your eyes open this time, and take the test again.