text:
I have a two-year-old daughter named Naya
who is under the mistaken impression
that this conference
is named in honor of her father.

(Laughter)

Who am I to contradict my baby girl?
As many of you know, there's something
about becoming a parent
that concentrates the mind
on long-term problems like climate change.
It was the birth of my daughter
that inspired me
to launch this climate organization,
in order to counteract the excessive
polarization of this issue
in the United States,
and to find a conservative
pathway forward.

It may even be better.

(Laughter)

Let me try to prove that to you.
What we really need
is a killer app to climate policy.
In the technology world, a killer app
is an application so transformative
that it creates its own market,
like Uber.
In the climate world,
a killer app is a new
solution so promising
that it can break through
the seemingly insurmountable
barriers to progress.
These include the psychological barrier.
Climate advocates have long
been encouraging their fellow citizens
to make short-term sacrifices now
for benefits that accrue to other people
in other countries 30 or 40
years in the future.
It just doesn't fly because it runs
contrary to basic human nature.
Next is the geopolitical barrier.
Under the current rules of global trade,
countries have a strong incentive
to free ride off the emissions reductions
of other nations,
instead of strengthening
their own programs.
This has been the curse
of every international
climate negotiations, including Paris.
Finally, we have the partisan barrier.
Even the most committed countries --
Germany, the United Kingdom, Canada --
are nowhere near reducing emissions
at the required scale and speed.
Not even close.
And the partisan climate divide
is far more acute
here in the United States.
We are fundamentally stuck,
and that is why we need
a killer app of climate policy
to break through each of these barriers.
I'm convinced that the road
to climate progress in the United States
runs through the Republican Party
and the business community.
So in launching
the Climate Leadership Council,
I started by reaching out to a who's who
of Republican elder statesmen
and business leaders,
including James Baker and George Schultz,
the two most respected Republican
elder statesmen in America;
Martin Feldstein and Greg Mankiw,
the two most respected
conservative economists in the country;
and Henry Paulson and Rob Walton,
two of the most successful
and admired business leaders.
Together, we co-authored
"The Conservative Case
For Carbon Dividends."
This represents the first time
that Republican leaders put forth
a concrete market-based climate solution.

(Applause)

Thank you.

(Applause)

We presented our plan at the White House
two weeks after President Trump moved in.
Almost every leading
editorial board in the country
has since endorsed our plan,
and Fortune 100 companies
from a wide range of industries
are now getting behind it.
So by now you're probably wondering,
what exactly is this plan?
Well, our carbon dividends solution
is based on four pillars.
The first is a gradually
rising carbon tax.
Although capitalism is a wonderful system,
like many operating systems,
it's prone to bugs,
which, in this case, are called
"market failures."
By far the largest is that
market prices fail to take
social and environmental
costs into account.
That means every market transaction
is based on incorrect information.
This fundamental bug of capitalism,
more than any other single factor,
is to blame for our climate predicament.
Now in theory, this should be
an easy problem to fix.
Economists agree
that the best solution is to put a price
on the carbon content of fossil fuels,
otherwise known as a carbon tax.
This would discourage carbon emissions
in every single economic transaction,
every day of the year.
However, a carbon tax by itself
has proven to be unpopular
and a political dead end.
The answer is to return
all the money raised
directly to citizens,
in the form of equal monthly dividends.
This would transform
an unpopular carbon tax
into a popular and populist solution,
and it would also solve
the underlying psychological barrier
that we discussed,
by giving everyone a concrete benefit
in the here and now.
And these benefits would be significant.
Assuming a carbon tax rate
that starts at 40 dollars per ton,
a family of four would receive
2,000 dollars per year
from the get-go.
According to the US Treasury Department,
the bottom 70 percent of Americans
would receive more in dividends
than they would pay
in increased energy prices.
That means 223 million Americans
would win economically
from solving climate change.
And that --

(Applause)

is revolutionary,
and could fundamentally
alter climate politics.
But there's another
revolutionary element here.
The amount of the dividend would grow
as the carbon tax rate increases.
The more we protect our climate,
the more our citizens benefit.
This creates a positive feedback loop,
which is crucial,
because the only way we will reach
our long-term emission-reduction goals
is if the carbon tax rate
goes up every year.
The third pillar of our program
is eliminating regulations
that are no longer needed
once a carbon dividends plan is enacted.
This is a key selling point
to Republicans and business leaders.
So why should we trade
climate regulations for a price on carbon?
Well, let me show you.
Our plan would achieve nearly twice
the emissions reductions
of all Obama-era climate
regulations combined,
and nearly three times the new baseline
after President Trump repeals
all of those regulations.
That assumes a carbon tax
starting at 40 dollars per ton,
which translates into roughly
an extra 36 cents per gallon of gas.
Our plan by itself
would meet the high end
of America's commitment
under the Paris Climate Agreement,
and as you can see,
the emissions reductions
would continue over time.
This illustrates the power
of a conservative climate solution
based on free markets
and limited government.
We would end up with less regulation
and far less pollution at the same time,
while helping working-class
Americans get ahead.
Doesn't that sound like something
we could all support?

(Applause)

The fourth and final pillar of our program
is a new climate domino effect,
based on border carbon adjustments.
Now that may sound complicated,
but it, too, is revolutionary,
because it provides us
a whole new strategy
to reach a global price on carbon,
which is ultimately what we need.
Let me show you an example.
Suppose Country A adopts
a carbon dividends plan,
and Country B does not.
Well, to level the playing field
and protect the competitiveness
of its industries,
Country A would tax imports from Country B
based on their carbon content.
Fair enough.
But here's where it gets
really interesting,
because the money raised at the border
would increase the dividends
going to the citizens of Country A.
Well, how long do you think it would take
the public in Country B to realize
that that money should be going to them,
and to push for a carbon
dividends plan in their own land?
Add a few more countries,
and we get a new climate domino effect.
Once one major country or region
adopts carbon dividends
with border carbon adjustments,
other countries are compelled
to follow suit.
One by one the dominoes fall.
And this domino effect
could start anywhere.
My preference, strongly,
is the United States,
but it could also start
in the United Kingdom,
in Germany or another European country,
or even in China.
Let's take China as an example.
China is committed to reducing
greenhouse gas emissions,
but what its leaders care even more about
is transitioning their economy
to consumer-led economic development.
Well, nothing could do more
to hasten that transition
than giving every Chinese citizen
a monthly dividend.
In fact, this is the only policy solution
that would enable China to meet
its environmental and economic goals
at the same time.
That's why this is the killer app
of climate policy,
because it would enable us to overcome

each of the barriers we discussed earlier:
the psychological barrier,
the partisan barrier,
and, as we've just seen,
the geopolitical barrier.
All we need is a country to lead the way.
And one method of finding
what you're looking for
is to take out an ad.
So let's read this one together.

Wanted: country to pioneer
carbon dividends plan.

Cost to country: zero.

Starting date: as soon as possible.

Advantages: most effective
climate solution,
popular and populist,
pro-growth and pro-business,
shrinks government
and helps the working class.

Additional compensation: gratitude
of current and future generations,
including my daughter.
Thank you.

(Applause)

Chris Anderson: Just one
question for you, Ted.
I'm actually not sure
I've seen a conservative
get a standing O at TED before that.
That's pretty cool.
The logic seems really powerful,
but some people you talk to in politics
say it's hard to imagine this
still getting through Congress.
How are you feeling
about momentum behind this?

Ted Halstead: So I understand
that many are very pessimistic
about what's happening in
the United States with President Trump.
I'm less pessimistic; here's why.
The actions of this White House,
the early actions on climate,
are just the first move
in a complex game of climate chess.
So far it's been a repeal-only strategy;
the pressure is going to mount
for a replacement program,
which is where we come in.
And there are three reasons why,
which I'll go through real quickly.
One, the business community
is fundamentally parting ways
with the White House on climate change.
In fact, we're finding
a number of Fortune 100 companies
supporting our program.
Within two months,
we're going to be announcing
some really surprising names
coming out in favor of this program.
Two, there is no issue
in American politics
where there's a more fundamental gap
between the Republican base
and the Republican leadership
than climate change.
And three, thinking of
this analogy of chess,

the big decision up ahead is:
Does the administration stay in Paris?
Well, let's pan it out both ways.
If it stays in Paris, as many
are pushing for in the administration,

well then that begs a question:
What's the plan?
We have the plan.
But if they don't stay in Paris,
the international pressure
will be overwhelming.
Our Secretary of State will be asking
other countries for NATO contributions,
and they'll be saying,
"No, give us our Paris commitment.
Come through on your commitments,
we'll come through on ours."
So, international, business
and even the Republican base
will all be calling for
a Republican replacement plan.
And, hopefully, we've provided one.

CA: Thank you so much, Ted.

TH: Thank you, Chris.

(Applause)

repository: prewittdavon/TEDVis

gha_language: Python

repo_name: prewittdavon/TEDVis


text:
# echosounder

`echosounderd` is a simple REPL TCP service with a HTTP statistics service embedded.

## Usage

You may simply run it by cloning it to `$GOPATH/src/echosounder` and run

```sh
go run cmd/echosounderd/echosounderd.go --listen ':23' --stat-listen ':80'
```

**Note:** Without specifying `--listen` and `--stat-listen`, the default REPL TCP service and HTTP statistics service listen on `:10023` and `10080`.

Or run it as a docker container

```sh
docker-compose up -d
```

### REPL TCP service

```sh
$ telnet localhost 23
Trying ::1...
telnet: connect to address ::1: Connection refused
Trying fe80::1...
telnet: connect to address fe80::1: Connection refused
Trying <IP_ADDRESS>...
Connected to localhost.
Escape character is '^]'.
>>> dummy
        Title: sunt aut facere repellat provident occaecati excepturi optio reprehenderit
        Body: quia et suscipit
suscipit recusandae consequuntur expedita et cum
reprehenderit molestiae ut ut quas totam
nostrum rerum est autem sunt rem eveniet architecto
>>> stat

        Current connection: 1
        Total request: 1
        Processed request: 1
        Waiting request: 0
>>> quit
bye~
Connection closed by foreign host.
```

3 commands are supported: `dummy`, `stat`, `quit`.

- `dummy` sends a request to an external API service jsonplaceholder.typicode.com, gets the first post and returns it back to client.
- `stat` shows current statistics just like what you request from HTTP statistics server (but in different format).
- `quit` exits REPL and closes the connection.

### Statistics HTTP service

```sh
$ curl http://localhost/stat
{"current_connection":0,"total_request":1,"processed_request":1,"waiting_request":0}
```

license: MIT

repository: yzlin/echosounder

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: yzlin/echosounder


text:
---
title: "CRMUG Summit 2017"
date: 2017-11-27T00:00:00-00:00
tags: [CRM, Dynamics 365, User Group]
toc: false
---
![CRMUG Summit 2017](/images/2017/crmug_summit2017.jpeg)

I was able to attend [CRMUG Summit](https://na.usergroupsummit.com/home "CRMUG Summit") again this year. The 2017 Summit was hosted in Nashville, TN at the Gaylord Opryland Resort. I have been so impressed with the amount of content and the people who attend Summit both times now.

## My Goals
Before I leave for the Summit, I always prepare by listing out my goals. The number of sessions available is amazing and it is very easy to become overwhelmed and miss some very good sessions. Having my goals helps *lower*, not eliminate this. I keep my goals simple and also use the available app to “favorite” sessions I want to attend.

- GDPR
- Dynamics 365 v9 Update
- Reporting
- Customization

The topics listed above are what I wanted to focus this year. Of course, this can change based on further discussion with others at Summit. This year I heard there were about **7,000 people** in attendance. Each year it continues to grow.

### GDPR

On April 27, 2016, the European Parliament adopted the [General Data Protection Regulation](https://eugdpr.org/ "General Data Protection Regulation"). I work with a global company and knew this topic was very important even though I am not personally involved in the project myself. This regulation becomes enforceable on May 25, 2018.

I attended a round-table discussion about GDPR with others who have had a lot more time to research and prepare for GDPR. I wanted to become more familiar and be able to bring back information I learned.

One thing that I learned about GDPR is that there is still a lot of questions about this regulation.

#### Right To Be Forgotten

One major discussion was the Right To Be Forgotten and how this impacts other requirements for organizations. If a person is an EU citizens, they have the right to be forgotten and this is a personal option available to each EU citizen. This becomes complicated as personal information is many times exported to Excel or other reports used by organizations and all of these exports must be destroyed if a person requests to be forgotten. One thing to keep in mind is that if the data is required for other regulations such as financial reporting the data can be maintained. A major part of this is the ability to anonymize information so there is no way of personally identifying a person.

#### Data Policy

A data policy is a key component of GPDR. Having a data policy that not only specifies what data is being stored but also why it is stored. The policy must explain why the company needs the data that is stored and how they are protecting this data. A person’s consent is very important, once the data policy is available an individual must consent to a company’s use of their personal data. This means a person; a company cannot provide this consent for one of their employees. It was also discussed how if and when the data policy is changed consent must be collected again from people.
This one–hour roundtable was very informative but brought many more questions to me. As I stated this was my first exposure to GDPR and I am looking forward to learning more and correcting any misconceptions that I may have.

### Dynamics 365 v9 Update

Last year at Summit we learned about the launch and rebranding of Microsoft CRM Online to Dynamics 365. This year version 9 of Dynamics 365 was already announced and webinars available. But, we had the opportunity to attend sessions and hands-on labs with version 9. With version 9 of Dynamics 365, Microsoft has made available some new features that I am excited to use. Two of the biggest features that I am excited about are UUI and Virtual Entities.

#### Updated User Interface

The user interface has been updated even without using the new UUI. The updated user interface is cleaner to make it easier on the eyes and usability.

**UUI Unified User Interface**

Dynamics 365 will now have a new user interface that is designed to be responsive and offer cross-device viewing. A big advantage of the UUI is to make a consistent user interface on any device. So, you can design a form once and have it available on all devices.

But, we must keep in mind this is not a feature that you just turn on and it works. A new “app”, a feature that was released in version 8.2 needs to be created where we set the user interface to UUI and then build out the forms and menus to be available in this app. This will take time to design and implement but will bring users a more streamlined experience.

Currently, Advanced Find is NOT available in the UUI which is a big limitation for us.

### Virtual Entities

There is never one single system that contains all of the data that is needed. Integration with other systems is common and I have been doing integration for all of my career.The purpose of a Virtual Entity is to allow data from a different system to be available within Dynamics 365. The data in the system is NOT stored on Dynamics 365, but to the end-user it appears as if it is.

A virtual entity provides a way of creating an entity based on an OData feed to Dynamics without storing data in Dynamics and thus reducing the storage being used. A requirement of Virtual Entities is that the primary key must be a GUID.
During the hands-on lab time, I created a virtual entity and added this entity as a related entity to the account entity. I was then about to open a form and use a drop down that pulled from the oData feed that was NOT stored on Dynamics. I could save data and use Advanced Find to find accounts that had data from this oData feed set.

1.  Define a Virtual Entity Data Source, currently, it only supports OData V4 Data Provider.
2.  Create a new custom Entity of type Virtual Entity, specifying External Name and External Collection Name corresponding to the name of the entity and entity set in the OData service to connect to.
3.  Set the Id and Name attributes (or any custom attribute) of the Virtual Entity to the corresponding fields of OData entity.
4.  Id (Primary Key) field must be of type GUID else we will get the exception.

repository: ljrain/MyLiveResume

repo_name: ljrain/MyLiveResume


text:
# randombooks

> A React/express project
> To randmoize books from goodreads.

## Development Setup

In the Development enivroment the react application (client folder) is using `proxy` to consume the api request coming from the express server.

``` bash
# Open the project folder
cd randombooks && npm install

# Open a second terminal tab simultaneous with the first one and open the client folder
cd client && npm install

# In the randombooks terminal run
node server.js || nodemon server.js

# In the client terminal run
npm start
```

## Producation Setup

In the Producation enviroment, first we build the react app (from Inside the client folder) by running `npm run build`. Then add this line to the `server.js` file, which will serve the app as a static file.

``` bash
# Everytime the server get request, it services as the app from the build folder
app.use(express.static(path.resolve(__dirname, 'client/build')));
```

``` bash
# From inside the client folder run
npm run build

# From the randombooks folder run
echo “node_modules/” > .gitignore

# Also from the randombooks folder run
npm start || node server.js

```


text:
# Bulk Migrate Repositories From GitLab to GitHub

A set of Python scripts to migrate repositories from GitLab to GitHub using [GitHub Importer](https://help.github.com/articles/importing-a-repository-with-github-importer/) (i.e. without creating a local clone).

## Prerequisities

- Python 3.7 or newer
- [Pipenv](https://pipenv.readthedocs.io/)

## Setup

Install dependencies by running `pipenv install`.

### Access Tokens

Create personal access token both for GitLab and GitHub.

For GitLab, visit [Settings / Access Tokens](https://gitlab.com/profile/personal_access_tokens). Create a new token with any name and the scopes: `api` and `read_repository`.

For GitHub, follow the [documentation](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/). Create a new token with scope `repo`.

Export the resulting tokens either as environment variables:

```sh
export GITLAB_TOKEN=<paste your GitLab token here>
export GITHUB_TOKEN=<paste your GitHub token here>
```

or modify [config.py](config.py) and paste the tokens as value of `GITLAB_TOKEN` and `GITHUB_TOKEN` respectively.

## Usage

With tokens setup, you can start import process. The process is separated into three phases.

### 1. Get a list of GitLab projects

Run:

```
pipenv run python 1-projects.py
```

This will create a file `gitlab_projects.json` with a list of projects to be imported in the following phase.
You can modify this list, for example change `name` property if you wish to import the project under different name, set `visibility` to `"private"` if the imported project should be private or delete the project completely if you don't wish to import it.

### 2. Create GitHub repositories and start import

Run:

```
pipenv run python 2-import.py
```

This will use a list of projects from the previous step, create a new repository (respecting privacy of the original project) and start an import task using the GitLab's HTTPS URL and access token. If the repository of the same name exists, it will be skipped. The results are stored into `github_projects.jsonl` file for the next step.

You will receive an e-mail from GitHub for each repository as the import finishes (or fails).

### 3. Archive imported repositories

Once the repositories are imported, you can optionally re-archive the imported GitHub repositories by running:

```
pipenv run python 3-archive.py
```

This will use the output file from the previous phase. Repositories which were skipped, not originally archived, or not completely imported will be ignored.

## License

MIT

repository: jnv/gitlab-to-github

gha_license_id: MIT

repo_name: jnv/gitlab-to-github


text:
# Storage service

The following action are supported:

#### move

```json
{
  "action": "move",
  "Request": {
    "source": "sourceURL",
    "dest": "destURL"
  }
}
```

### delete

```json
{
  "action": "delete",
  "Request": {
    "source": "sourceURL"
  }
}
```

repository: viant/bqtail

gha_language: Go

repo_name: viant/bqtail


text:
# final_project_wanyingli

![](https://github.com/wanyinglixx/final_project_wanyingli/workflows/build/badge.svg) [![codecov](https://codecov.io/gh/wanyinglixx/final_project_wanyingli/branch/main/graph/badge.svg)](https://codecov.io/gh/wanyinglixx/final_project_wanyingli) ![Release](https://github.com/wanyinglixx/final_project_wanyingli/workflows/Release/badge.svg) [![Documentation Status](https://readthedocs.org/projects/final_project_wanyingli/badge/?version=latest)](https://final_project_wanyingli.readthedocs.io/en/latest/?badge=latest)

Hi! Welcome to use my package. This package allows you to search for the historical country lending projects from the World Bank and the Asian Development Bank (ADB).

Context of this package: The World Bank (WB) and Asian Development Bank (ADB) are the major sources for countries in the Asia & Pacific region to get lending from. However, each bank maintains its own lending database, which makes it difficult to understand the big picture of each country --- the integrated historical lending information from all lending sources. Therefore, this package allows users to look at the cumulative lending amount a country received from the major multilateral development banks by searching a specific country code and time period.

## Installation

```bash
$ pip install -i https://test.pypi.org/simple/ final_project_wanyingli
```

## Features

- TODO

## Dependencies

-Pandas
-json
-os
-requests
-numpy
-matplotlib
-pytest

## Usage

Below are some examples for the functions provided in the package.

1. Get a dataframe and print the cumulative WB project lending amount received by China from 2018-2019:
```bash
get_wb_countryyear('CN', 2018, 2019)
```

2. Get a dataframe and print the cumulative WB project lending amount with environmental cateory "B" from 2018-2019:
```bash
get_wb_environment('B', 2018, 2019)
```

3. Get a dataframe of all historical sovereign lending projects information since 2008:
```bash
get_adb_lending()
```

4. Get a dataframe and print the cumulative ADB lending amount received by China from 2018-2019:
```bash
get_adb_countryyear('CN', 2018, 2019)
```

5. Plot the top 10 receipient countries from the ADB since 2008:
```bash
plot_adb_top10()
```

## Documentation

The official documentation is hosted on Read the Docs: https://final_project_wanyingli.readthedocs.io/en/latest/

## Contributors

We welcome and recognize all contributions. You can see a list of current contributors in the [contributors tab](https://github.com/wanyinglixx/final_project_wanyingli/graphs/contributors).

### Credits

This package was created with Cookiecutter and the UBC-MDS/cookiecutter-ubc-mds project template, modified from the [pyOpenSci/cookiecutter-pyopensci](https://github.com/pyOpenSci/cookiecutter-pyopensci) project template and the [audreyr/cookiecutter-pypackage](https://github.com/audreyr/cookiecutter-pypackage).


text:
# Add Comment Bot

[![Downloads][npm-downloads]][npm-url] [![version][npm-version]][npm-url]
[![Build Status][travis-status]][travis-url]

A [Probot](https://probot.github.io) bot to perform label additions/removals based on specific github event actions.

## Setup

Add a `.github/label.yml` file to your repository and then run the bot against it.

If the config is empty or doesn't exist, the bot will not run.

```yml

# Config

issues:
  opened:
    add:
      - triage/untriaged
    remove:
      - needs-triage
pulls:
  opened:
    add:
      - needs-review
```

## Contribute

If you have suggestions for how this bot could be improved, or want to report a bug, open an issue! We'd love all and any contributions.

[travis-status]: https://travis-ci.org/lswith/probot-labeler.svg?branch=master
[travis-url]: https://travis-ci.org/lswith/probot-labeler
[npm-downloads]: https://img.shields.io/npm/dm/probot-labeler.svg?style=flat
[npm-version]: https://img.shields.io/npm/v/probot-labeler.svg?style=flat
[npm-url]: https://www.npmjs.com/package/probot-labeler

repository: mdelapenya/probot-labeler

repo_name: mdelapenya/probot-labeler


text:
# custom elements in react

To make a custom jsx element, one easy way is to wrap it as a single-function component:

```js
const React = require('react')

const MyTag = function (props) {
  return React.createElement(props.inline ? 'span' : 'div', props)
}

// then we can use it in jsx:

<div>
  <MyTag>This is rendered as a div</MyTag>
  <MyTag inline>This is rendererd as a span</MyTag>
</div>
```

I like the approach of declaring a react component as a set of custom meaningful elements. Eg.

```js
<Root>
  <MainImage />
  <Caption />
</Root>
```

is much better to work with than:

```js
<div className={'root'}>
  <img className={'main'} />
  <div className={'caption'} />
</div>
```

repository: joshwnj/knowledge

repo_name: joshwnj/knowledge


text:
# Code of Conduct

This project has adopted the Contributor Covenant code of conduct to clarify expected behavior in our community.

For more information, see the [Bonsai Foundation Code of Conduct](https://bonsai-rx.org/code-of-conduct).

repository: bonsai-rx/bonsai

branch_name: refs/heads/main

gha_language: C#

repo_name: bonsai-rx/bonsai


text:
# DSL-to-Python-prototype
A parser and a source code generator that uses Lark to create a DSL and then converts a given script written in that DSL to Python.

### Dependencies

* Lark

### Description

#### Grammar

A simple grammar is defined for a print statement and a loop in Python as follows:

```start : instruction+
   instruction : "print" STRING [STRING]  -> print
                | "repeat" NUMBER code_block  -> repeat

    code_block : "{" instruction+ "}"
    STRING:  LETTER+

    %import common.LETTER
    %import common.INT -> NUMBER
    %import common.WS
    %ignore WS
```

As we input the `repeat 9 print HelloWorld` to the script, it prints HelloWorld for the specified number of times.

#### Parsing and Code Generation

Given an input to the DSL, a parse tree is constructed using the `Lark` library and a corresponding code is generated in Python and stored in the 'output.py' file.

For example the previously mentioned example when given as an input to the program, it generates a file containing the code:
```
for i in range(9):
  print "Hello World"
```

repository: RavicharanN/DSL-to-Python-prototype

repo_name: RavicharanN/DSL-to-Python-prototype


text:
# FamilyDash

## Live Link
https://acd37-familydash.herokuapp.com

## Contributors
@acd37

## Technologiy Stack
* NodeJS, ExpressJS, ReactJS, Passport, Redux, Semantic-UI, NodeMailer

## About
* FamilyDash is a proprietary family dashboard & management system for home users.

## Using this Code
* Clone the repository to your desired location.
* `npm install`
* `npm run dev`

In order to use advanced functions such as YNAB budgeting, you will need your own developer API keys.

## License
* MIT

## Contact
#### Developer/Full-stack Web Software Developer
* Name: Alec Down (@acd37)
* Homepage: [alecdown.com](https://alecdown.com)
* e-mail<EMAIL_ADDRESS>* Twitter: @acdown87
* LinkedIn: https://www.linkedin.com/in/alecdown/

gha_language: JavaScript


text:
# wheelSpy #

A lightweight JavaScript parallax scroll library.

## How to use ##

### Basic Usage ###

You can create a new spy by calling

```js
var spy = wheelSpy.add(selector);
```

The following code will add an action to the spy in the specific frame range:

```js
spy.to(startFrame:number, endFrame:number, styles:object [, callback:function]);
```

Explanation of the parameters:

| Param         | Explanation                                           |
| ------------- | ----------------------------------------------------- |
| startFrame    | start frame in all scroll frames, from 0 to infinite  |
| endFrame      | end frame, from startFrame to infinite                |
| styles        | the expected styles for the element                   |
| callback      | callback with this progress percent                   |

Also you can chain together methods as many as you like:

```js
spy.to(0, 200, {
    left: 0,
    top: 0,
    width: 400,
    height: 400,
    'line-height': '400px'
}).to(250, 400, {
    left: '400px',
	top: '100%',
    width: 100,
    height: 100,
    'line-height': '100px',
}).to(400, 450, {
    opacity: 0
}, function(percent) {
	$('#info').text(percent);
});
```

Everytime `.to()` method is called, the total scroll frames will extend with the maximum of all end frames.

### Stop and Play ###

You can stop/play whellSpy by calling

```js
wheelSpy.stop();
wheelSpy.play();
````

which will stop/play all the spys.

### Scroll to frame ###

By calling

```js
wheelSpy.scrollTo(frame:number [, duration:number, callback:function]);
```

all spys will scroll to the frame you want.

### Debug ###

By calling

```js
wheelSpy.debug();
```

you will get a list of current spys info in console.

## Configuration ##

You can specific your wheelSpy config by calling

```js
wheelSpy.config(yourConfig:object)
```

Explanation of the config fields:

| Name          | Explanation                                           |
| ------------- | ----------------------------------------------------- |
| throttle      | event capture frequency, default is 16(ms)            |
| wheelSpeed    | a number config mouse wheel speed, default is 1       |
| touchSpeed    | a number config touch move speed, default is 1        |
| keyboardSpeed | a number config speed on keyboard press, default is 1 |
| useTweenLite  | whether use TweenLite or not, default is true         |

## Supported CSS Properties ##

- **box module**
	- width
	- height
	- margin
	- padding
	- border-width
	- line-height
- **positioning**
	- top
	- right
	- left
	- bottom
- **others**
	- opacity

CSS shorthand properties is also welcomed, eg:

```css
margin: 1px 2px 3px 4px;

/* Will be converted to */
margin-top: 1px;
margin-right: 2px;
margin-bottom: 3px;
margin-left: 4px;
```

## Supported CSS Units ##

- px
- em
- rem
- percentage

## License ##

MIT.

repository: idiotWu/wheelSpy

repo_name: idiotWu/wheelSpy


text:
---
layout: page
title: Establish Committee
permalink: /establish-committee/
---

**Establishing the Thesis Committee**

A master's thesis has a committee of minimum three members. The chair and at least one other member must be members of the Information Technology graduate faculty.

It is the responsibility of the student to assemble a committee of professors who have agreed to serve on the committee. The student's faculty advisor can assist the student in establishing the committee; however the advisor is not required to be a part of the committee.

The committee should be selected upon the basis of the members' knowledge of the subject of the thesis, the methodology that will be used, and their willingness to serve.

gha_language: CSS


text:
Normal Text

# heading 1

## Heading 2

_Italics_

**Strong/Bold**

~~10000~~ **999**

Links

[Visit website](https://learncodeonline.in "LCO")

Images

![LCO Mascot](https://learncodeonline.in/mascot.png "LCO")

Use `for` loop

```javascript

var name = "hitesh";

console.log(name);

```

Tables

| Table | Goes | Here  |

| ----- | ---- | ----- |

| one   | Two  | Three |

> Keep smiliing and work harder

---

1. List one

1. List Two

1. List three

   4.List four

- List four

---

repository: AH-Rifat/Handdirty

repo_name: AH-Rifat/Handdirty


text:
# README

This README would normally document whatever steps are necessary to get the
application up and running.

Things you may want to cover:

* Ruby version 2.3.1

# Tutoriels :
* http://railsforzombies.org/
* http://railspremierspas.humancoders.com/
* https://www.codecademy.com

# Workspace  Installation :

### rbenv :
ruby version manager
```
git clone https://github.com/rbenv/rbenv.git ~/.rbenv
```
Optionaly :
```
cd ~/.rbenv && src/configure && make -C src
```
then add to terminal profile (need to choose your shell profile):
```
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.(bash_profile|bashrc|zshrc)
echo 'export RUBYOPT="-KU"' >> ~/.(bash_profile|bashrc|zshrc)
echo 'eval "$(rbenv init -)"' >> ~/.(bash_profile|bashrc|zshrc)

```
add to rbenv install version helper :

```
git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build

```

run init to allow autocompletion :
```
~/.rbenv/bin/rbenv init
```

restart your terminal or source it

### ruby 2.3.1 :
due to rbenv and ruby-build :

```
rbenv install 2.3.1
```

to show all versions avaliable to install :
```
rbenv install -l
```

to set the newly install ruby version as default one :
```
rbenv global 2.3.1
```

### Packages pré-requis
```
sudo apt-get install curl git-core build-essential zlib1g-dev libssl-dev libreadline6-dev gem libyaml-dev libpq-dev libsqlite3-dev
```

### bundler :
gem manager for project : (no sudo required)
```
gem install bundler
```
this command may failed but will give you witch requirement missing like libsqlite3-dev and libpg-dev

# IDE and Text Editor Personally tested for ruby
* Sublime text (need to add multiple plugins)
* Rubymine

# Set up project

###install all gem of the current project :
due to bundler gem :
```
bundle install
```

### generate and add secret key base for puma :
copy for your local env :
```
cp config/_secrets.yml config/secrets.yml
```
execute twice to generate 2 keys :
```
rake secret
```
and replace the "here one" and "here two" with the two generated keys inside the previously copied config/secret.yml

* To be operationnal need to make a first migration (cf to database section)

# Usefull command line
### runtime :
use zeus and guard gem (Present in Gemfile and loaded with bundle install)
zeus is the runtime environment of this project
guard is a continous unitary test executor

to start zeus :
```
zeus start
```
to have the continous server :
```
zeus server
```
to have a terminal on the application (for database check, run script ...) :
```
zeus c
```
to lunch all test once :
```
zeus test
```
to have the continous test (execute only affected test while edit file) :
```
bundle exec guard
```

### database :
using the rake helper :

```
rake db:
```
* migrate
* rollback
* seed #add precreated element form the db/seeds.rb file
* drop
* setup
* reset # remove everithing need to migrate again and not create the base before
* create
* schema:load # seems to make : drop create migrate

all of this command must be prefixed to been applied on the test environnement with  :
```
RAILS_ENV=test
```


text:
{% include header.html %}

# Full Stack Software Engineer

## What You'll Be Doing

- Code in a variety of languages powering our microservices. You can check the FAQ for details about our stack and technologies used
- Design core components of our ad serving technology that can scale as our product does
- Design and implement services that can scale to million of RPM
- Develop, test and deploy our data analytics tools that collect hundred of million billions of events and visualize them in clever and innovative ways
- Build elegant, highly responsive front-end interfaces, and continuously optimize for the best user experience
- Design the architecture and choose the technologies to be used for new front-end apps
- Work in a team of talented hackers learning as much as you can and having fun while doing it

[Read the full job description](https://glispa.workable.com/j/983725C1AB){:target="_blank"}

## Recruitment Process

| Step | Description |
|---|---|
| CV review | We review candidates' CV applications looking mainly at past projects and areas of expertise. |
| [Assignment](../front-end/code-review-bidders/assignment.md) | Candidates receive an assignment based on real-life work we do at {{site.companyName}}. |
| [On-site interview](../back-end/code-review-exchange/on-site.md) | This part extends the work the candidate has done in the assignment. The candidate works with our team on designing and implementing a software system. |
| Offer | An offer is made to the candidate. |

repository: PeriGK/hiring

repo_name: PeriGK/hiring


text:
CogTom - a computational implementation of the Theory of Mind model.
The intent of this software program is to evaluate false belief tasks.

Directory structure:
\scenes - Scene description inputs
\input - handles environment inputs
\memory - simulation for Belief Memory, Affordances and Intentions
\model - Theory of Mind model modules
\output - utility classes and output logs
\query - query module for task evaluation


text:
# Configuration

When starting a project, you need to configure your application.

## Simple settings

For small program, you could use the default `settings` which is provided by `Prologue`.

```nim
import prologue

var app = newApp()
app.run()
```

You may want to specify settings by yourself. `Prologue` provides `newSettings` function to create a new settings. The program below creates a new settings with `debug = false`. This will disable the default logging.

```nim
import prologue

let settings = newSettings(debug = false)
var app = newApp(settings = settings)
app.run()
```

You can also read settings from `.env` file. `Prologue` provides `loadPrologueEnv` to read data from `.env` file. You can use `get` or `getOrDefault` to retrieve the value.

```nim
import prologue

let
  env = loadPrologueEnv(".env")
  settings = newSettings(appName = env.getOrDefault("appName", "Prologue"),
                         debug = false,
                         port = Port(env.getOrDefault("port", 8080))
    )

var app = newApp(settings = settings)
app.run()
```

## Config file

You need to specify a config file for a big project. `Prologue` provides `loadSettings` to read JSON file. You should give the path of the Json config file.

```nim
let settings = loadSettings(".config/config.debug.json")
var app = newApp(settings)
```

`.config/config.debug.json`

In config file, the `prologue` key must be present. The corresponding data will be used by framework. Among the corresponding data, the `secretKey` must be present and should not be empty. Otherwise, the program will raise exception. Other keys can be absent, they will be given a default value setting by `Prologue`.

Below is the type of settings:

```
address: string
port: int
debug: bool
reusePort: bool
appName: string
secretKey: string
bufSize: int
```

```json
{
  "prologue": {
    "address": "",
    "port": 8080,
    "debug": true,
    "reusePort": true,
    "appName": "",
    "secretKey": "Set by yourself",
    "bufSize": 40960
  },
  "name": "debug"
}
```

## Changing config file via environment variable

`Prologue` also supports automatically loading configure file by environment variables. The `.config` directory must be present in the current path(in the same directory as the main program). If you don't set the environment variable(namely `PROLOGUE`) or the value is `default`, the application will read `.config/config.json` file. Otherwise, if you set the `PROLOGUE` environment variable to `custom`, the application will read `.config/config.custom.json`. The common names includes `debug` and `production`. If the file doesn't exist, it will raise exception.

```nim
import prologue

var app = newAppQueryEnv()
app.run()
```

repository: planety/prologue

branch_name: refs/heads/devel

gha_language: Nim

repo_name: planety/prologue


text:
# Unsecured Transport Server

This section demonstrates the deployment of unsecured Transport Servers.

CIS VirtualServer CRD implements a full proxy architecture for virtual servers configured with a HTTP profile allowing Layer 7 load balancing and SSL processing. User may able to expose non-http traffic such as databases via CIS using Transport Server CRD.

## TCP Transport Server

* TCP mode is the default type of transport server.
* By deploying `tcp-transport-server.yaml` yaml file in your cluster, CIS will create a TCP Virtual Server on BIG-IP with VIP "<IP_ADDRESS>" and port "8544". It will forward traffic to specified pool.

### Health Monitor

This section demonstrates the option to configure health monitors for pools in a transport server of type TCP.
You can define the health monitors for each pool members as follows:

#### Single Health Monitor

Option which can be used to configure health monitor:

type `tcp` monitor
```
monitor:
    type:
    interval:
    timeout:
    targetPort:
```
* type and interval are required fields.

#### Multiple Health Monitors

You can also provide multiple health monitors for your TS CR as follows:
```
monitors:
-   type:
    targetPort:
    interval:
    timeout:
-   type:
    interval:
    timeout:
```
Note: **monitors** take priority over **monitor** if both are provided in TS spec.

#### Referencing existing BIG- IP health monitors

You can also create a health monitor in BIG IP and reference it in your TS Spec as follows:

* Using monitor in spec
```
monitor:
    name:
    reference:
```

* Using monitors in spec
```
monitors:
-   name:
    reference:
-   type:
    interval:
    targetPort:
    timeout:
-   type:
    interval:
    timeout:
```

## UDP Transport Server

* For UDP type transport servers, yaml spec should contain a `type` parameter. Refer `udp-transport-server.yaml` example for more details
* By deploying `udp-transport-server.yaml` yaml file in your cluster, CIS will create a UDP Virtual Server on BIG-IP with VIP "<IP_ADDRESS>" and port "8444". It will forward traffic to specified pool.

## SCTP Transport Server

* For SCTP type transport servers, yaml spec should contain a `type` parameter. Refer `sctp-transport-server.yaml` example for more details
* By deploying `sctp-transport-server.yaml` yaml file in your cluster, CIS will create a SCTP Virtual Server on BIG-IP with VIP "<IP_ADDRESS>" and port "30102". It will forward traffic to specified pool.


text:
# babel-plugin-transform-class-properties

> This plugin transforms es2015 static class properties as well as properties declared with the es2016 property initializer syntax.

## Example

Below is a class with four class properties which will be transformed.

```js
  class Bork {
    //Property initializer syntax
    instanceProperty = "bork";
    boundFunction = () => {
      return this.instanceProperty;
    }

    //Static class properties
    static staticProperty = "babelIsCool";
    static staticFunction = function() {
      return Bork.staticProperty;
    }
  }

  let myBork = new Bork;

  //Property initializers are not on the prototype.
  console.log(myBork.prototype.boundFunction); // > undefined

  //Bound functions are bound to the class instance.
  console.log(myBork.boundFunction.call(undefined)); // > "bork"

  //Static function exists on the class.
  console.log(Bork.staticFunction()); // > "babelIsCool"
```

## Installation

```sh
npm install --save-dev babel-plugin-transform-class-properties
```

## Usage

### Via `.babelrc` (Recommended)

**.babelrc**

```json
// without options
{
  "plugins": ["transform-class-properties"]
}

// with options
{
  "plugins": [
    ["transform-class-properties", { "spec": true }]
  ]
}
```

### Via CLI

```sh
babel --plugins transform-class-properties script.js
```

### Via Node API

```javascript
require("babel-core").transform("code", {
  plugins: ["transform-class-properties"]
});
```

## Options

### `spec`

`boolean`, defaults to `false`.

Class properties are compiled to use `Object.defineProperty`. Static fields are now defined even if they are not initialized.

## References

* [Proposal: ES Class Fields & Static Properties](https://github.com/jeffmo/es-class-static-properties-and-fields)

gha_language: HTML


text:
# Home Assistant Community Add-on: WireGuard

[![Release][release-shield]][release] ![Project Stage][project-stage-shield] ![Project Maintenance][maintenance-shield]

[![Discord][discord-shield]][discord] [![Community Forum][forum-shield]][forum]

[![Sponsor Frenck via GitHub Sponsors][github-sponsors-shield]][github-sponsors]

[![Support Frenck on Patreon][patreon-shield]][patreon]

WireGuard: fast, modern, secure VPN tunnel.

## About

[WireGuard®][wireguard] is an extremely simple yet fast and modern VPN that
utilizes state-of-the-art cryptography. It aims to be faster, simpler, leaner,
and more useful than IPsec, while avoiding the massive headache.

It intends to be considerably more performant than OpenVPN. WireGuard is
designed as a general-purpose VPN for running on embedded interfaces and
supercomputers alike, fit for many different circumstances.

Initially released for the Linux kernel, it is now cross-platform (Windows,
macOS, BSD, iOS, Android) and widely deployable,
including via an Hass.io add-on!

WireGuard is currently under heavy development, but already it might be
regarded as the most secure, easiest to use, and the simplest VPN solution
in the industry.

[discord-shield]: https://img.shields.io/discord/478094546522079232.svg
[discord]: https://discord.me/hassioaddons
[forum-shield]: https://img.shields.io/badge/community-forum-brightgreen.svg
[forum]: https://community.home-assistant.io/t/home-assistant-community-add-on-wireguard/134662?u=frenck
[github-sponsors-shield]: https://frenck.dev/wp-content/uploads/2019/12/github_sponsor.png
[github-sponsors]: https://github.com/sponsors/frenck
[maintenance-shield]: https://img.shields.io/maintenance/yes/2023.svg
[patreon-shield]: https://frenck.dev/wp-content/uploads/2019/12/patreon.png
[patreon]: https://www.patreon.com/frenck
[project-stage-shield]: https://img.shields.io/badge/project%20stage-experimental-yellow.svg
[release-shield]: https://img.shields.io/badge/version-v0.8.1-blue.svg
[release]: https://github.com/hassio-addons/addon-wireguard/tree/v0.8.1
[wireguard]: https://www.wireguard.com

repository: hassio-addons/repository

gha_language: Jinja

repo_name: hassio-addons/repository


text:
# ebayKleinanzeigenAlert - (ebAlert)
Small CLI program that will send you a Telegram message for every new posts on the specific links of the Ebay Kleinanzeigen website.

No API required - Only URL of the query.

## Install
* Download folder or clone
* cd yourself to the main directory
* create a telegram bot -> https://core.telegram.org/bots
* Hard code your telegram API key and messageID in the telegramclass.py file.
* Install or run straight from the directory.
  * install with ````pip install .  ````
  * run with ````python -m ebAlert ````

## Usage & Example
* ```ebAlert links [opts] ``` to show, add, remove links
* ```ebAlert links --help ``` to get list of options for the links

* ```ebAlert start``` to start receiving notification

* ```ebAlert links -a "https://www.ebay...k0l9354r20"```  This assumes that you just had a look through the web page already, so no notification will be send.
* Typically, this would be run as a cron job on an hourly basis.

## Requirements
* A telegram bot API token and your personal conversation id
* Python 3
* click, requests, bs4 and sqlalchemy (arguably sqlalchemy is a little overkill for that purpose)

## Future Plans

* add functionality to add links directly via telegram.

## Development Branch

** dev_telegram **
* Bot data stored in the database
* Multibot allowed
* Possibilite to choice towards which bot goes which notification
* Docker