Welcome!
This is a quick demo of how to use Angular! Currently there is very little here, apart from an extremely basic todo app. You are encouraged to add to this site!
This is intended to be a collaborative project, so once you've made some changes, make a pull request, and we'll merge them in.
With any luck, we'll collaborate to make a decent site.
If you aren't sure what to do, or are having trouble doing what you want to, don't hesitate to ask!
To get started modifying this site take a look at the Getting Started page.
If you don't have any ideas for something to do here are some suggestions (roughly listed in easy to hard order):
- Add some more fields to the todo list, for example deadlines (html/javascript)
- Make it look prettier (html/css)
- Make changes to the todo list persist to the browser(javascript)
- Allow modifications to your existing items (javascript)
- Add searching for items (javascript)
- Add tags to items (javascript/html/css)
- Add bootstrap to the site (html/css)
- Add notifications (javascript)
- Add linting to the project (javascript/CLI)
- Add another app to the site (javascript/html/css)
- Add jasmine tests to the project (javascript)
- Add a build system to build the site (javascript/grunt/gulp/broccoli/brunch)
- Make changes to the todo list persist to a server via REST (javascript/serverside language)


--- type: formControls title: Multiline input usage: This is a serie of inputs to add multiple entries for the same field type. stylesheet: '/scss/controls/multiline-field.scss' ---


The update check failed.
Here are some possible reasons :
is free application. Mainly used for creating notes.
Copyright 2016 creNote.
All Rights Reserved.
creNote thanks the creators and contributors of the following projects that creNote uses :
Countable.js • DOMPurify • Electron • electron-builder • emojify.js • findAndReplaceDOMText • foreach.js • getmdl-select • github-markdown-css • jsVideoUrlParser • LightRange.js • marked • Material Design Lite • Mousetrap • Mousetrap Global Bind • Normalize.css • reqwest • Sortable • to-markdown • versions-compare • wysiwyg.js
To print your document, save it as a HTML document, open it in your Web browser and use the Ctrl+P⌘P keyboard shortcut.
One or several documents are still unsaved.
You can close all documents all by once without saving their changes or one by one.
A new version of is released (version )
Download the latest version here
Don't panic ;)
There has been a file reading or writing error.
It means that can't read the content of one or several of its files, edit them or create them.
Don't worry we will find a solution.
This error can appear at the application startup, when you try to modify a setting, or save a document with a theme.
In these cases, encountering this error means that is probably installed in a restricted location on your computer.
The easy and recommended way to solve this error is to uninstall the application and reinstall it into a more common location.
On windows, you can ALTERNATIVELY run as administrator if the user account you are using allows you to do so.
This error can also appear when you try to open, or save a document, with or without a theme.
In these cases, encountering this error means that the documents you're trying to save or open, are probably located in a restricted location on your computer.
The easy and recommended way to solve this error is to choose another saving location or move the documents you're trying to open and retry opening them.


Algorithm Analysis
Given a board with n number of unfilled slots, each guess takes O(1) time (for now). An ideal situation is when EVERY guess leads to a solution, meaning not having to re-guess or backtrack at all, this makes the best case:
O(n)
But life doesn't always give you the best, if EVERY guess leads to a dead end except the last one, then this will take the same amount of time as trying EVERY permutation. Let's analyze this, for each slot, there're 9 possible options,
and there are n slots to fill. By the definition of permutations, we can conclude that the worst case:
9 x 9 x ... (n times) = O(9n)
Space complexity is straightforward for this one, we have a 2D array of size d x d, where d = 9 in classic Sudoku. Space complexity:


If you would like to contribute to our gallery, please contact us.
Low swirl burner
Low-swirl burners (LSB) are emerging as an important technology for meeting design requirements in terms of both reliability and emissions for next generation combustion devices. The low-swirl burner concept is extremely simple: premixed fuel exits a pipe after passing through a turbulence generation plate and an annular set of curved vanes. A detached premixed flame anchors in the diverging flow above the pipe exit. Turbulence in fuel stream wrinkles the flame, which enhances the overall rate of combustion in the device.
PeleLM has been used to simulate lean hydrogen and methane flames at the full scale of the laboratory experiments, and the results were probed to explore the details of flame stability and emissions production.
- M. Day, S. Tachibana, J. Bell, M. Lijewski, V. Beckner and R. Cheng, "A combined computational and experimental characterization of lean premixed turbulent low swirl laboratory flames. II. Hydrogen flames," Combustion and Flame, 162(5), pp. 2148-2165, 2015.


Description
The Commission create incredible nights with unrivaled experiences, showcasing the finest emerging talent alongside phenomenal superstar DJs.
My fellow designer, John Porter, and I were asked to co-designed The Commission's identity; I was also asked to create a simple single page website for this exciting startup.


In the middle of 2018, I moved to Europe with my partner. Before this I had never really thought about how my culture had influenced my values and identity. Most of the foreigners that I had met previously I had met in New Zealand. I’m not sure whether like-minded people are drawn to New Zealand, or that is simply the type of people I surround myself with, but whether they were long term residents or tourists backpacking around the country they all had a certain “New Zealandness” about them.
As a consequence, I had this idea that most people were very similar to New Zealanders and although I still believe that people all over the world are more alike than different the small differences when travelling through other countries were extremely contrasting. Overall, I think growing up in New Zealand has given me a much calmer demeaner than many of the people I have met on my travels. The “she’ll be right” attitude means that I don’t stress so much about the little everyday inconveniences. The do-it-yourself, No.8 wire, mentality of Kiwis has allowed me to experience a breadth of experience that I also took for granted. On the other hand, I have also become more conscious of the values that sometimes display negatively and I hadn’t realised I had internalised. Often, when I thought of Tall Poppy Syndrome, I thought of a phenomenon which promoted modesty and a perceived equality among a culture. But hadn’t thought about how it often treads a fine line as an excuse for jealousy or negative self-deprecation.
What I see as some of my greatest strengths have, at times, also been my biggest weaknesses. I am an Idealist at heart; I like to believe that people are inherently good, if not misguided, and I am constantly striving to be a better version of myself. This means that I like to constantly push my idea of what I am capable of and never shy away from a challenge. I am most happy when myself or the people who depend on me are improving and it is not uncommon for me to drop what I am doing and spend an entire day learning, or helping others to learn, a single concept. However, this idealism can often manifest itself in my work and study as perfectionism and I am also guilty of holding myself, and often those around me, to an unreasonable standard.
Working in a busy high-class restaurant is a very demanding job, both mentally and physically. Trying to organize a team in a hot, often cramped, space in a job that provides high intensity, constant stress, and long hours will eventually lead to some resistance or tension. Having worked as a chef for over ten years, I have experienced this resistance and tension mount and subsequently “boil over” many times. Often you can see when another person is struggling, and I think a sign of a good leader is being able to spot that and make adjustments so that person takes away as much as they can from a tough situation. Sometimes it is more beneficial to let a person struggle just enough so that they push their boundaries and come away feeling as though they can do more than they could the day before. Conversely, sometimes it is more beneficial to jump in and help another person if you can so that they know they are part of a team. Each method has its merits and drawbacks and it is important to tailor the approach not only to the situation but to the individual as well. Some people like to say that a team is only as strong as its weakest member but I think in most cases a team that plays to the strengths of each player will far surpass one that tries to have each person take a perfectly equal amount of involvement in every play. Therefore, I think the best strategy is to try to provide people with the type of support they respond to best so that they can grow and improve their skills.
I like to lead my life by following stoic virtues. From this I have developed the belief that it is important to not only be aware of your good qualities but also your bad. Only by recognising when you are making a mistake can you attempt to change it. Likewise, don’t give any negative actions or events any more weight than they deserve. Take what you can use to develop and grow from them and discard the rest.


Bite Size Bayes¶
Copyright 2020 Allen B. Downey
License: Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
Review¶
In a previous notebook we used the time between goals to update our estimate of the goal-scoring rate of a soccer team.
Under the assumption that goal-scoring is well-modeled by a Poisson process, the time between goals follows an exponential distribution.
In other words, if the goal-scoring rate is λ, the probability of seeing an interval between goals of \(t\) is proportional to the PDF of the exponential distribution:
\(f(t; λ) = λ~\exp(-λ t)\)
Because \(t\) is a continuous quantity, the value of this expression is not really a probability; technically it is a probability density. However, it is proportional to the probability of the data, so we can use it as a likelihood in a Bayesian update.
In this notebook, we’ll use the PDF of a normal distribution the same way, in order to estimate the value of prizes on a game show. Once we compute a posterior distribution, we’ll use it to optimize a decision-making process.
This example demonstrates the real power of Bayesian methods, not just computing posterior distributions, but using them to make better decisions.
The Price is Right problem¶
On November 1, 2007, contestants named Letia and Nathaniel appeared on The Price is Right, an American game show. They competed in a game called “The Showcase”, where the objective is to guess the price of a collection of prizes. The contestant who comes closest to the actual price, without going over, wins the prizes.
Nathaniel went first. His showcase included a dishwasher, a wine cabinet, a laptop computer, and a car. He bid $26,000.
Letia’s showcase included a pinball machine, a video arcade game, a pool table, and a cruise of the Bahamas. She bid $21,500.
The actual price of Nathaniel’s showcase was $25,347. His bid was too high, so he lost.
The actual price of Letia’s showcase was $21,578.
She was only off by $78, so she won her showcase and, because her bid was off by less than 250, she also won Nathaniel’s showcase.
For a Bayesian thinker, this scenario suggests several questions:
Before seeing the prizes, what prior beliefs should the contestant have about the price of the showcase?
After seeing the prizes, how should the contestant update those beliefs?
Based on the posterior distribution, what should the contestant bid?
The third question demonstrates a common use of Bayesian methods: decision analysis.
This problem is inspired by this example in Cameron Davidson-Pilon’s book, Probablistic Programming and Bayesian Methods for Hackers.
The prior¶
To choose a prior distribution of prices, we can take advantage of data from previous episodes. Fortunately, fans of the show keep detailed records.
For this example, I downloaded files containing the price of each showcase from the 2011 and 2012 seasons and the bids offered by the contestants.
The following cells load the data files.
# Load the data files
import os
if not os.path.exists('showcases.2011.csv'):
!wget https://github.com/AllenDowney/BiteSizeBayes/raw/master/showcases.2011.csv
if not os.path.exists('showcases.2012.csv'):
!wget http://github.com/AllenDowney/BiteSizeBayes/raw/master/showcases.2012.csv
The following function reads the data and cleans it up a little.
def read_data(filename):
"""Read the showcase price data.
filename: string
returns: DataFrame
"""
df = pd.read_csv(filename, index_col=0, skiprows=[1])
return df.dropna().transpose()
I’ll read both files and concatenate them.
df2011 = read_data('showcases.2011.csv')
df2011.shape
(191, 6)
df2012 = read_data('showcases.2012.csv')
df2012.shape
(122, 6)
df = pd.concat([df2011, df2012], ignore_index=True)
df.shape
(313, 6)
Here’s what the dataset looks like:
df.head()
| Showcase 1 | Showcase 2 | Bid 1 | Bid 2 | Difference 1 | Difference 2 | |
|---|---|---|---|---|---|---|
| 0 | 50969.0 | 45429.0 | 42000.0 | 34000.0 | 8969.0 | 11429.0 |
| 1 | 21901.0 | 34061.0 | 14000.0 | 59900.0 | 7901.0 | -25839.0 |
| 2 | 32815.0 | 53186.0 | 32000.0 | 45000.0 | 815.0 | 8186.0 |
| 3 | 44432.0 | 31428.0 | 27000.0 | 38000.0 | 17432.0 | -6572.0 |
| 4 | 24273.0 | 22320.0 | 18750.0 | 23000.0 | 5523.0 | -680.0 |
Kernel density estimation¶
This dataset contains the prices for 313 previous showcases, which we can think of as a sample from the population of possible prices.
We can use this sample to estimate the prior distribution of showcase prices. One way to do that is kernel density estimation (KDE), which uses the sample to estimate a smooth distribution.
SciPy provides gaussian_kde
, which takes a sample and returns an object that represents the estimated distribution.
from scipy.stats import gaussian_kde
kde = gaussian_kde(df['Showcase 1'])
kde
<scipy.stats.kde.gaussian_kde at 0x7fb351bcaeb0>
We can use kde
to evaluate the estimated distribution for a sequence of values:
xs = np.linspace(0, 80000, 81)
ps = kde(xs)
And put the results into a normalized Series that represents the prior distribution for Showcase 1.
def make_pmf(xs, ps, **options):
"""Make a Series that represents a PMF.
xs: sequence of values
ps: sequence of probabilities
options: keyword arguments passed to Series constructor
returns: Pandas Series
"""
pmf = pd.Series(ps, index=xs, **options)
return pmf
prior1 = make_pmf(xs, ps)
prior1 /= prior1.sum()
Here’s what it looks like:
prior1.plot(label='Prior 1')
plt.xlabel('Showcase value ($)')
plt.ylabel('Probability')
plt.title('Prior distribution of showcase value')
plt.legend();
The following function takes a sample, makes a KDE, evaluates it at a given sequence of xs
, and returns the result as a normalized PMF.
def make_kde(xs, sample):
"""Make a PMF based on KDE:
xs: places where we should evaluate the KDE
sample: sequence of values
returns: Series that represents a normalized PMF
"""
kde = gaussian_kde(sample)
ps = kde(xs)
pmf = make_pmf(xs, ps)
pmf /= pmf.sum()
return pmf
Exercise: Use this function to make a Pmf that represents the prior distribution for Showcase 2, and plot it.
# Solution
xs = np.linspace(10000, 80000, 71)
prior2 = make_kde(xs, df['Showcase 2'])
# Solution
prior1.plot(label='Prior 1')
prior2.plot(label='Prior 2')
plt.xlabel('Showcase value ($)')
plt.ylabel('Probability')
plt.title('Prior and posterior distribution of showcase value')
plt.legend();
Distribution of error¶
To update these priors, we have to answer these questions:
What data should we consider and how should we quantify it?
Can we compute a likelihood function; that is, for each hypothetical price, can we compute the conditional likelihood of the data?
To answer these questions, I will model the contestant as a price-guessing instrument with known error characteristics. In other words, when the contestant sees the prizes, they guess the price of each prize — ideally without taking into consideration the fact that the prize is part of a showcase — and add up the prices. Let’s call this total guess
.
Under this model, the question we have to answer is, “If the actual price is price
, what is the likelihood that the contestant’s estimate would be guess
?”
Equivalently, if we define error = guess - price
, we can ask, “What is the likelihood that the contestant’s estimate is off by error
?”
To answer this question, I’ll use the historical data again. For each showcase in the dataset, let’s look at the difference between the contestant’s bid and the actual price:
sample_diff1 = df['Bid 1'] - df['Showcase 1']
sample_diff2 = df['Bid 2'] - df['Showcase 2']
To visualize the distribution of these differences, we can use KDE again.
xs = np.linspace(-40000, 20000, 61)
kde_diff1 = make_kde(xs, sample_diff1)
kde_diff2 = make_kde(xs, sample_diff2)
kde_diff1.plot(label='Diff 1')
kde_diff2.plot(label='Diff 2')
plt.xlabel('Difference in value ($)')
plt.ylabel('Probability')
plt.title('Difference between bid and actual value')
plt.legend();
It looks like the bids are too low more often than too high, which makes sense. Remember that under the rules of the game, you lose if you overbid, so contestants probably underbid to some degree deliberately.
Here is the mean and standard deviation of Diff
for Player 1.
mean_diff1 = sample_diff1.mean()
std_diff1 = sample_diff1.std()
mean_diff1, std_diff1
(-4116.3961661341855, 6899.909806377115)
We can use the observed distribution of differences to model the contestant’s distribution of errors.
This step is a little tricky because we don’t actually know the contestant’s guesses; we only know what they bid.
 In other word, the mean of their errors is 0.
But I’ll assume that the spread of the differences reflects the actual spread of their errors. So, I’ll use the standard deviation of the differences as the standard deviation of their errors.
Based on these assumptions, I’ll make a normal distribution with parameters 0 and std_diff1
.
from scipy.stats import norm
error_dist1 = norm(0, std_diff1)
error_dist1
<scipy.stats._distn_infrastructure.rv_frozen at 0x7fb32b7d0a60>
We’ll use this distribution to do the update.
Update¶
Suppose you are Player 1. You see the prizes in your showcase and your estimate of the total price is $23,000.
For each hypothetical price in the prior distribution, I’ll subtract away your guess. The result is your error under each hypothesis.
guess1 = 23000
xs = prior1.index
error1 = guess1 - xs
Now suppose you know based on past performance that your estimation error is well modeled by error_dist1
.
Under that assumption we can compute the likelihood of your estimate under each hypothesis.
likelihood1 = error_dist1.pdf(error1)
And we can use that likelihood to update the prior.
posterior1 = prior1 * likelihood1
posterior1 /= posterior1.sum()
Here’s what the posterior distribution looks like:
prior1.plot(color='gray', label='Prior 1')
posterior1.plot(color='C0', label='Posterior 1')
plt.xlabel('Showcase value ($)')
plt.ylabel('Probability')
plt.title('Prior and posterior distribution of showcase value')
plt.legend();
Because your estimate is in the lower end of the range, the posterior distribution has shifted to the left. We can use the posterior mean to see by how much.
def pmf_mean(pmf):
"""Compute the mean of a PMF.
pmf: Series representing a PMF
return: float
"""
return np.sum(pmf.index * pmf)
pmf_mean(prior1), pmf_mean(posterior1)
(30299.488817891375, 26192.02400239254)
Before you saw the prizes, you expected to see a showcase with a value close to $30,000.
After making an estimate of $23,000, you updated the prior distribution.
Based on the combination of the prior and your estimate, you now expect the actual price to be about $26,000.
Exercise: Now suppose you are Player 2. When you see your showcase, you estimte that the total price is $38,000.
Use diff2
to construct a normal distribution that represents the distribution of your estimation errors.
Compute the likelihood of your estimate for each actual price and use it to update prior2
.
Plot the posterior distribution and compute the posterior mean. Based on your estimate, what do you expect the actual price of the showcase to be?
# Solution
mean_diff2 = sample_diff2.mean()
std_diff2 = sample_diff2.std()
mean_diff2, std_diff2
(-3675.891373801917, 6886.26071132341)
# Solution
error_dist2 = norm(0, std_diff2)
# Solution
guess2 = 38000
xs = prior2.index
error2 = guess2 - xs
likelihood2 = error_dist2.pdf(error2)
# Solution
posterior2 = prior2 * likelihood2
posterior2 /= posterior2.sum()
# Solution
prior2.plot(color='gray', label='Prior 2')
posterior2.plot(color='C1', label='Posterior 2')
plt.xlabel('Showcase value ($)')
plt.ylabel('Probability')
plt.title('Prior and posterior distribution of showcase value')
plt.legend();
# Solution
pmf_mean(prior2), pmf_mean(posterior2)
(31047.686915520928, 34305.20163595075)
Probability of winning¶
Now that we have a posterior distribution for each player, let’s think about strategy.
First, from the point of view of Player 1, let’s compute the probability that Player 2 overbids. To keep it simple, I’ll use only the performance of past players, ignoring the estimated value of the showcase.
The following function takes a sequence of past bids and returns the fraction that overbid.
def prob_overbid(sample_diff):
"""Returns the probability this player overbids.
sample_diff: sequence of differences
"""
return np.mean(sample_diff > 0)
Here’s an estimate for the probability that Player 2 overbids.
prob_overbid(sample_diff2)
0.29073482428115016
Now suppose Player 1 underbids by $5000. What is the probability that Player 2 underbids by more?
The following function uses past performance to estimate the probabily that a player underbids by more than a given amount, diff
:
def prob_worse_than(diff, sample_diff):
"""Probability the opponents's diff is worse than the given diff.
diff: how much the oppenent is off by (always negative)
sample_diff: sequence of differences for the opponent
"""
return np.mean(sample_diff < diff)
Here’s the probability that Player 2 underbids by more than $5000.
prob_worse_than(-5000, sample_diff2)
0.38338658146964855
And here’s the probability they are off by more than $10,000.
prob_worse_than(-10000, sample_diff2)
0.14376996805111822
We can combine these function to compute the probability that Player 1 wins, given the difference between their bid and the actual price:
def compute_prob_win(diff, sample_diff):
"""Computes the probability of winning for a given diff.
diff: how much your bid was off by
sample_diff: sequence of differences for the opponent
"""
# if you overbid you lose
if diff > 0:
return 0
# if the opponent over bids, you win
p1 = prob_overbid(sample_diff)
# or of their bid is worse than yours, you win
p2 = prob_worse_than(diff, sample_diff)
return p1 + p2
Here’s the probability that you win, given that you underbid by $5000.
compute_prob_win(-5000, sample_diff2)
0.6741214057507987
Now let’s look at the probability of winning for a range of possible differences.
xs = np.linspace(-30000, 5000, 121)
ys = [compute_prob_win(x, sample_diff2) for x in xs]
plt.plot(xs, ys)
plt.xlabel('Difference between guess and actual price ($)')
plt.ylabel('Probability of winning')
plt.title('Player 1');
If you underbid by $30,000, the chance of winning is about 30%, which is mostly the chance your opponent overbids.
As your bids gets closer to the actual price, your chance of winning approaches 1.

Exercise: Run the same analysis from the point of view of Player 2. Using the sample of differences from Player 1, compute:
The probability that Player 1 overbids.
The probability that Player 1 underbids by more than $5000.
The probability that Player 2 wins, given that they underbid by $5000.
Then plot the probability that Player 2 wins for a range of possible differences between their bid and the actual price.
prob_overbid(sample_diff1)
0.24600638977635783
prob_worse_than(-5000, sample_diff1)
0.3993610223642173
compute_prob_win(-5000, sample_diff1)
0.6453674121405751
xs = np.linspace(-30000, 5000, 121)
ys = [compute_prob_win(x, sample_diff1) for x in xs]
plt.plot(xs, ys)
plt.xlabel('Difference between guess and actual price ($)')
plt.ylabel('Probability of winning')
plt.title('Player 2');
Decision analysis¶
In the previous section we computed the probability of winning, given that we have underbid by a particular amount.
In reality the contestants don’t know how much they have underbid by, because they don’t know the actual price.
But they do have a posterior distribution that represents their beliefs about the actual price, and they can use that to estimate their probability of winning with a given bid.
The following function take a possible bid, a posterior distribution of actual prices, and a sample of differences for the opponent.
It loops through the hypothetical prices in the posterior distribution and for each price:
Computes the difference between the bid and the hypothetical price.
Computes the probability that the player wins, given that difference.
Adds up the weighted sum of the probabilities, where the weights are the probabilites in the posterior distribution.
def total_prob_win(bid, posterior, sample_diff):
"""Computes the total probability of winning with a given bid.
bid: your bid
posterior: Pmf of showcase value
sample_diff: sequence of differences for the opponent
returns: probability of winning
"""
total = 0
for price, prob in posterior.items():
diff = bid - price
total += prob * compute_prob_win(diff, sample_diff)
return total
This loop implements the law of total probability:
\(P(win) = \sum_{price} P(price) ~ P(win ~|~ price)\)
total_prob_win(25000, posterior1, sample_diff2)
0.4842210945439813
bids = posterior1.index
probs = [total_prob_win(bid, posterior1, sample_diff2)
for bid in bids]
prob_win_series = pd.Series(probs, index=bids)
prob_win_series.plot(color='C1')
plt.xlabel('Bid ($)')
plt.ylabel('Probability of winning')
plt.title('Player 1');
And here’s the bid that maximizes your chance of winning.
prob_win_series.idxmax()
21000.0
Recall that your estimate was $23,000.
After using your estimate to compute the posterior distribution, the posterior mean is about $26,000.
But the bid that maximizes your chance of winning is $21,000.
Exercise: Do the same analysis for Player 2.
# Solution
bids = posterior2.index
probs = [total_prob_win(bid, posterior2, sample_diff1)
for bid in bids]
prob_win_series = pd.Series(probs, index=bids)
# Solution
prob_win_series.plot(color='C2')
plt.xlabel('Bid ($)')
plt.ylabel('Probability of winning')
plt.title('Player 2');
# Solution
prob_win_series.idxmax()
29000.0
Maximizing expected gain¶
In the previous section we computed the bid that maximizes your chance of winning. And if that’s your goal, the bid we computed is optimal.
But winning isn’t everything. Remember that if your bid is off by $250 or less, you will both showcases. So it might be a good idea to increase your bid a little: it increases the chance you overbid and lose, but it also increases the chance of winning both showcases.
Let’s see how that works out. The following function computes how much you will win, on average, given your bid, the actual price, and a sample of errors for your opponent.
def compute_gain(bid, price, sample_diff):
"""Computes expected gain given a bid and actual price.
bid: number
price: actual price
sample_diff: sequence of differences for the opponent
"""
diff = bid - price
prob = compute_prob_win(diff, sample_diff)
# if you are within 250 dollars, you win both showcases
if -250 <= diff <= 0:
return 2 * price * prob
else:
return price * prob
For example, if the actual price is $35000
and you bid $30000,
you will win about $23,600 worth of prizes on average.
compute_gain(30000, 35000, sample_diff2)
23594.249201277955
In reality we don’t know the actual price, but we have a posterior distribution that represents what we know about it. By averaging over the prices and probabilities in the posterior distribution, we can compute the “expected gain” for a particular bid.
def expected_gain(bid, posterior, sample_diff):
"""Computes the expected return of a given bid.
bid: your bid
posterior: distribution of showcase values
sample_diff: distribution of differences for the opponent
"""
total = 0
for price, prob in posterior.items():
total += prob * compute_gain(bid, price, sample_diff)
return total
For the posterior we computed earlier, based on an estimate of $23,000,
the expected gain for a bid of $21,000
is about $16,900.
expected_gain(21000, posterior1, sample_diff2)
16923.59933856512
But can we do any better?
To find out, we can loop through a range of bids and find the one that maximizes expected gain.
bids = posterior1.index
gains = [expected_gain(bid, posterior1, sample_diff2) for bid in bids]
expected_gain_series = pd.Series(gains, index=bids)
Here are the results.
expected_gain_series.plot(color='C1')
plt.xlabel('Bid ($)')
plt.ylabel('Expected gain ($)')
plt.title('Player 1');
And here is the optimal bid.
expected_gain_series.idxmax()
22000.0
With that bid, the expected gain is about $17,400.
expected_gain_series.max()
17384.8995844308
Recall that the estimated value of the prizes was $23,000.
The bid that maximizes the chance of winning is $21,000.
And the bid that maximizes your the expected gain is $22,000.
Exercise: Do the same analysis for Player 2.
bids = posterior2.index
gains = [expected_gain(bid, posterior2, sample_diff1) for bid in bids]
expected_gain_series = pd.Series(gains, index=bids)
Here are the results.
expected_gain_series.plot(color='C2')
plt.xlabel('Bid ($)')
plt.ylabel('Expected gain ($)')
plt.title('Player 2');
And here is the optimal bid.
expected_gain_series.idxmax()
30000.0


Component: PlatformP
module PlatformP
Provides
interface
Init
Uses
interface
Init
as
LedsInit
interface
Init
as
MoteClockInit
interface
Init
as
MoteInit


Tools for working with and comparing sets of points and intervals.
| Version: | 0.15.1 |
| Depends: | R (≥ 2.9.0) |
| Imports: | utils, graphics, methods |
| Published: | 2015-08-27 |
| Author: | Richard Bourgon |
| Maintainer: | Edzer Pebesma <edzer.pebesma at uni-muenster.de> |
| License: | Artistic-2.0 |
| URL: | http://github.com/edzer/intervals |
| NeedsCompilation: | yes |
| Materials: | README NEWS |
| CRAN checks: | intervals results |
| Reference manual: | intervals.pdf |
| Vignettes: |
Overview of the intervals package. |
| Package source: | intervals_0.15.1.tar.gz |
| Windows binaries: | r-devel: intervals_0.15.1.zip, r-release: intervals_0.15.1.zip, r-oldrel: intervals_0.15.1.zip |
| OS X binaries: | r-release: intervals_0.15.1.tgz, r-oldrel: intervals_0.15.1.tgz |
| Old sources: | intervals archive |
| Reverse depends: | prototest, selectiveInference |
| Reverse imports: | eyelinker, spacetime, stacomiR, vmsbase, VTrack |
| Reverse suggests: | plotKML, surveillance |
Please use the canonical form https://CRAN.R-project.org/package=intervals to link to this page.


About Me!
What's your name?
Shreya Patel
Where were you born?
Kenya, Africa
Where do you currently live?
Chicago, Illinois
What's your favorite animal?
Elephants
What are your favorite sports?
Soccer
Baskertball
Football
Contact Info
My E-mail


--- layout: page title: "Rate-Limit Header Fields for HTTP" description: "This document defines the RateLimit-Limit, RateLimit-Remaining, RateLimit-Reset header fields for HTTP, thus allowing servers to publish current request quotas and clients to shape their request policy and avoid being throttled out." ---
| Document Name: | Internet Draft ietf-httpapi-ratelimit-headers |
|---|---|
| Document URI: |
urn:ietf:id:ietf-httpapi-ratelimit-headers
|
| Online Version: |
https://datatracker.ietf.org/doc/html/draft-ietf-httpapi-ratelimit-headers
|
| Organization: | Internet Engineering Task Force (IETF) |
| Series: | Internet Draft (I-D) |
| Abstract: | This document defines the RateLimit-Limit, RateLimit-Remaining, RateLimit-Reset header fields for HTTP, thus allowing servers to publish current request quotas and clients to shape their request policy and avoid being throttled out. |
RateLimit-Limit
,
RateLimit-Remaining
,
RateLimit-Reset
Return to ( Series | Organization | all Specifications )


When in doubt, wash cats secretly make all the worlds muffins. Attack dog, run away and pretend to be victim i am the best and go into a room to decide you didn't want to be in there anyway brown cats with pink ears destroy the blinds. My left donut is missing, as is my right sit and stare.  Cats secretly make all the worlds muffins man running from cops stops to pet cats, goes to jail for where is my slave?


../vignettes/package_setup.Rmd
package_setup.Rmd
This vignette details the steps required to set up and configure the orgsurveyr package, in particular how to use the shiny applications embedded within the package.
To run the test_viz
shiny app within RStudio type the name of the function:
test_viz()
Other shiny apps:
test_viz
- simulates an organisation with different characteristicsorgviz
- permits visualisation of either simulated or real data as long as the data formats described in orgsurveyr-data-formats as used.Whilst the test_viz
function has no parameters, the orgviz
function takes two parameters, tg
and df
. These allow the user to pass a tidygraph object and a data frame containing summary metrics for the organisation into the shiny app for plotting. For example:
orgviz(tg = orgsurveyr::tg_org, df = orgsurveyr::tg_org_summarised_df)
Assuming that a Shiny Server is available and the orgsurveyr package is installed, it is a case of constructing a shiny app file as follows:
library(shiny)
library(orgsurveyr)
shinyApp(ui = test_viz_ui(),
server = function(input, output) {
test_viz_server(input, output)
}
)
This can be modified as required and copied to the user’s shiny server directory.
For convenience there is a make_shiny_app
function which creates a template shiny application file like that above for both the test_viz
and orgviz
shiny apps.
A shiny app file for the orgviz
package which includes custom data might look like this:
library(shiny)
library(orgsurveyr)
my_tg <- orgsurveyr::tg_org
my_df <- orgsurveyr::tg_org_summarised_df
shinyApp(ui = orgviz_ui(),
server = function(input, output) {
orgviz_server(input, output, tg = my_tg, df = my_df)
}
)
The orgsurveyr package can be installed and run within a Docker container that runs both RStudio Server and Shiny Server. This is a convenient way of trying out the Shiny apps with minimal setup overhead and is also a useful way to learn how to configure a Shiny Server. See the README on the package’s GitHub repository README for more information.
sessionInfo()
#> R version 3.5.1 (2018-07-02)
#> Platform: x86_64-pc-linux-gnu (64-bit)
#> Running under: Debian GNU/Linux 9 (stretch)
#>
#> Matrix products: default
#> BLAS: /usr/lib/openblas-base/libblas.so.3
#> LAPACK: /usr/lib/libopenblasp-r0.2.19.so
#>
#> locale:
#> [1] LC_CTYPE=en_US.UTF-8 LC_NUMERIC=C
#> [3] LC_TIME=en_US.UTF-8 LC_COLLATE=en_US.UTF-8
#> [5] LC_MONETARY=en_US.UTF-8 LC_MESSAGES=C
#> [7] LC_PAPER=en_US.UTF-8 LC_NAME=C
#> [9] LC_ADDRESS=C LC_TELEPHONE=C
#> [11] LC_MEASUREMENT=en_US.UTF-8 LC_IDENTIFICATION=C
#>
#> attached base packages:
#> [1] stats graphics grDevices utils datasets methods base
#>
#> other attached packages:
#> [1] orgsurveyr_0.6.0 ggplot2_3.0.0 dplyr_0.7.6
#>
#> loaded via a namespace (and not attached):
#> [1] tidyselect_0.2.4 purrr_0.2.5 colorspace_1.3-2
#> [4] htmltools_0.3.6 viridisLite_0.3.0 yaml_2.2.0
#> [7] rlang_0.2.2 pkgdown_<IP_ADDRESS>00 pillar_1.3.0
#> [10] later_0.7.5 glue_1.3.0 withr_2.1.2
#> [13] tweenr_1.0.0 bindrcpp_0.2.2 bindr_0.1.1
#> [16] plyr_1.8.4 stringr_1.3.1 munsell_0.5.0
#> [19] commonmark_1.5 gtable_0.2.0 memoise_1.1.0
#> [22] evaluate_0.11 knitr_1.20 httpuv_1.4.5
#> [25] Rcpp_0.12.18 xtable_1.8-3 scales_1.0.0
#> [28] backports_1.1.2 promises_1.0.1 desc_1.2.0
#> [31] mime_0.5 farver_1.0 fs_1.2.6
#> [34] gridExtra_2.3 ggforce_0.1.3 digest_0.6.17
#> [37] stringi_1.2.4 ggrepel_0.8.0 shiny_1.1.0
#> [40] grid_3.5.1 rprojroot_1.3-2 tools_3.5.1
#> [43] magrittr_1.5 lazyeval_0.2.1 tibble_1.4.2
#> [46] ggraph_1.0.2 crayon_1.3.4 pkgconfig_2.0.2
#> [49] MASS_7.3-50 xml2_1.2.0 assertthat_0.2.0
#> [52] rmarkdown_1.10 roxygen2_6.1.0 rstudioapi_0.7
#> [55] viridis_0.5.1 R6_2.2.2 units_0.6-1
#> [58] igraph_1.2.2 compiler_3.5.1


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use Binder | |
|---|---|
| com.google.inject | Google Guice (pronounced "juice") is an ultra-lightweight dependency injection framework. |
| com.google.inject.multibindings | Extension for binding multiple instances in a collection; this extension requires guice-multibindings-2.0.jar . |
| com.google.inject.name | Support for binding to string-based names. |
| com.google.inject.spi | Guice service provider interface |
| com.google.inject.spring | Spring integration; this extension requires guice-spring-2.0.jar . |
| com.google.inject.throwingproviders | Extension for injecting objects that may throw at provision time; this extension requires guice-throwingproviders-2.0.jar . |
| Uses of Binder in com.google.inject |
|---|
| Subinterfaces of Binder in com.google.inject | |
|---|---|
interface |
PrivateBinder
Returns a binder whose configuration information is hidden from its environment by default. |
| Methods in com.google.inject that return Binder | |
|---|---|
protected Binder |
AbstractModule.binder()
Gets direct access to the underlying Binder . |
Binder |
Binder.skipSources(Class... classesToSkip)
Returns a binder that skips classesToSkip when identify the
calling code. |
Binder |
Binder.withSource(Object source)
Returns a binder that uses source as the reference location for
configuration errors. |
| Methods in com.google.inject with parameters of type Binder | |
|---|---|
void |
PrivateModule.configure(Binder binder)
|
void |
Module.configure(Binder binder)
Contributes bindings and other configurations for this module to binder . |
void |
AbstractModule.configure(Binder builder)
|
| Uses of Binder in com.google.inject.multibindings |
|---|
| Methods in com.google.inject.multibindings with parameters of type Binder | ||
|---|---|---|
static
|
MapBinder.newMapBinder(Binder binder,
Class<K> keyType,
Class<V> valueType)
Returns a new mapbinder that collects entries of keyType /valueType in a
Map that is itself bound with no binding annotation. |
|
static
|
MapBinder.newMapBinder(Binder binder,
Class<K> keyType,
Class<V> valueType,
Annotation annotation)
Returns a new mapbinder that collects entries of keyType /valueType in a
Map that is itself bound with annotation . |
|
static
|
MapBinder.newMapBinder(Binder binder,
Class<K> keyType,
Class<V> valueType,
Class<? extends Annotation> annotationType)
Returns a new mapbinder that collects entries of keyType /valueType in a
Map that is itself bound with annotationType . |
|
static
|
MapBinder.newMapBinder(Binder binder,
TypeLiteral<K> keyType,
TypeLiteral<V> valueType)
Returns a new mapbinder that collects entries of keyType /valueType in a
Map that is itself bound with no binding annotation. |
|
static
|
MapBinder.newMapBinder(Binder binder,
TypeLiteral<K> keyType,
TypeLiteral<V> valueType,
Annotation annotation)
Returns a new mapbinder that collects entries of keyType /valueType in a
Map that is itself bound with annotation . |
|
static
|
MapBinder.newMapBinder(Binder binder,
TypeLiteral<K> keyType,
TypeLiteral<V> valueType,
Class<? extends Annotation> annotationType)
Returns a new mapbinder that collects entries of keyType /valueType in a
Map that is itself bound with annotationType . |
|
static
|
Multibinder.newSetBinder(Binder binder,
Class<T> type)
Returns a new multibinder that collects instances of type in a Set that is
itself bound with no binding annotation. |
|
static
|
Multibinder.newSetBinder(Binder binder,
Class<T> type,
Annotation annotation)
Returns a new multibinder that collects instances of type in a Set that is
itself bound with annotation . |
|
static
|
Multibinder.newSetBinder(Binder binder,
Class<T> type,
Class<? extends Annotation> annotationType)
Returns a new multibinder that collects instances of type in a Set that is
itself bound with annotationType . |
|
static
|
Multibinder.newSetBinder(Binder binder,
TypeLiteral<T> type)
Returns a new multibinder that collects instances of type in a Set that is
itself bound with no binding annotation. |
|
static
|
Multibinder.newSetBinder(Binder binder,
TypeLiteral<T> type,
Annotation annotation)
Returns a new multibinder that collects instances of type in a Set that is
itself bound with annotation . |
|
static
|
Multibinder.newSetBinder(Binder binder,
TypeLiteral<T> type,
Class<? extends Annotation> annotationType)
Returns a new multibinder that collects instances of type in a Set that is
itself bound with annotationType . |
| Uses of Binder in com.google.inject.name |
|---|
| Methods in com.google.inject.name with parameters of type Binder | |
|---|---|
static void |
Names.bindProperties(Binder binder,
Map<String,String> properties)
Creates a constant binding to @Named(key) for each entry in
properties . |
static void |
Names.bindProperties(Binder binder,
Properties properties)
Creates a constant binding to @Named(key) for each property. |
| Uses of Binder in com.google.inject.spi |
|---|
| Methods in com.google.inject.spi with parameters of type Binder | |
|---|---|
void |
TypeListenerBinding.applyTo(Binder binder)
|
void |
TypeConverterBinding.applyTo(Binder binder)
|
void |
StaticInjectionRequest.applyTo(Binder binder)
|
void |
ScopeBinding.applyTo(Binder binder)
|
void |
ProviderLookup.applyTo(Binder binder)
|
void |
Message.applyTo(Binder binder)
|
void |
MembersInjectorLookup.applyTo(Binder binder)
|
void |
InterceptorBinding.applyTo(Binder binder)
|
void |
InjectionRequest.applyTo(Binder binder)
|
void |
ExposedBinding.applyTo(Binder binder)
Unsupported. |
void |
Element.applyTo(Binder binder)
Writes this module element to the given binder (optional operation). |
| Uses of Binder in com.google.inject.spring |
|---|
| Methods in com.google.inject.spring with parameters of type Binder | |
|---|---|
static void |
SpringIntegration.bindAll(Binder binder,
ListableBeanFactory beanFactory)
Binds all Spring beans from the given factory by name. |
| Uses of Binder in com.google.inject.throwingproviders |
|---|
| Methods in com.google.inject.throwingproviders with parameters of type Binder | |
|---|---|
static ThrowingProviderBinder |
ThrowingProviderBinder.create(Binder binder)
|
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


Autonomous Underwater Vehicle (AUV)
Funded by DoRD, IIT Kanpur
Duration: November’14 - June’18
Supervisors: Prof. Mangal Kothari, Prof. K. S. Venkatesh
As a student- initiated project at IIT Kanpur, the project aims to build marine systems to serve as a platform for research on underwater robotics in the institute and create affliations with industries looking for marine technology solutions. As one of the founding members of the team, I contributed towards various mechanical, electrical and software aspects of the project.
We participated with our first vehicle, Varun, at the National Student Autonomous Vehicle (SAVe) Competition in December 2016, and achieved the runners-up position on our debut. Since then the project has been take over by next generation of students and the team has been participating at national and international events.
Mechanical Work
Compared to other robotic systems, in AUVs we need to seal the robot enclosures for protection against water. The recommended ingress protection is referred to IP68 (or above) for all the enclosures. Failure to meet this requirement could lead to damaging of the electronics. In our vehicle Varun, we used O-rings and marine-grade expoxy for sealing.
Varun’s mechanical design comprises of an aluminum structural frame, enclosures for electronics and cameras, pneumatic system and electromagnetic actuators. The vehicle has 5 degrees of freedom and roll is stabilized by ensuring a symmetric design. I designed the main pressure hull and other casings, along with the marker dropper. All mechanical parts were first designed on Solidworks and then optimized for weight and structural strength using Ansys Workbench. Their fabrication was done using in-house available facilities at the institute.
Electrical Work
The vehicle is powered using Lithium Polymer batteries. I designed a power distribution board, comprising of buck and boost converters, to meet the different voltage and power requirements of various electonic components. I used off-the-shelf motor drivers to control brushed DC actuators through an Atmega microcontroller, and also worked on intergating the sensors with ROS.
Software Work
The Software Architecture is based on the Robot Operating System (ROS) framework. We dvided the entire software stack into motion planning, controls, navigation and vision layers. I contributed mainly to the controls and navigation aspects of the vehicle. The code is open sourced and can be viewed over here.


RICKS DRONE PIZZA DELIVERY
"I feel the need......the need for speed!"---Maverick from Top Gun.


Vim for Google Chrome.  With my desktop (Linux), I have a lot of key bindings that make doing things easier: I open Chrome with Alt+w
, I close a window with Alt+Shift+d
, I open a terminal with Alt+t
. This is harder to do with Chrome because it has no section for customizing keyboard shortcuts, and it is still necessary to use the mouse to do things like click links. cVim aims to eliminate this problem as best as the Chrome extensions API will allow it to.
.zip
file here and enable cVim by going to the chrome://extensions
URL and checking developer mode, then pointing Chrome to the unzipped folder via the Load unpacked extensions...
button.These extensions do a wonderful job of adding Vim-like keybindings to Google Chrome, but they lack many of the features that Firefox Addon, Pentadactyl, have.
'set' + <SETTING_NAME>
and disabled with
the command 'set' + no<SETTING_NAME>
(for example, set regexp
and set noregexp
)=
used as a separator and are prefixed by let
(for example, let hintcharacters="abc"
)| setting | type | description | default |
|---|---|---|---|
| searchlimit | integer | set the amount of results displayed in the command bar | 25 |
| scrollstep | integer | set the amount of pixels scrolled when using the scrollUp and scrollDown commands | 70 |
| timeoutlen | integer | The amount of time to wait for a <Leader> mapping in milliseconds |
1000 |
| fullpagescrollpercent | integer | set the percent of the page to be scrolled by when using the scrollFullPageUp and scrollFullPageDown commands | 0 |
| typelinkhintsdelay | integer | the amount of time (in milliseconds) to wait before taking input after opening a link hint with typelinkhints and numerichints enabled | 300 |
| scrollduration | integer | the duration of smooth scrolling | 500 |
| vimport | integer | set the port to be used with the editWithVim insert mode command |
8001 |
| zoomfactor | integer / double | the step size when zooming the page in/out | 0.1 |
| scalehints | boolean | animate link hints as they appear | false |
| hud | boolean | show the heads-up-display | true |
| regexp | boolean | use regexp in find mode | true |
| ignorecase | boolean | ignore search case in find mode | true |
| linkanimations | boolean | show fade effect when link hints open and close | false |
| numerichints | boolean | use numbers for link hints instead of a set of characters | false |
| dimhintcharacters | boolean | dim letter matches in hint characters rather than remove them from the hint | true |
| defaultnewtabpage | boolean | use the default chrome://newtab page instead of a blank page | false |
| cncpcompletion | boolean | use <C-n> and <C-p> to cycle through completion results (requires you to set the nextCompletionResult keybinding in the chrome://extensions page (bottom right) |
false |
| smartcase | boolean | case-insensitive find mode searches except when input contains a capital letter | true |
| incsearch | boolean | begin auto-highlighting find mode matches when input length is greater thant two characters | true |
| typelinkhints | boolean | (numerichints required) type text in the link to narrow down numeric hints | false |
| autohidecursor | boolean | hide the mouse cursor when scrolling (useful for Linux, which doesn’t auto-hide the cursor on keydown) | false |
| autofocus | boolean | allows websites to automatically focus an input box when they are first loaded | true |
| insertmappings | boolean | use insert mappings to navigate the cursor in text boxes (see bindings below) | true |
| smoothscroll | boolean | use smooth scrolling | false |
| autoupdategist | boolean | if a GitHub Gist is used to sync settings, pull updates every hour (and when Chrome restarts) | false |
| nativelinkorder | boolean | Open new tabs like Chrome does rather than next to the currently opened tab | false |
| showtabindices | boolean | Display the tab index in the tab’s title | false |
| sortlinkhints | boolean | Sort link hint lettering by the link’s distance from the top-left corner of the page | false |
| localconfig | boolean | Read the cVimrc config from configpath (when this is set, you connot save from cVim’s options page |
false |
| completeonopen | boolean | Automatically show a list of command completions when the command bar is opened | false |
| configpath | string | Read the cVimrc from this local file when configpath is set | "" |
| changelog | boolean | Auto open the changelog when cVim is updated | true |
| completionengines | array of strings | use only the specified search engines | ["google", "duckduckgo", "wikipedia", "amazon"] |
| blacklists | array of strings | disable cVim on the sites matching one of the patterns | [] |
| mapleader | string | The default <Leader> key |
\ |
| defaultengine | string | set the default search engine | "google" |
| locale | string | set the locale of the site being completed/searched on (see example configuration below) | "" |
| homedirectory | string | the directory to replace ~ when using the file command |
"" |
| qmark <alphanumeric charcter> | string | add a persistent QuickMark (e.g. let qmark a = ["http://google.com", "http://reddit.com"] ) |
none |
| previousmatchpattern | string (regexp) | the pattern looked for when navigating a page’s back button | ((?!last)(prev(ious)?|newer|back|«|less|<|‹| )+) |
| nextmatchpattern | string (regexp) | the pattern looked for when navigation a page’s next button | ((?!first)(next|older|more|>|›|»|forward| )+) |
| hintcharacters | string (alphanumeric) | set the default characters to be used in link hint mode | "asdfgqwertzxcvb" |
| barposition | string ["top", "bottom"] | set the default position of the command bar | "top" |
| langmap | string | set a list of characters to be remapped (see vims langmap) | "" |
" Settings
set nohud
set nosmoothscroll
set noautofocus " The opposite of autofocus; this setting stops
" sites from focusing on an input box when they load
set typelinkhints
let searchlimit = 30
let scrollstep = 70
let barposition = "bottom"
let locale = "uk" " Current choices are 'jp' and 'uk'. This allows cVim to use sites like google.co.uk
" or google.co.jp to search rather than google.com. Support is currently limited.
" Let me know if you need a different locale for one of the completion/search engines
let hintcharacters = "abc123"
let searchengine dogpile = "http://www.dogpile.com/search/web?q=%s" " If you leave out the '%s' at the end of the URL,
" your query will be appended to the link.
" Otherwise, your query will replace the '%s'.
" This will do the same thing as above, except typing ':tabnew withbase' into to command bar
" without any search parameters will open 'http://www.dogpile.com'
let searchengine withbase = ["http://www.dogpile.com", "http://www.dogpile.com/search/web?q=%s"]
" alias ':g' to ':tabnew google'
command g tabnew google
let completionengines = ["google", "amazon", "imdb", "dogpile"]
let searchalias g = "google" " Create a shortcut for search engines.
" For example, typing ':tabnew g example'
" would act the same way as ':tabnew google example'
" Open all of these in a tab with `gnb` or open one of these with <N>goa where <N>
let qmark a = ["http://www.reddit.com", "http://www.google.com", "http://twitter.com"]
let blacklists = ["https://mail.google.com/*", "*://mail.google.com/*", "@https://mail.google.com/mail/*"]
" blacklists prefixed by '@' act as a whitelist
let mapleader = ","
" Mappings
map <Leader>r reloadTabUncached
map <Leader>x :restore<Space>
" This remaps the default 'j' mapping
map j scrollUp
" You can use <Space>, which is interpreted as a
" literal " " character, to enter buffer completion mode
map gb :buffer<Space>
" This unmaps the default 'k' mapping
unmap k
" This unmaps the default 'h', 'j', 'k', and 'l' mappings
unmap h j k l
" This remaps the default 'f' mapping to the current 'F' mapping
map f F
" Toggle the current HUD display value
map <C-h> :set hud!<CR>
" Switch between alphabetical hint characters and numeric hints
map <C-i> :set numerichints!<CR>
map <C-u> rootFrame
map <M-h> previousTab
map <C-d> scrollPageDown
map <C-e> scrollPageUp
iunmap <C-y>
imap <C-m> deleteWord
" Create a variable that can be used/referenced in the command bar
let @@reddit_prog = 'http://www.reddit.com/r/programming'
let @@top_all = 'top?sort=top&t=all'
let @@top_day = 'top?sort=top&t=day'
" TA binding opens 'http://www.reddit.com/r/programming/top?sort=top&t=all' in a new tab
map TA :tabnew @@reddit_prog/@@top_all<CR>
map TD :tabnew @@reddit_prog/@@top_day<CR>
" Use paste buffer in mappings
map T :tabnew wikipedia @"<CR>
" Code blocks (see below for more info)
getIP() -> {{
httpRequest({url: 'http://api.ipify.org/?format=json', json: true},
function(res) { Status.setMessage('IP: ' + res.ip); });
}}
" Displays your public IP address in the status bar
map ci :call getIP<CR>
" Script hints
echo(link) -> {{
alert(link.href);
}}
map <C-f> createScriptHint(echo)
let configpath = '/path/to/your/.cvimrc'
set localconfig " Update settings via a local file (and the `:source` command) rather
" than the default options page in chrome
" As long as localconfig is set in the .cvimrc file. cVim will continue to read
" settings from there
" this will enable the config block below on the domain 'reddit.com'
site '*://*.reddit.com/*' {
unmap j
unmap k
set numerichints
}
call
keyword" In this case, when pages with a file ending in '.js' are loaded,
" cVim will pin the tab and then scroll down
site '*://*/*.js' {
call :pintab
call scrollDown
}
map <KEY> <MAPPING_NAME>
<C-u> " Ctrl + u
<M-u> " Meta + u
<A-u> " Alt + u
unmap <KEY>
and insert bindings with iunmap <KEY>
unmapAll
. To unmap all default insert bindings, use iunmapAll
:tabnew
and :open
) have three different properties!
=> Open in a new tab$
=> Open in a new window|
=> Open in an incognito window&
=> Open in a new tab (inactive/unfocused)*
=> Pin the tab?
=> Treat the query as a search=
=> Treat the query as a URL:open! google<CR> " This is the same as :tabnew google<CR>
:open google!<CR> " This is another way of writing the above
" (these flags can can be added to either
" the base command or the end of the final command)
:open& google<CR> " This will open Google in a new inactive tab
:open$ google<CR> " This will open Google in a new window
:open&* google<CR> " The will open Google in a new inactive, pinned tab
:tabnew google&*<CR> " Once again, this will do the same thing as the above command
:open google&*<CR> " Again, same as above
:open google!&  To be used by the code block
set hintset_a
" Create a code block named switchHintCharacters
switchHintCharacters -> {{
// We are now in JavaScript mode
// Settings are contained in an object named settings
settings.hintset_a = !settings.hintset_a;
if (settings.hintset_a) {
settings.hintcharacters = 'abc'; // equivalent to "let hintcharacters = 'abc'"
} else {
settings.hintcharacters = 'xyz';
}
// Propagate the current settings to all tabs for the
// rest of the session
PORT('syncSettings', { settings: settings });
// Display cVim's status bar for 2 seconds.
Status.setMessage('Hint Set: ' + (true ? 'a' : 'b'), 2);
}}
" Run the JavaScript block
map <Tab> :call switchHintCharacters<CR>
completionengines
variable.
let completionengines = ['google', 'google-image', 'youtube'] " Show only these engines in the command bar
| Movement | Mapping name | |
|---|---|---|
j , s |
scroll down | scrollDown |
k , w |
scroll up | scrollUp |
h |
scroll left | scrollLeft |
l |
scroll right | scrollRight |
d |
scroll half-page down | scrollPageDown |
| unmapped | scroll full-page down | scrollFullPageDown |
u , e |
scroll half-page up | scrollPageUp |
| unmapped | scroll full-page up | scrollFullPageUp |
gg |
scroll to the top of the page | scrollToTop |
G |
scroll to the bottom of the page | scrollToBottom |
0 |
scroll to the left of the page | scrollToLeft |
$ |
scroll to the right of the page | scrollToRight |
# |
reset the scroll focus to the main page | resetScrollFocus |
gi |
go to first input box | goToInput |
gI |
go to the last focused input box by gi |
goToLastInput |
zz |
center page to current search match (middle) | centerMatchH |
zt |
center page to current search match (top) | centerMatchT |
zb |
center page to current search match (bottom) | centerMatchB |
| Link Hints | ||
f |
open link in current tab | createHint |
F |
open link in new tab | createTabbedHint |
| unmapped | open link in new tab (active) | createActiveTabbedHint |
W |
open link in new window | createHintWindow |
A |
repeat last hint command | openLastHint |
q |
trigger a hover event (mouseover + mouseenter) | createHoverHint |
Q |
trigger a unhover event (mouseout + mouseleave) | createUnhoverHint |
mf |
open multiple links | createMultiHint |
| unmapped | edit text with external editor | createEditHint |
| unmapped | call a code block with the link as the first argument | createScriptHint(<FUNCTION_NAME> ) |
| unmapped | opens images in a new tab | fullImageHint |
mr |
reverse image search multiple links | multiReverseImage |
my |
yank multiple links (open the list of links with P) | multiYankUrl |
gy |
copy URL from link to clipboard | yankUrl |
gr |
reverse image search (google images) | reverseImage |
; |
change the link hint focus | |
| QuickMarks | ||
M<*> |
create quickmark <*> | addQuickMark |
go<*> |
open quickmark <*> in the current tab | openQuickMark |
gn<*> |
open quickmark <*> in a new tab | openQuickMarkTabbed |
gw<*> |
open quickmark <*> in a new window | openQuickMarkWindowed |
| Miscellaneous | ||
a |
alias to ":tabnew google " | :tabnew google |
. |
repeat the last command | repeatCommand |
: |
open command bar | openCommandBar |
/ |
open search bar | openSearchBar |
? |
open search bar (reverse search) | openSearchBarReverse |
| unmapped | open link search bar (same as pressing /? ) |
openLinkSearchBar |
I |
search through browser history | :history |
<N>g% |
scroll <N> percent down the page | percentScroll |
<N> unmapped |
pass <N> keys through to the current page |
passKeys |
i |
enter insert mode (escape to exit) | insertMode |
r |
reload the current tab | reloadTab |
gR |
reload the current tab + local cache | reloadTabUncached |
;<*> |
create mark <*> | setMark |
'' |
go to last scroll position | lastScrollPosition |
<C-o> |
go to previous scroll position | previousScrollPosition |
<C-i> |
go to next scroll position | nextScrollPosition |
'<*> |
go to mark <*> | goToMark |
cm |
mute/unmute a tab | muteTab |
| none | reload all tabs | reloadAllTabs |
cr |
reload all tabs but current | reloadAllButCurrent |
zi |
zoom page in | zoomPageIn |
zo |
zoom page out | zoomPageOut |
z0 |
zoom page to original size | zoomOrig |
z<Enter> |
toggle image zoom (same as clicking the image on image-only pages) | toggleImageZoom |
gd |
alias to :chrome://downloads<CR> | :chrome://downloads<CR> |
ge |
alias to :chrome://extensions<CR> | :chrome://extensions<CR> |
yy |
copy the URL of the current page to the clipboard | yankDocumentUrl |
yY |
copy the URL of the current frame to the clipboard | yankRootUrl |
ya |
copy the URLs in the current window | yankWindowUrls |
yh |
copy the currently matched text from find mode (if any) | yankHighlight |
b |
search through bookmarks | :bookmarks |
p |
open the clipboard selection | openPaste |
P |
open the clipboard selection in a new tab | openPasteTab |
gj |
hide the download shelf | hideDownloadsShelf |
gf |
cycle through iframes | nextFrame |
gF |
go to the root frame | rootFrame |
gq |
stop the current tab from loading | cancelWebRequest |
gQ |
stop all tabs from loading | cancelAllWebRequests |
gu |
go up one path in the URL | goUpUrl |
gU |
go to to the base URL | goToRootUrl |
gs |
go to the view-source:// page for the current Url | :viewsource! |
<C-b> |
create or toggle a bookmark for the current URL | createBookmark |
| unmapped | close all browser windows | quitChrome |
g- |
decrement the first number in the URL path (e.g www.example.com/5 => www.example.com/4 ) |
decrementURLPath |
g+ |
increment the first number in the URL path | incrementURLPath |
| Tab Navigation | ||
gt , K , R |
navigate to the next tab | nextTab |
gT , J , E |
navigate to the previous tab | previousTab |
g0 , g$ |
go to the first/last tab | firstTab, lastTab |
<C-S-h> , gh |
open the last URL in the current tab’s history in a new tab | openLastLinkInTab |
<C-S-l> , gl |
open the next URL from the current tab’s history in a new tab | openNextLinkInTab |
x |
close the current tab | closeTab |
gxT |
close the tab to the left of the current tab | closeTabLeft |
gxt |
close the tab to the right of the current tab | closeTabRight |
gx0 |
close all tabs to the left of the current tab | closeTabsToLeft |
gx$ |
close all tabs to the right of the current tab | closeTabsToRight |
X |
open the last closed tab | lastClosedTab |
t |
:tabnew | :tabnew |
T |
:tabnew <CURRENT URL> | :tabnew @% |
O |
:open <CURRENT URL> | :open @% |
<N>% |
switch to tab <N> | goToTab |
H , S |
go back | goBack |
L , D |
go forward | goForward |
B |
search for another active tab | :buffer |
< |
move current tab left | moveTabLeft |
> |
move current tab right | moveTabRight |
]] |
click the "next" link on the page (see nextmatchpattern above) | nextMatchPattern |
[[ |
click the "back" link on the page (see previousmatchpattern above) | previousMatchPattern |
gp |
pin/unpin the current tab | pinTab |
<C-6> |
toggle the focus between the last used tabs | lastUsedTab |
| Find Mode | ||
n |
next search result | nextSearchResult |
N |
previous search result | previousSearchResult |
v |
enter visual/caret mode (highlight current search/selection) | toggleVisualMode |
V |
enter visual line mode from caret mode/currently highlighted search | toggleVisualLineMode |
| unmapped | clear search mode highlighting | clearSearchHighlight |
| Visual/Caret Mode | ||
<Esc> |
exit visual mode to caret mode/exit caret mode to normal mode | |
v |
toggle between visual/caret mode | |
h , j , k , l |
move the caret position/extend the visual selection | |
y |
copys the current selection | |
n |
select the next search result | |
N |
select the previous search result | |
p |
open highlighted text in current tab | |
P |
open highlighted text in new tab | |
| Text boxes | ||
<C-i> |
move cursor to the beginning of the line | beginningOfLine |
<C-e> |
move cursor to the end of the line | endOfLine |
<C-u> |
delete to the beginning of the line | deleteToBeginning |
<C-o> |
delete to the end of the line | deleteToEnd |
<C-y> |
delete back one word | deleteWord |
<C-p> |
delete forward one word | deleteForwardWord |
| unmapped | delete back one character | deleteChar |
| unmapped | delete forward one character | deleteForwardChar |
<C-h> |
move cursor back one word | backwardWord |
<C-l> |
move cursor forward one word | forwardWord |
<C-f> |
move cursor forward one letter | forwardChar |
<C-b> |
move cursor back one letter | backwardChar |
<C-j> |
move cursor forward one line | forwardLine |
<C-k> |
move cursor back one line | backwardLine |
| unmapped | select input text (equivalent to <C-a> ) |
selectAll |
| unmapped | edit with Vim in a terminal (need the cvim_server.py script running for this to work and the VIM_COMMAND set inside that script) | editWithVim |
| Command | Description |
|---|---|
| :tabnew (autocomplete) | open a new tab with the typed/completed search |
| :new (autocomplete) | open a new window with the typed/completed search |
| :open (autocomplete) | open the typed/completed URL/google search |
| :history (autocomplete) | search through browser history |
| :bookmarks (autocomplete) | search through bookmarks |
| :bookmarks /<folder> (autocomplete) | browse bookmarks by folder/open all bookmarks from folder |
| :set (autocomplete) | temporarily change a cVim setting |
| :chrome:// (autocomplete) | open a chrome:// URL |
| :tabhistory (autocomplete) | browse the different history states of the current tab |
:command <NAME> <ACTION> |
aliases :<NAME> to :<ACTION> |
| :quit | close the current tab |
| :qall | close the current window |
| :restore (autocomplete) | restore a previously closed tab (newer versions of Chrome only) |
| :tabattach (autocomplete) | move the current tab to another open window |
| :tabdetach | move the current tab to a new window |
| :file (autocomplete) | open a local file |
| :source (autocomplete) | load a cVimrc file into memory (this will overwrite the settings in the options page if the localconfig setting had been set previously |
| :duplicate | duplicate the current tab |
| :settings | open the settings page |
| :nohlsearch | clear the highlighted text from the last search |
| :execute | execute a sequence of keys (Useful for mappings. For example, "map j :execute 2j<CR>") |
| :buffer (autocomplete) | change to a different tab |
| :mksession | create a new session from the current tabs in the active window |
| :delsession (autocomplete) | delete a saved session |
| :session (autocomplete) | open the tabs from a saved session in a new window |
| :script | run JavaScript on the current page |
| :togglepin | toggle the pin state of the current tab |
| :pintab | pin the current tab |
| :unpintab | unpin the current tab |
@%
in "open" commands to specify the current URL.
For example, :open @%
would essentially refresh the current page.ta
in the command bar and pressing the up arrow will search command
history for all matches beginning with ta
Nice that you want to spend some time improving this extension. Solving issues is always appreciated. If you’re going to add a feature, it would be best to submit an issue. You’ll get feedback whether it will likely be merged.
npm install
in the repository’s root foldermake
chrome://extensions


On April 15th, 1912 the passenger liner ship RMS Titanic collided with an iceberg during its inaugural voyage from Southampton dock to New York City. It is commonly believed that the 19th Century code of conduct that states "Women and children first" was enforced by the ship crew during the accident, but since there has been long time skepticism about this notion upon examination of historical shipwreck survival data, I wanted to examine with information visualization techniques whether the profile of the passengers of the Titanic, in terms of their sex, age (children or adults), survival status, and travel class, provide any support to the former hypothesis.
The dataset was obtained from the datasets package included in the R Statistical Computing language. The original data was extracted from a report of the British Board of Trade on the loss of the Titanic and recovered and compiled by Prof. Robert J. MacG. Dawson for use in statistics. A treemap was built with the area of the squares being proportional to the number of passengers in each category.
To interact with the figure below, please hover the mouse over the boxes to consult the number of passengers belonging to the categories described in the text.
From the observed data we can conclude that the common belief that women and children were not the largest group of survivors from the sinking, thus debunking a myth from the most famous shipwreck of the 20th Century.


α-Co(OH) heterojunction /α-Ni(OH) electrode high rate material structure materials capacitance supercapacitors Mater. performance density surface α-Ni(OH) Ni(OH) foam nickel nanorods supercapacitor energy {border-style nanowires Chem. px;} specific #ffffff;} (Fig. Fig. excellent three-electrode two-electrode A g //AC asymmetric ion stability .%@ A g Wang current device electrochemical electron hierarchical high-performance synthesis transport utilization Energy crystal retention curves cycle . W kg Adv. Figure advantages hybrid peak Co(OH) arrays discharge higher layered nanosheet system, (. Wh kg active anions conductive conductivity electronic peaks using Zhu addition, ionic materials. px; respectively, scanning single test {font-family NiCo Zhang complementary contact distribution font-size intercalated large life nanorods. respectively. solution storage two-dimensional cm (the ACS Chen Nano SEM \documentclass[pt]{minimal} \setlength{\oddsidemargin}{-pt} \usepackage{amsbsy} \usepackage{amsfonts} \usepackage{amsmath} \usepackage{amssymb} \usepackage{mathrsfs} \usepackage{upgreek} \usepackage{wasysym} attributed cobalt composites construction corresponding deformation design double; efficient elements foam. hydroxide indicates long low material, porous power reaction structural used water ./j.electacta... ./j.jallcom... . F g . Wh kg @Ni(OH) Acta Compd. Electrochim. Sci. Wei Zhou abundant based border-color border-width confirms core-shell cycling diagram display effect enhanced graphene improve ions lower material. mild morphology nanosheets nanowire novel potential present ratio resistance sample situ small solid; stable stress weight {font-style {font-weight ./adma. ./j.cej... /Ni(OH) Appl. Co, Commons Creative EDX Eng. Environ. FTIR Preparation X-ray Yang achieve advanced all-solid-state analyzed aqueous bold carbon collector courier; cycles different edge electrolyte. element em; evolution exhibits grown growth heterojunctions highly images indicate initial interlayer mass materials, mesoporous nanowires. network nitrate obtain order oxidation preparation pt;} rapid result reversible second shown shows synergistic synthesized system. three-dimensional transmission values work −),


{{define "page_edit"}} {{template "partial_header" .}}
See these guides for how to use Markdown.
These special rules are used by Tradgard.


The TCP server is meant for integration into Control systems like EPICS and Tango. It exposes an ASCII Control interface on port 8888 and a binary Data interface on port 8889.


{{(photographerToDisplay | async)?.bio}}
Preferred Media for Photography: {{(photographerToDisplay | async)?.format}}
{{(photographerToDisplay | async)?.website}}


In this example, sentences can be sent to J for execution.
First start the server. To do so, run jconsole then enter:
load 'net/websocket/demo1/run'
Then connect, enter an expression and send to J:


 For instance, consider the Fibonacci sequence: F_n = F_{n-1} + F_{n-2}, where the first values are F_0 = 0 and F_1 = 1.
A function to find the nth fibonacci number should be fairly straightforward:
int fib(int n) { return fib(n-1) + fib(n-2); }
But be careful! We didn’t set any limits on n, so the parameter can just keep decreasing forever without bound. It’s extremely easy to accidentally enter into an infinite loop, so we must set a base case, or a case of n in which we already know the answer. Namely, we know that F_0 = 0 and F_1 = 1.
int fib(int n) { if (n == 0) return 0; if (n == 1) return 1; return fib(n-1) + fib(n-2); }
Each recursive function needs to have a base case before entering a recursive step. Always carefully define what f(n) is and how it relates to the subproblems, i.e. if we know f(n-1) and f(something less), how can we get f(n)?
There is another way to recursively do fibonacci that is many times faster than the first version. You may be wondering what many times faster means, look at the following images of recursive trees for fibonacci to see the efficiency of our original function.
See that the number of recursive calls gets exponentially bigger the higher you go. So although F(5) and even F(10) is done instantly, F(42) takes almost 2 seconds to run, and if we go even higher it can take hundreds of days to solve even 1 number. Luckily, there are many ways to make this recursion faster.
One way is called tail-recursion. And it goes like the following. We have a function like the following:
int fib(int n, int a = 0, int b = 1) { if (n == 0) return a; return fib(n-1, b, a+b) }
a represents f(n-2), while b represents f(n-1) and to shift these values up to f(n-1) and f(n) we do b and a+b. Instead of calling another fib function to find the values of f(n-1) and f(n-2) we just have them calculated already so this makes it much more efficient.
Notice that this only calls 1 extra call per 1 more n while the other does exponentially more, so this is much more efficient. This method is called tail-recursion and is very useful to know. There are other methods of making this more efficient for example we can make fibonacci through matrix multiplication but we ain’t going to get into that right now.
Ternary statements have the form (condition ? val1 : val2). If the condition is true the ternary statement becomes equal to val1, but if it isnt true it becomes equal to val2, an example for using ternary statements is given below.
int main() { int n; cin >> n; string res = (n % 2 == 0 ? "even" : "odd"); cout << res << "\n"; }
This code checks if a given number is even, and if it is, it sets res to the string literal "even", and if it is not, it sets res to the string literal "odd". Notice that the ternary statement above is equivalent to an if statement in the following manner:
int main() { int n; cin >> n; string res; if (n % 2 == 0) res = "even"; else res = "odd"; cout << res << "\n"; }
The two above pieces of code are completely equivalent, ternary statements just make it a bit shorter to type.
Recursively write the factorial function, where n! = n * (n-1) * … * 2 * 1.
int fact(int n) { if (n == 0) return 1; return n * fact(n-1); }
The base case is that 0! = 1 because we can not have negative factorials, so if n == 0 we just return 1. Now we can realize that fact(n) = n * fact(n-1), and just implement that into our function.
We have bunnies standing in a line, numbered 1, 2, ... The odd bunnies (1, 3, ..) have the normal 2 ears. The even bunnies (2, 4, ..) we'll say have 3 ears, because they each have a raised foot. Recursively return the number of "ears" in the bunny line 1, 2, ... n (without loops or multiplication).
int bunnyEars2(int bunnies) { if (bunnies == 0) return 0; return bunnyEars2(bunnies-1) + (bunnies % 2 == 1 ? 2 : 3); }
Our base case is that if there are 0 bunnies there are 0 ears. Now lets check out recursion, if our current number n is even we need to do 3 + bunnyEars2(n-1), but if our current number n is odd we need to fo 2 + bunnyEars2(n-1). We can implement this with either if statements or a ternary statements.


Why You Should Join, Part 1: Join as a Voting Member
At the Connect event in December, we announced .NET Foundation Open Membership and a new Corporate Sponsor program. We're planning to kick off our first community board member election later this month, so now is a great time to join! Beth Massi and I were guests on the .NET Rocks podcast earlier this month to review our announcements and talk you into joining, and I'm starting a series of posts to explain things in more detail, as well as to answer some common questions.
Here's the planned series, let me know if you've got specific questions on any of these or would like to see more topics covered:
- Why You Should Join: Part 1 - Voting Member (this post)
- Why You Should Join: Part 2 - Corporate Sponsor
- Why You Should Join: Part 3 - Board Member
What did we announce?
We made two big announcements at Microsoft Connect(); 2018: Open Membership and a new Corporate Sponsor program.
First, Open Membership: we're expanding the board from three to seven members, with one single seat appointed by Microsoft and the remaining six elected by the community. The .Net Foundation Board election campaigns will start on January 28, 2019; any person who has contributed to a.NET Foundation open source project is eligible to run for the board and to vote. This new structure will help the .NET Foundation scale with the growing .NET open source ecosystem and allows our entire community to get a lot more involved.
Secondly, we are also expanding our current technical steering group to a Corporate Sponsor program. In addition to our current sponsors – Red Hat, JetBrains, Google, Unity, Microsoft and Samsung, we are also welcoming Pivotal, Progress Telerik and Insight. We're working with some other companies who are interested in joining, and I'll be going into more detail on the Corporate Sponsor program in the next post.
Wait, I thought open source projects join the .NET Foundation… Is it for projects, people, or companies?
Yes, all of them! In the past, we've really talked about open source projects joining the .NET Foundation. That's been great but limited. A lot of things wait on one person (the executive director) to get things done, and there hasn't been a good way to let you get involved. For instance, we've got a backlog of projects that want to join and a great community that would like to help, but no good way to empower them to get involved.
So we're keeping open source .NET project support as a key focus of the .NET Foundation, and using open membership as a way to scale that up, leverage ideas from the community, etc.
So now people, project, and companies can all join the .NET Foundation:
- Projects can join the .NET Foundation for a ton of reasons including IP and legal support, technical and back end support services (certs, hosting, CLA's, etc.)
- Companies can join the .NET Foundation as corporate sponsors, to collaboratively support the .NET open source ecosystem (more in the next post)
- People - individual community members - can join as voting members of the .NET Foundation
Why should I join?
Most importantly, you should join because you care about .NET. Maybe you're an open source project leader or contributor and want to make sure the .NET Foundation is solving the problems you care about. Maybe you've gotten involved in a few Twitter threads or conference discussions about how things ought to be but didn't have a way to turn those ideas into reality. This is that way.
Or maybe you're a .NET developer who doesn't do much open source, but cares about .NET because it's important to you professionally. You're happy that Microsoft is working away on the runtime and tools, but you want to make sure that your favorite open source projects are supported. You want to make sure things like Meetups and student programs will be there to help new programmers get started with .NET. You should join the .NET Foundation because .NET is important to you.
Joining as a voting member gives you the right to run for a board seat, and to vote in the yearly elections. This is your opportunity to decide what the .NET Foundation will do for the next year.
Note: This applies to employees of any company, including Microsoft.  There is a limitation of two board members from any company, but every member gets a vote in the elections.
What do I get for joining?
The most important part is what we just talked about. We're thinking of some other things, like exclusive swag and events (online to start, maybe in person at some point), etc. We're interested in your ideas.
We've had some people suggest that members should get goodies from Microsoft, like discounted conference tickets. It's important to remember that the .NET Foundation is separate from - it's not owned or controlled by Microsoft, as the board expansion should make clear. So Microsoft, or other corporate sponsors, may decide to offer something to members, but that's up to them and outside of the .NET Foundation's control.
How do I join?
- Fill out a short form (https://dotnetfoundation.org/become-a-member) with your contact info and references to your contributions to the .NET open source community
- We'll review applications and get back to you - we plan to accept every reasonable application, and provide feedback in the rare cases your contributions weren't clear
- We'll notify you with a link to accept your membership and pay the annual dues
Dues? What's the deal with the $100 dues?
We're asking voting members for $100 annual dues, but please don't let dues keep you from joining! If $100 dues are a problem for you, you can set a lower dues amount, down to $0. That applies to students, people in parts of the world where $100 is expensive, etc. You know your circumstances, and we trust you. Again, please don't let dues keep you from joining. Contact us<EMAIL_ADDRESS>if you have any question about this.
So why are we asking for dues at all? For a few reasons:
- We want you to value your membership. Personally, when I contribute $20 to a Kickstarter, I feel like I'm part of it. I check back on it and want it to be successful. This is a little like that - we don't want this to just be some random form you fill out on the internet because you're bored We want you to participate.
- The .NET Foundation is an independent organization, and independent funding is an important part of that. We've been running on donations from Microsoft for the past few years, which is both really cool and something people don't give Microsoft credit for. We hope they keep coming! But, for the .NET Foundation to really be sustainable, independent, impactful, and real, it needs independent support. We'll have corporate sponsorship, but voting member dues could be a significant part of that support as our member base grows.
- We want to use your money to support the things you care about - sustainable open source, your favorite open source .NET projects, your open source .NET community.
Who is eligible?
Anyone who has contributed to any .NET Foundation project. Usually that will be with code, but can include documentation, or filing significant issues. It might be something we haven’t thought of yet - if in doubt, ask!
UPDATE: We've expanded and clarified the contribution requirements. Any individual contributor to a .NET Foundation project can apply to become a member. Contributions may include code contributions, documentation, or other significant project contribution, including evangelism, teaching, code, organizing events, etc. If in doubt, please ask us at<EMAIL_ADDRESS>How can I get started contributing to a .NET Foundation project?
We've had some questions from people who tried to dive right into some of the more complex ones - CoreCLR, CoreFX, ASP.NET Core. We'd recommend starting with some small contributions, and look at Docs and some other .NET Foundation projects. If you're having trouble finding one, ping me at<EMAIL_ADDRESS>and I'll help.
As with dues, we don't want to exclude anyone that really wants to be involved. We'll be flexible, and do what we can to get the boxes checked to get you in. If in doubt, ask!
Sign up today!
If you've already contributed to any .NET Foundation project, apply for membership today: https://dotnetfoundation.org/become-a-member
If you haven't contributed yet and need some help getting started, e-mail us<EMAIL_ADDRESS>and we'll help.


{block name="keywords"}{/block} {block name="header"}{include file='public/header'}{/block}
{block name="top"}{include file="public/top"}{/block} {block name="headw"}{include file="public/headw"}{/block} {block name="main"}{/block} {block name="footer"}{include file="public/footer"}{/block}


We added class attributes to our menu and did some styling in a CSS file, to make it a little nicer. We will come back at the end and deconstruct all that CSS.
Go back to the Starting page.


Access Star Trek content from Memory Alpha (https://memory-alpha.fandom.com/wiki/Portal:Main).
memory_alpha(endpoint)
| endpoint | character, See details. |
|---|
a data frame
The content returned is always a data frame. The structure changes slightly depending on the nature of the endpoint, but results from different endpoints can be merged easily.
At the highest level, passing enpoind = "portals"
returns a data frame listing the available Memory Alpha portals supported by rtrek
.
A column of relative URLs is also included for reference, but can be ignored.
In all other cases, the endpoint string must begin with one of the valid portal IDs.
Passing only the ID returns a data frame with IDs and relative URLs associated with the available categories in the specific portal.
There are two additional columns, group
and subgroup
, that may provide additional grouping context for the entry IDs in larger tables.
As with the relative URLs, you do not have to make explicit use of these variables.
Selecting a specific category within a portal is done by appending the portal ID in endpoint
with the category ID, separated by a forward slash.
You can append nested subcategory IDs with forward slashes, provided they subcategories exist.
When the endpoint is neither a top-level portal or one of a portal's categories (or subcategories, if available), it is an article.
An article is a terminal node, meaning you cannot nest further. An article will be any entry whose URL does not begin with Category:
.
In this case, the content returned is still a data frame for consistency, but differs substantially from the results of non-terminal endpoints.
Memory Alpha is not a database containing convenient tables. Articles comprise the bulk of what Memory Alpha has to offer.
They are not completely unstructured text, but are loosely structured.
Some assumptions are made and memory_alpha
returns a data frame containing article text and links.
It is up to the user what to do with this information, e.g., performing text analyses.
The url
column included in results for context uses relative paths to save space. The full URLs all begin the same.
To visit a URL directly, prepend it with https://memory-alpha.fandom.com/wiki/
.
Also note that once you know the relative URL for an article, e.g., "Worf"
,
you do not need to traverse through one of the portals using an endpoint
string to retrieve its content.
You can instead use ma_article("Worf")
.
memory_alpha
provides an overview perspective on how content available at Memory Alpha is organized and can be searched for through
a variety of hierarchical layouts. And in some cases this structure that can be obtained in table form can be useful as data or metadata
in itself. Alternatively, ma_article
is focused exclusively on pulling back content from known articles.
memory_alpha("portals") # show available portals#> # A tibble: 6 x 2 #> id url #> <chr> <chr> #> 1 alternate Portal:Alternate_Reality #> 2 people Portal:People #> 3 science Portal:Science #> 4 series Portal:TV_and_films #> 5 society Portal:Society_and_Culture #> 6 technology Portal:Technology# \donttest{ memory_alpha("people") # show portal categories for People portal#> # A tibble: 103 x 3 #> id url group #> <chr> <chr> <chr> #> 1 Acamarians Category:Acamarians By species #> 2 Akritirians Category:Akritirians By species #> 3 Aldeans Category:Aldeans By species #> 4 Andorians Category:Andorians By species #> 5 Androids Category:Androids By species #> 6 Aquans Category:Aquans By species #> 7 Ardanans Category:Ardanans By species #> 8 Augments Category:Augments By species #> 9 Ba'ku Category:Ba%27ku By species #> 10 Bajorans Category:Bajorans By species #> # ... with 93 more rowsmemory_alpha("people/Klingons") # show people in Klingons subcategory#> # A tibble: 222 x 2 #> Klingons url #> <chr> <chr> #> 1 Memory Alpha images (Klingons) Category:Memory_Alpha_images_(Klingons) #> 2 Amar (Klingon) Amar_(Klingon) #> 3 Antaak Antaak #> 4 A'trom A%27trom #> 5 Atul Atul #> 6 Augments Category:Augments #> 7 Azetbur Azetbur #> 8 Ba'el Ba%27el #> 9 Ba'ktor Ba%27ktor #> 10 Barak-Kadan Barak-Kadan #> # ... with 212 more rowsmemory_alpha("people/Klingons/Worf") # return terminal article content#> # A tibble: 1 x 4 #> title content metadata categories #> <chr> <list> <list> <list> #> 1 Worf <xml_ndst> <tibble[,16] [1 x 16]> <tibble[,2] [12 x 2]># }


All notable changes to this project will be documented in this file.
jwt.verify
now requires an algorithm
parameter, and
jws.createVerify
requires an algorithm
option. The "alg"
field
signature headers is ignored. This mitigates a critical security flaw
in the library which would allow an attacker to generate signatures with
arbitrary contents that would be accepted by jwt.verify
. See
https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/
for details.BREAKING: Default payload encoding changed from binary
to
utf8
. utf8
is a is a more sensible default than binary
because
many payloads, as far as I can tell, will contain user-facing
strings that could be in any language. ([6b6de48]
)
Code reorganization, thanks @fearphage! ([7880050]
)
encoding
. For those few users
that might be depending on a binary
encoding of the messages, this
is for them. ([6b6de48]
)


Request a route from A to B using public transport and display it on the map.
This example calculates a route from the Fernsehturm at Panoramastraße in Berlin (52.5208°N, 13.4093°E) to Kurfürstendamm (52.5034°N, 13.3295°E) in the west of the city using public transport routing, and displays it on the map. The calculation finds the fastest available route using public transport.
Access to the routing service is obtained from the H.service.Platform
by calling
getRoutingService()
. The calculateRoute()
method is used to calculate the fastest
public transport (mode:fastest;publicTransport
) route by passing in the relevant parameters as defined in
Routing API.
The styling and display of the response is under the control of the developer.


OCLC API Key
Select tab that contains ISBNs
Select search criteria tab
Select first record when no match?
Start search at row#
(optional)
After you have performed the search you can receive an email of records (that will contain new fields you've setup in the spreadsheet).
Create MARC record file and mail to:
001 Value is in field:
Start with record at row#
(optional)
v. 16
github repo.


The rapid growth of technology influences design trends every year.
Here you can see 5 UI/UX design trends that you should watch in 2020:
Check out previous trends of Design on the Youtube channel (This is not a Link):
Design Trends for the current year on the video bellow:
| UX Design | UI Design | Web Design |
|---|---|---|
| Responsive UX | Hand-drawn Illustrations | Micro interactions |
| Sound | Variable Typography | Dark Mode |
| Creative loaders | Low Gradients | Ultra minimalist navigation |


Check out our documentation at
twitch4j.github.io
Aggregated Javadocs (all modules)
Installation
Usage


Experienced product developer in the software industry with strengths in application engineering, process optimization, and technology researches. Successful in developing a technology that has resulted in an over 40% increase in operational efficiency of waste collection companies.
Loves to work with micro-interactions and layout architectures, especially the component-based ones. With the current goal of building a web development architecture/methodology, creates experiments to develop proofs of concepts.
With a business process engineering background, studies the critical success factors of the company and works to improve its productivity, efficiency, and operational costs. The goal is to make everyone understand its activities and focus on what matters for business health.
See the Pen CSS Grid Card Skeleton Screen (w/ Custom Properties) by Rafael Goulart (@faelplg) on CodePen.