text:
# Contributing

Contributions to KeystoneJS in the form of issues and PRs are welcomed.

Contributions which improve the documentation and test coverage are particularly welcomed.

### Community Ecosystem

Keystone makes no assumptions about type of applications it powers. It achieves flexibility through small, highly composable parts that allow you to build a foundation for any type of application.

For this reason we might not add features to Keystone if they are prescriptive about:

- Data structures
- Workflows
- Access controls
- Front-end application UI

But we want your contributions! We recognise many types of applications share common features and prescriptive patterns can sometimes be helpful, even at the expense of flexibility.

If you develop custom fields, adapters, apps or any other Keystone feature, (or have an idea) join us on the [Keystone Slack channel](https://launchpass.com/keystonejs) or make a pull request to [KeystoneJS-Contrib](https://github.com/keystonejs-contrib/keystonejs-contrib) and we will add it to our list of community libraries.

## Code of Conduct

KeystoneJS adheres to the [Contributor Covenant Code of Conduct](code-of-conduct.md).

## Repository Setup

KeystoneJS follows the [Thinkmill Monorepo Style Guide](https://github.com/Thinkmill/monorepo). For more information on the reasoning behind using certain tooling, please refer to it.

### Version management

Keystone uses @noviny's [@changesets/cli](https://github.com/noviny/changesets) to track package versions and publish packages.
This tool allows each PR to indicate which packages need a version bump along with a changelog snippet.
This information is then collated when performing a release to update package versions and `CHANGELOG.md` files.

#### What all contributors need to do

- Make your changes (as per usual)
- Before you make a Pull Request, run the `yarn changeset` command and answer the questions that are asked. It will want to know:
  - which packages you want to publish
  - what version you are releasing them at
  - a message to summarise the changes (this message will be written to the changelog of bumped packages)
- Before you accept the changeset, it will display all the data that will be written to the changeset. If this looks fine, agree, and a changeset will be generated in the `.changeset` directory.

After this, a new changeset will be added which is a markdown file with YAML front matter.

```
-| .changeset/
-|-| UNIQUE_ID.md
```

The message you typed can be found in the markdown file. If you want to expand on it, you can write as much markdown as you want, which will all be added to the changelog on publish. If you want to add more packages or change the bump types of any packages, that's also fine.

While not every changeset is going to need a huge amount of detail, a good idea of what should be in a changeset is:

- WHAT the change is
- WHY the change was made
- HOW a consumer should update their code

An example, if you generate a changeset that includes `adapter-mongoose` as a patch, and `keystone` as a minor, you can merge your PR, and the next time the `version-packages` command is run, these will both be updated.

```md
---
'@keystonejs/adapter-mongoose': patch
'@keystonejs/keystone': minor
---

A very useful description of the changes should be here.
```

You can have multiple changesets in a single PR. This will give you more granular changelogs, and is encouraged.

#### Changeset guidelines

We’re sometimes lovingly picky on the wording of our changesets because these end up in changelogs that people like you read. We want to try to get a consistent tone of voice while providing useful information to the reader.

In particular, please try to write in the past tense (e.g. "Added a new feature" rather than "Add a new feature") and write in complete sentences. This means proper capitalisation and punctuation, including full stops/periods at the end of sentences. We try to be terse when possible but if needed it's fine to write multiple lines including examples for changing APIs.

Thanks for your help with this.

### Release Guidelines

#### How to do a release

> This should only ever be done by a very short list of core contributors

Releasing is a two-step process. The first step updates the packages, and the second step publishes updated packages to npm.

##### Update Packages (automatic)

This step is handled for us by the Changesets GitHub Action. As PRs are opened
against `master`, the bot will open and update a PR which generates the
appropriate `CHANGELOG.md` entries and `package.json` version bumps.

Once ready for a release, merge the bot's PR into `master`.

> _NOTE: For information on manually updating packages, see [Update Packages
> (manual)](#update-packages-manual)_

##### Publish Packages

Once the version changes are merged back in to master, to do a manual release:

```sh
yarn fresh && \
yarn publish-changed && \
git push --tags
```

The `yarn publish-changed` command finds packages where the version listed in the `package.json` is ahead of the version published on npm, and attempts to publish just those packages.

NOTE: There is no reason you should ever manually edit the version in the `package.json`

##### Update Packages (manual)

If you wish to do a manual release (useful for back-porting fixes), follow these
steps. Otherwise, skip on to the next section for _Publishing Packages_.

The first step is `yarn version-packages`. This will find all changesets that have been created since the last release, and update the version in package.json as specified in those changesets, flattening out multiple bumps to a single package into a single version update.

The `yarn version-packages` command will generate a release commit, which will bump all versions, necessary dependency version changes, and update changelog.mds.

Finally, make sure you've got the latest of everything locally

```sh
git checkout master && \
git pull && \
yarn
```

#### A quick note on changelogs

The release process will automatically generate and update a `CHANGELOG.md` file, however this does not need to be the only way this file is modified. The changelogs are deliberately static assets so past changelogs can be updated or expanded upon.

In addition, content added above the last released version will automatically be appended to the next release. If your changes do not fit comfortably within the summary of a changelog, we encourage you to add a more detailed account directly into the `CHANGELOG.md`.

#### Backporting Fixes

Occasionally a bug goes undetected for a few versions. When a fix is discovered,
it may need to be applied to all affected versions (depending on the
severity, security considerations, etc). This is called _backporting_.

First, find out the oldest version which was affected. This can be done using
`git blame`, browsing the `CHANGELOG.md`s, etc.

Once we know which version introduced the bug, walk forward through the
`CHANGELOG.md` noting all the _minor_ and _major_ releases made since.

> Example: If a bug was introduced in `14.0.0`, but not discovered until after
> `15.1.1` was released, the list of _minor_ and _major_ releases may look like:
>
> - `14.0.x`
> - `14.1.x`
> - `15.0.x`
> - `15.1.x`

We're going to do a backport and release for the HEAD of every _minor_ and
_major_ release, ignoring any interim patch releases.

> Example: These may be the releases we'd backport to:
>
> - ❌ `14.0.0`
> - ✅ `14.0.1`
> - ✅ `14.1.0`
> - ❌ `15.0.0`
> - ❌ `15.0.1`
> - ✅ `15.0.2`
> - ✅ `15.1.0`

Now, for each release we want to backport to, we follow this process:

1. Checkout the tag of the release

   Let's say the package being patched is `@keystonejs/keystone`, then we
   want to run:

   ```sh
   git checkout -b backport-keystone-14.0.1<EMAIL_ADDRESS>   ```

2. Cherry pick the commit across.

   Fix any merge conflicts that might arise.

   NOTE: Make sure the changeset is either regenerated or edited to accurately
   relfect the change to the one package you're bumping, otherwise weirdness
   will happen.

   ```sh
   git cherry-pick abc123123
   ```

3. Bump package versions

   ```sh
   yarn fresh --prefer-offline && \
   yarn build && \
   yarn version-packages && \
   yarn format && \
   git add . && \
   git commit -m "Backport fix"
   ```

4. Do _NOT_ open a PR

   This change is not going to be PR'd into master. Instead we'll later push
   the tag which contains the commits.

   To confirm everything is as expected, look at the git log:

   ```sh
   git log -p
   ```

5. Publish the newly version bumped package

   Note we can't use changesets to do this special publish as it doesn't handle backports.

   ```sh
   (\
   export PACKAGE_NAME=@keystonejs/keystone && \
   export OTP_CODE= && \
   cd packages/keystone && \
   yarn publish --tag=backport --otp=$OTP_CODE && \
   export BACKPORTED_VERSION=`npm dist-tag ls $PACKAGE_NAME | grep 'backport' | sed -e 's/backport: //'` && \
   yarn tag remove $PACKAGE_NAME backport --otp=$OTP_CODE && \
   git tag -a "$PACKAGE_NAME@$BACKPORTED_VERSION" -m "$PACKAGE_NAME@$BACKPORTED_VERSION"
   git push --tags \
   )
   ```

     <!-- this was the cd command but we don't have a command to replace the exact bolt part yet    cd `bolt ws $PACKAGE_NAME exec -- pwd | grep pwd | sed -e 's/.*pwd[ ]*//'` && \ w
   -->

   _NOTE: When prompted for "New version", just hit Enter_

6. Confirm it was published

   ```sh
   npm show <PACKAGE_NAME> versions
   ```

### Build Process

Some of the packages in keystone-5 need to compiled before they're published, we use [preconstruct](https://github.com/preconstruct/preconstruct) to do this.

Preconstruct reads from the `packages.json` preconstruct field for configuration, in keystone-5 all we need to do is set the packages that we need to build. Preconstruct reads all of the packages specified in the packages and checks the `main` and `module` fields and generates compiled versions. Preconstruct under the hood uses rollup to bundle all of the modules together which means people can't expose and interact with the modules (e.g. to change internals that could change in a patch version), it's also results in smaller builds because rollup is better at tree shaking than webpack. Preconstruct also uses babel and reads from the babel config in the repo to compile the code, there is one important babel plugin that Preconstruct adds which is `@babel/plugin-transform-runtime` which tells babel to import the helpers that it uses in generated code from a certain place rather than duplicating them in each package.

Preconstruct can generate a couple different types of modules, in keystone-5, we build esm and commonjs modules.

ESM bundles are built for newer bundlers like parcel, rollup and newer versions of webpack which understand ES modules and can build more optimised bundles from them than they can with commonjs.

We also build commonjs builds to run in node (for testing with jest or etc.) and for bundlers which don't understand esm. Preconstruct generates three files for commonjs, a production, development and a file to import those modules. The production one compiles out `process.env.NODE_ENV !== 'production'` checks which are common in front end libraries but `process.env.NODE_ENV` is expensive to check in node if it happens very often.

## Contributors

Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

<!--  ALL-CONTRIBUTORS-LIST:END -->

This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

```

```


text:
---
title: "receivedNotifyMessage"
description: "Message ID, for which PUSH-notifications were cancelled."
nav_exclude: true
image: https://docs.madelineproto.xyz/favicons/android-chrome-256x256.png
---
# Constructor: receivedNotifyMessage
[Back to constructors index](/API_docs/constructors/index.html)

Message ID, for which PUSH-notifications were cancelled.

### Attributes:

| Name     |    Type       | Required | Description |
|----------|---------------|----------|-------------|
|id|[int](/API_docs/types/int.html) | Yes|Message ID, for which PUSH-notifications were canceled|

### Type: [ReceivedNotifyMessage](/API_docs/types/ReceivedNotifyMessage.html)

### Example:

```
$receivedNotifyMessage = ['_' => 'receivedNotifyMessage', 'id' => int];
```

license: MIT

repository: danog/MadelineProtoDocs

branch_name: refs/heads/master

extension: md

gha_language: PHP

license_type: permissive

repo_name: danog/MadelineProtoDocs


text:
# Welcome! Thank you for contributing to Akka!

We follow the standard GitHub [fork & pull](https://help.github.com/articles/using-pull-requests/#fork--pull) approach to pull requests. Just fork the official repo, develop in a branch, and submit a PR!

You're always welcome to submit your PR straight away and start the discussion (without reading the rest of this wonderful doc, or the README.md). The goal of these notes is to make your experience contributing to Akka as smooth and pleasant as possible. We're happy to guide you through the process once you've submitted your PR.

# The Akka Community

In case of questions about the contribution process or for discussion of specific issues please visit the [akka/dev gitter chat](https://gitter.im/akka/dev).

You may also check out these [other resources](https://akka.io/get-involved/).

# Reconcile state

In most cases you can make a change to the playbook and run `pulumi up` to reconcile with the target.
If you made manual changes in your target you can attempt to reconcile the target state with local state by calling `pulumi refresh`.
This is useful during development so you can test changes. If your changes create an incorrect or broken state you can manually clean up the cluster and then reconcile state without reprovisioning everything.

# Update Dependencies

Use `npm-check-updates`.

```bash
npm i -g npm-check-updates
```

Update `package.json`:

```bash
ncu -u
npm install
```

repository: seglo/akka-cloud-platform-deploy

repo_name: seglo/akka-cloud-platform-deploy


text:
# Authentication
When a site owner installs your app, they will grant you permission to collect their site data during the installation flow, which is based on the settings you provide in the Wix Developers Center. You will then receive an authorization code which you will use to request an access token and a refresh token. Then you’ll pass the access token as an authorization header in the API call.
> **Note:**
> Access and refresh tokens are user-specific. [Access tokens](https://dev.wix.com/api/rest/authorization/oauth-2/refresh-an-access-token) are valid for 5 minutes. Refresh tokens are valid as long as the app is installed on the user's site.

> **Note:**
> In certain installation flows, Wix will load your app and redirect URLs in an iframe.
> Make sure your content can be loaded on an iframe. For example, make sure you don't send the header 'X-FRAME-OPTIONS'

# The OAuth Flow
We use [OAuth 2.0](https://tools.ietf.org/html/rfc6749) to authorize you to access our APIs and receive webhooks.
> **Note:**
> You’ll need to [set up OAuth, Permissions, and Webhooks settings](https://devforum.wix.com/en/article/setting-up-oauth-permissions-and-webhooks-in-the-wix-developers-center) in the Wix Developers Center.

![oauth flow diagram](../media/oauth-diagram.png)

## Step 1: User Installs Your App
When the user chooses to install your app from within the Wix App Market, we redirect users to the App URL you defined in the Wix Developers Center. We include a `token` query parameter when we direct users to your App URL (we use it to keep track of the user as they go through the OAuth flow).
> **Note:**
> This redirect to the App URL is a back-end process only. The user shouldn't have to log in or sign up here - send them straight to the authorization request step described next.

    Important:

    When the user installs your app from your own platform, skip this step and go straight to step 2.
    The user can choose whether to install from the Wix App Market or your platform, but your app must support both flows.

## Step 2: App Sends Users to Authorize the App
Your app should redirect users to the URL below so that we can ask them to approve a list of permissions your app is requesting (based on the [permissions](https://dev.wix.com/api/getting-started#permissions) you added in the Wix Developers Center).

Redirect users to the following URL:
`https://www.wix.com/installer/install`

Send the following query parameters with the URL above:
- `token` (*required during installation from Wix only*): The token you received as a query parameter to the App URL. We use it to keep track of users as they go through the OAuth flow.
- `appId`: Your App ID, as defined in the Wix Developers Center.
- `redirectUrl`: One of the redirect URLs you defined in the Wix Developers Center. You may define a separate redirect URL for each workflow (e.g., from the App Market and from your platform).
- `state` (*optional*): You can add a unique string to identify users that were authenticated in the previous step. This is how you'll identify the user when we send them to your redirect URL.

    Important:

    Every redirect URL your app might use must be defined in the Wix Developers Center in advance.

## Step 2a: User Authorizes the App
When the user approves the permissions your app has requested, Wix will continue to the next step.

## Step 3: Wix Redirects the User to App Server With an Authorization Code
Wix will redirect the user back to your specified `redirectUrl` along the following query parameters:
* `code` - A temporary authorization code, valid for up to 10 minutes. You’ll need this to request an access token to use our API.
* `state` - The same value in case you provided one in the previous step. If the states don't match, the request may have been created by a third party and you should abort the process.
* `instanceId` - The unique ID created for your app installation in the user specific site. All of your app’s components in the site share the same [instance ID](https://devforum.wix.com/en/article/identifying-your-users). Your app should always identify users using the instance ID.

    Important:

    If your app requires user login or signup - do so here.

     Note:

After this step, the user is done. However, your app still has some work to do.

## Step 4: App Submits the Authorization Code
Once the user completes the installation process and gives your app permission to access their data, use the temporary authorization code we sent you, together with your secret key, to request an access token and a refresh token. (The access token is only valid for 5 minutes.)

> You can find your secret key in the [Wix Developers Center](https://dev.wix.com).

> **Deprecation:** We updated the OAuth endpoint URL in the code below. If you're still using the old URL, then you'll need to change this by December 1st, 2022.

    Important:

    This request must be a secure, server-to-server request.

Exchange the temporary authorization code for an access token using the [OAuth > Access Token Request](https://dev.wix.com/api/rest/authorization/oauth-2/request-an-access-token) API method:

```
curl -X POST \
  https://www.wixapis.com/oauth/access \
  -H 'Content-Type: application/json' \
  -d '{
    "grant_type": "authorization_code",
    "client_id": <APP_ID>,
    "client_secret": <APP_SECRET>,
    "code": <AUTH_CODE>
  }
```

## Step 5: App Receives Access and Refresh Tokens
Wix will respond to your request in step 4 with a JSON response containing an access token and a refresh token (These tokens are not relevant for webhooks):
```
{
   "refresh_token": <REFRESH_TOKEN>,
   "access_token": <FRESH_ACCESS_TOKEN>
}
```
> **Note:**
> Request a new access token every time you call an API.
> Access tokens expire after 5 minutes. Use your refresh token to request a new access token.

## Step 5a: App Completes the OAuth Flow

> **Note:**
>This step is only required for apps that display their consent in a new window, not a new tab. This is primarily for apps with a dashboard component that opens inside of Wix as an iframe, or another internal component.

![how does your consent appear](./../media/how-does-your-consent.png)

Now that you have access and refresh tokens, you must close the consent window by redirecting the user to the following URL with the user's access token after the equals sign (`=`):

```
https://www.wix.com/installer/close-window?access_token=<ACCESS_TOKEN>
```

## Step 6: App Requests Protected Data
Follow our [API Reference](https://dev.wix.com/api/rest/app-management) section to request the user's protected data, with a fresh access token as the authorization header.

> **Important**:
For all future API calls, you will need to [request a new access token](https://dev.wix.com/api/rest/authorization/oauth-2/refresh-an-access-token), using the refresh token you received in step 5.

## Step 7: App Finishes Installation

At this point your app is designated “**Setup Incomplete**”. This state is useful if your app requires users to create an account or set other configuration parameters in order for the app to become active.

Once your app requires no further setup steps, create the following request to mark the installation as finished:

```
curl -X POST \
 https://www.wixapis.com/apps/v1/bi-event \
 -H 'Authorization: <AUTH>' \
 -d '{
   	"eventName": "APP_FINISHED_CONFIGURATION"
  	}’
\
```

>**Note:**
>Until the endpoint is called, the app is marked as "Setup Incomplete" in the Wix database.

![note to complete setup](./../media/auth-step7.png)

repository: wix-incubator/wix-rest-docs

gha_license_id: MIT

repo_name: wix-incubator/wix-rest-docs


text:
# Password Generator

## Description
This repository is for creating a password generator. This is for the 3rd homework assignment in my web development class. This password generator can create a randomly generated password from 8-128 characters long. The user has the ability to select what character types to include. If the user does not select any types of characters they will recieve a message to indicate the error. User can continue to generate random passwords. user can copy the generated password.

## Images
Starting View:

![Starting View](./assets/start-view.png)

Password Generation Example:

![Password Generation Example](./assets/password-example.png)

Error Message Example:

![Error Message Example](./assets/error-message.png)

## Installation
If all files are kept in a single folder a web browser should be able to run the project and you have an internet connection.

## Usage
The usage of this is just for me to practice HTML, CSS, and javascript. It could be used to generate random passwords.

## Credits
I created this code based on the homework prompt created by Triology Education Services. Certain pieces of code I used online resources for help. I have included citations in the form of comments throughout the html and javascript.

## Contributing
I was the only one to work on this project, but of course I had help from my instructor, TA's, and classmates.

## Challenges
Early on I tried creating an array that included the names of each character array. I was hoping I could use this array to select each array at random. Turns out you can't use strings to as variable names due to the way Javascrit works. I think this could have been possible by creating an object that contained the arrays, but since we haven't done a deep dive on objects yet, I decided to figure out how to complete the assignment without using functionality of objects. I quickly realized my strategy included copy pasting my code multiple times to achieve my end result. I am well aware that my code is not even close to D.R.Y. and a combonation of functions and using objects could probably make it more dry, but I ran out of time to simplify the code.

## Live site:
https://sirpotatoiv.github.io/password-generator/

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: SirPotatoIV/password-generator

repo_name: SirPotatoIV/password-generator


text:
# myrl
Implementations of some standard reinforcement learning algorithms

- Written in pytorch
- All implentations are encapsulated into a single file
- Algorithms implemted as classes which take OpenAI gym env as inputs
- All classes have uniform interface with `train` and `eval` methods
- All references are given in the code

Algorithms -
- [X] Vanilla Policy Gradient (VPG)
- [X] Deep Q Network (DQN)
- [X] Deep Deterministic Policy Gradient (DDPG)
- [X] Twin Delayed DDPG (TD3)
- [X] Soft Actor Critic
- [X] Proximal Policy Optimization
- [ ] Trust Region Policy Optimization

Features to add -
- [ ] Better hyperparamter management
- [ ] Adding tensorboard logging
- [ ] Add documentation for each algorithm
- [ ] Add results for each algorithm

repository: threewisemonkeys-as/myrl

repo_name: threewisemonkeys-as/myrl


text:
## Nugz-Firefighers

A simple whitelisted job for firefighters written in Typescript/Javascript for the QBCore Framework.  Modify and extend for any other whitelisted job as desired.

### Usage
1.  Clone repository into a local folder
2.  Open a command prompt, browse to the folder, then `npm install`
3.  Modify as desired (See `config.ts` for configuation options)

### While Developing

Use `npm run watch` to build the project on the fly while you are modifying.  Watch the output for warnings and errors.

### Putting into Production

1. Use `npm run build`.  This will build the client/server files and put them in the `dist/` directory.
2.  Upload the `fxmanifest.lua` file and `dist` folder into the `nugz-firefighters` directory
4. Add `start nugz-firefighters` to your resources.cfg file
5. Enjoy!

### Build Automatically (Optional, Not Recommended)

Due to the length of time it takes for the server to build the project with webpack/yarn, it's advised to NOT build this server side, but instead follow the instructions in 'Putting into Production' above.  However, if you'd rather:

1. `git clone` this repository into your `resources/folder-of-your-choice/nugz-firefighters`
2. cd into that directory and run `npm install`
3. Modify the `fxmanifest.lua` file and add:

```lua
dependency 'yarn'
dependency 'webpack'

webpack_config 'webpack.config.js'
```
4. Configure how you'd like `config.ts`
5. Restart your server

### Credits

- [FiveM TS Boilerplate](https://github.com/d0p3t/fivem-ts-boilerplate)
- [NativeUI in Javascript (Typescript Compatible)](https://github.com/PichotM/FiveM-NativeUI)
- [QBCore Framework](https://github.com/qbcore-framework)

### License

This resource is MIT licensed.  Please make sure you give proper credits and include this license.

repository: BoubonicNugz/nugz-firefighters

repo_name: BoubonicNugz/nugz-firefighters


text:
---
layout: post
title: historic melbourne rail map
date: 2017-11-03 10:30:00
description: what if none of the railways had closed?
comments: true
redirect_to: "https://maps.philipmallis.com/historical-melbourne-rail-map/"
---
{% include map_header.html %}

This time I am trying something a little bit different - a historical map of Melbourne's railway lines.

The map shows what the city's heavy rail network would look like today if no railways had ever been closed down.

I should add that this map is not an exercise in wishful thinking or network proposals. It is purely something fun with which to play around and a visual representation of an interesting thought experiment.

### The Map

Fans of geographic maps - rejoice! Unlike most of my previous projects, this one is geographically accurate rather than schematic.

I took the map that I recently made for Wikipedia showing the current railway lines in Melbourne and added in all closed and former railways that existed throughout the history of Melbourne. Obviously there is a little historical license that is further explained in the notes below.

When I began work on this, it seemed relatively straightforward. However, because of the close proximity of many railway stations and lines, trying to fit everything while keeping the map legible was challenging. The data required to trace the former railways was also quite patchy.

Looking at the completed map is pretty interesting. There are some obvious differences with entirely new lines in operation (e.g. the Outer Circle) but also some small changes that might not be entirely obvious at first.

#### Added rail lines

Outer Circle Line

Inner Circle Line (including Fitzroy North branch)

Port Melbourne Line

St Kilda Line

Kew Line

Mornington Line

Red Hill Line

Warburton Line

Healesville Line

South Gippsland Line

Queenscliff Line

Extension of Werribee Line to Werribee Racecourse

Extension of South Morang Line to Whittlesea

#### Added stations (excluding new lines)

Werribee Racecourse Station

Galvin

Paisley

Mobiltown

Lyndhurst

General Motors

#### Operations
One consideration with making this map was how some former lines would operate. For example, were the Healesville and Warburton Lines still in existence, would they be run by Metro or V/Line?

This is more of a judgement call on my part than any sort of historical revisionism. In the case of Healesville/Warburton, I decided to make them V/Line-operated. I figure that there would be a small Sprinter or 2-3 carriage train shuttling back and forth between the two termini and Lilydale.

The Mornington and Red Hill Lines would be operated in the same manner as the Stony Point Line; that is with a train hired by Metro from V/Line.

Whittlesea didn't seem to make much sense to operate separately given its isolation from the network and relatively proximity to Melbourne. Besides, being in the countryside hasn't stopped the Hurstbridge Line from being operated with suburban trains.

As I said above, these were pure judgement calls on my part. Happy to hear alternative proposals and suggestions. This is a fictional scenario after all.

#### Some other important notes

I have only included passenger railways.

Railway stations are named for what they were called at the time of their closure.

There are two or three parts of the map that were impossible to make without screwing with some of the design rules, particularly with station labels. See the area around Hawthorn and Rushall for examples.

I am aware that there was another East Camberwell Station just south of the present site on the Outer Circle Line. This is not included for practical space reasons, as well as the fact that it had the same name as the present station.

Some of the ticketing zones have changed slightly from their present-day boundaries. I have made these changes based on the fact that with some of these railway lines in existence, the current zones would make no sense. For example, at the southern end of the Outer Circle Line, the present-day Alamein Line located entirely in Zone 1, would intersect with the Zone 1+2 overlap on the Glen Waverley Line. As a consequence, I have pushed the overlap out two stations on the Glen Waverley Line to begin at Holmesglen rather than Darling.

Small branches in operation for very short periods of time, such as the St Kilda - Windsor branch, have not been included.

Yes, the railway station was spelled 'Queenscliff' without an 'e'.

### Data
The data showing all current and former railways and railway stations was surprisingly difficult to find. There were several good datasets but none were totally comprehensive. In the end, I used a combination of:

DEDTJR datasets from data.vic.gov.au

OpenStreetMap data from Overpass.eu

Wikipedia articles on closed lines and stations

### Future development

Not being someone very well versed in historic railways, I have probably made a couple of errors. If you find anything that is missing or needs improvement, please do not hesitate to let me know.

UPDATE 2017-11-04: thanks once again to the feedback from Reddit and rail Facebook groups, I have made a number of additions of railways and stations that I missed in v1.0:

Added Gembrook Line (Puffing Billy)

Added Springvale Cemetery branch

Added Williamstown Racecourse Station

Added Williamstown Pier Station

Added White City Station

Added V/Line track from Werribee

Added Upfield to Somerton track

Added Altona Beach Station

Added Hatherley Station

Fixed spelling of 'Traralgon'

Added Manor Station

Added Botanical Gardens Station

Added Campbellfield Station

I hope to also work on three further projects out of this map:

A Victoria-wide geographic map showing all current and former railways;

A schematic version of the Melbourne map; and

A schematic version of the Victoria map.

Judging from my initial attempt on the Victoria-wide maps a few days ago that crashed Illustrator, this could take a while.

extension: markdown


text:
# note-taker

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
## Description
An app to help save notes.

## Table of Contents

* [Installation](#installation)
* [Usage](#usage)
* [Credits](#credits)
* [License](#license)

## Features

This app has the ability to get, save, and delete notes on a server

## Installation

Requires node and the ability to use npm install to pull down the node dependencies.

## Contact Me

By<EMAIL_ADDRESS>or by [Github](https://github.com/leot42).

## Usage

To use run the command "npm start" within the project directory.

## License

The MIT License

branch_name: refs/heads/main


text:
# -Caesar-Cipher

* This program was created using Java .
#### Author
* Ken Kibet

### Description
* This program uses a command line interface to encrypt or decrypt words using an appropriate key which is a number.
* The action of a Caesar cipher is to replace each plaintext letter with a different one a fixed number of places down the alphabet

## Prerequisites & setup
#### Prerequisites
* Git.
* Java
* Intellij
* Gradle

#### Set up
* clone the repo into your computer by running `git clone https://github.com/kenkibet/-Caesar-Cipher` on your terminal.
* run the command `gradle build`
* navigate into the build\classes/java/main/ directory created using the command `cd build\classes/java/main/`.
* run the command `java Main`.

* Or open in intellij and click run

|example|input| output
|----|----|------
|encrypt => word: 'ken', key: 1|String=>word, Integer=>key|String:'lfo'
|decrypt => word: 'lfo', key: 1|String=>word, Integer=>key|String:'ken'
|encrypt => word: 'kibet', key: 2|String=>word, Integer=>key|String:'mkdgv'
|decrypt => word: 'mkdgv', key: 2|String=>word, Integer=>key|String:'kibet'

### How to use
* Enter the word you would like to encrypt.
* Type number '1' to encrypt.
* Enter a number to use as the key for the encryption.
* Type number '2' to decrypt.
* Type the word to be decrypted.
* Enter the number to be used as the key for decryption.
* To exit type number '3'.

#### Known Bugs
* In case of of any bugs found please contact using the information below.

#### Contact Information
* email -<EMAIL_ADDRESS>
## Copyright and license.
* (c) 2021 Ken Kibet Moringa School.
* MIT License.

repository: Kenkibet/-Caesar-Cipher

gha_language: Java

repo_name: Kenkibet/-Caesar-Cipher


text:
# Nodobryoria oregana (Tuck.) Common & Brodo SPECIES

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Bryologist 98(2): 198 (1995)

#### Original name
Alectoria oregana Tuck.

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
number: 476
title: Browser CSS Page Transitions API aka Shared Element Transitions
date:<PHONE_NUMBER>110
url: https://traffic.libsyn.com/secure/syntax/Syntax_-_476.mp3
---

In this Hasty Treat, Scott and Wes talk about the new Browser CSS Page Transitions API proposal and what features it opens up for developers on the web.

## Prismic - Sponsor

Prismic is a Headless CMS that makes it easy to build website pages as a set of components. Break pages into sections of components using React, Vue, or whatever you like. Make corresponding Slices in Prismic. Start building pages dynamically in minutes. Get started at [prismic.io/syntax](https://prismic.io/syntax).

## LogRocket - Sponsor

LogRocket lets you replay what users do on your site, helping you reproduce bugs and fix issues faster. It's an exception tracker, a session re-player and a performance monitor. Get 14 days free at [logrocket.com/syntax](https://logrocket.com/syntax).

## Show Notes

* WICG [Shared Element Transitions](https://github.com/WICG/shared-element-transitions/)

* **[00:21](#t=00:21)** Welcome
* **[01:33](#t=01:33)** Sponsor: Prismic
* **[02:43](#t=02:43)** Sponsor: LogRocket
* **[04:18](#t=04:18)** Browser animations on the web vs native apps
* **[06:15](#t=06:15)** What is the targeted use case for it?
* **[06:56](#t=06:56)** Shared Element to Root Transitions
* **[11:14](#t=11:14)** Entry and Exit
* **[17:33](#t=17:33)** How to enable this in Chrome
* [Example Code](https://github.com/WICG/shared-element-transitions/tree/main/sample-code)
* [Shared Element Transition history](https://css-tricks.com/shared-element-transitions/#aa-weird-history)
* [Sarah Drasner’s demo](https://twitter.com/sarah_edo/status/988414671232339970)

```
async function doTransition() {
  let transition = document.createDocumentTransition();

  // Specify offered elements. The tag below is used to refer
  // to the generated pseudo elemends in script/CSS.
  document.querySelector(".old-message").style.pageTransitionTag = "message";

  // The start() call triggers an async operation to capture
  // snapshots for the offered elements,
  await transition.start(async () => {
    // This callback is invoked by the browser when the capture
    // finishes and the DOM can be switched to the new state.
    // No frames are rendered until this callback returns.

    // Asynchronously load the new page.
    await coolFramework.changeTheDOMToPageB();

    // Clear the old message if that element is still in the page
    document.querySelector(".old-message").style.pageTransitionTag = "";
    // Set new message as the shared element 'message'
    document.querySelector(".new-message").style.pageTransitionTag = "message";

    // Set up animations using WA-API on the next frame.
    requestAnimationFrame(() => {
      document.documentElement.animate(keyframes, {
      ...animationOptions,
      pseudoElement: "::page-transition-container(message)",
      });
    });

    // Note that when this callback finishes, the animations will start with the tagged elements.
  });
}
```

## Tweet us your tasty treats

* [Scott's Instagram](https://www.instagram.com/stolinski/)
* [LevelUpTutorials Instagram](https://www.instagram.com/LevelUpTutorials/)
* [Wes' Instagram](https://www.instagram.com/wesbos/)
* [Wes' Twitter](https://twitter.com/wesbos)
* [Wes' Facebook](https://www.facebook.com/wesbos.developer)
* [Scott's Twitter](https://twitter.com/stolinski)
* Make sure to include [@SyntaxFM](https://twitter.com/SyntaxFM) in your tweets

repository: barrymcgee/Syntax

path: /shows/476 - Hasty browser.md

filename: 476 - Hasty browser.md

gha_language: JavaScript

repo_name: barrymcgee/Syntax


text:
I'd like to share with you a discovery that I made a few months ago
while writing an article for Italian Wired.
I always keep my thesaurus handy whenever I'm writing anything,
but I'd already finished editing the piece,
and I realized that I had never once in my life
looked up the word "disabled" to see what I'd find.

Antonyms, healthy, strong, capable."
I was reading this list out loud to a friend and at first was laughing,
it was so ludicrous,
but I'd just gotten past "mangled," and my voice broke,
and I had to stop and collect myself
from the emotional shock and impact that the assault from these words unleashed.
You know, of course, this is my raggedy old thesaurus
so I'm thinking this must be an ancient print date, right?
But, in fact, the print date was the early 1980s,
when I would have been starting primary school
and forming an understanding of myself outside the family unit
and as related to the other kids and the world around me.
And, needless to say, thank God I wasn't using a thesaurus back then.
I mean, from this entry, it would seem that I was born into a world
that perceived someone like me
to have nothing positive whatsoever going for them,
when in fact, today I'm celebrated for the opportunities and adventures
my life has procured.
So, I immediately went to look up the 2009 online edition,
expecting to find a revision worth noting.
Here's the updated version of this entry.
Unfortunately, it's not much better.

I find the last two words under "Near Antonyms," particularly unsettling:
"whole" and "wholesome."
So, it's not just about the words.
It's what we believe about people when we name them with these words.
It's about the values behind the words, and how we construct those values.
Our language affects our thinking and how we view the world
and how we view other people.
In fact, many ancient societies, including the Greeks and the Romans,
believed that to utter a curse verbally was so powerful,
because to say the thing out loud brought it into existence.

So, what reality do we want to call into existence:
a person who is limited, or a person who's empowered?
By casually doing something as simple as naming a person, a child,
we might be putting lids and casting shadows on their power.
Wouldn't we want to open doors for them instead?
One such person who opened doors for me was my childhood doctor
at the A.I. duPont Institute in Wilmington, Delaware.
His name was Dr. Pizzutillo,
an Italian American, whose name, apparently,
was too difficult for most Americans to pronounce,
so he went by Dr. P.
And Dr. P always wore really colorful bow ties
and had the very perfect disposition to work with children.

I had to do what seemed like innumerable repetitions of exercises
with these thick, elastic bands -- different colors,
you know -- to help build up my leg muscles,
and I hated these bands more than anything --
I hated them, had names for them. I hated them.
And, you know, I was already bargaining, as a five year-old child,
with Dr. P to try to get out of doing these exercises,
unsuccessfully, of course.
And, one day, he came in to my session --
exhaustive and unforgiving, these sessions --
and he said to me, "Wow.
When you do break it, I'm going to give you a hundred bucks."
Now, of course, this was a simple ploy on Dr. P's part
to get me to do the exercises I didn't want to do
before the prospect of being the richest five-year-old in the second floor ward,
but what he effectively did for me was reshape an awful daily occurrence
into a new and promising experience for me.
And I have to wonder today to what extent his vision
and his declaration of me as a strong and powerful little girl
shaped my own view of myself
as an inherently strong, powerful and athletic person well into the future.
This is an example of how adults in positions of power
can ignite the power of a child.
But, in the previous instances of those thesaurus entries,
our language isn't allowing us to evolve into the reality that we would all want,
the possibility of an individual to see themselves as capable.
Our language hasn't caught up with the changes in our society,
many of which have been brought about by technology.
Certainly, from a medical standpoint,
my legs, laser surgery for vision impairment,
titanium knees and hip replacements for aging bodies
that are allowing people to more fully engage with their abilities,
and move beyond the limits that nature has imposed on them --
not to mention social networking platforms
allow people to self-identify, to claim their own descriptions of themselves,
so they can go align with global groups of their own choosing.
So, perhaps technology is revealing more clearly to us now

what has always been a truth:
that everyone has something rare and powerful to offer our society,
and that the human ability to adapt is our greatest asset.
The human ability to adapt, it's an interesting thing,
because people have continually wanted to talk to me about overcoming adversity,

and I'm going to make an admission:
This phrase never sat right with me,
and I always felt uneasy trying to answer people's questions about it,
and I think I'm starting to figure out why.
Implicit in this phrase of "overcoming adversity"
is the idea that success, or happiness,
is about emerging on the other side of a challenging experience
unscathed or unmarked by the experience,
as if my successes in life have come about from an ability
to sidestep or circumnavigate the presumed pitfalls of a life with prosthetics,
or what other people perceive as my disability.
But, in fact, we are changed. We are marked, of course, by a challenge,
whether physically, emotionally or both.
And I'm going to suggest that this is a good thing.
Adversity isn't an obstacle that we need to get around
in order to resume living our life.
It's part of our life.
And I tend to think of it like my shadow.
Sometimes I see a lot of it, sometimes there's very little,
but it's always with me.
And, certainly, I'm not trying to diminish the impact, the weight, of a person's struggle.
There is adversity and challenge in life,
and it's all very real and relative to every single person,
but the question isn't whether or not you're going to meet adversity,
but how you're going to meet it.
So, our responsibility is not simply shielding those we care for from adversity,
but preparing them to meet it well.
And we do a disservice to our kids
when we make them feel that they're not equipped to adapt.
There's an important difference and distinction
between the objective medical fact of my being an amputee
and the subjective societal opinion of whether or not I'm disabled.
And, truthfully, the only real and consistent disability I've had to confront
is the world ever thinking that I could be described by those definitions.
In our desire to protect those we care about
by giving them the cold, hard truth about their medical prognosis,
or, indeed, a prognosis on the expected quality of their life,
we have to make sure that we don't put the first brick in a wall
that will actually disable someone.
Perhaps the existing model of only looking at what is broken in you
and how do we fix it, serves to be more disabling to the individual
than the pathology itself.
By not treating the wholeness of a person,
by not acknowledging their potency,
we are creating another ill on top of whatever natural struggle they might have.
We are effectively grading someone's worth to our community.
So we need to see through the pathology
and into the range of human capability.
And, most importantly, there's a partnership
between those perceived deficiencies
and our greatest creative ability.
So it's not about devaluing, or negating, these more trying times
as something we want to avoid or sweep under the rug,
but instead to find those opportunities wrapped in the adversity.
So maybe the idea I want to put out there is
not so much overcoming adversity
as it is opening ourselves up to it,
embracing it,
grappling with it,
to use a wrestling term,
maybe even dancing with it.
And, perhaps, if we see adversity as natural, consistent and useful,
we're less burdened by the presence of it.
This year we celebrate the 200th birthday of Charles Darwin,
and it was 150 years ago, when writing about evolution,
that Darwin illustrated, I think, a truth about the human character.

To paraphrase: It's not the strongest of the species that survives,
nor is it the most intelligent that survives;
it is the one that is most adaptable to change.
Conflict is the genesis of creation.
From Darwin's work, amongst others, we can recognize that
the human ability to survive and flourish
is driven by the struggle of the human spirit through conflict
into transformation.
So, again, transformation, adaptation, is our greatest human skill.
And, perhaps, until we're tested, we don't know what we're made of.

Maybe that's what adversity gives us:
a sense of self, a sense of our own power.
So, we can give ourselves a gift.
We can re-imagine adversity as something more than just tough times.
Maybe we can see it as change.
Adversity is just change that we haven't adapted ourselves to yet.
I think the greatest adversity that we've created for ourselves
is this idea of normalcy.
Now, who's normal?
There's no normal.
There's common, there's typical. There's no normal,
and would you want to meet that poor, beige person if they existed?

(Laughter)

I don't think so.
If we can change this paradigm from one of achieving normalcy
to one of possibility -- or potency, to be even a little bit more dangerous --
we can release the power of so many more children,
and invite them to engage their rare and valuable abilities with the community.
Anthropologists tell us that the one thing
we as humans have always required of our community members
is to be of use, to be able to contribute.
There's evidence that Neanderthals, 60,000 years ago,
carried their elderly and those with serious physical injury,
and perhaps it's because the life experience of survival of these people
proved of value to the community.
They didn't view these people as broken and useless;
they were seen as rare and valuable.
A few years ago, I was in a food market in the town where I grew up
in that red zone in northeastern Pennsylvania,
and I was standing over a bushel of tomatoes.

It was summertime: I had shorts on.
I hear this guy, his voice behind me say, "Well, if it isn't Aimee Mullins."
And I turn around, and it's this older man. I have no idea who he is.
And I said, "I'm sorry, sir, have we met? I don't remember meeting you."
He said, "Well, you wouldn't remember meeting me.
I mean, when we met I was delivering you from your mother's womb."

(Laughter)

Oh, that guy.
And, but of course, actually, it did click.
This man was Dr. Kean,
a man that I had only known about through my mother's stories of that day,
because, of course, typical fashion, I arrived late for my birthday by two weeks.
And so my mother's prenatal physician had gone on vacation,
so the man who delivered me was a complete stranger to my parents.
And, because I was born without the fibula bones,
and had feet turned in, and a few toes in this foot and a few toes in that,
he had to be the bearer -- this stranger had to be the bearer of bad news.
He said to me, "I had to give this prognosis to your parents
that you would never walk,
and you would never have the kind of mobility that other kids have
or any kind of life of independence,
and you've been making liar out of me ever since."

(Laughter)

(Applause)

The extraordinary thing is that he said he had saved
newspaper clippings throughout my whole childhood,
whether winning a second grade spelling bee,
marching with the Girl Scouts, you know, the Halloween parade,
winning my college scholarship, or any of my sports victories,
and he was using it, and integrating it into teaching resident students,
med students from Hahnemann Medical School and Hershey Medical School.
And he called this part of the course the X Factor,
the potential of the human will.
No prognosis can account for how powerful this could be
as a determinant in the quality of someone's life.
And Dr. Kean went on to tell me,
he said, "In my experience, unless repeatedly told otherwise,
and even if given a modicum of support,
if left to their own devices, a child will achieve."
See, Dr. Kean made that shift in thinking.
He understood that there's a difference between the medical condition
and what someone might do with it.
And there's been a shift in my thinking over time,
in that, if you had asked me at 15 years old,
if I would have traded prosthetics for flesh-and-bone legs,
I wouldn't have hesitated for a second.
I aspired to that kind of normalcy back then.
But if you ask me today, I'm not so sure.
And it's because of the experiences I've had with them,
not in spite of the experiences I've had with them.
And perhaps this shift in me has happened
because I've been exposed to more people who have opened doors for me
than those who have put lids and cast shadows on me.
See, all you really need is one person
to show you the epiphany of your own power, and you're off.
If you can hand somebody the key to their own power --
the human spirit is so receptive -- if you can do that
and open a door for someone at a crucial moment,
you are educating them in the best sense.
You're teaching them to open doors for themselves.
In fact, the exact meaning of the word "educate"
comes from the root word "educe."
It means "to bring forth what is within,
to bring out potential."
So again, which potential do we want to bring out?
There was a case study done in 1960s Britain,
when they were moving from grammar schools to comprehensive schools.
It's called the streaming trials. We call it "tracking" here in the States.
It's separating students from A, B, C, D and so on.
And the "A students" get the tougher curriculum, the best teachers, etc.
Well, they took, over a three-month period,
D-level students, gave them A's,
told them they were "A's," told them they were bright,
and at the end of this three-month period,
they were performing at A-level.
And, of course, the heartbreaking, flip side of this study,
is that they took the "A students" and told them they were "D's."
And that's what happened at the end of that three-month period.
Those who were still around in school, besides the people who had dropped out.
A crucial part of this case study was that the teachers were duped too.
The teachers didn't know a switch had been made.
They were simply told, "These are the 'A-students,' these are the 'D-students.'"
And that's how they went about teaching them and treating them.
So, I think that the only true disability is a crushed spirit,
a spirit that's been crushed doesn't have hope,
it doesn't see beauty,
it no longer has our natural, childlike curiosity
and our innate ability to imagine.
If instead, we can bolster a human spirit to keep hope,
to see beauty in themselves and others,
to be curious and imaginative,
then we are truly using our power well.
When a spirit has those qualities, we are able to create new realities
and new ways of being.
I'd like to leave you with a poem
by a fourteenth-century Persian poet named Hafiz
that my friend, Jacques Dembois told me about,

and the poem is called "The God Who Only Knows Four Words":
"Every child has known God,
not the God of names,
not the God of don'ts,
but the God who only knows four words and keeps repeating them,
saying, 'Come dance with me.
Come, dance with me. Come, dance with me.'"
Thank you.

(Applause)

repository: prewittdavon/TEDVis

gha_language: Python

repo_name: prewittdavon/TEDVis


text:
Vuex ORM Plugin: Axios

    <img<EMAIL_ADDRESS>alt="License">

Vuex ORM Axios plugin adds smooth integration between API requests and [Vuex ORM](https://github.com/vuex-orm/vuex-orm) data persistence through the awesome [axios](https://github.com/axios/axios).

```js
User.api().get('/api/users')
```

## Sponsors

Vuex ORM is sponsored by awesome folks. Big love to all of them from the whole Vuex ORM community :two_hearts:

### Super Love Sponsors

#### Big Love Sponsors

#### A Love Sponsors

## Documentation

You can check out the full documentation for Vuex ORM Axios at https://vuex-orm.github.io/plugin-axios.

## Questions & Discussions

Join us on our [Slack Channel](https://join.slack.com/t/vuex-orm/shared_invite/enQtNDQ0NjE3NTgyOTY2LTc1YTI2N2FjMGRlNGNmMzBkMGZlMmYxOTgzYzkzZDM2OTQ3OGExZDRkN2FmMGQ1MGJlOWM1NjU0MmRiN2VhYzQ) for any questions and discussions.

Although there is the Slack Channel, do not hesitate to open an [issue](https://github.com/vuex-orm/vuex-orm/issues) for any question you might have. We're always more than happy to hear any feedback, and we don't care what kind of form they are.

## Quick Start

Here's a quick start guide to demonstrate how Vuex ORM Axios can be integrated effortlessly.

### Install and Setup Vuex ORM Axios

Install Vuex ORM Axios with npm or yarn. Note that the Vuex ORM Axios requires [axios](https://github.com/axios/axios) to be installed, so don't forget to install it too!

```bash
$ npm install axios @vuex-orm/core @vuex-orm/plugin-axios
# OR
$ yarn add axios @vuex-orm/core @vuex-orm/plugin-axios
```

To register Vuex ORM Axios with Vuex ORM, pass Vuex ORM Axios to the `VuexORM.use` method. Here, you should pass your axios instance as an option.

```js
import axios from 'axios'
import VuexORM from '@vuex-orm/core'
import VuexORMAxios from '@vuex-orm/plugin-axios'

VuexORM.use(VuexORMAxios, { axios })
```

### Usage

After setting up Vuex ORM Axios, you may use `Model.api` method to perform API calls.

```js
User.api().get('/api/users')
```

Vuex ORM Axios can perform all basic Axios requests, which is `get`, `post`, `put`, `patch`, `delete`, and `request`. These methods take the same arguments as Axios and perform exactly as same as Axios, except it's going to store response data to the store corresponding to the `Model` that is calling the API.

Vuex ORM Axios lets you define [Custom Actions](https://vuex-orm.github.io/plugin-axios/guide/custom-actions) too.

```js
import { Model } from '@vuex-orm/core'

export default class User extends Model {
  static entity = 'users'

  static fields () {
    return {
      id: this.attr(null),
      name: this.attr('')
    }
  }

  static apiConfig = {
    actions: {
      fetch: {
        method: 'get',
        url: '/api/users'
      }
    }
  }
}
```

And then, you can use the defined `fetch` method through your model.

```js
User.api().fetch()
```

Ready to learn more about the plugin? Let's [jump right into it](https://vuex-orm.github.io/plugin-axios).

## Plugins

Vuex ORM can be extended via plugins to add additional features. Here is a list of available plugins.

- [Vuex ORM GraphQL](https://github.com/vuex-orm/plugin-graphql) – The plugin to sync the store against a [GraphQL](https://graphql.org) API.
- [Vuex ORM Search](https://github.com/vuex-orm/plugin-search) – The plugin adds a search() method to filter records using fuzzy search logic from the [Fuse.js](http://fusejs.io).
- [Vuex ORM Change Flags](https://github.com/vuex-orm/plugin-change-flags) - Vuex ORM plugin for adding IsDirty / IsNew flags to model entities.
- [Vuex ORM Soft Delete](https://github.com/vuex-orm/plugin-soft-delete) – Vuex ORM plugin for adding soft delete feature to model entities.

## Contribution

We are excited that you are interested in contributing to Vuex ORM Axios! Anything from raising an issue, submitting an idea of a new feature, or making a pull request is welcome!

### Development

```bash
$ yarn build
```

Compile files and generate bundles in `dist` directory.

```bash
$ yarn lint
```

Lint files using a rule of Standard JS.

```bash
$ yarn test
```

Run the test using [Jest](https://jestjs.io/).

```bash
$ yarn test:watch
```

Run the test in watch mode.

```bash
$ yarn coverage
```

Generate test coverage in `coverage` directory.

## License

The Vuex ORM Plugin Axios is open-sourced software licensed under the [MIT license](LICENSE.md).

repository: Thomasbayy/plugin-axios

repo_name: Thomasbayy/plugin-axios


text:
# Chapter 5 Resources

This contains a set of reference links related to the content presented in the chapter. I added this file to the code repo to give readers of the print book quick access to sites with supporting content.

+ [Amazon Web Services: AppSync](https://aws.amazon.com/appsync/)
+ [Couchbase](https://www.couchbase.com/)
+ [Firebase Cloud Firestore](https://firebase.google.com/products/firestore/)
+ [Firebase Realtime Database](https://firebase.google.com/products/realtime-database/)
+ [MDN IndexedDB API](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API)
+ [Live Data in the Service Worker](https://developers.google.com/web/ilt/pwa/live-data-in-the-service-worker)
+ [Offline Storage for Progressive Web Apps](https://developers.google.com/web/fundamentals/instant-and-offline/web-storage/offline-for-pwa)
+ [IndexedDB Stores](https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore)
+ [SweetAlert2](https://sweetalert2.github.io/)
+ [Chrome, the Background Sync API and exponential backoff](https://notes.eellson.com/2018/02/11/chrome-the-background-sync-api-and-exponential-backoff/)

repository: dmitrymailk/pwa

repo_name: dmitrymailk/pwa


text:
---
layout: page
title: Responsabilities
permalink: /responsabilities/
---
I am the curricula co-director and co-responsible (with Romain Gandia) of the IAE Savoie Mont Blanc University School of Management Master Degree in *Computer Science and Enterprise Management* (in french *[Master Informatique et Management d'Entreprise - IME](https://formations-iae.univ-smb.fr/fr/toute-l-offre-de-formation/master-XB/master-management-KGYPN5A6//informatique-et-management-d-entreprise-KGYUCXOL.html)*) (from 2021 to present).

I was vice-dean (directeur adjoint) of the [IAE Savoie Mont Blanc University School of Management](http://www.iae.univ-savoie.fr/) (from 2013 to 2018).

I led the Master in _Management, Information Technology and Innovation_ (from 2004 to 2013 and from 2016 to 2017).

I was a member of the IAE Mont Blanc staff direction committee as permanent staff (from 2004 to 2019).

I was the head of the IAE - Technology and Management Dept (from Sept. 2008 to 2013). I was also the IAE Management and Information Systems MS. degree's manager - students may follow one of the two academia curricula: one is centred on _Management and Information Technology (MTI)_  (information system engineering) and the second is centred on the _Management and Development of Manufacturing Systems (MDI)_ (especially industrial engineering). I am also responsible of several student internships.

I am a member of the Universite Savoie Mont Blanc Information System's governance board (COSSI)

I am a member of the executive and governing board of IAE Savoie Mont Blanc.

I am also a member of the LISTIC's informatics commission.

I am a member of the Université Savoie Mont Blanc employment commission (CNU section 27 as permanent staff from 2012\.

I am and was a member of the Université Savoie Mont Blanc employment commission (CNU sections 27/61 as permanent staff and CNU section 05 as substitute - from 2005 to 2009 when such commissions desappear).

I was the IUP GSI Scholar Program Manager covering three years (students from the Bachelor to the last year of the professional MS degree) from 2004 to 2005 and the Information System Bachelor degree manager/responsible from 2001 to 2004\. _Note: IUP GSI has disapeared and has been transformed in the IMUS Tech. and Management Dept. and is now IAE Savoie Mont-BLanc - Technology and Management Dept_.

I was member of the Technical Committee and Executive Committee of the University of Savoie Information System Direction (DSI) from 2003 to 2004.

gha_language: SCSS


text:
![tenancy logo](https://avatars3.githubusercontent.com/u/33319474?s=50&v=4)

This is the successor of [hyn/multi-tenant](https://github.com/hyn/multi-tenant). It is still
in development. Feel free to show support by starring the project
following progress via [twitter](https://twitter.com/laraveltenancy) and
backing its development over at [OpenCollective](https://opencollective.com/tenancy).

[![CircleCI](https://circleci.com/gh/tenancy/framework.svg?style=svg)](https://circleci.com/gh/tenancy/framework)

# Roadmap 2018

- Finish the tenancy/tenancy package with all necessary contracts and bare logic.
- Create tenant identification drivers that replicate the logic of the predecessor (eg hostname based identification).
- Create mysql (including mariadb) and postgres database drivers.
- Enforce a code coverage of at least 90%.


text:
### python-api-challenge

# Observations

1. We see declining max temperatures at latitudes 20 and up.

  ![max temps](/output_data/lat_max_temp.png)

2. In the Northern Hemisphere, humidity seems to increase as you head towards north.

  ![northern humidity](/output_data/north_lat_humidity_lr.png).

3.In the Southern Hemisphere, humidity slightly increases as you approach the equator.

  ![southern humidity](/output_data/south_lat_humidity_lr.png)

## Combined heatmap

  ![heat map](/output_data/combined_map.png)


text:
---
title: "7 actions that will humanize your brand"
date: "2019-01-16T16:24:04.000Z"
template: blog
tags: Small Business
image: "./media/humanize-your-brand.jpg"
---

**Humanize your brand**. If we have to choose the 10 commandments for brands this year, this would be number one.

A human face and feel, make that potential customers connect with brands because they feel related.

This is more than a trend, it is a commandment because humanizing your brand you will be able to catch, convert, and get loyal people. Sells are implicit. Actually, we include this element to the [trends for 2019 on social media](https://cobuildlab.com/blog/social-media-trends-for-2019/).

<title-2>What is humanizing a brand?</title-2>

Humanizing a brand is getting It more human, tell stories and show the whole people that are behind the brand or people who are related to the brand.

Humanizing a brand is a work that you should do in every digital platform that you have. We mean, on your website, your social media accounts, emails, etc.

Every day you should do It, and following the next pieces of advice you Will do It successfully.

<title-3>1. Tell many stories; authentic stories</title-3>

In your feed, in your Instagram stories, in Facebook stories, in every web platform you have, and if you accompany that story with an image or a video the result will be even better.

Stories about what? All it will depend on your brand qualities and your customers’ profile.

If you have a personal brand you could say what you learn in a day, which alliances you are doing now, what is your favorite food and why. This kind of information is appropriate for sharing in social media and web platforms.

If you have a corporate brand, a story that you could share is in what is working your team, stories behind your employees, team achievements, even jokes, team meetings. If you are brave enough you could share these things (failures, hardships, and lessons) that are not so good and also happen in your daily teamwork.

“According to Psychological Science, research suggests that shared pain may have positive social consequences; shared pain acts as a “social glue” to promote solidarity and togetherness between groups.”

[Newstime](https://www.newstimes.com/news/article/5-Things-You-Can-Do-to-Humanize-Your-Brand-13514289.php)

Your followers will love this kind of content, actually, they could feel identified because they are human and all of these things also happen to them. This will not only humanize your brand, but also it will boost sales.

<title-3>2. Let your clients know how important they are</title-3>

Humanize a brand is also possible if you give to your clients a specialized and personal treatment. What does it mean? Well, call them by his or her name, personalized messages and offers, bring them personalized gifts, attending the customers’ requirements immediately, making suggestions, offering special discounts, and talking person by person with them.

Also, you can make events, send emails, and every action to give them a personalized treatment.

That will give to your brand a human feeling.

In that way, clients will be more than a client, they will be a fan of your brand. They will be loyal to your brand and ambassadors of her.

An example of that is the next: “Buffer thanked one of its stand-out customers with not only company swag, but a personalized gift”.

[Newstime](https://www.newstimes.com/news/article/5-Things-You-Can-Do-to-Humanize-Your-Brand-13514289.php)

This was the answer:

![humanize-your-brand](media/humanize-your-brand1.png)
Source: [Open.Buffer](https://open.buffer.com/community-delight/)

<youtube-video id="AiCwm8Gf-ts"></youtube-video>

<title-3>3. Share all content that your clients generate</title-3>

When we say all content, we mean to the whole content related to your brand. Experiences that will make more human and authentic your brand.

It is more than a review. It could be a comment on your website, a publication in their social media account, and every publication they make about their experience using your product or before enjoy your service.

Even you can share comments or private chats where they are thanking you or making a good comment.

A good place for sharing this is the stories in social media platform. Potential customers will see these experiences and they will be attracted to have your product or service to feel the same.

“What your user says is the best publicity for every brand in the world.”

Especially on the internet.

“Instead of being asked to blindly trust a company’s claims, consumers will see real-life people falling in love with your products, which will promote trust in your brand”.

![starbucks](media/starbucks1.jpg)

<title-3>4. Show your team members as much as you can</title-3>

Even if you offer a product, your users could be eager to know the people is behind than the same product.

Bigger brands in the world do it and they have gotten an amazing result with this technique.

This example of Starbucks sums it up well.

![starbucks](media/starbucks2.jpg)

Is not necessary that the information you bring has been about the work. It could be about their life. But don’t get confused. It is necessary that you tell the employees’ story related to their work and your brand.

The employee of the month, a story about what makes that staffer so great, and that is the kind of content that your client would love in your website and social media account.

<title-3>5. Shows a funny side of your brand</title-3>

Some laughs always are good and when it's about relationships between brands and customers it is good too.

Scientists from urku PET Centre, Oxford and Aalto universities discovered that when people have social laugh leads to an endorphin release in the brain and that helps to establish social bonds. So, if laugh improves social connections you can take advantage of them and use them in favor to your brand.

You don’t have to be a comedian, with share popular, viral, and funny content is enough.

But remember, this funny content should be related to your product or service. At least with a characteristic of your brand.

This is a good example of this.

![netflix](media/netflix.jpg)

![netflix](media/netflix2.jpg)

Netflix is the best brand to understand it.

<title-3>6. Interact fast and directly through your social media accounts</title-3>

Interactions are the best weapon for humanizing a brand. If a person answer all questions, comments, and suggestions fastly and as a human, these clients will feel confident and they will know that behind the brand there are nice people.

Use emoticons, be polite and kind. That will give a good impression.

<title-3>7. Share a balance between personal information and commercial information</title-3>

Nowadays, the big influencers and brands tell to their followers, clients, and community personal quotes, phrase, culture, and information that alone could be not interesting, but in a web platform and accompanies with commercial information will be a condiment.

We propose a percent of 40% of personal content, and 60% of commercial content. But be. Commercial content indirect. Or how we say, content that sells without sell. Be as creative as you can!

From now, be the best friend of your clients and make them loyal to you. Humanizing your brand It will happen. If you want more tips and actions to achieve the goal of **humanize your brand**, communicate with us, and we can do it faster together.

repository: cobuildlab/cobuildlab-web

repo_name: cobuildlab/cobuildlab-web


text:
###Bitwise AND of Numbers Range
URL: https://leetcode.com/problems/bitwise-and-of-numbers-range/</br>
Given a range [m, n] where 0 <= m <= n <=<PHONE_NUMBER>, return the bitwise AND of all numbers in this range, inclusive.

For example, given the range [5, 7], you should return 4.

__Code:__

	/*
	    Idea:
	    1) we know when a number add one, some of the right bit changes from 0 to 1 or  from 1 to 0
	    2) if a bit is 0, then AND will cause this bit to 0 eventually.
	    So, we can just simply check how many left bits are same for m and n.

	    for example:
	        5 is 101
	        6 is 110
	        when 5 adds 1, then the right two bits are changed.  the result is 100

	        6 is 110
	        7 is 111
	        when 6 adds 1, then the right one bit is changed. the result is 110.

	         9 is 1001
	        10 is 1010
	        11 is 1011
	        12 is 1100
	        Comparing from 9 to 12, we can see the first left bit is same, that's result.
	*/
	int rangeBitwiseAnd(int m, int n) {
	    int mask = 0xffffffff;

	    /* find out the same bits in left side*/
	    while (mask != 0) {
	        if ((m & mask) == (n & mask)) {
	            break;
	        }
	        mask <<= 1;
	    }

	    return m & mask;

	}

repository: wuzhiyi/leetcode

repo_name: wuzhiyi/leetcode


text:
---
title: Environment Configuration
layout: framework_docs
objective: Add environment variables to your Rails applications, configure secrets, and use the encrypted `credentials.yml` file to manage your application's configuration on Fly.
order: 4
---

Rails applications are usually configured via the encrypted `credentials.yml` file or via environmental variables.

## Environmental variables

Environment variables are a great way to configure a Rails application that needs to run in multiple environments.

### Secret variables

Environment variables that have sensitive data in them, like a `DATABASE_URL` that contains a password, can be kept in a secret that can't be viewed except when the container is running.

To set a secret in Fly, run:

```cmd
fly secrets set SUPER_SECRET_KEY=password1234
```

### Non-sensitive variables

Variables that don't have sensitive data can be set in the `fly.toml` file under the `[env]` directive. An example file might look like:

```toml
[env]
  RAILS_LOG_TO_STDOUT = x
```

### View the variables

To view the environment variables of your Fly Rails app, run:

```cmd
fly ssh console -C "printenv"
```

There you'll see all of the environment variables in your application that have been set by `fly secrets`, the `[env]` directive in the `fly.toml` file, and the `environment` directive from your Dockerfile.

## Encrypted credentials file

Another approach to managing credentials in Rails is to use an encrypted credentials file, such as `config/credentials.yml.enc` or `config/credentials/production.yml.enc`, which you can learn more about by running the following from the root of your Rails application:

```cmd
bin/rails credentials:help
```

When deploying to production, the `RAILS_MASTER_KEY` that will decrypt the credentials file can be set via `fly secrets set`. For example, if your master key is stored in `config/master.key`, you can run:

```cmd
fly secrets set RAILS_MASTER_KEY=$(cat config/master.key)
```

For Windows/PowerShell:

```powershell
$Env:RAILS_MASTER_KEY = Get-Content 'config\master.key'
```

repository: superfly/docs

gha_language: HTML

repo_name: superfly/docs


text:
---
layout: post
category : voxel
tagline: "or not..."
tags : [voxel, graphics, sparse, octree, bloom-filter]
---
{% include JB/setup %}

## Introduction

[This recent Reddit post](http://www.reddit.com/r/VoxelGameDev/comments/37rc9m/what_did_you_wish_you_knew_when_you_started_out/) has inspired me to write a short entry on a method I developed to reduce the data needs of my voxel structure as far as possible. My goal was the commonly cited "1-Bit-Per-Voxel". From a pure information theory standpoint I strongly believed that this was impossible without encoding the data somewhere else in the algorithm. I still do, but I tried nonetheless to see how close I could get.

I am currently working on a voxel based game (no, it's neither sandbox, nor first person) with the goal of realistic rendering of voxels sized in milimeters. Obviously this required lots and lots of data. A compression algorithm was needed, but there are few that suited real-time rendering. I started with [Gigavoxels](http://maverick.inria.fr/Publications/2009/CNLE09/) and [Sparse Voxel Octrees](https://research.nvidia.com/publication/efficient-sparse-voxel-octrees). They formed the basis, but still required lots of data.

After months and months of trying different things, I finally found a method that seemed promising. And it worked! At least at compressing data. My best attempt so far? 1.8-Bits-Per-Voxel compression. I felt like on an episode of Silicon Valley, except that my algorithm sucked. And here I wish to tell you why.

However, I do believe that the method does have some interesting parts and hope that someone, somewhere out there might find inspiration in it and give us a real working compression algorithm for voxels.

Ohh and just to clarify, I am currently rewriting my entire ray-traced voxel engine just to get rid of this method. It's that bad.

## Sooo, what's this "idea"?

[Bloom Filters!](http://en.wikipedia.org/wiki/Bloom_filter) Err, what? Yeah, did I mention it was a lossy algorithm? ... There go 99% of the readers.

Let's start with a simple Sparse Voxel Octree of depth 3 trying to represent that blue triangle as pictured below.

![Sparse Voxel Octree of depth 3]({{ site.url }}/assets/images/sparse.png)

This will result in a very blocky representation of said triangle. To improve it, we can either add contour data / marching cubes or simply add more voxel levels to the octree.

Marching cubes and countour data both have their own problems. Furthermore I explicitly wanted square voxels. Ever since the good old Novalogic [Comanche](http://www.novalogic.com/novaworld/nl_clone/c3g/screens/Snap0009.JPG) and [Delta Force](http://www.novalogic.com/images/DF/screen4_large.jpg) days I just love the look and feel of voxels.

So, more Voxels it is! But, adding more depth to our tree requires alot of data. We need to store pointers, colors... And as we go deeper, these pointers will need more bits to address the far away nodes. So, it seemed obvious, at some level down the octree, I stopped using octrees. The octrees job now was to localise where in space we are and use some other data structure to fill that space with voxels (see red voxels below)

![Sparse Voxel Octree of depth 3 and 2 more levels]({{ site.url }}/assets/images/sparse-bloom.png)

This would be equivalent to 2 more Octree levels, except it is now of a different data structure! A simple bit array would do the trick, but I wanted something fancy!

This data structure could then be traversed using a modified [3D Bresenham's Algorithm](http://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm) in the ray-tracing routine. Simple.

## Bloom Filters

And that structure is a [Bloom filter](http://en.wikipedia.org/wiki/Bloom_filter)!  Each point in space, when hashed in the bloom filter will return 1 of the following 2 outcomes:

* This Spot in Space is NOT a Voxel
* This Spot in Space might be a Voxel

Yes, might. The bloomfilter will only confirm the non-existence of a voxel. But if it returns true, there is a slight chance it might be a false positive. As I said, lossy.

However! Since we "pre-filtered" our space with a sparse voxel octree, the overall shape of our object we voxelized should still be the same! Furthermore, we can scale Bloom Filters in such a way, that the false positive rate is very small. Seems good!

What we still need is a Hashing function. I decided to go with [MurmurHash3](https://code.google.com/p/smhasher/wiki/MurmurHash3). The murmur series is really fast and has a great distribution as was visualized in this [great StackExchange answer](http://programmers.stackexchange.com/questions/49550/which-hashing-algorithm-is-best-for-uniqueness-and-speed).

## Some Pictures

So, what can be done? Let's first take a look of an early in-game picture I took a while back using said bloom filtered voxels

![7 Bit]({{ site.url }}/assets/images/7bit.jpg)

At first glance, looks like a standard Landscape scene rendered with Voxels. This is in fact a 8192 x 8192 sized Terrain fully loaded inside the VRAM using the presented method. My pure Sparse Octree implementation took around 400 MB (non-optimized). The bloom filtered version here? 56 MB. That's roughly 7 Bits-Per-Voxel. Not exactly 1-Bit-Per-Voxel territory, but getting there.

The Catch? If you look closely, you will see minor artifacts (false-positive voxels floating around). Furthermore, a big problem with the bloom filtered voxels is, you can't store any data in them. Merely a "might be here" and "is not here". All the color data is stored in the Sparse Voxel Octree overlay ontop of the bloom filter. You can see this, as there are alot of 4 x 4 patches in the terrain of the same color. This could be circumvented by introducing procedural texturing or similar.

The details of this are as follows:

* 18 MB of Sparse Voxel Octree overlay
* 38 MB of Bloom Filter data
* 10% [false positive rate](http://en.wikipedia.org/wiki/Bloom_filter#Optimal_number_of_hash_functions)
* 5 times hashed with [MurmurHash3](https://code.google.com/p/smhasher/wiki/MurmurHash3)

Yes, the false positive rate does seem rather high. But, visually, it seemed acceptable to me. The seeds for the Hashing were tweaked in such a way to receive the best looking result. No magical numbers I can give, just trial and error.

And the great thing is? It scales! If I wanted a lower false positive rate and higher detail, I simply would need to increase the Bloom Filter size! Voila! Almost like JPGs.

I did say in the beginning that I managed a 1.8-Bits-Per-Voxel compression at some point. Well. Here is a picture of that

![1 Bit]({{ site.url }}/assets/images/1bit.png)

And now forget that this abomination ever saw the light of day (Voxelized with [Binvox](http://www.cs.princeton.edu/~min/binvox/)). Yes, some tricks can be applied to reduce the artifact count significantly. For example in the above picture, all "free floating" voxels were not rendered, as I assumed that those must be false-positives. This was done by doing a hash look up for all neighbouring voxels. Slow, but it did improve image quality quite a bit.

## Some Conclusions

At first, I was super excited with this method. I believed for sure that I could reach 1-Bit-per-Voxel territory. But I tried and tried and failed. Anyways,

The Good

* Low memory footprint
* It Scales well!
* You can quickly find out if there might be neighbouring voxels
* [Adding and deleting voxels is possible](http://en.wikipedia.org/wiki/Bloom_filter#Counting_filters)

The Bad

* It's slow, hashing takes time
* It's super cache unfriendly

And the Ugly

* Nothing can be stored inside of the voxels
* Artifacts... Artifacts everywhere

So, DON'T use it. It's bad. But I do hope that it might have given someone out there the inspiration to come up with a really usable compression algorithm for our little voxels.

Currently I am using something based on this idea, but far less memory efficient. It's working really well, and if it turns out as hoped, I'll do another post. But sadly, I had to abandon my realism based voxel dream.

** Cheers! **


text:
---
name: Age of Sail Troi
rarity: 4
series: tng
memory_alpha:
bigbook_tier: 5
events: 21
in_portal: true
date: 27/02/2020
obtained: Event
mega: false
published: true
---

"Will, I sense that we should have retracted the plank, not removed the plank."

Any crew who relies on their voyage ability below the Legendary rarity level absolutely needs ancillary benefits to have any staying power. While Marina’s med-led skill set gives her a chance to still contribute there on new rosters, it’s really the rest of the card that will decide if she’s earned her crew slot on your team.

If voyaging the high seas aboard the HMS Enterprise doesn't work out, this variant’s MED base is tops among Super Rare Troi options, her +9 attack boost on ships is relevant for newcomers, and there’s a reasonable collection ceiling for her to hit if WRG ever decides to favor Troi’s standard Betazoid-y, counselor-y traits in the cryo vault.

repository: joshurtree/datacore-website

gha_language: TypeScript

repo_name: joshurtree/datacore-website


text:
---
title: Specifying Tab appearance
page_title: Specifying Tab appearance - RadSplitter
description: Check our Web Forms article about Specifying Tab appearance.
slug: splitter/sliding-zones/specifying-tab-appearance
tags: specifying,tab,appearance
published: True
position: 2
---

# Specifying Tab appearance

The sliding zone tab of a **RadSlidingPane** control can represent its content using both a title and an image:

* Use the **IconUrl** property to specify the image that appears on the tab for a sliding pane.

* Use the **Title** property to specify the text that appears on the tab for a sliding pane.

Once you have set the **Title** and/or **IconUrl** properties of a **RadSlidingPane** control, you can control the way its sliding zone tab is rendered by setting its **TabView** property. The **TabView** property uses the **Telerik.Web.UI.SplitterSlidePaneTabView** enumeration which has the following values:

* **TextAndImage** (default) - both the Icon and Title are displayed in the tab

* **TextOnly** - only the Title is displayed

* **ImageOnly** - only the Icon is displayed

>tip Since the vertical alignment of the text in pane tabs is not supported by Mozilla-based browsers at this time, you can use the **TabView** property to let the pane tabs look the same in all browsers. Just prepare images that include both the title and the icon of the pane, and set **TabView="ImageOnly"** .

## Example

The following example shows a splitter that contains a sliding pane with each of the possible **TabView** values:

````ASP.NET
<telerik:RadSplitter RenderMode="Lightweight" ID="RadSplitter1" runat="server" Height="300" Width="700">
 <telerik:RadPane ID="LeftPane" runat="server" width="22" Scrolling="None">
   <telerik:RadSlidingZone ID="SlidingZone1" runat="server" width="22">
	 <telerik:RadSlidingPane
		  ID="Pane1"
		  runat="server"
		  Width="150"
		  Title="Pane1"
		  IconUrl="Pane1Icon.gif">
		This pane has the default Setting of <b>TabView</b> property.<br />
		It displays both the icon and the title of the pane.
	 </telerik:RadSlidingPane>
	 <telerik:RadSlidingPane
		  ID="Pane2"
		  runat="server"
		  Width="150"
		  Title="Pane2"
		  IconUrl="Pane2Icon.gif"
		  TabView="ImageOnly">
		This pane has the <b>TabView</b> property set to <b>ImageOnly</b>.
	 </telerik:RadSlidingPane>
	 <telerik:RadSlidingPane
		  ID="Pane3"
		  runat="server"
		  Width="150"
		  Title="Pane3"
		  IconUrl="Pane3Icon.gif"
		  TabView="TextOnly">
	   This pane has the <b>TabView</b> property set to <b>TextOnly</b>.
	 </telerik:RadSlidingPane>
   </telerik:RadSlidingZone>
 </telerik:RadPane>
 <telerik:RadSplitBar id="RadSplitbar1" runat="server" />
 <telerik:RadPane id="MainPane" runat="server">Main Pane</telerik:RadPane>
</telerik:RadSplitter>
````

When you run the splitter declared above, the first sliding pane shows both its image and title, the second shows only its image, and the third only its title:

![](images/splitter-tabview.png)

## See Also

 * [Skins]({%slug splitter/appearance-and-styling/skins%})

repository: telerik/ajax-docs

gha_language: C#

repo_name: telerik/ajax-docs


text:
# Data-Structures-Indexing-Websites
Binary search tree ADT and AVL Tree and make a comparıson between both data structures through complexıty analysis. Writing a program that creates an index of a given list of the top popular websites and their IP addresses.

# Requirements
In this program, given a text file that includes the list of the top popular websites and
their IP addresses. When you typically request a website from your browser by typing in a URL1,
that URL is converted to an IP address2 that is used to retrieve that page from the given URL.
In this prigram, it will process this external file with URLs and IP addresses, and then it will
create an index of those pages. The attached file includes the list of IP addresses as follows:
google.com > <IP_ADDRESS>
youtube.com > <IP_ADDRESS>
facebook.com > <IP_ADDRESS>
baidu.com > <IP_ADDRESS>
yahoo.com > <IP_ADDRESS>
amazon.com > <IP_ADDRESS>
wikipedia.org > <IP_ADDRESS>
qq.com > <IP_ADDRESS>
google.co.in > <IP_ADDRESS>
As you can see here, the first page is the main Google page and the last page is the Google
page in Italy (because of the extension “co.in” in the IP address).
Programming task here is to process this file, and generate an AVL tree and a BST that indexes the list of
pages and their IP addresses. However, in this file, when it process the page URLs, it need to
consider that google.com and google.co.in are both belong to Google. For this, it need to just
retrieve the name of the page which is the one until the first dot in the URL. For example, once
you insert the 9 entries given above you should have the following AVL tree.
![alt text](https://i.imgur.com/Z9XUtWt.png)

# Functions
• read_ip_data: This function will mainly process the external file. As an input, it will take
the file name and it will return an AVL tree and simple BST.

• insert_page: This function will take an AVL tree and a simple BST, a page, and its IP
address, and then it will try to insert it to the AVL tree and BST seperately. If the page is
already in the tree, then it will update the existing node with the IP. You cannot again
make assumptions about the number of IP address here (i.e., you do not know how many
IP addresses a website has), so make sure that you use a dynamic list (you are
encouraged to use a linked list here). If the page is not in the AVL tree and BST, then the
functions will create a new node and add it to the tree.

• display_index: This function will mainly take an AVL tree and BST and display the index
of the pages in an alphabetical order.

• search_url: This function will mainly take an AVL tree , BST and a page, and will return
the list of IPs of that page.

• search_ip: This function will mainly take an AVL tree and an IP and BST and an IP, and
will return the page with that IP.

# Sample Output
1. Display the full index: This will display the full AVL tree constructed and Full BST. For example,
for the first 9 entries given above it will show the following.
amazon, IP addresses: <IP_ADDRESS>
baidu, IP addresses: <IP_ADDRESS>
facebook, IP addresses: <IP_ADDRESS>
google, IP addresses: <IP_ADDRESS>, <IP_ADDRESS>
qq, IP addresses: <IP_ADDRESS>
wikipedia, IP addresses: <IP_ADDRESS>
yahoo, IP addresses: <IP_ADDRESS>
youtube, IP addresses: <IP_ADDRESS>
2. Search for a URL: This will allow the user to enter a page and then retrieve the list of all IPs for
that page. For example, for the first 9 entries given above, it will say:
Please enter the page: google
IP addresses for google: <IP_ADDRESS>, <IP_ADDRESS>
3. Search for an IP address: This will allow the user to enter an IP address and find the page that
it belongs to:
Page 3 of 6
Please enter the URL: 216.58.219.
IP has to be in this format xxx.xxx.xxx.xxx
Please enter the URL: <IP_ADDRESS>
It belongs to google

gha_language: C


text:
## Introduction ##

Http server for Gateway v4

## Requirement ##

* Install nodejs and yarn
* Install packages
```
yarn install
```

## How To Run ##

Open a http server at port 8000

```
node index.js
```

repository: AprilBrother/ab-ble-gateway-sdk

repo_name: AprilBrother/ab-ble-gateway-sdk