git-push - Update remote refs along with associated objects
git push [--all | --mirror | --tags] [--follow-tags] [-n | --dry-run] [--receive-pack=<git-receive-pack>]
[--repo=<repository>] [-f | --force] [--prune] [-v | --verbose] [-u | --set-upstream]
[--force-with-lease[=<refname>[:<expect>]]]
[--no-verify] [<repository> [<refspec>...]]
Updates remote refs using local refs, while sending objects necessary to complete the given refs.
You can make interesting things happen to a repository every time you push into it, by setting up hooks there. See documentation for git-receive-pack(1).
When the command line does not specify where to push with the <repository> argument, branch.*.remote configuration for the current branch is consulted to determine where to push. If the configuration is missing, it defaults to origin.
When the command line does not specify what to push with <refspec>... arguments or --all, --mirror, --tags options, the command finds the default <refspec> by consulting remote.*.push configuration, and if it is not found, honors push.default configuration to decide what to push (See git-config(1) for the meaning of push.default).
<repository>
The "remote" repository that is destination of a push operation. This parameter can be either a URL (see the section GIT URLS below) or the name of a remote (see the section REMOTES below).
<refspec>...
Specify what destination ref to update with what source object. The format of a <refspec> parameter is an optional plus +, followed by the source object <src>, followed by a colon :, followed by the destination ref <dst>.
The <src> is often the name of the branch you would want to push, but it can be any arbitrary "SHA-1 expression", such as master~4 or HEAD (see gitrevisions(7)).
The <dst> tells which ref on the remote side is updated with this push. Arbitrary expressions cannot be used here, an actual ref must be named. If git push [<repository>] without any <refspec> argument is set to update some ref at the destination with <src> with remote.<repository>.push configuration variable, :<dst> part can be omitted---such a push will update a ref that <src> normally updates without any <refspec> on the command line. Otherwise, missing :<dst> means to update the same ref as the <src>.
The object referenced by <src> is used to update the <dst> reference on the remote side. By default this is only allowed if <dst> is not a tag (annotated or lightweight), and then only if it can fast-forward <dst>. By having the optional leading +, you can tell Git to update the <dst> ref even if it is not allowed by default (e.g., it is not a fast-forward.) This does not attempt to merge <src> into <dst>. See EXAMPLES below for details.
tag <tag> means the same as refs/tags/<tag>:refs/tags/<tag>.
Pushing an empty <src> allows you to delete the <dst> ref from the remote repository.
The special refspec : (or +: to allow non-fast-forward updates) directs Git to push "matching" branches: for every branch that exists on the local side, the remote side is updated if a branch of the same name already exists on the remote side.
--all
Push all branches (i.e. refs under refs/heads/); cannot be used with other <refspec>.
--prune
Remove remote branches that don(cqt have a local counterpart. For example a remote branch tmp will be removed if a local branch with the same name doesn(cqt exist any more. This also respects refspecs, e.g. git push --prune remote refs/heads/*:refs/tmp/* would make sure that remote refs/tmp/foo will be removed if refs/heads/foo doesn(cqt exist.
--mirror
Instead of naming each ref to push, specifies that all refs under refs/ (which includes but is not limited to refs/heads/, refs/remotes/, and refs/tags/) be mirrored to the remote repository. Newly created local refs will be pushed to the remote end, locally updated refs will be force updated on the remote end, and deleted refs will be removed from the remote end. This is the default if the configuration option remote.<remote>.mirror is set.
-n, --dry-run
Do everything except actually send the updates.
--porcelain
Produce machine-readable output. The output status line for each ref will be tab-separated and sent to stdout instead of stderr. The full symbolic names of the refs will be given.
--delete
All listed refs are deleted from the remote repository. This is the same as prefixing all refs with a colon.
--tags
All refs under refs/tags are pushed, in addition to refspecs explicitly listed on the command line.
--follow-tags
Push all the refs that would be pushed without this option, and also push annotated tags in refs/tags that are missing from the remote but are pointing at commit-ish that are reachable from the refs being pushed.
--receive-pack=<git-receive-pack>, --exec=<git-receive-pack>
Path to the git-receive-pack program on the remote end. Sometimes useful when pushing to a remote repository over ssh, and you do not have the program in a directory on the default $PATH.
--[no-]force-with-lease, --force-with-lease=<refname>, --force-with-lease=<refname>:<expect>
Usually, "git push" refuses to update a remote ref that is not an ancestor of the local ref used to overwrite it.
This option bypasses the check, but instead requires that the current value of the ref to be the expected value. "git push" fails otherwise.
Imagine that you have to rebase what you have already published. You will have to bypass the "must fast-forward" rule in order to replace the history you originally published with the rebased history. If somebody else built on top of your original history while you are rebasing, the tip of the branch at the remote may advance with her commit, and blindly pushing with --force will lose her work.
This option allows you to say that you expect the history you are updating is what you rebased and want to replace. If the remote ref still points at the commit you specified, you can be sure that no other people did anything to the ref (it is like taking a "lease" on the ref without explicitly locking it, and you update the ref while making sure that your earlier "lease" is still valid).
--force-with-lease alone, without specifying the details, will protect all remote refs that are going to be updated by requiring their current value to be the same as the remote-tracking branch we have for them, unless specified with a --force-with-lease=<refname>:<expect> option that explicitly states what the expected value is.
--force-with-lease=<refname>, without specifying the expected value, will protect the named ref (alone), if it is going to be updated, by requiring its current value to be the same as the remote-tracking branch we have for it.
--force-with-lease=<refname>:<expect> will protect the named ref (alone), if it is going to be updated, by requiring its current value to be the same as the specified value <expect> (which is allowed to be different from the remote-tracking branch we have for the refname, or we do not even have to have such a remote-tracking branch when this form is used).
Note that all forms other than --force-with-lease=<refname>:<expect> that specifies the expected current value of the ref explicitly are still experimental and their semantics may change as we gain experience with this feature.
"--no-force-with-lease" will cancel all the previous --force-with-lease on the command line.
-f, --force
Usually, the command refuses to update a remote ref that is not an ancestor of the local ref used to overwrite it. Also, when --force-with-lease option is used, the command refuses to update a remote ref whose current value does not match what is expected.
This flag disables these checks, and can cause the remote repository to lose commits; use it with care.
Note that --force applies to all the refs that are pushed, hence using it with push.default set to matching or with multiple push destinations configured with remote.*.push may overwrite refs other than the current branch (including local refs that are strictly behind their remote counterpart). To force a push to only one branch, use a + in front of the refspec to push (e.g git push origin +master to force a push to the master branch). See the <refspec>... section above for details.
--repo=<repository>
This option is only relevant if no <repository> argument is passed in the invocation. In this case, git push derives the remote name from the current branch: If it tracks a remote branch, then that remote repository is pushed to. Otherwise, the name "origin" is used. For this latter case, this option can be used to override the name "origin". In other words, the difference between these two commands
git push public #1 git push --repo=public #2
is that #1 always pushes to "public" whereas #2 pushes to "public" only if the current branch does not track a remote branch. This is useful if you write an alias or script around git push.
-u, --set-upstream
For every branch that is up to date or successfully pushed, add upstream (tracking) reference, used by argument-less git-pull(1) and other commands. For more information, see branch.<name>.merge in git-config(1).
--[no-]thin
These options are passed to git-send-pack(1). A thin transfer significantly reduces the amount of sent data when the sender and receiver share many of the same objects in common. The default is --thin.
-q, --quiet
Suppress all output, including the listing of updated refs, unless an error occurs. Progress is not reported to the standard error stream.
-v, --verbose
Run verbosely.
--progress
Progress status is reported on the standard error stream by default when it is attached to a terminal, unless -q is specified. This flag forces progress status even if the standard error stream is not directed to a terminal.
--recurse-submodules=check|on-demand
Make sure all submodule commits used by the revisions to be pushed are available on a remote-tracking branch. If check is used Git will verify that all submodule commits that changed in the revisions to be pushed are available on at least one remote of the submodule. If any commits are missing the push will be aborted and exit with non-zero status. If on-demand is used all submodules that changed in the revisions to be pushed will be pushed. If on-demand was not able to push all necessary revisions it will also be aborted and exit with non-zero status.
--[no-]verify
Toggle the pre-push hook (see githooks(5)). The default is --verify, giving the hook a chance to prevent the push. With --no-verify, the hook is bypassed completely.
In general, URLs contain information about the transport protocol, the address of the remote server, and the path to the repository. Depending on the transport protocol, some of this information may be absent.
Git supports ssh, git, http, and https protocols (in addition, ftp, and ftps can be used for fetching and rsync can be used for fetching and pushing, but these are inefficient and deprecated; do not use them).
The native transport (i.e. git:// URL) does no authentication and should be used with caution on unsecured networks.
The following syntaxes may be used with them:
h'-04'(buh'+03'c
ssh://[user@]host.xz[:port]/path/to/repo.git/
h'-04'(buh'+03'c
git://host.xz[:port]/path/to/repo.git/
h'-04'(buh'+03'c
http[s]://host.xz[:port]/path/to/repo.git/
h'-04'(buh'+03'c
ftp[s]://host.xz[:port]/path/to/repo.git/
h'-04'(buh'+03'c
rsync://host.xz/path/to/repo.git/
An alternative scp-like syntax may also be used with the ssh protocol:
h'-04'(buh'+03'c
[user@]host.xz:path/to/repo.git/
This syntax is only recognized if there are no slashes before the first colon. This helps differentiate a local path that contains a colon. For example the local path foo:bar could be specified as an absolute path or ./foo:bar to avoid being misinterpreted as an ssh url.
The ssh and git protocols additionally support ~username expansion:
h'-04'(buh'+03'c
ssh://[user@]host.xz[:port]/~[user]/path/to/repo.git/
h'-04'(buh'+03'c
git://host.xz[:port]/~[user]/path/to/repo.git/
h'-04'(buh'+03'c
[user@]host.xz:/~[user]/path/to/repo.git/
For local repositories, also supported by Git natively, the following syntaxes may be used:
h'-04'(buh'+03'c
/path/to/repo.git/
h'-04'(buh'+03'c
file:///path/to/repo.git/
These two syntaxes are mostly equivalent, except when cloning, when the former implies --local option. See git-clone(1) for details.
When Git doesn(cqt know how to handle a certain transport protocol, it attempts to use the remote-<transport> remote helper, if one exists. To explicitly request a remote helper, the following syntax may be used:
h'-04'(buh'+03'c
<transport>::<address>
where <address> may be a path, a server and path, or an arbitrary URL-like string recognized by the specific remote helper being invoked. See gitremote-helpers(1) for details.
If there are a large number of similarly-named remote repositories and you want to use a different format for them (such that the URLs you use will be rewritten into URLs that work), you can create a configuration section of the form:
[url "<actual url base>"] insteadOf = <other url base>
For example, with this:
[url "git://git.host.xz/"] insteadOf = host.xz:/path/to/ insteadOf = work:
a URL like "work:repo.git" or like "host.xz:/path/to/repo.git" will be rewritten in any context that takes a URL to be "git://git.host.xz/repo.git".
If you want to rewrite URLs for push only, you can create a configuration section of the form:
[url "<actual url base>"] pushInsteadOf = <other url base>
For example, with this:
[url "ssh://example.org/"] pushInsteadOf = git://example.org/
a URL like "git://example.org/path/to/repo.git" will be rewritten to "ssh://example.org/path/to/repo.git" for pushes, but pulls will still use the original URL.
The name of one of the following can be used instead of a URL as <repository> argument:
h'-04'(buh'+03'c
a remote in the Git configuration file: $GIT_DIR/config,
h'-04'(buh'+03'c
a file in the $GIT_DIR/remotes directory, or
h'-04'(buh'+03'c
a file in the $GIT_DIR/branches directory.
All of these also allow you to omit the refspec from the command line because they each contain a refspec which git will use by default.
You can choose to provide the name of a remote which you had previously configured using git-remote(1), git-config(1) or even by a manual edit to the $GIT_DIR/config file. The URL of this remote will be used to access the repository. The refspec of this remote will be used by default when you do not provide a refspec on the command line. The entry in the config file would appear like this:
[remote "<name>"] url = <url> pushurl = <pushurl> push = <refspec> fetch = <refspec>
The <pushurl> is used for pushes only. It is optional and defaults to <url>.
You can choose to provide the name of a file in $GIT_DIR/remotes. The URL in this file will be used to access the repository. The refspec in this file will be used as default when you do not provide a refspec on the command line. This file should have the following format:
URL: one of the above URL format Push: <refspec> Pull: <refspec>
Push: lines are used by git push and Pull: lines are used by git pull and git fetch. Multiple Push: and Pull: lines may be specified for additional branch mappings.
You can choose to provide the name of a file in $GIT_DIR/branches. The URL in this file will be used to access the repository. This file should have the following format:
<url>#<head>
<url> is required; #<head> is optional.
Depending on the operation, git will use one of the following refspecs, if you don(cqt provide one on the command line. <branch> is the name of this file in $GIT_DIR/branches and <head> defaults to master.
git fetch uses:
refs/heads/<head>:refs/heads/<branch>
git push uses:
HEAD:refs/heads/<head>
The output of "git push" depends on the transport method used; this section describes the output when pushing over the Git protocol (either locally or via ssh).
The status of the push is output in tabular form, with each line representing the status of a single ref. Each line is of the form:
<flag> <summary> <from> -> <to> (<reason>)
If --porcelain is used, then each line of the output is of the form:
<flag> et <from>:<to> et <summary> (<reason>)
The status of up-to-date refs is shown only if --porcelain or --verbose option is used.
flag
A single character indicating the status of the ref:
(space)
for a successfully pushed fast-forward;
+
for a successful forced update;
-
for a successfully deleted ref;
*
for a successfully pushed new ref;
!
for a ref that was rejected or failed to push; and
=
for a ref that was up to date and did not need pushing.
summary
For a successfully pushed ref, the summary shows the old and new values of the ref in a form suitable for using as an argument to git log (this is <old>..<new> in most cases, and <old>...<new> for forced non-fast-forward updates).
For a failed update, more details are given:
rejected
Git did not try to send the ref at all, typically because it is not a fast-forward and you did not force the update.
remote rejected
The remote end refused the update. Usually caused by a hook on the remote side, or because the remote repository has one of the following safety options in effect: receive.denyCurrentBranch (for pushes to the checked out branch), receive.denyNonFastForwards (for forced non-fast-forward updates), receive.denyDeletes or receive.denyDeleteCurrent. See git-config(1).
remote failure
The remote end did not report the successful update of the ref, perhaps because of a temporary error on the remote side, a break in the network connection, or other transient error.
from
The name of the local ref being pushed, minus its refs/<type>/ prefix. In the case of deletion, the name of the local ref is omitted.
to
The name of the remote ref being updated, minus its refs/<type>/ prefix.
reason
A human-readable explanation. In the case of successfully pushed refs, no explanation is needed. For a failed ref, the reason for failure is described.
When an update changes a branch (or more in general, a ref) that used to point at commit A to point at another commit B, it is called a fast-forward update if and only if B is a descendant of A.
In a fast-forward update from A to B, the set of commits that the original commit A built on top of is a subset of the commits the new commit B builds on top of. Hence, it does not lose any history.
In contrast, a non-fast-forward update will lose history. For example, suppose you and somebody else started at the same commit X, and you built a history leading to commit B while the other person built a history leading to commit A. The history looks like this:
B / ---X---A
Further suppose that the other person already pushed changes leading to A back to the original repository from which you two obtained the original commit X.
The push done by the other person updated the branch that used to point at commit X to point at commit A. It is a fast-forward.
But if you try to push, you will attempt to update the branch (that now points at A) with commit B. This does not fast-forward. If you did so, the changes introduced by commit A will be lost, because everybody will now start building on top of B.
The command by default does not allow an update that is not a fast-forward to prevent such loss of history.
If you do not want to lose your work (history from X to B) or the work by the other person (history from X to A), you would need to first fetch the history from the repository, create a history that contains changes done by both parties, and push the result back.
You can perform "git pull", resolve potential conflicts, and "git push" the result. A "git pull" will create a merge commit C between commits A and B.
B---C / / ---X---A
Updating A with the resulting merge commit will fast-forward and your push will be accepted.
Alternatively, you can rebase your change between X and B on top of A, with "git pull --rebase", and push the result back. The rebase will create a new commit D that builds the change between X and B on top of A.
B D / / ---X---A
Again, updating A with this commit will fast-forward and your push will be accepted.
There is another common situation where you may encounter non-fast-forward rejection when you try to push, and it is possible even when you are pushing into a repository nobody else pushes into.  In such a case, and only if you are certain that nobody in the meantime fetched your earlier commit A (and started building on top of it), you can run "git push --force" to overwrite it. In other words, "git push --force" is a method reserved for a case where you do mean to lose history.
git push
Works like git push <remote>, where <remote> is the current branch(cqs remote (or origin, if no remote is configured for the current branch).
git push origin
Without additional configuration, pushes the current branch to the configured upstream (remote.origin.merge configuration variable) if it has the same name as the current branch, and errors out without pushing otherwise.
The default behavior of this command when no <refspec> is given can be configured by setting the push option of the remote, or the push.default configuration variable.
For example, to default to pushing only the current branch to origin use git config remote.origin.push HEAD. Any valid <refspec> (like the ones in the examples below) can be configured as the default for git push origin.
git push origin :
Push "matching" branches to origin. See <refspec> in the OPTIONS section above for a description of "matching" branches.
git push origin master
Find a ref that matches master in the source repository (most likely, it would find refs/heads/master), and update the same ref (e.g. refs/heads/master) in origin repository with it. If master did not exist remotely, it would be created.
git push origin HEAD
A handy way to push the current branch to the same name on the remote.
git push mothership master:satellite/master dev:satellite/dev
Use the source ref that matches master (e.g. refs/heads/master) to update the ref that matches satellite/master (most probably refs/remotes/satellite/master) in the mothership repository; do the same for dev and satellite/dev.
This is to emulate git fetch run on the mothership using git push that is run in the opposite direction in order to integrate the work done on satellite, and is often necessary when you can only make connection in one way (i.e. satellite can ssh into mothership but mothership cannot initiate connection to satellite because the latter is behind a firewall or does not run sshd).
After running this git push on the satellite machine, you would ssh into the mothership and run git merge there to complete the emulation of git pull that were run on mothership to pull changes made on satellite.
git push origin HEAD:master
Push the current branch to the remote ref matching master in the origin repository. This form is convenient to push the current branch without thinking about its local name.
git push origin master:refs/heads/experimental
Create the branch experimental in the origin repository by copying the current master branch. This form is only needed to create a new branch or tag in the remote repository when the local name and the remote name are different; otherwise, the ref name on its own will work.
git push origin :experimental
Find a ref that matches experimental in the origin repository (e.g. refs/heads/experimental), and delete it.
git push origin +dev:master
Update the origin repository(cqs master branch with the dev branch, allowing non-fast-forward updates. This can leave unreferenced commits dangling in the origin repository. Consider the following situation, where a fast-forward is not possible:
o---o---o---A---B origin/master e X---Y---Z dev
The above command would change the origin repository to
A---B (unnamed branch) / o---o---o---X---Y---Z master
Commits A and B would no longer belong to a branch with a symbolic name, and so would be unreachable. As such, these commits would be removed by a git gc command on the origin repository.
Part of the git(1) suite


Mpd is supplied as a
FreeBSD port, under the name net/mpd5
.
Therefore, the simplest way to get mpd onto your machine
is to install the mpd package or port.
For information on how to do this, see the
FreeBSD ports web page.
Mpd can also be compiled and installed manually. This is useful for example if you want to change the set of device types supported by mpd.


Start Making Your Voice Heard
By clicking the "Sign Up" button, you have agreed to our Privacy Policy, Terms and Conditions and you are a Nigerian
Already have an account, Login here
Signup as an Administrator Or a User
By clicking the "Sign Up" button, you have agreed to our Privacy Policy, Terms and Conditions and you are a Nigerian
Already have an account, Login here
Signup as an Administrator Or a User


A rectangle with a black border. In the background is a pink circle. Partially overlaying the circle is a green square and a purple triangle, both of which are semi-opaque, so the full circle can be seen underneath.
A rectangle with a black border. In the background is a pink circle. Partially overlaying the circle. Partially overlaying the circle is a green square and a purple triangle, both of which are semi-opaque, so the full circle can be seen underneath.
Note: role=presentation added to <canvas> to mute repeated announcement of graphic role by some screen readers when navigating canvas subtree
role=presentation
<canvas>


Have any questions? Please, don't hesitate to contact me directly.
Portland, OR 97230, USA
(503) xxx-xxxx
weekdaypablo@gmail.com


--- title: "How big is too big: variance inflation factors" author: "Drew Tyre" date: '2021-06-21' output: html_document: code_folding: hide word_document: default og_image: draft: no slug: how-big-is-too-big-vif tags_include: - R categories: Research ---
In a comment Jacob E. asked “Also, you mention using VIF for testing multi-collinearity. Is there a cutoff score you recommend for AIC?” I gave a snarky answer because I didn’t have a good answer. What would a good answer look like?
One way to proceed is to simulate data from the situation where the assumption is not violated, and look at the distribution of VIF scores.
library("tidyverse")
## -- Attaching packages --------------------------------------- tidyverse 1.3.1 --
## v ggplot2 3.3.3 v purrr 0.3.4
## v tibble 3.1.2 v dplyr 1.0.6
## v tidyr 1.1.3 v stringr 1.4.0
## v readr 1.4.0 v forcats 0.5.1
## -- Conflicts ------------------------------------------ tidyverse_conflicts() --
## x dplyr::filter() masks stats::filter()
## x dplyr::lag() masks stats::lag()
n <- 100
N <- 1000
make_data <- function(beta = c(0, 0.1, 1, 10), sigma = 1, residual_error = 1, n = 1){
if (is.null(dim(sigma))){
tmp <- sigma
sigma <- matrix(0, nrow = length(beta), ncol = length(beta))
diag(sigma) <- tmp
}
X <- MASS:::mvrnorm(n, mu = rep(0, length(beta)), Sigma = sigma)
Y <- X %*% beta + rnorm(n, mean = 0, sd = residual_error)
return(data.frame(Y, X))
}
#Test it out
test_df <- make_data(n = n)
ggplot(data = test_df,
mapping = aes(x = X4, y = Y, color = X3)) +
geom_point()
OK, now generate a bunch of data sets, fit linear models to them, and get the VIF scores.
vif_null <- map(1:N, ~make_data(n = n)) %>%
map(~lm(Y~X1+X2+X3+X4, data = .)) %>%
map_dfr(car::vif) %>%
mutate(rep = 1:N) %>%
pivot_longer(cols = -rep, names_to = "variable",values_to = "vif")
ggplot(data = vif_null,
mapping = aes(x = vif)) +
geom_histogram() +
facet_wrap(~variable)
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
OK, wow! Didn’t expect that – if there is NO correlation between the predictor variables then VIF rarely exceeds 1.2. Lets do an example where a couple of the variables are highly correlated.
sigma <- matrix(c(1, 0, 0, 0,
0, 1, -0.9, 0,
0, -0.9, 1, 0,
0, 0, 0, 1), nrow = 4, ncol = 4)
vif_bad <- map(1:N, ~make_data(n = n, sigma = sigma)) %>%
map(~lm(Y~X1+X2+X3+X4, data = .)) %>%
map_dfr(car::vif) %>%
mutate(rep = 1:N) %>%
pivot_longer(cols = -rep, names_to = "variable",values_to = "vif")
ggplot(data = vif_bad,
mapping = aes(x = vif)) +
geom_histogram() +
facet_wrap(~variable)
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
So a correlation of ~ -0.9 between two of the variables gives VIF scores bigger than 2, about 5 on average. So choosing a cutoff of 2 is going to exclude the worst offenders.


I recently had a routine medical checkup and as I was signing in I always look over to see if they have an old fax machine sitting somewhere. It’s rare that you see a stand-alone fax machine as most offices have online faxing and multi-function printer integration. At some point a medical assistant asked one of the ladies at the desk if the fax needed a cover sheet. The woman at the desk quickly assured her that all faxes get coversheets no matter what. “All Faxes get cover sheets! No exceptions…ever!”.
It’s good to see that my doctors office takes HIPAA seriously as ignorance of the laws are not an excuse any longer. HIPAA has been around since 1996 so we have had over 20 years to get it right however we are still talking about it and struggling with compliance.
It’s not just doctors offices that have to deal with these directives either. Pharmacies, therapists, hospitals and even insurance companies have HIPAA Fax requirements.
Some of these rules are obvious like all fax machines are to be placed in a secure area and not publicly accessible. Many faxes are digital and just saving them to the local hard drive or “G Drive” is not enough either. A lack of technical knowledge or inadequate IT budgets can lead to massive HIPAA fines.
A recent HIPAA violation that made headlines was Affinity Health Plan and their used copier. They returned a copier after a lease was complete and failed to wipe the hard drives. Over 350,000 patient records were exposed. HHS fined them $1.2 million. It could have been worse. All because an IT admin didn’t know or didn’t have a solid HIPAA compliant IT plan for disposing of devices that contain ePHI. It was only found because the copier leasing office checked the hard drives. How many times has this happened and not been reported?
Faxing doesn’t have to be complicated. Now with integrated Multi-function printers and Print to Fax drivers your organization’s fax platform can be seamlessly integrated into your EMR.
IT budgets are tight and enterprise fax is a critical element in every medical environment. Don’t cut corners or ignore the common sense HIPAA Fax guidelines.
BTW, here are the penalties for a HIPAA violation:
WestFax can service all your Secure HIPAA Compliant Fax needs from a simple email / fax portal to full API Integration with your EMR / EHR / Salesforce and more. Learn more.
Barry Clark


Seven-Minute Final Fantasy VII Remake Ad is the Longest Advert Ever on Japanese TV
by Brian AshcraftClocking in at seven minutes long, this is the longest advert to ever air on Japanese television. Sure, this is an ad, but it’s like a seven-minute short-film about people into Final Fantasy VII.
As pointed out on GameSpark, the advert aired during an annual 27-hour block of programming hosted by Beat Takeshi that aired over the weekend.
The spot stars popular actors Masataka Kubota, Misato Morita, and Tetsuji Tamayama.
Kubota stars as a young businessman who has never played Final Fantasy VII. At the beginning, he finds a copy of FFVII his wife had left out after reminiscing. They don’t have a PlayStation at home, so he cannot play the game. At work, his superiors talk about the game and later, his wife recalls playing the game with her now estranged brother. Kubota gets more and more interested in playing the upcoming remake and by the end, he decides to go buy a PS4 to play the game with his wife.
Again, this is an ad, but it’s refreshing to see adults on television talk about video games in a fairly normal way. These games are part of our lives, and this seven-minute short understands that.
It also hopes you’ll buy Final Fantasy VII Remake.
Here is the longer 13-minute cut.
Featured image: Screenshot: スクウェア・エニックス


AddLive SDK JS Tutorials
Tutorials list
- Tutorial 1.0 - Platform init
- Tutorial 1.1 - Platform lifecycle
- Tutorial 1.2 - Platform init with Setup Assistant
- Tutorial 2 - Devices configuration
- Tutorial 3 - Advanced devices configuration
- Tutorial 4 - Rendering
- Tutorial 5.0 - Basic connectivity
- Tutorial 5.1 - Basic connectivity and video reconfiguration
- Tutorial 5.2 - Basic connectivity and stats
- Tutorial 6 - Conference app
- Tutorial 6.1 - Conference app and allowed senders
- Tutorial 6.2 - Conference app and monitor speech
- Tutorial 7 - Messaging
- Tutorial 8 - Screen sharing
- Tutorial 9 - User boarding
- Tutorial 10 - Connectivity check
- Tutorial 11 - Platform loading with AMD/require.js
- Tutorial 12 - Recording


"KITE "an unclean and keen-sighted bird of prey (Leviticus 11:14; Deuteronomy 14:13). The Hebrew word used, ’ayet, is rendered “vulture” in Job 28:7 in Authorized Version, “falcon” in Revised Version. It is probably the red kite (Milvus regalis), a bird of piercing sight and of soaring habits found all over Palestine.
"KITE "an unclean and keen-sighted bird of prey (Leviticus 11:14; Deuteronomy 14:13). The Hebrew word used, ’ayet, is rendered “vulture” in Job 28:7 in Authorized Version, “falcon” in Revised Version. It is probably the red kite (Milvus regalis), a bird of piercing sight and of soaring habits found all over Palestine.


FRCGadgets is an open source initiative to bring new tools to FRC teams to help optimize their workflow.
All the software produced by FRCGadgets are open source and any team is welcome to contribute to them.
Start the journey towards optimizing your team by selecting one of the software tools we offer.


|
MAX32665 SDK Documentation
0.2
Software Development Kit Overview and API Documentation
|
Modules | |
| SPIXF_Registers | |
| Registers, Bit Masks and Bit Positions for the SPIXF Peripheral Module. | |
Data Structures | |
| struct | spixf_req_t |
| SPIXF Transaction request. More... | |
Enumerations | |
| enum | spixf_cfg_mode_t { SPI_MODE_0 = MXC_S_SPIXF_CFG_MODE_SCLK_HI_SAMPLE_RISING, SPI_MODE_3 = MXC_S_SPIXF_CFG_MODE_SCLK_LO_SAMPLE_FAILLING } |
| SPIXF_CFG. More... | |
| enum | spixf_cfg_sspol_t { SSPOL_ACTIVE_HI = 0, SSPOL_ACTIVE_LO = MXC_F_SPIXF_CFG_SSPOL } |
| Polarity of slave select. | |
| enum | spixf_cfg_ssact_t { SYS_CLOCKS_0 = MXC_S_SPIXF_CFG_SSACT_OFF, SYS_CLOCKS_2 = MXC_S_SPIXF_CFG_SSACT_FOR_2_MOD_CLK, SYS_CLOCKS_4 = MXC_S_SPIXF_CFG_SSACT_FOR_4_MOD_CLK, SYS_CLOCKS_8 = MXC_S_SPIXF_CFG_SSACT_FOR_8_MOD_CLK } |
| Slave select active timing. | |
| enum | spixf_cfg_ssiact_t { SYS_CLOCKS_1 = MXC_S_SPIXF_CFG_SSIACT_FOR_1_MOD_CLK, SYS_CLOCKS_3 = MXC_S_SPIXF_CFG_SSIACT_FOR_3_MOD_CLK, SYS_CLOCKS_5 = MXC_S_SPIXF_CFG_SSIACT_FOR_5_MOD_CLK, SYS_CLOCKS_9 = MXC_S_SPIXF_CFG_SSIACT_FOR_9_MOD_CLK } |
| Slave select Inactive timing. More... | |
| enum | spixf_fctl_cmdwth_t { SINGLE_SDIO_CMD = MXC_S_SPIXF_FETCH_CTRL_CMD_WIDTH_SINGLE, DUAL_SDIO_CMD = MXC_S_SPIXF_FETCH_CTRL_CMD_WIDTH_DUAL_IO, QUAD_SDIO_CMD = MXC_S_SPIXF_FETCH_CTRL_CMD_WIDTH_QUAD_IO, INVALID_CMD = MXC_S_SPIXF_FETCH_CTRL_CMD_WIDTH_INVALID } |
| SPIXF_FETCH_CTRL. More... | |
| enum | spixf_fctl_adrwth_t { SINGLE_SDIO_ADDR = MXC_S_SPIXF_FETCH_CTRL_ADDR_WIDTH_SINGLE, DUAL_SDIO_ADDR = MXC_S_SPIXF_FETCH_CTRL_ADDR_WIDTH_DUAL_IO, QUAD_SDIO_ADDR = MXC_S_SPIXF_FETCH_CTRL_ADDR_WIDTH_QUAD_IO, INVALID_ADDR = MXC_S_SPIXF_FETCH_CTRL_ADDR_WIDTH_INVALID } |
| Addr Width, # of data I/O used to send addr and mode/dummy clks. | |
| enum | spixf_fctl_datwth_t { SINGLE_SDIO_DATA = MXC_S_SPIXF_FETCH_CTRL_DATA_WIDTH_SINGLE, DUAL_SDIO_DATA = MXC_S_SPIXF_FETCH_CTRL_DATA_WIDTH_DUAL_IO, QUAD_SDIO_DATA = MXC_S_SPIXF_FETCH_CTRL_DATA_WIDTH_QUAD_IO, INVALID_DATA = MXC_S_SPIXF_FETCH_CTRL_DATA_WIDTH_INVALID } |
| Data Width, # of data I/O used to rcv data. | |
| enum | spixf_fctl_addr4_t { THREE_BYTE_ADDR_MODE = 0, FOUR_BYTE_ADDR_MODE = MXC_F_SPIXF_FETCH_CTRL_FOUR_BYTE_ADDR } |
| 3 or 4 byte address mode flash | |
| enum | spixf_mctl_nocmd_t { SND_RDCMD_EVRYTIME = 0, SND_RDCMD_ONLYONCE = MXC_F_SPIXF_MODE_CTRL_NO_CMD } |
| SPIXF_MODE_CTRL. More... | |
| enum | spixf_fctrl_fbmd_t { DISABLE_SCLK_FB = 0, ENABLE_SCLK_FB = MXC_F_SPIXF_SCLK_FB_CTRL_FB_EN } |
| SPIXF_FB_CTRL. More... | |
| enum | spixf_fctrl_finv_t { DISABLE_FBCLK_INV = 0, ENABLE_FBCLK_INV = MXC_F_SPIXF_SCLK_FB_CTRL_INVERT_EN } |
| Feedback clock invert. | |
| enum | spixf_ioctl_sclk_t { LO_DRIVE_STRENGTH_SCLK = 0, HI_DRIVE_STRENGTH_SCLK = MXC_F_SPIXF_IO_CTRL_SCLK_DS } |
| SPIXF_IOCTRL. More... | |
| enum | spixf_ioctl_ss_t { LO_DRIVE_STRENGTH_SS = 0, HI_DRIVE_STRENGTH_SS = MXC_F_SPIXF_IO_CTRL_SS_DS } |
| Slave Sel. Drive Strength. | |
| enum | spixf_ioctl_sdio_t { LO_DRIVE_STRENGTH_SDIO = 0, HI_DRIVE_STRENGTH_SDIO = MXC_F_SPIXF_IO_CTRL_SDIO_DS } |
| SDIO Drive Strength. | |
| enum | spixf_ioctl_pup_t { TRISTATE = MXC_S_SPIXF_IO_CTRL_PU_PD_CTRL_TRI_STATE, PULL_UP = MXC_S_SPIXF_IO_CTRL_PU_PD_CTRL_PULL_UP, PULL_DOWN = MXC_S_SPIXF_IO_CTRL_PU_PD_CTRL_PULL_DOWN } |
| IO pullup/pulldown Control. | |
Functions | |
| void | SPIXF_setup (mxc_spixf_regs_t *spixf, spixf_req_t *req) |
| Setup SPIXF for Execute in Place. More... | |
| void | SPIXF_ioctrl (spixf_ioctl_sclk_t sclk_ds, spixf_ioctl_ss_t ss_ds, spixf_ioctl_sdio_t sdio_ds, spixf_ioctl_pup_t pupdctrl) |
| Setup Drive Strength on the I/O pins. More... | |
| enum spixf_cfg_mode_t |
SPI Mode 0 & 3 selected
| enum spixf_cfg_ssiact_t |
| enum spixf_fctl_cmdwth_t |
Command Width, # of data I/O used to send commands
| enum spixf_mctl_nocmd_t |
No command mode
| enum spixf_fctrl_fbmd_t |
SCLK Feedback enable/disable
| enum spixf_ioctl_sclk_t |
SCLK Drive Strength
| void SPIXF_setup | ( | mxc_spixf_regs_t * | spixf, |
| spixf_req_t * | req | ||
| ) |
| spixf | Pointer to SPIXF regs. |
| req | Request for a SPIXF transaction. |
| void SPIXF_ioctrl | ( | spixf_ioctl_sclk_t | sclk_ds, |
| spixf_ioctl_ss_t | ss_ds, | ||
| spixf_ioctl_sdio_t | sdio_ds, | ||
| spixf_ioctl_pup_t | pupdctrl | ||
| ) |
| sclk_ds | SCLK drive strength |
| ss_ds | Slave Select Drive Strength |
| sdio_ds | SDIO Drive Strength |
| pupdctrl | IO Pullup/Pulldown Control |


Debit/Credit Card Number
Please enter a valid card number
Cardholder's First Name
Please enter the cardholder's name exactly as it appears on the card.
Carholder's Last Name
Please enter the cardholder's name exactly as it appears on the card.
Security Code
Please enter a valid card security code.
Expiration month
Please choose a valid month.
Expiration year
Please choose a valid year.


Data transmission over sound waves written in JavaScript without any dependencies. All you need is just microphone, speakers and the browser!
Audio Network library is a hobby project in which the goal was to create simple network stack that uses sound waves to transmit data. Initialy it was using PSK modulation technique which was later changed into FSK. If you are interested in details you can read more in polish Programista magazine:
Part 3 of the article was the last one. It means that more focus will go to this website and Audio Network releases. If you can't wait please go trought some of the examples:
Full list of examples is available here:
Note: some of the modules are not yet in main NPM package. Please verify roadmap.
This library is supported by PGS Software - the place where I work as Frontend Developer
UPDATE 2018.02.06 - Project looks like dead but it's not. Now I'm focusing on configuration that allows me to move entire AudioNetwork project to TypeScript, WebPack, Jest unit test with coverge, Travis etc.
Initial versions of this lib were based on Phase-Shift Keying modulation technique. Unfortunatelly after some tests in turned out that this implementation was not working reliable on mobile devices. Starting from v1.2.0 this part of the lib will be marked as deprecated.
If you want to try AudioNetwork by yourself I would recommend to first open Demo - simple
because Demo - full
features
might be little scary for the first time. You can also watch YouTube video that shows how to transmit
data over sound between two laptops:
This project is still under development. Documentation is also planned but... little later :)
First of all you need to have two devices. One for sending, one for receiving data. It should work with any device (PC, Mac, tablet, smartphone) with browser that supports Web Audio API. Next you need to open Demo - simple at both devices and follow steps below:
[Receiver] - Before you load demo page you need to be quiet :) Receiving device needs to listen to 'silence'
around you when there is no signal in the air. It's indicated by IDLE_INIT
state and it ends when FIRST_SYNC_WAIT
state will come. If you fell that your silence wasn't good enough you can always use RESET
button to start again.
[Transmitter] - All you need to do is to click on SYNC
button.
[Receiver] - When SYNC
transmission is in progress state should change to FIRST_SYNC
. After about 2 seconds
it should switch to IDLE
. At this point we are ready to send some data!
[Transmitter] - Now you can put some data to textarea and click on Send packet
button. After short moment your
data will appear on the receiver's side.
By default PSK-2 modulation is used so you can use only symbols
0
and1
but it's enough to send data bit by bit. For example to send ASCIIa
character (0x61) you need to put inside textarea0 1 1 0 0 0 0 1
. Please remember to always put one space between each symbol but whole text needs to be without trailing and leading spaces.If at any point you will see
FATAL_ERROR
state you need to click onRESET
button and start all points again.AudioNetwork needs raw microphone output without any filter applied. You can verify that by opening
Sound
settings in your operating system. When you enter your microphone properties you might need to un-check all filters.  In this case you need to throw it away and buy a new one ;)
Audio Network is available at GitHub and npm so you can just run one of the commands below:
git clone https://github.com/robertrypula/AudioNetwork.git
cd AudioNetwork
npm install
gulp serve
or
npm install audio-network
In both cases at build
directory you will find minified and unminified js file with whole library. Pick one and
include it into your HTML file. For example:
<script src="node_modules/audio-network/build/audio-network-v1.3.0.min.js"></script>
Now you can access AudioNetwork
object at global JavaScript scope. It's the entry point for all components:
var physicalLayer, transmitAdapter, receiveAdapter;
physicalLayer = new AudioNetwork.PhysicalLayer.PhysicalLayer({
// config
});
transmitAdapter = new AudioNetwork.PhysicalLayerAdapter.TransmitAdapter(physicalLayer);
receiveAdapter = new AudioNetwork.PhysicalLayerAdapter.ReceiveAdapter(physicalLayer);
Below you can find Demo - simple
source code:
To work properly
Web Audio API
requires running your HTML file via web server (http://localhost...
) like Apache or some Node stuff likegulp-webserver
(I'm using it and it works great). In case of local machine normalhttp
connection would work. Unfortunately when you will want to go live you have to providehttps
. It's because in some browsers accessing microphone is not allowed when site is not hosted overhttps
. You can read more about this here
In case you are curious about long namespaces: Under the hood AudioNetwork works on simple Injector implementation. For example AudioNetwork.PhysicalLayer.PhysicalLayer is just alias for AudioNetwork.Injector.resolve('PhysicalLayer.PhysicalLayer'). Other public classes/services that have aliases you can find here
Full feature demo
is growing with AudioNetwork library core. It's developer sandbox for all new features.
Demo is divided into two sections - Receive
and Transmit
(blue bar with white text). You can show or hide
stuff by clicking on View type
buttons at Initialize
section.
Here you can find lots of information like input spectrum, constellation diagrams, power chart.
At Receive
section you can also check current status of ReceiveAdapter
.
ReceiveAdapter
is wrapper for lower levelPhysicalLayer
's objectrx
events.
The most important thing in this adapter is its state. You can find it at the top of the orange box (capital letters
text like IDLE_INIT
, FIRST_SYNC_WAIT
, etc). Other important area to look is output of RX adapter - PACKETS
.
Here you can find any potential packet that will be found in the air. I wrote potential because integrity of
incoming packets is not verified so some of them might be corrupted. It's because it's not PhysicalLayer
responsibility to deal with it. In some future release of AudioNetwork packet verification will be added.
This would be in next layer in the network stack - DataLinkLayer
(like in
OSI model).
Orange box is kind of developer debug box - it will be replaced to some nicer UX in the future...
At Transmit
section there is not that much as at Receive
section. You will find there only few buttons to send
SYNC
signal, PACKET
and individual symbols (0
, 1
, ...). Number of unique symbols is determined by
PSK symbol size
(you need to switch view type to Complex
to see that). At Packet
textarea please remember to
always put one space between each symbol but whole text needs to be without trailing and leading spaces.
SyncPreamble
(symbol with zero
phase offset relative to reference) before each packet. ReceiveAdapter takes that SyncPreamble
and restores symbol
alignment before each packet. During packet transmission it may still rotate but at least at the beginning of the
packet symbols are aligned at both sides - sender and receiveraverageIdlePower
(during IDLE_INIT state). Then it waits for sender for synchronization signal which is
basically symbol zero transmitted for few seconds. During sync transmission receiver stores averageFirstSyncPower
at FIRST_SYNC
state. After those steps receiver calculates powerThreshold
and it's ready for packets from sender. All above is needed to propperly determine signal and noise power levels. Without it we will not be able to decode packet.Internally AudioNetwork library uses Web Audio API for retrieving audio data from the microphone and sending audio data to the speakers. To be more precise it is using ScriptProcessorNode. ScriptProcessorNode fires event when new portion of samples arrives (from mic) or new portion of samples is required (for speakers). Basically AudioNetwork library is analysing/providing raw arrays of sound samples inside audio events handlers. In other words all DSP is performed by internal AudioNetwork's classes or services written in pure JavaScript.
Apart from ScriptProcessorNode two other Web Audio API nodes were used. First was GainNode for connecting other nodes together and the second was AnalyserNode. AnalyserNode was used only to show some 'nice' visual stuff to the user. We can switch between time domain (to see raw samples) and frequency domain (spectrum analyzer like on FM radio display). It's optional and not required when we want to just send or receive data.
If somebody is familiar with Web Audio API one question may now come - why I didn't use OscillatorNode for sound generation or AnalyzerNode's FrequencyData output for detecting carrier frequencies? Well... I could, but the main goal for this project was to use PSK (Phase Shift Keying) modulation to send/receive data and learn a bit about modern wireless communication techniques. Those two goals even forced me to write everything from scratch because AnalyserNode's frequency domain data output (it is using FFT - Fast Fourier Transform) provides only amplitude information without any phase information. It turned out that the only way to achieve PSK modulation was to implement own Discrete Fourier Transform with amplitude/phase or use some DSP library. I wanted to dig into the details so I picked the first option :) Wikipedia about DFT looks ultra scary but in the code there is no rocket science. Basic implementation of Discrete Fourier Transform is very simple. We will not find there any mathematical tricks like used in FFT. If you don't believe me, check this class CarrierRecovery.
There's no rose without a thorn... CarrierRecovery class code is simple but when we would like to create more of its instances, to have more carrier frequencies, we will reduce overall performance pretty fast. It is not good but at least it's closer to KISS design principle ;)
The MIT License (MIT)
Copyright (c) 2015-2018 Robert Rypuła - https://audio-network.rypula.pl
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.


LXDMXWiFi_Library encapsulates functionality for sending and receiving DMX over and ESP8266 WiFi connection.
LXDMXWiFi is a virtual class with concrete subclasses LXWiFiArtNet and LXWiFiSACN which specifically
implement the Artistic Licence Art-Net and PLASA sACN 1.31 protocols.


fun queueEpochUpdate(): Unit
Queues genetic algorithm update and waits until it finishes. Returns outselected vehicles.


File tclhdl.tcl¶
-
namespace
tclhdl
¶ Namespace Declaration
Functions
-
get_version
()¶ Get Library Version
-
set_project_root
()¶ Set Project Root
-
get_project_list
()¶ Get Project List
-
add_source
()¶ Add Source File To The Project Structure
-
add_tcl
()¶ Add Tcl File To Project
-
add_ip
()¶ Add IP To The Project Structure
-
add_constraint
()¶ Add Constraint To The Project Structure
-
add_simulation
()¶ Add Simulation File To The Project Structure
-
add_settings
()¶ Add Settings To The Project Structure
-
add_project
()¶ Add Project
-
add_pre
()¶ Add Pre Script
-
add_post
()¶ Add Post Script
-
project_verify
()¶ Verify if Project is compliant with TCLHDL
-
project_create
()¶ Create/Generate Project
-
project_build
()¶ Build Project
-
project_info
()¶ Get Project Information
-
project_open
()¶ Open Existent Project
-
project_close
()¶ Close Project
-
project_clean
()¶ Clean Project
-
is_project_created
()¶ Verify If Create Project is Set
-
project_shell
()¶ Shell Project
-
fetch_pre
()¶ Fetch Post Scripts
-
fetch_ips
()¶ Fetch IP sources
-
fetch_sources
()¶ Fetch Sources
-
fetch_constraints
()¶ Fetch Constraints
-
fetch_simulations
()¶ Fetch Simulations
-
fetch_settings
()¶ Fetch Settings
-
fetch_post
()¶ Fetch Post Scripts
-
set_project_name
()¶ Set Project Name
-
set_project_dir
()¶ Set Project Directory
-
set_project_type
()¶ Set Project Type
-
set_project_part
()¶ Set Project Part
-
set_project_jobs
()¶ Set Project Jobs
-
set_project_target_dir
()¶ Set Project Target Directory
-
set_source_dir
()¶ Set Project Source Directory
-
set_ip_dir
()¶ Set Project IP Directory
-
set_ip_output_dir
()¶ Set Porject IP Output Directory
-
set_constraint_dir
()¶ Set Project Constraint Directory
-
set_simulation_dir
()¶ Set Project Simulation Directory
-
set_settings_dir
()¶ Set Project Settings Directory
-
set_scripts_dir
()¶ Set Project Scripts Directory
-
build_pre
()¶ Build Pre
-
build_ip
()¶ Build IP
-
build_synthesis
()¶ Build Synthesis
-
build_fitting
()¶ Build Fitting
-
build_timing
()¶ Build Timing
-
build_post
()¶ Build Post
-
build_bitstream
()¶ Build Bitstream
-
build_report
()¶ Build Report
Variables
-
tclhdl::project_root
-
tclhdl::project_name
-
tclhdl::project_dir
-
tclhdl::project_type
-
tclhdl::project_tool
-
tclhdl::project_part
-
tclhdl::project_jobs
-
tclhdl::project_target_dir
-
tclhdl::project_source_dir
-
tclhdl::project_ip_dir
-
tclhdl::project_constraint_dir
-
tclhdl::project_simulation_dir
-
tclhdl::project_settings_dir
-
tclhdl::project_scripts_dir
-
tclhdl::project_build_dir
-
tclhdl::project_build_ip_dir
-
tclhdl::project_build_full
-
tclhdl::project_build_step
-
tclhdl::list_projects
-
tclhdl::list_source
-
tclhdl::list_ip
-
tclhdl::list_constraint
-
tclhdl::list_settings
-
tclhdl::list_target_dir
-
tclhdl::list_pre_scripts
-
tclhdl::list_post_scripts
-
tclhdl::flag_project_create
-
tclhdl::home
-


Musings of a Moderate Code and Copyright Maverick
Hello. My name is Nathan Krantz-Fire. Sometimes, I go by the name zippynk. I'm a high school student who codes, sings, plays clarinet, writes music, and writes words. When I write words, I usually write them about Linuxy things. And sometimes other things.
Posts
Ideally, You Don't Motivate TJ
So why let TJ excessively motivate you?
Nathan Krantz-Fire Private License, Version 0.1.5
Please agree to the following REAR END USER LICENSE AGREEMENT.
Linux Wants To Be Free
Why that's a problem, and who's doing what to solve it


Kubernetes Failures
Sort by
total count
count in last day
error message
Display normalized errors
Include results from:
CI
PR
Filter (these are regexes):
Failure text
Job
Test
Loading...


Idea: Research Coin and futuristic research labs
April 1, 2017
Futuristic research labs
A few months ago, I started asking myself this question:
How can we run a futuristic research lab and fund great research?
This is the type of questions that the excellent people at Protocol Labs Inc. are also trying to tackle. Their strategy as a company and as an industry R&D&D lab is to launch token-based network protocols and use the token sales to fund new research.
Universities are not companies, and it is difficult to fund research from which the outcomes are unknown (or yet to be researched!). Given the incentive power that tokens have in these new blockchain-based decentralized systems, I wonder if we can borrow some ideas from these systems to rethink the way we fund and we run university research labs.
The above question lead to another question:
Can we fund research at MIT by launching an MITCoin?
While I am still trying to answer that question, I have no clear idea about what values an MITCoin could actually bring. Is there a more generic Research Coin that can be used to reward great research?
In the rest of this post, I am describing a sort of proposal for Research Coin. My plan here is to update this blogpost and propose a lot of bad ideas, which I don’t necessarly endorse. Hopefully a great idea will come out of this, if you are interested in the problem or you are running a research lab and want to be part of this conversation, please get in touch with me! :)
Attempt 1: Research Coin
Motivation
- Reward academics for their good research
- Finding new funding strategy beyond grants!
- Incentivize peer-review
Assumptions
- Assumption 0: There is a set of great peer-reviewed conferences/journal
- Assumption 1: A research paper is good if it gets reviewed from those
- Assumption 2: Peer review is always wise and unbiased
Idea
- Oracles: There is a set of well known conferences that is chosen and they are trusted to reveal the published papers (we can just rely on HTTPS)
- Minting Tokens: If a paper is published in one of these conferences, the paper receives a reward (that can is shared between the authors) (can still be automated)
- Tokens: Tokens can be exchanged and sold by the academics
What to do with these tokens? (crazy ideas starting here)
-
Reputation score
Organizations that support research could have a reputation score based on how much they have donated to academics (?).
For example: A company can be a sponsor of the conference only if they have a minimum amount of research coins
-
Incentivizing Peer-Review
A peer-to-peer network of peer reviewers can review the papers, and bet whether a paper will be accepted or not for a particular conference. On the conference deadlines, all the winning reviewers get rewarded. This system could re-create interesting behaviors, where peer-reviewers will try to look for great papers that need some more work and give comments to the authors.
Questions
- Are there better uses for the token? (I think the peer review betting idea can be really powerful - although there should be no insider trading!)
- Are the assumptions correct?
- Do these ideas distort the way we do research?
I also have other inexplored ideas:
- Can we find a way for researchers to “bet” on their research?
- Can we turn the reputation of citations into revenue streams?
Future directions
I am struggling to see why Attempt 1 can really work, and I scared it might incentivize new types of behaviour (corrupted peer reviewers!) or even disagreement on who decides, who is in the “closed” circle of conferences and journals.
Attempt 2: University Coin
This idea comes from a midnight conversation with Matt from MIT. It’s an improvement (or different attempt) for a Research Coin.
New token model
Each institution, research lab or group can create an “org”. Each org is assigned 100 org-tokens that are specific to the org. For example, the org “MIT” will have MITCoin, “Cornell” will have CornellCoin and so on. Even a specific lab, can decide to create an org, for example MIT PDOS can create a PDOS token. An org can decide whether to sell or not their 100 org-tokens.
Betting system
Similarly to Research Coin, anyone can bet on a paper being accepted at a specific conference. However, one can bet on a paper by using the org-token representing the org used by the researchers. In other words, if I want to bet that the MIT paper will be accepted, I must bet tokens from MIT.
Bets run in rounds, for each conference, owners of tokens can bet org-tokens on papers from a specific org. When papers are selected by the conference, all the lost bets are split proportionally (however, I am not sure how, this is actually non-trivial) to the amount they bet.
Intuitions
The intuition here is that universities (and research labs) can use do great research to increase the value of their tokens, since many would prefer to bet on their research. I expect that the token of a very active university will have a higher price, but bets will have a low risk, hence a lower return, however, I will need to revisit this intuition soon.
This is however is more difficult to implement in practice than idea 1. This requires research organizations to actively create orgs and sell a percentage of their coins (well, we can still bootstrap this with researchers getting reward coins for their published research..!)
I am overall convinced that this is NOT a good idea yet. I am not sure if betting on research paper passing through a conference is the best use of a currency.
Questions
- Would this lead to making great research or would this be optimize for short-term good publishable research?
- Can universities do “ICO”s for selling betting credit for their university?
- Would this really increase peer-review or there will just be speculation?
Help me think about Attempt 3!
- Nicola Greco,
Keep on rocking the decentralized web


Select a rectangle by holding shift, followed by two corner squares of the rectangle.
Select an Aztec diamond by holding command (Windows key for PC), followed by two corner vertices of the diamond (see example).
Change the grid size with the buttons to the right.
Number of Tilings:


Fourier Transforms¶
In the C++ layer we use FFTW for our 2D Fourier transforms. This package is generally faster than numpy fft functions. So for at least a subset of the functionality available in the numpy versions, we have implemented python functions that call out to the backend C++ FFTW functions.
These should be drop in replacements for np.fft.* functions. e.g.:
>>> karray = galsim.fft.fft2(xarray)
is functionally equivalent to:
>>> karray = np.fft.fft2(xarray)
but should be a bit faster.
Note
The GalSim versions often only implement the normal use case without many of the advanced options available with the numpy functions. This is mostly laziness on our part – we only implemented the functions that we needed. If your usage requires some option available in the numpy version, feel free to post a feature request on our GitHub page.
-
galsim.fft.
fft2
(a, shift_in=False, shift_out=False)[source]¶ Compute the 2-dimensional discrete Fourier Transform.
For valid inputs, the result is equivalent to numpy.fft.fft2(a), but usually faster.:
>>> ka1 = numpy.fft.fft2(a) >>> ka2 = galsim.fft.fft2(a)
Restrictions on this version vs the numpy version:
The input array must be 2-dimensional.
The size in each direction must be even. (Ideally 2^k or 3*2^k for speed, but this is not required.)
If it has a real dtype, it will be coerced to numpy.float64.
If it has a complex dtype, it will be coerced to numpy.complex128.
The returned array will be complex with dtype numpy.complex128.
If shift_in is True, then this is equivalent to applying numpy.fft.fftshift to the input.:
>>> ka1 = numpy.fft.fft2(numpy.fft.fftshift(a)) >>> ka2 = galsim.fft.fft2(a, shift_in=True)
If shift_out is True, then this is equivalent to applying numpy.fft.fftshift to the output.:
>>> ka1 = numpy.fft.fftshift(numpy.fft.fft2(a)) >>> ka2 = galsim.fft.fft2(a, shift_out=True)
- Parameters
a – The input array to be transformed
shift_in – Whether to shift the input array so that the center is moved to (0,0). [default: False]
shift_out – Whether to shift the output array so that the center is moved to (0,0). [default: False]
- Returns
a complex numpy array
-
galsim.fft.
ifft2
(a, shift_in=False, shift_out=False)[source]¶ Compute the 2-dimensional inverse discrete Fourier Transform.
For valid inputs, the result is equivalent to numpy.fft.ifft2(a), but usually faster.:
>>> a1 = numpy.fft.ifft2(ka) >>> a2 = galsim.fft.ifft2(ka)
Restrictions on this version vs the numpy version:
The array must be 2-dimensional.
The size in each direction must be even. (Ideally 2^k or 3*2^k for speed, but this is not required.)
The array is assumed to be Hermitian, which means the k values with kx<0 are assumed to be equal to the conjuate of their inverse. This will always be the case if a is an output of fft2 (with a real input array). i.e.
for kx >= N/2, ky > 0: a[ky, kx] == a[N-ky, N-kx].conjugate()
for kx >= N/2, ky = 0: a[0, kx] == a[0, N-kx].conjugate()
Only the elements a[:,0:N/2+1] are accessed by this function.
If it has a real dtype, it will be coerced to numpy.float64.
If it has a complex dtype, it will be coerced to numpy.complex128.
The returned array will be complex with dtype numpy.complex128.
If shift_in is True, then this is equivalent to applying numpy.fft.fftshift to the input:
>>> a1 = numpy.fft.ifft2(numpy.fft.fftshift(ka)) >>> a2 = galsim.fft.ifft2(ka, shift_in=True)
If shift_out is True, then this is equivalent to applying numpy.fft.fftshift to the output:
>>> a1 = numpy.fft.fftshift(numpy.fft.ifft2(ka)) >>> a2 = galsim.fft.ifft2(ka, shift_out=True)
- Parameters
a – The input array to be transformed
shift_in – Whether to shift the input array so that the center is moved to (0,0). [default: False]
shift_out – Whether to shift the output array so that the center is moved to (0,0). [default: False]
- Returns
a complex numpy array
-
galsim.fft.
rfft2
(a, shift_in=False, shift_out=False)[source]¶ Compute the one-dimensional discrete Fourier Transform for real input.
For valid inputs, the result is equivalent to numpy.fft.rfft2(a), but usually faster.:
>>> ka1 = numpy.fft.rfft2(a) >>> ka2 = galsim.fft.rfft2(a)
Restrictions on this version vs the numpy version:
The input array must be 2-dimensional.
If it does not have dtype numpy.float64, it will be coerced to numpy.float64.
The size in each direction must be even. (Ideally 2^k or 3*2^k for speed, but this is not required.)
The returned array will be complex with dtype numpy.complex128.
If shift_in is True, then this is equivalent to applying numpy.fft.fftshift to the input.:
>>> ka1 = numpy.fft.rfft2(numpy.fft.fftshift(a)) >>> ka2 = galsim.fft.rfft2(a, shift_in=True)
If shift_out is True, then this is equivalent to applying numpy.fft.fftshift to the output.:
>>> ka1 = numpy.fft.fftshift(numpy.fft.rfft2(a),axes=(0,)) >>> ka2 = galsim.fft.rfft2(a, shift_out=True)
- Parameters
a – The input array to be transformed
shift_in – Whether to shift the input array so that the center is moved to (0,0). [default: False]
shift_out – Whether to shift the output array so that the center is moved to (0,0). [default: False]
- Returns
a complex numpy array
-
galsim.fft.
irfft2
(a, shift_in=False, shift_out=False)[source]¶ Compute the 2-dimensional inverse FFT of a real array.
For valid inputs, the result is equivalent to numpy.fft.irfft2(a), but usually faster.:
>>> a1 = numpy.fft.irfft2(ka) >>> a2 = galsim.fft.irfft2(ka)
Restrictions on this version vs the numpy version:
The array must be 2-dimensional.
If it does not have dtype numpy.complex128, it will be coerced to numpy.complex128.
It must have shape (M, N/2+1).
The size M must be even. (Ideally 2^k or 3*2^k for speed, but this is not required.)
The returned array will be real with dtype numpy.float64.
If shift_in is True, then this is equivalent to applying numpy.fft.fftshift to the input.:
>>> a1 = numpy.fft.irfft2(numpy.fft.fftshift(a, axes=(0,))) >>> a2 = galsim.fft.irfft2(a, shift_in=True)
If shift_out is True, then this is equivalent to applying numpy.fft.fftshift to the output.:
>>> a1 = numpy.fft.fftshift(numpy.fft.irfft2(a)) >>> a2 = galsim.fft.irfft2(a, shift_out=True)
- Parameters
a – The input array to be transformed
shift_in – Whether to shift the input array so that the center is moved to (0,0). [default: False]
shift_out – Whether to shift the output array so that the center is moved to (0,0). [default: False]
- Returns
a real numpy array


Tailscale’s website reads:
A secure network that just works
Zero config VPN. Installs on any device in minutes, manages firewall rules for you, and works from anywhere.
gokrazy-based devices are no exception! This guide shows you how to use Tailscale with gokrazy.
Tailscale’s networking will come in handy when accessing your gokrazy server remotely (no static DHCP leases, port-forwarding and DynDNS required!), or even to secure your communication when gokrazy is connected to an unencrypted WiFi network.
We need to specify the following flags for the tailscaled
daemon (see Package
config: flags and environment variables if you’re
unfamiliar with this mechanism):
mkdir -p flags/tailscale.com/cmd/tailscaled
echo '--statedir=/perm/tailscaled/' > flags/tailscale.com/cmd/tailscaled/flags.txt
echo '--tun=userspace-networking' >> flags/tailscale.com/cmd/tailscaled/flags.txt
tailscaled
requires the --statedir
flag, so we need to set it
explicitly. /perm/tailscaled
is the working directory of the tailscaled
process and will contain the tailscaled.sock
socket, so it makes sense to
place the state file into the same directory.
The --tun=userspace-networking
flag selects the Userspace
networking mode.
It would be nice to use the tun
-based networking eventually, but currently
Tailscale requires components that gokrazy does not provide for tun
mode. For
accessing the services on your gokrazy installation, the Userspace networking
mode works fine, though :)
In your gokr-packer
invocation (see Quickstart if you don’t
have one yet), include the Tailscale daemon and CLI Go packages:
gokr-packer \
-update=yes \
github.com/gokrazy/hello \
github.com/gokrazy/breakglass \
github.com/gokrazy/serial-busybox \
tailscale.com/cmd/tailscaled \
tailscale.com/cmd/tailscale
Log in to your gokrazy device interactively using
breakglass, change to the
/perm/tailscaled
directory and run tailscale up
to print the authentication
link:
% breakglass gokrazy
breakglass# cd /perm/tailscaled
breakglass# /user/tailscale up
(If you only want to connect to services on your gokrazy device, you don’t need this step.)
To make the github.com/stapelberg/dr
package able to connect to addresses on
the tailscale network, we need to first enable tailscaled
’s HTTP
proxy:
echo '--outbound-http-proxy-listen=localhost:9080' > flags/tailscale.com/cmd/tailscaled/flags.txt
And then set the proxy environment variables:
mkdir -p env/github.com/stapelberg/dr
echo 'HTTPS_PROXY=localhost:9080' > env/github.com/stapelberg/dr/env.txt
echo 'HTTP_PROXY=localhost:9080' >> env/github.com/stapelberg/dr/env.txt
You need to use tailscale at commit b3abdc3 or later for this to work!
If you want to make a program listen on tailscale without listening on any other
network interface, you can use the tsnet
package (find this program at
github.com/gokrazy/tsnetdemo):
package main
import (
"crypto/tls"
"flag"
"fmt"
"log"
"net/http"
"os"
"tailscale.com/client/tailscale"
"tailscale.com/tsnet"
)
func main() {
os.Setenv("TAILSCALE_USE_WIP_CODE", "true")
// TODO: comment out this line to avoid having to re-login each time you start this program
os.Setenv("TS_LOGIN", "1")
os.Setenv("HOME", "/perm/tsnetdemo")
hostname := flag.String("hostname", "tsnetdemo", "tailscale hostname")
allowedUser := flag.String("allowed_user", "", "the name of a tailscale user to allow")
flag.Parse()
s := &tsnet.Server{
Hostname: *hostname,
}
log.Printf("starting tailscale listener on hostname %s", *hostname)
ln, err := s.Listen("tcp", ":443")
if err != nil {
log.Fatal(err)
}
ln = tls.NewListener(ln, &tls.Config{
GetCertificate: tailscale.GetCertificate,
})
httpsrv := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
who, err := tailscale.WhoIs(r.Context(), r.RemoteAddr)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if who.UserProfile.LoginName != *allowedUser || *allowedUser == "" {
err := fmt.Sprintf("you are logged in as %q, but -allowed_user flag does not match!", who.UserProfile.LoginName)
log.Printf("forbidden: %v", err)
http.Error(w, err, http.StatusForbidden)
return
}
fmt.Fprintf(w, "hey there, %q! this message is served via the tsnet package from gokrazy!", who.UserProfile.LoginName)
}),
}
log.Fatal(httpsrv.Serve(ln))
}
--allowed_user
flag to verify that tailscale authentication works as expected


You can have the best quality eye glasses, sunglasses or reading glasses just for $39. Visit 39 Dollar Glasses online to check it out. You no longer have to spend a lot of money on expensive eye glasses. Check out www.39dollarglasses.com and choose from a wide array of high quality, finished prescription glasses only for $39. You will love the product and the price. Use our discount coupons to get the best prices on the best product.
39dollarglasses.com was developed by eye doctors so that everyone to acquire glasses at an affordable price. When you shop at 39dollarglasses.com the only thing you will give up is high prices. Get the best, stylish, attractive and high quality glasses today, shop at 39dollarglasses.com online. They have huge inventories and buy in bulk that is why 39dollarglasses gets a volume discounts. They are able to pass on that discounts to you. Also, they are an online store, so they save money on the overheads. They use the only the best polycarbonate lenses; the lightest, most impact-resistant material. With an index of refraction of 1.59, they are much thinner than standard (CR39) optical lenses. They also come with both 100% UV and tough scratch-resistant coatings applied to both sides of the lenses. You will get all this and more when you purchase your eyewear from 39dollarglasses.com.
Buy progressive lenses, or sunglasses or eye glasses from 39dollarglasses.com. You can also get rimless or semi rimless, bi focal, contact lenses, metal or titanium bendable glasses. There is so much waiting for you at 39dollarglasses.com, including great discounts. Check it out now and use our discount coupons to save lots of money.


Before Change
def __init__(self, source, record=True, when="end", order=0,
name="spikemonitor*", codeobj_class=None):
self.record = bool(record)
//: The source we are recording from
self.source =source
self.codeobj_class = codeobj_class
After Change
// Since this now works for general events not only spikes, we have to
// pass the information about which variable to use to the template,
// it can not longer simply refer to "_spikespace"
eventspace_name = "_{}space".format(event)
template_kwds = {"eventspace_variable": source.variables[eventspace_name]}
needed_variables= [eventspace_name]
CodeRunner.__init__(self, group=self, code="", template="spikemonitor",
name=name, clock=source.clock, when=when,


{% extends 'base.html' %} {% block title %}Twin Cities Landlord App{% endblock title %} {% block content %}
Are you considering renting, but want to check out a landlord? Having trouble with your landlord and want to find other properties and tenants with the same landlord? It can be difficult to identify all the properties owned by a landlord because ownership may be masked by corporation and the many spellings and mis-spellings of an owner's name. This site does its best to pull together all properties that are actually owned by the same entity and treats them as a single portfolio.
This site grew out of a Twinc Cities Open Data project proposal. Currently, this site is a mashup of two datasets. The Minneapolis Rental License dataset is our source of information about ownership of rental properties. It is better than the property tax data because it includes owner email and phone number. After cleaning up owner name, address, email, and phone number, we join together owners that match on any one of these fields. Minneapolis Regulatory Services provided the data about violations. This was exported from the Tableau interface. We had to do one precinct at a time because of Tableau limitations. After the raw data were downloaded as csv files, they are brought into Python using the Pandas package and then exposed as a Django web application hosted on Azure The source is available on Github
{% endblock content %}


The workers you selected answered {{average_qansII}} questions correctly on average in Round 2. Hence you will receive a bonus of $ {{bonus}}.”
| The average number of questions that the workers you choose answer correctly | Your earnings | Number (and Proportion) of the workers who answered correctly in this range |
| <0.5 question | $0 | 20 (19%) |
| 0.5-1 questions | $1.0 | 36 (34%) |
| 1-2 questions | $2.0 | 27 (25%) |
| 2-3 questions | $3.0 | 16 (15%) |
| 3-4 questions | $4.0 | 8 (6%) |
| 4-5 questions | $5.0 | 1 (0.9%) |


Using Bootstrap, jQuery some vanila javascript I built the site with help from the thumbzup team.
Bid2Stay is an initiative by the City Lodge Hotel Group, bringing you hotel stays at reduced prices
Book a hotel room at City Lodge. For an unforgettable business trip.
It's always a 'best time to visit South Africa', all year round...


For multiple decades, Apple has been the one company to take a concept that seems good on paper and not executed well and change it up their way to be simple and be overall better. But there is a secret side to Apple that Apple does not want the public to see. This has been a secret that has been well hidden since 1997. What is this super secret thing that Apple wants to hide from the public. Well this secret is that Apple is controlled by the Illuminati. Thanks to our agents penetrating Apple HQ for their secrets, we have finally managed to uncover this secret that will be shown to the world to show the evilness of the illuminati and the lives it distroyed at Apple
Sub Menu


--- tags: - recreation - ski author: display_name: JP email<EMAIL_ADDRESS>date: 2011-11-22 15:09:02 -0700 categories: [] SkiAreas: downloads: - url: https://drive.google.com/drive/folders/0ByStJjVZ7c7mY0Z0UkF1QkdiTVU label: Ski Area Package updates: - October 2014 endpoints: - url: https://utah.maps.arcgis.com/home/item.html?id=24029712a33f47feacc7b3f2ef75f179 label: ArcGIS Online Feature Layer --- {% include abstract.html name="Ski Areas" stewards="AGRC" abstract="This data package contains ski area boundaries and ski lifts for Alta, Beaver Mountain, Brian Head, Brighton, The Canyons, Deer Valley, Eagle Point, Park City, Snowbird, Solitude, Sundance, Nordic Valley, and Cherry Peak. It also contains some cross country ski trail systems." %}
{% include contact.html subject=page.title contact=site.data.contacts.agrc %}


--- subject: IMPORTANT Updates Regarding COVID-19 ---
Hello {\{email\}}
Just like everyone else, we are closely monitoring this dynamic situation, both globally and locally. Nothing is more important to us than keeping you and our employees safe, as well as doing our part to help protect the most vulnerable people in our families and communities.
With the number of COVID-19 coronavirus infections and casualties growing, you need to identify how this epidemic could affect your organization. Many quarantine protocols are failing, making it even more critical for you to plan for prevention and treatment now
Health Protection Scotland (HPS)


Coders - Gain industry experience, expand connections, earn side cash, and learn different technologies.
Companies - Identify talents, reduce software costs, acquire diverse solutions, devise new directions, and broaden participation.
For coders For companies


Click the "Join Now" button below and start earning rewards right away.
Every time you reach $50 in book purchases we will send you a $5 coupon.
Increased discounts for referring a friend and other savings. See Bonus Savings below.
Receive a coupon for $5.00 every time you spend $50.00 (shipping not included)
ReadingRewards members who use our Tell-A-Friend program get a 20% off coupon for qualifying referrals (15% for non-members).
For their birthdays, ReadingRewards members receive a 20% off coupon (15% off for non-members).
THRIFT BOOKS© BOOK BONUS PROGRAM
TERMS & CONDITIONS
Effective Date: May 11, 2015
Introduction
We want you to read more and spend less. The Thrift Books® Reading Rewards Program has been introduced to provide registered members of Thriftbooks.com with special reward, discount and promotional offers. These Terms & Conditions (“T&Cs”) constitute a legally binding agreement governing your participation in the Thrift Books® Reading Rewards. By participating in the Thrift Books® Reading Rewards, you indicate your unconditional agreement to the terms set forth in the T&Cs, and the terms set forth in the Conditions of Use and the Privacy Policy, both of which are incorporated into the T&Cs, and as each may be modified by Thrift Books, LLC. Please read each of these documents carefully before participating in the Thrift Books® Reading Rewards program. This program is not targeted towards, nor intended for use by, anyone under the age of 13. If you are between the ages of 13 and 18, you may only participate in the Thrift Books® Reading Rewards Program under the supervision of a parent or legal guardian who agrees to be bound by these T&Cs. This program is for the benefit of individual readers for their own reading pleasure and it is not intended to benefit the large order buyer/reseller.
Eligibility for & Conditions of the Program
The Program is operated by Thrift Books, LLC and its affiliates (collectively referred to as “Thrift Books”, “we”, “us” or “our”) in the United States. No “Guest” account orders are eligible for this program (a “Guest” account order is one placed by a customer who has ordered from Thriftbooks.com but not submitted their full account details and created a registered account. To register an account with Thriftbooks.com, visit https://www.thriftbooks.com/account/login.aspx Registration with Thriftbooks.com is offered solely at the discretion of Thrift Books and subject to the Conditions of Use and the Privacy Policy. By participating in the Program, you agree to provide and maintain accurate personal information about yourself (including first name, last name, e-mail address and zip code) and submit accurate and valid billing and shipping information. You are responsible for ensuring the accuracy of all information submitted in relation to your registered account.
Companies, associations, or other groups also may not participate in the Program. Membership in and the benefits of the Program are offered at the sole and exclusive discretion of Thrift Books. Thrift Books may, at any time, terminate, change, limit, modify or cancel the Program or any rules, regulations, benefits or conditions of participation by posting the modified rules on this page.
By participating in the Program, you affirmatively consent to (i) receiving emails from us at the email address associated with your registered account (provided, however, that you may later withdraw your consent to receive commercial emails by following email opt-out procedures in our Privacy Policy), (ii) our requesting (with the understanding that you may refuse our request), recording, using and keeping, for as long as we deem necessary, information about you (including, but not limited to, your name, mailing address, zip code, telephone number, credit, debit or payment account information and email address) as such information is required, or deemed necessary by us, for the purposes of fulfilling your requests that we service your registered account (including, but not limited to, your requests that we establish your account, look up or edit your account information, or associate a purchase with your account), (iii) our requesting that you present Program or account information when you purchase goods at Thriftbooks.com so that you may receive Program benefits, and (iv) our compiling information about items you purchased from us, when purchases and returns were made, your method of payment, or if you open, access hyperlinks in or respond to emails from us.
Features of the Program
By participating in the Program, you will be eligible to receive the following benefits: (i) coupons, promotions and offers that we extend to Program participants and (ii) advance notification of certain advertisements and select coupons, promotions and offers (collectively, the "Program benefits"). We reserve the right to offer non-transferable, targeted Program benefits to select Program participants based upon purchase history or to encourage Program participation. Your use of Program benefits may be subject to additional terms and conditions and limitations and exclusions may apply. Program benefits may be used only at Thriftbooks.com and may be used only by you, the person to whom the account is registered. Your account must be in good standing to redeem Program benefits. You may be required to input promotional codes in order to collect certain Program benefits and we may refuse to honor such Program benefits if you do not do so. Unless otherwise noted in writing, coupons, promotions and offers cannot be used with any other discounts. If a purchase is removed from your registered account as a result of you returning a previously purchased item or for any other reason, you may no longer qualify for Program benefits that had previously been offered to you.
If, at the time you make a purchase, your purchase is not associated with your registered account for any reason, it is your responsibility to have the purchase associated with your registered account within 30 days of the purchase date. Any purchase not associated with your registered account within 30 days of the date of purchase will expire and will not be available to associate with your registered account. If you return any item, that portion of the purchase will no longer be credited to your registered account. We reserve the right to require proof of any purchase, including, but not limited to, an original e-mail receipt, in order to associate a purchase with your registered account. Purchases that are determined to be invalid for any reason are subject to disqualification and will no longer be credited to your registered account.
Promotional codes, coupons or discounts cannot be combined. For coupons and discount promotions with minimum purchase requirements, only the purchase price of qualifying items is included in calculating the minimum purchase level. Tax and shipping charges are not included in calculating the minimum purchase level. Coupons are not valid if purchased or sold and must be surrendered and have no cash/credit back features.
Current Program Offers
READING REWARDS $5 OFF COUPON FOR $50 SPENT OFFER
Offer Start Date: May 11, 2015
When Registered Members spend a total of $50.00 (including only the actual purchase price (net of any discounts or coupons) and excluding applicable shipping charges and taxes), Thrift Books will send you a coupon good for $5.00 of your next purchase. For every additional $50.00 (including only the actual purchase price (net of any discounts or coupons) and excluding applicable shipping charges and taxes) you spend, Thrift Books will send you another coupon good for $5.00 off your next purchase. The amount you spend is based on a cumulative total of the books you buy across future qualifying orders. Each coupon will expire 365 days after the date it is issued.
TELL-A-FRIEND COUPON OFFER
Offer Start Date: May 11, 2015
As a Program Member, for every friend you refer to through the “Tell-a-Friend” feature, you will receive a coupon for 20% off your next order once your friend makes a qualifying purchase from Thriftbooks.com.
BIRTHDAY COUPON BONUS
Offer Start Date: May 11, 2015
As a Program Member, on your birthday you will receive a coupon for 20% off your next order from Thriftbooks.com.
Modifications and Termination
We reserve the right to modify any of the T&Cs set forth herein — including, but not limited to, the Program benefits and the requirements for redeeming them — at any time, with or without notice, even though these changes may adversely affect your ability to receive and/or use Program benefits.
We reserve the right to terminate the Program at any time, for any reason, even though termination may adversely affect your ability to receive and/or use Program benefits. You will have the lesser of the then-remaining term of any Program benefit or 30 days from the date Program termination is announced to use any unexpired Program benefit.
Your continued participation in the Program constitutes your acceptance of the T&Cs, Conditions of Use and the Privacy Policy and all changes made to the T&Cs, Conditions of Use and the Privacy Policy. You are responsible for remaining knowledgeable as to any changes that we may make to the T&Cs, Conditions of Use and the Privacy Policy. The most current version of the T&Cs, Conditions of Use and the Privacy Policy will be available at Thriftbooks.com and will supersede all previous versions of the T&Cs, Conditions of Use and the Privacy Policy.
General Terms and Conditions
We reserve the right to discontinue the participation privileges of any person who engages in any fraudulent activity or uses the Program in a manner inconsistent with the T&Cs, Conditions of Use, the Privacy Policy or any federal, state or local laws, regulations or ordinances. Discontinued participation privileges may result in the loss of all Program benefits. In addition to discontinuance of participation privileges, we shall have the right to take appropriate administrative and/or legal action, including criminal prosecution, as we deem necessary in our sole discretion.
The Program is provided to individuals only. It is fraudulent for any individual or company to direct, encourage or allow individuals to use a single registered account for the purpose of accumulating Program benefits for combined use.
Program benefits do not constitute property of any individual and may be revoked by us at any time. Registered accounts and Program benefits may not be transferred or assigned, and are not transferable upon death, as part of a domestic relations matter, or otherwise by operation of law. None of the Program benefits are redeemable for cash. We are not responsible for the failure to make Program benefits available. We will not issue an accounting of any purchases.
If there is no activity in connection with your registered account during any consecutive 24 month period, we reserve the right to terminate your Program account and we will not be obligated to provide you with Program benefits after the termination date. If you re-registered an account or create a separate account, you may not transfer your old Program participation or benefits to your new registered account.
All questions or disputes regarding eligibility for the Program, earning or redeeming Program benefits, interpretation of the T&Cs, Conditions of Use and the Privacy Policy, , or a participant’s compliance with the T&Cs, Conditions of Use and the Privacy Policy will be resolved by us in our sole and absolute discretion.
This Membership Agreement is effective as of the date stated above.


Home
Planets
Ships
Stations
Money: $0
Wood: 0
Quit
Save
Next Quarter
Planets
Coyto
Mercius
Poloki
Coyto
The is home base
Wood
Current Price: 25$
See 1
Sell 10
Sell 100
Sell All
Mercius
A very, very, very cold planet.
Poloki
This planet has great trees.
Build New Tree Farm - 500$
Build a Wood Refinery - 1500$
Tree Farm
Description: Produces wood
Cost: 500$
Produces: 1 wood per second
Wood Refinery
Description: Creates charcoal
Cost: $15,000
Produces: 2.5 charcoal


{% extends "base_generic.html" %} {% load staticfiles %} {% block content %}
If you have not created an account yet, then please sign up first.


We are organizing the sixth edition of our intensive class in data-driven ecological synthesis, with support from the NSERC BIOS² CREATE program and the Fondation Courtois. Enrolment is limited to 30 students. The course will run online only from the first week of May 2021, for six weeks, with three meetings every week.
The class is free for students registered at a Québec university, and the registration fees are (approx.) 800 CAD for other attendees. We will automatically award a no-questions-asked grant equal to this amount to attendees from under-represented minorities in STEM, members of Canada’s “designated groups” for EDI initiatives (women, people with disabilities, Aboriginal peoples, and visible minorities), as well as members of the LGBTQIA+ community; we will also award several grants for the same amount to attendees who can justify the need for it.
In a departure from the usual format of this course, this year’s cohort will work collaboratively on a single project: predicting interactions between viruses and mammals. This project will be led by and done in collaboration with the VERENA consortium. We will put a specific emphasis on building up skills related to machine learning (building recommender systems, ensemble models) and the automation of synthesis of large amounts of data. A group of researchers with expertise in data science, virology, public health, and disease ecology, will be mentoring the different projects over the course of the six weeks.
The application deadline is Dec. 31, 2020 - please apply on-line using this link.
Goals and target audience
This intensive class will give early-career biologists the tools and skills needed to interact with, manage, clean, and analyze data. We will put a great deal of emphasis on the transparency and reproducibility of the data transformation pipeline. We will specifically do so by working on leveraging open data to address novel questions about ecological systems. You can read more about the approach of computational ecology in a paper co-authored by students from the 2017 cohort.
We expect that the attendees can turn the computer on or be willing to learn how to do so. We will take care of the rest from here. A passing knowledge of statistics or mathematics and programming is a good thing, but eagerness to learn is far more important than previous knowledge; we always strive to have a balance between novice and advanced users. Due to this year’s topic, we are particularly eager to receive applications from learners with a background in infectious diseases, virology, public health, species distribution modeling, or genomics.
The class is open to all, and previous attendees included undergraduate and graduate students, staff scientists, data analysts, and post-doctoral fellows. We think it is particularly relevant for Ph.D. students and post-doctoral fellows.
The core skills we will cover during the class are
- best practices for data management
- acceptable practices in scientific computing
- good-enough practices for programming with data
- useful statistical and mathematical tools
- data cleaning and data analysis tools
- parallel and distributed computing for data processing
- data visualization and presentation
- automation and reproducibility of analyses
The class is extremely participatory, where a lot of training modules are delivered based on the learners’ needs. Some of the modules delivered over the last years included Bayesian statistics, code optimization, and introduction to GIS.
General information
Instructors
The summer school will be led by Timothée Poisot and will include guest appearances by other investigators from the VERENA consortium.
Timothée is a researcher at the Québec Center for Biodiversity Sciences and an associate professor in Quantitative and Computational Ecology at the Université de Montréal. He is a certified Software Carpentry and Data Carpentry instructor, serves on the editorial board of Ecology Letters, Methods in Ecology & Evolution and PLOS Computational Biology, and on the scientific board of Calcul Québec and the Canadian Institute for Ecology & Evolution. He contributes to the artificial intelligence branch of the activities of the GEO BON secretariat. His research focuses on the spatio-temporal dynamics of species interactions and the applications of graph theory to a variety of ecological questions.
Credits
Students from Québec universities can get four credits for this class through CRÉPUQ (class code BIO6065). Please indicate if you want to claim these credits when applying. If you are registered to a non-Québécois university, you can be issued a letter of participation with the details of the course content to claim credits in your own institution.


--- layout: documentation title: COATakenType ---
| Field Name | Type | Description |
|---|---|---|
| Time0..1 | COATimeType |
The Time field specifies the relative time criteria for this taken CourseOfAction. |
| Contributors0..1 | ContributorsType |
The Contributors field specifies contributing actors for the CourseOfAction taken. |
| Course_Of_Action0..1 | CourseOfActionBaseType |
The Course_Of_Action field specifies the actual CourseOfAction taken. This field is implemented through the xsi:type extension mechanism. The default and strongly recommended type is CourseOfActionType in the http://stix.mitre.org/CourseOfAction-1 namespace. This type is defined in the course_of_action.xsd file or at the URL http://stix.mitre.org/XMLSchema/course_of_action/1.1/course_of_action.xsd. |


Are you sure you'd like to delete this vizzy?
Please name your new vizzy
Please type a message you'd like to share with your Vizzy
Would you like to give this Vizzy a new name?
Please enter a new name:
{{shape.id}}
X-axis:
Y-axis:
Music Link:
Angle:
Music Link:
Width:
Height:
Music Link:
Hue
Opacity
Music Link:


Creative theme is a modern and fantastic html template
If you want to contribute to the development of the theme you will be updated on each release. In addition to the completion of the PRO theme you will be sent via email.
The things I love most in life cost nothing. It is evident that the most precious resource we all have is time.
STEVE JOBS
Hi, I'm Creative Theme
I have been developed in bootstrap 4, HTML5 and css3. My structure is very simple. I'm organized into pages and sections.
I can be customized in a short time.
Who We Are
click below to watch our video
Our Work
Courage and curiosity inspire our way of being and identify the people we work with.
The things I love most in life cost nothing. It is evident that the most precious resource we all have is time.
STEVE JOBS


{% extends "website/framework/base_success.html" %} {% block message %} Repository {{ repository.name }} has been deleted successfully. {% endblock %} {% block javascript %} $(location).attr('href', '/website/'); {% endblock %}