text:
# github-task-manager

[![npm version](https://badge.fury.io/js/github-task-manager.svg)](https://badge.fury.io/js/github-task-manager)
[![Build Status](https://travis-ci.org/zotoio/github-task-manager.svg?branch=master)](https://travis-ci.org/zotoio/github-task-manager)
[![Code Climate](https://img.shields.io/codeclimate/maintainability/zotoio/github-task-manager.svg)](https://codeclimate.com/github/zotoio/github-task-manager)
[![Test Coverage](https://codeclimate.com/github/zotoio/github-task-manager/badges/coverage.svg)](https://codeclimate.com/github/zotoio/github-task-manager/coverage)
[![Greenkeeper badge](https://badges.greenkeeper.io/zotoio/github-task-manager.svg)](https://greenkeeper.io/)
[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg?clear)](http://commitizen.github.io/cz-cli/)
[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
[![Docker Build Status](https://img.shields.io/docker/build/zotoio/github-task-manager.svg)](https://hub.docker.com/r/zotoio/github-task-manager)

receive github hook, notify agent, receive task results, notify github (Unofficial)

<image align="right" height="160" width="160" src="https://storage.googleapis.com/github-bin/gtm-logo.svg">

## Aims
Create an asynchronous CI agnostic mechanism for running custom test stage gates for github pull requests.
- allow team leads to configure task sequences without leaving github
- allow developers to see output from tasks without leaving github
- trigger multiple jobs in parallel and indicate pending status on pr checks
- then add results for each back to pull request check/comments as they complete
- make extensible for other github event handling
- stateless and deployable to Kubernetes at scale

## Design

- Deploy two functions to lambda via serverless framework ('gtmGithubHook', 'gtmGithubResults')
- github PR open hook pointed at 'gtmGithubHook' lambda which adds event to a 'PendingQueue' SQS queue
- agent(s) watch SQS for new test execution jobs
- agent notifies 'ResultsQueue' SQS queue that a task has started (lambda updates github PR state)
- agent triggers CI PR build, deploy and tests (plugin for each CI type)
- agent formats and adds test results to 'ResultsQueue' SQS queue
- agent notifies SNS topic which triggers 'gtmGithubResults' lambda
- 'gtmGithubResults' lambda posts results to github pull request.

[![flow](https://storage.googleapis.com/github-bin/github-task-manager.png)]()

## Install
- clone this repo or `npm install --save github-task-manager`
- npm install
- setup serverless aws creds per https://github.com/serverless/serverless/blob/master/docs/providers/aws/guide/credentials.md
- setup a .env file in the repo root (copy from .envExample and modify)

| Environment variable | description |
| -------------------- | ----------- |
|GTM_AWS_REGION | awsregion to create resources in |
|GTM_SQS_PENDING_QUEUE | name of SQS queue for new event |
|GTM_SQS_RESULTS_QUEUE | name of SQS queue for results |
|GTM_SNS_RESULTS_TOPIC | name of SNS topic for result ping |
|GTM_GITHUB_WEBHOOK_SECRET | shared secret from github webook config |
|GTM_GITHUB_TOKEN | access token for accessing github |
|GTM_GITHUB_TOKEN_FUNCTIONAL_TESTS | access token for individual test type.  each task type can have a different token |
|GTM_GITHUB_HOST | api hostname can be updated for github enterprise |
|GTM_GITHUB_DEBUG | debug mode for api calls |
|GTM_GITHUB_TIMEOUT | github api timeout |
|GTM_GITHUB_PATH_PREFIX | path prefix for github enterprise |
|GTM_GITHUB_PROXY | github api client proxy |
|GTM_TASK_CONFIG_FILENAME | filename in repo to look for for task config - default is .githubTaskManager |
|GTM_AWS_ACCESS_KEY_ID | aws key id - for agent only |
|GTM_AWS_SECRET_ACCESS_KEY | aws secret - for agent only |
|AWS_PROXY|URL of proxy to use for network requests. Optional|
|GTM_AGENT_PORT| defaults to 9091 |
|GTM_AGENT_AWS_ACCESS_KEY_ID|access key for agent|
|GTM_AGENT_AWS_SECRET_ACCESS_KEY|secret key for agent|
|GTM_JENKINS_USER|login for jenkins executor|
|GTM_JENKINS_URL|url executor uses to talk to jenkins|
|GTM_JENKINS_CSRF| is csrf enabled? true or false|
|GTM_TEAMCITY_USER|teamcity executor user|
|GTM_TEAMCITY_PASSCODE|teamcity executor passcode|
|GTM_TEAMCITY_URL|teamcity api url|
|GTM_DOCKER_IMAGE_WHITELIST| comma separated list of regex of allows docker images eg. alpine:*,bash:latest|
|GTM_DOCKER_IMAGE_WHITELIST_FILE|use an optional docker whitelist file .dockerImageWhitelistExample|
|GTM_DOCKER_COMMANDS_ALLOWED| default is false, set to true to enable docker executor|
|GTM_DOCKER_ALLOW_PULL| allow agent to pull from registry |
|GTM_DOCKER_DEFAULT_WORKER_IMAGE| for running ci tasks, default is `zotoio/gtm-worker:latest` |
|IAM_ENABLED|agent host uses IAM ?|
|LAUNCHDARKLY_API_TOKEN|token for launchdarkly sass executor|
|GTM_LOGSTASH_HOST|optional logstash host for elasticsearch analysis|
|GTM_LOGSTASH_PORT|optional logstash port|
|GTM_SONAR_HOST_URL| sonar host url to connect to |
|GTM_SONAR_LOGIN| sonar access token |
|GTM_SONAR_PROJECTNAME_PREFIX| prefix if reporting to sonarqube |
|GTM_SONAR_ANALYSIS_MODE| mode for sonar runner, default preview for PRs |
|GTM_SONAR_GITHUB_OAUTH| github token for sonar to post comments and status |
|GTM_SONAR_SOURCES| default source dir is `src`|
|GTM_SONAR_JAVA_BINARIES| default is `target`|
|GTM_SONAR_MODULES| comma separated modules|
|GTM_SONAR_GITHUB_ENDPOINT| optional enterprise github api url|
|GTM_TASK_CONFIG_DEFAULT_URL| url to default sample config used when repo is missing .githubTaskManager.json|
|GTM_TASK_CONFIG_DEFAULT_MESSAGE_PATH| path to markdown comment file added to PRs when repo is missing .githubTaskManager.json|
|GTM_DYNAMO_TABLE_EVENTS| DynamoDB table to store event summaries |
|GTM_DYNAMO_TABLE_AGENTS| DynamoDB table to store agent summaries |
|GTM_AWS_VPC_ID| vpc id - only required for ddb endpoints |
|GTM_BASE_URL| Base url used to render links to agent ui - eg elb cname |
|GTM_WELCOME_MESSAGE_ENABLED| If not 'false', send a warning message on unconfigured repository pull requests |
|GTM_S3_DEPENDENCY_BUCKET| aws s3 storage of build dependencies|
|GTM_AWS_S3_PROXY| https_proxy for aws s3 |
|GTM_REPO_BLACKLIST| comma separated list of regex to blackist repo names from triggering events |

## Configure and deploy
- run: `npm run sls-deploy` - note that this will create aws re$ources..
- capture the hook url output in console and add to github repo pull request conf
- run: `npm run sls-logs-hook` or `npm run sls-logs-results` to tail the logs
- create a .githubTaskManager.json in your repo per https://github.com/zotoio/github-task-manager/wiki/Creating-a-Task-Configuration
- start an agent locally using `npm run build && npm start agent` (or use docker/k8s)
- create a pull request and confirm the hook is being hit and agent processes event

## Docker and Kubernetes agents
You can run the latest image from docker hub: https://hub.docker.com/r/zotoio/github-task-manager
```
npm run docker-hub-run
```
..or run using the local checkout and tail logs:
```
npm run docker-local-bounce
```
..or if you have a k8s cluster and kubectl configured:
```
npm run k8s-apply
npm run k8s-delete
```
note that these k8s npm script inject vars from .env into the manifest

[![k8s](https://storage.googleapis.com/github-bin/agent-k8s.png)]()

a starting point k8s manifest is in ./k8s/k8s-gtm-agent.yml

## Agent Configuration

### Running the Agent
The agent uses environment variables to configure itself as well as any executors running within it. The below environment variables are required for basic operation of the GTM Agent.

TODO: Provide Variables

### Agent Homepage
The GTM Agent provides an information page summarising the ongoing operation of the agent. The page is available on port 9091 by default.

<image src="gtm-agent-homepage.png">

## Plugins
Task executors for Jenkins, Teamcity, Travis, Http, Docker are in progress. Custom task executors can be added by adding this project as a dependency, and registering new Executors and EventHandlers.  Please see https://github.com/zotoio/gtm-agent for an example that you can fork and modify as required while still using this project as the core.

- Executors contain the logic to run tasks against a given system type, and format the results.
- EventHandlers are used to map Github events to specific functionality such as pull requests.

## Contributing

Fork this repository and work on your enhancements, then send a pull request.  If you build custom plugins that may be useful to others in your forked gtm-agent, please let us know and may be able to assist wwith backporting to this project.

Use commitizen for conventional commit messages via `git cz` instead of `git commit`.
To setup if not already installed:
```
npm install -g commitizen
npm install -g cz-conventional-changelog
echo '{ "path": "cz-conventional-changelog" }' > ~/.czrc
```
..or you can just use `npm run commit` which will use local commitizen install..


text:
# Packer Digital Oceans Mongo DB Server snapshot
## recent update added Terraform folder to deploy Mongodb server

Purpose of the repository is to provide a basic instruction set
for creating a ready to deploy Mongo database server instance
I have split the code base into two folders packer and terraform follow the first set
of instructions to create a digital snapshot of an Ubuntu 18.04 server with Mongo server installed
go to the section labled Terraform to deploy 1 or many instances.

## Installation

This code base was run on a Digital Oceans Ubuntu 18.04 x64 server droplet
The installion of the Hashicorp Packer software is stepped through here :

[Install Packer](https://learn.hashicorp.com/tutorials/packer/get-started-install-cli)

## Running the build
FIRST
change directory cd to packer

Be sure to replace the text string in variables.json file with your Digital Oceans
API token
Then from your terminal in the project root you can run

```bash
packer validate -var-file=variables.json template.json

packer build -var-file=variables.json template.json
```
## Results
The following image is what you should see at the end of the packer build
IMPORTANT please note at the bottom of the terminal return is (ID: xxxxxxxxxxx)
Be certain to record that number down as it will be needed to identify this snapshot
when you want to deploy this image using Hashicorp Terraform

![](images/terminal.png?raw=true)

The digital oceans console should have the snapshot image
## Digital Oceans web console

![](image/snapshotweb.png?raw=true)

## Why create automated snap shots
Well for one it produces more stable consistent deployments, your environments are always the same
Tools like Packer Terraform  Ansible all work to provide the same base everytime, repeatable and capable of being automated.
I'll leave you with an amazing speach given about the benefits

# Terraform
## Installation

This code base was run on a Digital Oceans Ubuntu 18.04 x64 server droplet
The installion of the Hashicorp Packer software is stepped through here :

[Install Terraform](https://www.terraform.io/docs/cli/install/apt.html)

## Running the build
FIRST
change directory cd to terraform

Be sure to replace the text string in definitions.tfvars file with your Digital Oceans
API token and your ssh_fingerprint, sprcify the number of instances in instance_count
and lastly modify the comment and number in d0_snapshot_id to only the number value of the snapshot you created with packer

Then from your terminal in the project terraform directory you can run

```bash
terraform init

terraform validate

terraform plan -var-file="definitions.tfvars"

terraform apply -var-file="definitions.tfvars"

```
If after you are finished and no longer need the asset you have created you can easily run
```bash

terraform destroy -var-file="definitions.tfvars"

```
## Further information on Terraform and tutorials

[Terraform](https://learn.hashicorp.com/terraform)

## Video
[IaaS video](https://www.youtube.com/watch?v=RTEgE2lcyk4)

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

license: MIT

branch_name: refs/heads/main

extension: md

license_type: permissive


text:
# Data Compression & Modeling :speaker:

This project is the analysis and compression of an audio signal, [Signal.wav](https://raw.githubusercontent.com/jjones646/ece6260/master/includes/Signal.wav).

The spectrogram below shows the raw signal.
![](./doc/signal-spectrogram.png)

## Prerequisites

You will need [MATLAB](http://www.mathworks.com/products/matlab/) to run the scripts.

## Usage

To export encoded & reconstructed files from the original [Signal.wav](https://raw.githubusercontent.com/jjones646/ece6260/master/includes/Signal.wav) file, run the [project_main.m](./project_main.m) script using [MATLAB](http://www.mathworks.com/products/matlab/).

## License
This project is licensed under the MIT License - see the [LICENSE.md](./LICENSE.md) file for details.

## Algorithm Approach

### Conceptual

|Signal Segmentation|
|:---|
|Bandpass filters are used to divide [Signal.wav](https://raw.githubusercontent.com/jjones646/ece6260/master/includes/Signal.wav) into manageable sections. The `fftFilter` function in [fftFilter.m](./includes/fftFilter.m) is used for the initial segmentation. A relevant compression technique is then applied for each section, which are shown below.|
|The signal is broken down into these 3 parts:

Speech

Morse Code

Chirp

|
|![](./doc/filtered-sections.png)|

### Section Implementations

|Speech|
|:---|
|7 compression schemes are tested for the speech section of the signal.|
|![](./doc/speech-methods.png)|

|Morse Code|
|:---|
|The original [Signal.wav](https://raw.githubusercontent.com/jjones646/ece6260/master/includes/Signal.wav) file contains Morse Code in the background audio. One of the steps involved for its compression is to first decode the signal. The [`makeMorse`](./includes/makeMorse.m) function is used for reconstruction of the message during decompression|
|![](./doc/morse-signal.png)|

|Chirp|
|:---|
|The sinusodial chirp in the signal is reconstructed from the equation below during decompression.|
|![](./doc/chirp-equation.png)|

branch_name: refs/heads/master

gha_language: Matlab


text:
---
layout: post
title: Rotterdam - The Day After
tags: [lchf, endurance, marathon]
---

## Achievements (what went wrong)
So I completed the [Rotterdam Marathon](https://www.strava.com/activities/2272071331), but it didn't go as planned. I identified the following reasons:
- it was a lot warmer (close to 23 Celcius) than was anticipated.
- the heat also came a lot quicker than anticipated (almost from the start instead of after 13:00 hrs)
- the course was very crowded (close to 17K people signed up for the marathon and just of 14K started or finished)
- overtaking many people cost/takes a lot of energy
- started in wave 4 (out of 5), but almost at the front
- the course is very narrow in a lot of places, not easy to overtake
- started to quick (yep rookie/beginner mistake) with 5:00min/km or faster instead of the 5:12min/km
- blister on right little tow (more an inconvenience than a problem)
- running shoes became to tight due to swelling of feet (too much water, maybe or just the heat)
- no hat or cap
- muscle aches upper legs, took an Aleeve (painkiller) on 30KM
- drank an AA-drink recovery (shouldn't have done that :-)) after the race
- had a banana after the race

## Takeaways for the next race
For the next marathon/race:
- [ ] stick with the pace
- [ ] negative split
- [ ] no stopping
- [ ] take Aleeve before the start
- [ ] UCAN in training for some lond distances or as recovery option
- [ ] follow the Plewes/Taren LCHF plan
![Plewes LCHF plan](../img/Plewes-1.jpg)
- [ ] follow the diet plan from Dan Plewes
![Plewes what to eat](../img/Plewes-2.jpg)

## The Plan
The idea was to run the Rotterdam Marathon without a large amount of carb. Most the training that I have done was fasted (if the running was in the morning) and with some carbs if it was in the afternoon/evening.
The goal is to run the marathon:
- [ ] without stopping
- [x] without carb loading (no pasta party for me :-))
- [x] using [Generation UCAN](https://www.generationucan.com/)
- [x] using [Ultra Salt](http://www.purevitaminclub.com) (before and during)
- [x] using ["Sport Rusten 100 dagen"](https://www.sportrusten.nl/sportrusten-schema-voor-de-marathon/) training
- [x] using ["Sport Rusten breathing"](https://www.sportrusten.nl/kennisbank/test-zelf-je-ademhaling/)
- [ ] with a pace of 5:12.00 per kilometer (or [08:22.00 mile](http://www.bane.info))
- [x] with only drinking water
- [x] while wearing the [The North Face Ultra Cardiac II Trail Shoes](https://www.thenorthface.com/shop/mens-ultra-cardiac-ii-nf0a2vuv?variationId=WU5#hero=0)
- [x] while wearing the [HUUB ACTIVE SOCK - WHITE](https://huubdesign.com/products/huub-active-sock-white)
- [x] while wearing the [huub-core-triathlon-suit](https://huubdesign.com/collections/triathlon-suits/products/huub-core-triathlon-suit-sleeved-mens-black-red?variant=22380811783)
- [x] using the [garmin fenix 5](https://buy.garmin.com/en-US/US/p/552982/pn/010-01688-00)
- [x] using the [garmin hrm-tri](https://buy.garmin.com/en-US/US/p/pn/010-10997-09)
- [x] using the [salomon fueling belt](https://www.salomon.com/en-us/shop/product/agile-500-belt-set.html#1191=9594)
- [x] using  [Project Rudy Rydon sun glasses](https://www.rudyproject.com/ww/en/products/performance-eyewear/rydon.html)
- [x] using [arm extentions from columbia](https://www.columbia.com/freezer-zero-arm-sleeves-SU9090.html?cgid=activity-trailrunning-accessories#start=1)
- [ ] using OOFOS slippers


text:
---
title: "Antimony"
date: 2019-08-25T21:44:17+05:30
draft: false
LatinName: "Stibium"
atomicnumber: "51"
AtomicWeight: "121.760"
NumberOfElectrons: "51"
NumberOfProtons: "51"
NumberOfNeutrons: "71"
classification: "Metalloid"
stateAtRoomTemp: Solid
DiscoveredBy: "Basil Valentine"
DiscoveredIn: "<3000 BCE"
imgurl: "antimony.jpeg"
Link: "https://en.wikipedia.org/wiki/Antimony"
about: "Antimony is a chemical element with the symbol Sb and atomic number 51. A lustrous gray metalloid, it is found in nature mainly as the sulfide mineral stibnite (Sb2S3). Antimony compounds have been known since ancient times and were powdered for use as medicine and cosmetics, often known by the Arabic name, kohl. Metallic antimony was also known, but it was erroneously identified as lead upon its discovery. The earliest known description of the metal in the West was written in 1540 by Vannoccio Biringuccio."

---

repository: ChivukulaVirinchi/periodic-table

gha_language: HTML

repo_name: ChivukulaVirinchi/periodic-table


text:
# Change Log

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [master] - Unreleased

## [0.1.0] - 2020-04-23
### Added
- Initial development

[master]: https://github.com/yngtodd/sixfive/compare/0.1.0...master
[0.1.0]: https://github.com/yngtodd/sixfive/tree/0.1.0

repository: scrivenshafts/sixfive

repo_name: scrivenshafts/sixfive


text:
# path-source

A [readable stream reader](https://streams.spec.whatwg.org/#readable-stream-reader) for reading files in Node or fetching URLs in browser. For example, to read a file in Node:

```js
var path = require("path-source");

path("README.md")
  .then(function read(source) {
    return source.read().then(result => {
      if (result.done) return;
      process.stdout.write(result.value);
      return read(source);
    });
  })
  .catch(error => console.error(error.stack));
```

Similarly, to fetch a resource in a browser (requires [array-source](https://github.com/mbostock/array-source) if [streaming fetch](https://www.chromestatus.com/feature/5804334163951616) is not supported):

```html
<!DOCTYPE html>
<script src="https://unpkg.com/array-source@0"></script>
<script src="https://unpkg.com/path-source@0"></script>
<script>

sources.path("README.md")
  .then(function read(source) {
    return source.read().then(result => {
      if (result.done) return;
      console.log(result.value);
      return read(source);
    });
  })
  .catch(error => console.error(error.stack));

</script>
```

## API Reference

# path(path[, options]) [<>](https://github.com/mbostock/path-source/blob/master/index.js "Source")

In Node, returns a Promise that yields a *source* for the file at the specified *path*; equivalent to [file-source](https://github.com/mbostock/file-source#file). In a browser, returns a Promise that yields a *source* for the resource at the specified *path* URL, using [streaming fetch](https://www.chromestatus.com/feature/5804334163951616) if available, and falling back to a [binary data](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data) [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest).

In Node, the following options are supported:

* `highWaterMark` - the stream’s internal buffer size; defaults to 65,536

In a browser, no options are currently supported.

# source.read() [<>](https://github.com/mbostock/stream-source/blob/master/read.js "Source")

Returns a Promise for the next chunk of data from the underlying stream. The yielded result is an object with the following properties:

* `value` - a [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) (a [Buffer](https://nodejs.org/api/buffer.html)), or undefined if the stream ended
* `done` - a boolean which is true if the stream ended

# source.cancel() [<>](https://github.com/mbostock/slice-source/blob/master/cancel.js "Source")

Returns a Promise which is resolved when the underlying stream has been destroyed.

repository: bluePlayer/practices

repo_name: bluePlayer/practices


text:
# Contributing Changes to regexes.yaml

Contributing to the project, especially `regexes.yaml`, is both welcomed and encouraged. To do so just do the following:

1. Fork the project

2. Create a branch for your changes

3. Modify `regexes.yaml` as appropriate

4. Create a text-file (e.g. ua.txt) which contains the User-Agent Strings (seperated by newline) you want to add to the testset in `./test_resources/tests.json`
   Please consider only real user-agents catched from your server logs for this file.

5. Run

        ./js/bin/add.js -u ua.txt -t check.json

   Check the results in `check.json`

6. If you are sure that all is ok, run
   `./js/bin/add.js -u ua.txt`

7. Run all tests with `npm test`

8. Push your branch to GitHub and submit a pull request

9. Monitor the pull request to make sure the Travis build succeeds. If it fails simply make the necessary changes to your branch and push it. Travis will re-test the changes.

That's it. If you don't feel comfortable forking the project or modifying the YAML you can also [submit an issue](https://github.com/commenthol/ua-parser2/issues) that includes the appropriate user-agent-string and the expected results of parsing.

Thanks!

## Advanced

The `regexes.yaml` does not claim to be perfect.
If you encounter that parsing results are too coarse or even wrong you will encounter a lot of test errors while running the tests.

1. To easily change the test-set contained in `./test_resources/tests.json` do the following.

        ./js/bin/regen.js -c

2. At this stage really check that you did not miss out something.

        diff test_resources/tests.js test_resources/new-tests.json

3. If you need to rerun tests and do not want to perform the full test-set, the previous tests for the bad-matching tests are stored in `./test_resources/bad-tests.json`.

        cp test_resources/bad-tests.json .
        ./js/bin/regen.js -i bad-tests.json -c

   When all is as you expect re-run Step 1. and Step 2.

        ./js/bin/regen.js -c
        diff test_resources/tests.js test_resources/new-tests.json

4. All is ok now, then replace the test-set

        cp  test_resources/new-tests.js test_resources/tests.json

   And rerun all tests

        npm test

## Find the right Regex-Matcher

The tool `./js/bin/debuginfo.js` adds for each regex in `regexes.yaml` a debug information which makes it easier together with `regen.js -c` to identify the matching regular-expression for a failed test.

Rerunning the tool removes the debuginfo again.


text:
## Welcome to the QBI NEURON tutorial

NEURON is a powerful simulation environment, allowing the detailed simulation of the nervous system in a wide range of scales - from channels to individual neurons to networks of neurons. In addition to the thousands of studies that have used NEURON, it is also the simulation environment used for large-scale projects such as the Blue Brain/Human Brain Projects.

We are offering an introductory workshop based on the recommended tutorials as well as actual experience used in generating models for research publications.  This is a one day workshop running through the basics of the NEURON interface then working up to loading experimental data and running simulations.

### Installation

NEURON software is freely available from [https://www.neuron.yale.edu/neuron/](https://www.neuron.yale.edu/neuron/).
Prior to the tutorial, please download and install NEURON on your system - you can refer to our [Quick Setup](setup).

### Course syllabus

| Time | Lesson | Duration |
| ------------- | ------------- | ------------- |
| 9:00-9:30 | [Introduction](lessons/intro) (info from Powerpoint and website)with step-by-step setup | 30 mins|
| 9:30-10:30 | UK tutorial (focussing on navigating the interface, compiling hoc files, running a basic model) - PARTS A,B,C | 60 mins|
| 10:30-10:45 | Morning tea | 15 mins |
| 10:45-12:00 | UK tutorial - PARTS D,E | 75 mins |
| 12:00-13:00 | Lunch | 60 mins |
| 13:00-14:30 | ACAN tutorial showing how it might actually be used with a real Neurolucida model. | 90 mins |
| 14:30-14:45 | Afternoon tea | 15 mins |
| 14:45-16:30 | Final session to cover using a ModelDB model, Simple networks | 135 mins |

### Acknowledgements

The course material is largely compiled from the online NEURON documentation as referenced here:

1. Official NEURON documentation
    1. [Neuron @ Yale](http://www.neuron.yale.edu/neuron/docs)
    2. [Neuron @ Duke](http://neuron.duke.edu/)
2. [Neuron Tutorial](http://web.mit.edu/neuron_v7.4/nrntuthtml/index.html) from University of Edinburgh by Andrew Gillies and David Sterratt
2. [Neurons in Action](http://neuronsinaction.com/tutorials/overview) by John H. Moore and Ann E. Stuart

repository: wisamreid/NEURON-tutorial

repo_name: wisamreid/NEURON-tutorial


text:
## Errors Code
Uiza uses conventional HTTP response codes to indicate the success or failure of an API request.
In general: Codes in the `2xx` range indicate success.
Codes in the `4xx` range indicate an error that failed given the information provided (e.g., a required parameter was omitted, a charge failed, etc.).
Codes in the `5xx` range indicate an error with Uiza's servers.

See details [here](https://docs.uiza.io/#errors-code).

## HTTP status code summary
| Error Code                  | Detail                                                                    |
| ---------------------------:|:--------------------------------------------------------------------------|
| 200 - OK                    | Everything worked as expected.                                            |
| 400 - Bad Request           | The request was unacceptable, often due to missing a required parameter.  |
| 401 - Unauthorized          | No valid API key provided.                                                |
| 404 - Not Found             | The requested resource doesn't exist.                                     |
| 422 - Unprocessable         | The syntax of the request is correct (often cause of wrong parameter).    |
| 500 - Internal Server Error | We had a problem with our server. Try again later.                        |
| 503 - Service Unavailable   | The server is overloaded or down for maintenance.                         |

## Error types
| Error Type                      | Detail                                                                    |
| -------------------------------:|:--------------------------------------------------------------------------|
| 400 - BadRequestError           | The request was unacceptable, often due to missing a required parameter.  |
| 401 - UnauthorizedError         | No valid API key provided.                                                |
| 404 - NotFoundError             | The requested resource doesn't exist.                                     |
| 422 - UnprocessableError        | The syntax of the request is correct (often cause of wrong parameter).    |
| 500 - InternalServerErrorError  | We had a problem with our server. Try again later.                        |
| 503 - ServiceUnavailableError   | The server is overloaded or down for maintenance.                         |
| 4xx - ClientError               | The error seems to have been caused by the client.                        |
| 5xx - ServerError               | The server is aware that it has encountered an error.                     |

## Example Request
```ruby
begin
  # use Uiza's library to make requests ...
rescue Uiza::Error::BadRequestError => e
  # BadRequestError
  puts "#description_link: {e.description_link}"
  puts "message: #{e.message}"
  puts "code: #{e.code}"
rescue Uiza::Error::UnauthorizedError => e
  # UnauthorizedError
rescue Uiza::Error::NotFoundError => e
  # NotFoundError
rescue Uiza::Error::UnprocessableError => e
  # UnprocessableError
rescue Uiza::Error::InternalServerErrorError => e
  # InternalServerErrorError
rescue Uiza::Error::ServiceUnavailableError => e
  # ServiceUnavailableError
rescue Uiza::Error::ClientError => e
  # ClientError
rescue Uiza::Error::ServerError => e
  # ServerError
rescue Uiza::Error::UizaError => e
  # UizaError
rescue => e
  # Something else happened, completely unrelated to Uiza
end
```

repository: uizaio/api-wrapper-ruby

gha_language: Ruby

gha_license_id: MIT

repo_name: uizaio/api-wrapper-ruby


text:
# Installation
> `npm install --save @types/istanbul-lib-coverage`

# Summary
This package contains type definitions for istanbul-lib-coverage ( https://github.com/istanbuljs/istanbuljs ).

# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/istanbul-lib-coverage

Additional Details
 * Last updated: Mon, 11 Mar 2019 20:18:58 GMT
 * Dependencies: none
 * Global values: none

# Credits
These definitions were written by Jason Cheatham <https://github.com/jason0x43>, Lorenzo Rapetti <https://github.com/loryman>.

repository: revolutionize-health/backend

gha_language: JavaScript

repo_name: revolutionize-health/backend


text:
# Typeclassopedia

![classes](https://wiki.haskell.org/wikiupload/d/df/Typeclassopedia-diagram.png)

https://wiki.haskell.org/Typeclassopedia

* Solid arrows point from the general to the specific; e.g. the arrow from `Functor` to `Applicative` means that every `Applicative` is a `Functor`.
* Dotted lines indicate some other sort of relationship.
* `Monad` and `ArrowApply` are equivalent.
* `Apply` and `Comonad` are greyed out since they're not in the std.

1. *Functor*
  - Definition
  - Instances
  - Laws
  - Intuition
  - Utility functions
2. *Applicative*
  - Definition
  - Laws
  - Instances
  - Intuition
  - Utility functions
  - Alternative formulation
3. *Monad*
  - Definition
  - Instances
  - Intuition
  - Utility functions
  - Laws
  - do notation
4. *MonadFail*
  - Definition
  - Law
5. *Monad transformers*
  - Standard monad transformers
  - Definition and laws
  - Transformer type classes and "capability" style
  - Composing monads
6. *MonadFix*
  - do rec notation
  - Examples and intuition
  - mdo syntax
7. *Semigroup*
  - Definition
  - Laws
8. *Monoid*
  - Definition
  - Laws
  - Instances
9. Failure and choice: *Alternative*, *MonadPlus*, *ArrowPlus*
  - Definition
  - Instances
  - Laws
  - Utility functions
10. *Foldable*
  - Definition
  - Instances and examples
  - Derived folds
  - Utility functions
  - Foldable actually isn't
11. *Traversable*
  - Definition
  - Intuition
  - Instances and examples
  - Laws
12. *Bifunctor*
  - Definition
  - Laws
  - Instances
13. *Category*
  - Definition
14. *Arrow*
  - Definition
  - Intuition
  - Instances
  - Laws
  - ArrowChoice
  - ArrowApply
  - ArrowLoop
  - Arrow notation
15. *Comonad*
  - Definition

## References

- https://wiki.haskell.org/Typeclassopedia
- https://wiki.haskell.org/Instances_of_List_and_Maybe


text:
# Connection throttling

With the default HTTP transport (PassThrough transport) and the HTTP NIO transport, you can enable connection throttling to restrict the number of simultaneous open connections.

To enable connection throttling, update the following property in the ei.toml file:

```toml tab='HTTP Passthrough'
[[transport.http]]
max_open_connections = 2
```

```toml tab='HTTP-NIO'
[[[custom_transport.listener]]]
max_open_connections=2

[[[custom_transport.sender]]]
max_open_connections=2
```

This will restrict simultaneous open incoming connections to 2. To disable throttling, delete the `         max_open_connections        `
setting or set it to -1.

!!! Info
    Connection throttling is never exact. For example, setting this property to 2 will result in roughly two simultaneous open connections at any given time.

repository: CharukaK/docs-ei

repo_name: CharukaK/docs-ei


text:
credmap: The Credential Mapper
===

Credmap is an open source tool that was created to bring awareness to the dangers of credential reuse. It is capable of testing supplied user credentials on several known websites to test if the password has been reused on any of these.

### V2
Version 2 is a complete rewrite which uses the Splinter module (pip install splinter). You can use the PhantomJS driver for transparent requests, or the Chrome driver which makes debugging easier. This is still a work in progress.

repository: Grukz/credmap

gha_language: Python

repo_name: Grukz/credmap


text:
---

## Introduction

The idea of the application is join NGOs/ONGs and people who can help financially.
The application consists in a NGOs/ONGs register a incident with a title, description and a value. That way, people can list all incident and choose what they'll help. The next step is contact the NGOs/ONGs by email or whatsapp.

## Dependencies

| Name | Version | Description |
|---------|--------|-------------|
| [express]          | [![express-version]][express-package] | Web application framework |
| [cors]                | [![cors-version]][cors-package] | Enable CORS with various options |
| [knex]             | [![knex-version]][knex-package] | SQL query builder |
| [sqlite3]             | [![sqlite3-version]][sqlite3-package] | Asynchronous, non-blocking SQLite3 |
| [celebrate]             | [![celebrate-version]][celebrate-package] | Express middleware with joi validation |

[express]: https://github.com/expressjs/express
[cors]: https://github.com/expressjs/cors
[knex]: https://github.com/knex/knex
[sqlite3]: https://github.com/mapbox/node-sqlite3
[celebrate]: https://github.com/arb/celebrate

[express-version]: https://img.shields.io/npm/v/express.svg
[cors-version]: https://img.shields.io/npm/v/cors.svg
[knex-version]: https://img.shields.io/npm/v/knex.svg
[sqlite3-version]: https://img.shields.io/npm/v/sqlite3.svg
[celebrate-version]: https://img.shields.io/npm/v/celebrate.svg

[express-package]: https://www.npmjs.com/package/express
[cors-package]: https://www.npmjs.com/package/cors
[knex-package]: https://www.npmjs.com/package/knex
[sqlite3-package]: https://www.npmjs.com/package/sqlite3
[celebrate-package]: https://www.npmjs.com/package/celebrate

## Dev Dependencies

| Name | Version | Description |
|---------|--------|-------------|
| [nodemon]          | [![nodemon-version]][nodemon-package] | Automatically restarting the node application |
| [eslint]                | [![eslint-version]][eslint-package] | Identify and reports patterns found in ECMAScript/JavaScript code |
| [jest]          | [![jest-version]][jest-package] | JavaScript testing solution |
| [supertest]          | [![supertest-version]][supertest-package] | HTTP assertions for tests |
| [cross-env]          | [![cross-env-version]][cross-env-package] | Use environment variables across platforms |

[nodemon]: https://github.com/remy/nodemon
[eslint]: https://github.com/eslint/eslint
[jest]: https://github.com/facebook/jest
[supertest]: https://github.com/visionmedia/supertest
[cross-env]: https://github.com/kentcdodds/cross-env

[nodemon-version]: https://img.shields.io/npm/v/nodemon.svg
[eslint-version]: https://img.shields.io/npm/v/eslint.svg
[jest-version]: https://img.shields.io/npm/v/jest.svg
[supertest-version]: https://img.shields.io/npm/v/supertest.svg
[cross-env-version]: https://img.shields.io/npm/v/cross-env.svg

[nodemon-package]: https://www.npmjs.com/package/nodemon
[eslint-package]: https://www.npmjs.com/package/eslint
[jest-package]: https://www.npmjs.com/package/jest
[supertest-package]: https://www.npmjs.com/package/supertest
[cross-env-package]: https://www.npmjs.com/package/cross-env

## Rocketseat Explication

To check out videos and download files, I uploaded in my Google Drive, visit [OmniStack 11](https://drive.google.com/drive/folders/1nEpuOaWbiNk1D4a7hsJ062_H5w4zAqiD?usp=sharing).

## How to Start

First you need to [clone](https://help.github.com/en/github/creating-cloning-and-archiving-repositories/cloning-a-repository) or [fork](https://help.github.com/en/github/getting-started-with-github/fork-a-repo) the repository.

With the code in your machine, you'll open the terminal and will install all dependencies.

``` npm i ```

After that you'll start the server.

``` npm start ```

Now all is working. Congratulations!

## Scripts Explication

| Script | Description |
|---------|-------------|
| ``` npm run start ```             | Start the nodemon/server |
| ``` npm run migrations ```             | Start the database (SQLite) |
| ``` npm run lint ```             | Verify patterns code |
| ``` npm run test-dao ```             | Test Dao files |
| ``` npm run test-lib ```             | Test Lib files |
| ``` npm run test-routes ```             | Test Routes files |

## Routes

If you are using [Insomnia](https://insomnia.rest/) or another REST API Client, you can download all routes [here](https://api.myjson.com/bins/169t3g) or in the [Google Drive](https://drive.google.com/file/d/1EaZfI0l6Zo3wKaTcx9PQscOlYgJYcx7O/view).

## Other Repositories of the Project

- [Front-end](https://github.com/marcolinolucas/be-the-hero)
- [Mobile](https://github.com/marcolinolucas/be-the-hero-mobile)

## Contact

- [GitHub](https://github.com/marcolinolucas)
- [LinkedIn](https://www.linkedin.com/in/lucas-marcolino)

## License

[MIT](http://opensource.org/licenses/MIT)

Copyright (c) 2020, Lucas Marcolino.

repository: marcolinolucas/be-the-hero-api

repo_name: marcolinolucas/be-the-hero-api


text:
# ACES Listener Ark

This an Ark implementation of the ACES Listener API. Consumers create subscriptions to register a
callback URL. The listener app then scans the ARK blockchain and sends new transactions to subscribers.

## Run Application

### Development

Set up a local database instance using docker:

```
docker run -d -p 5432:5432 \
--name aces_listener_ark_db \
-e POSTGRES_USER=postgres \
-e POSTGRES_PASSWORD=password \
-e POSTGRES_DB=aces_listener_ark_db \
postgres:9.6.1
```

Run application using maven:

```
mvn spring-boot:run
```

### Production

To run the application in a live environment, you can build a jar package using `mvn package` and then
run the jar app generated under `/target` build directory with you custom configuration:

```
java -jar application.jar --spring.config.location=file:/etc/my-application-config.yml
```

## Example Usage

Consumers register their Http callback endpoint by posting to the `subscriptions`
endpoint. Immediately following successful a subscription the encoded
listener will send all new Ark transactions to the registered callback
URL.

```bash
curl -X POST 'localhost:9091/subscriptions' \
-H 'Content-type: application/json' \
-d '{
  "callbackUrl": "http://localhost:9091/public/eventLogger",
  "minConfirmations": 5
}'
```

```json
{
  "id" : "1c2ddeb7-cf74-478d-8f77-2f326b8c2db4",
  "callbackUrl" : "http://localhost:9091/public/eventLogger",
  "createdAt" : "2017-10-24T04:15:17.091Z"
}
```

repository: ark-aces/aces-listener-ark

gha_language: Java

repo_name: ark-aces/aces-listener-ark


text:
# Self Study

Author: Jedi Chou, Create at 2021.5.26 8:20 AM

* NowCoder check-in. **7:05**
* 163 music APP check-in. **7:05**
* Read articles and check interview invitation (MaiMai APP). **7:05**
* 101WeiQi daily exercise check-in. **7:05** **7:05**
* Don't memorize words APP check-in. **8:28**
* Tencent cartoon APP check-in. **8:28**
* Download books from salttiger. **8:30**
* Read mails from<EMAIL_ADDRESS>**8:32**
* Read mails from<EMAIL_ADDRESS>**8:32**
* Check github messages. **8:33**
* Check news from ZhiHu app or website. **8:34**
* Check gitee messages. **8:36**
* Download ebook from jb51.net. **8:39**
* Update and upgrade packages at wsl. **8:48**
* Read Sina Blog. **8:52**
* Exercise of Vocabulary (vocabulary.com). **8:54**
* Go Game check
  * Leela Zero vs Leela Zero(B5s-W3s) **8:48** (90%-84%)
  * Leela Zero vs Leela Zero(B5s-W3s) **9:07** (84%-77%)
  * Leela Zero vs Leela Zero(B5s-W3s) **9:23** (77%-71%)
* 百词斩. **9:27**
* Reading mail from<EMAIL_ADDRESS>mails. **9:30**
* Reading 1 minutes at SIMPLE wiki or Baike.Baidu
* Have a browse through *Modern C++ for Absolute Beginners*
* Adjust Java study conceps list

repository: JediChou/jedi-md-book

repo_name: JediChou/jedi-md-book


text:
CHANGE LOG FOR 0.6
===

# Overview

The 0.6 upgrade involves extracting out various parts of the Data, Schema, and Modelling components
so that data artifacts can be passed around easier, and that they support polymorphism in a more succinct
and SOLID compliant manner.

In 0.5, the concepts of a data object and data transfer object are too tightly coupled, as are
model factories and data mediators. Ideally, a data object should only know about it's fields, their
names, types, values, whether those fields have changed, and whether they are being used to identify,
order, or otherwise alter the retrieval or storage of the data at the external source (if one exists).
Schemas, unfortunately, have not only this information but also information on how they are stored.
This means that in 0.5, Schemas are tightly coupled to their data storage and retrieval strategy -
it would be preferable if we could swap out the external data source/target from file system, to
database, to API, etc. The changes in 0.6 hope to address this.

To ease the transition from old components to new replacement components, a folder named `Transitional`
has been created housing various transitional interfaces that work with both old and new classes, as
well as services that consume them.

The following components are now deprecated and will be removed in a future version, likely 0.7:

* Data\Mediator (_replaced by `Data\Persistence\Strategy`_)
* Data\Operation (_replaced by `Data\Persistence\Operation`_)
* Modelling (_replaced by `Data\TransferObject`, see migration notes below_)
* Schema (_replaced by `Data\Entity`, see migration notes below_)

### New Features

The sub-components `Data\Entity` and `Data\ValueObject` have been introduced to replace the now deprecated
sub-components `Schema` and `Schema\SchemaField`. Classes that implement this interface should also implement
methodology to dictate which CRUD operations are legal. (_See `Data\Persistence\Strategy\AbstractPersistenceStrategy`
for examples_)

`PersistenceStrategy` objects are intended to negotiate with the external persistence entity, whether that be
a database, file system, API, or other external data stream. Any configuration, optionality, or other persistence-specific
attribute or methods should go in these classes. To aid in creation of these classes, two abstract classes have been created
that contain almost all necessary functionality, with remaining functionality declared as abstract methods:
`Data\Persistence\Strategy\AbstractPersistenceStrategy` and `Data\Persistence\Strategy\Database\AbstractDatabasePersistenceStrategy`.

### New Functions

`PersistenceStrategyInterface` introduces a new function `isLessVolatileThan($volatility)`. This is intended to be
used when attempting to determine whether to use cached database results or fresh retrievals.

`OperationMediatorInterface` now has four new methods that allow "forgetting" of cached results, each method allowing
forgetting at different levels of granularity:

* `forgetEnvironment(CallInterface $call)` - Removes all cached responses for an environment
* `forgetEndPoint(CallInterface $call)` - Removes all cached responses for an end point (i.e. database table / view)
* `forgetQuery(CallInterface $call)` - Removes all cached responses for a query
* `forgetResponse(CallInterface $call)` - Removes an individual cached response

`CallInterface` has a new method `endPoint()`, which is used by the `OperationMediator` to determine which end point
to cache results against.

### Backward Incompatible Changes

*None*

### Deprecated Features

The following components are now deprecated and will be removed in a future version, likely 0.7
_(for migration strategies, see Migration Notes below)_:

* Data\Mediator (_replaced by `Data\Persistence\Strategy`_)
* Data\Operation (_replaced by `Data\Persistence\Operation`_)
* Modelling (_replaced by `Data\TransferObject`, see migration notes below_)
* Schema (_replaced by `Data\Entity`, see migration notes below_)

In `AbstractDatabaseAccessor`, the method `getFullyQualifiedTableName()` is now deprecated  in lieu of
`delimitedFullyQualifiedTableName`.

### Changed Functions

`ResponseInterface` has changed the return type of the `result()` method from `array` to `mixed`. Determination of the
actual return type is now a responsibility of implementation.

### Other Changes

Circle314 Type has changed its dependency on Circle314 Concept from v1.0 to v1.1. This incurs no backwards incompatible changes.

# Migrating from 0.5 to 0.6

### Moving away from Models

Models are being removed because they were only really there to allow lazy loading via closures, which is not
a very good design pattern. If you rely on the lazy loading aspects of Models, it is suggested you either bring
that code into your application code base or, ideally, use a more robust pattern such as DDD.

### Moving from Schemas to DataEntities

The transition from `Schemas`/`SchemaFields` to `DataEntites`/`DVOs`
(Data Value Objects) is quite painless. All functionality is exactly the same, except for the data-source/target
knowledge, which has instead placed in `Data\Persistence\Strategy\PersistenceStrategyInterface`. See
`Data\Persistence\Strategy\AbstractPersistenceStrategy` for CRUD operation availability methods you would
normally find in `SchemaInterface`. Those methods are now protected, as it is now unnecessary for outside classes
to access them.

### Moving from Mediators to PersistenceStrategies

PersistenceStrategies are almost identical to Data Mediators in terms of the interface. The key differences are:

* PersistenceStrategies do not have a `clearTableCache()` method
* PersistenceStrategies include an `isLessVolatileThan($volatility)` method

Aside from those methods, nothing really changes here, and it should all work nicely between the old and new classes.

### General setup for Data objects in 0.6

For each persistence mechanism (e.g. database) your application should have one concrete class for each of the following:

* Accessor
* OperationRepository

For each end point (e.g. table) your application should have one concrete class for each of the following:

* Entity
* EntityRepository
* EntityFactory
* PersistenceStrategy

...and optionally...

* EntityCollection


text:
[![Build Status](https://travis-ci.org/bboyle/html5-constraint-validation-API.svg?branch=master)](https://travis-ci.org/bboyle/html5-constraint-validation-API)
[![devDependencies](https://david-dm.org/bboyle/html5-constraint-validation-API/dev-status.svg)](https://david-dm.org/bboyle/html5-constraint-validation-API#info=devDependencies)

[![Sauce Test Status](https://saucelabs.com/browser-matrix/benboyle-h5cvapi.svg)](https://saucelabs.com/u/benboyle-h5cvapi)

A partial polyfill for the HTML5 constraint validation API (form validation). Requires jQuery. Intended for use with jquery form validation UI scripts.

## Features implemented

* handle `@required` on `:text`, `textarea`, `select` and `:radio` controls
* fire `invalid` events
* support `form@novalidate`
* support `@type=email` and `validityState.typeMismatch`
* support `.setCustomValidity( message )`
* support `@pattern` and `validityState.patternMismatch`


text:
# Automate Martin's Website

Now that you have a module whose responsibility is to maintain the state of your application, now you need to convert that raw data into HTML representations and render them in the browser. In this chapter you will automate the creation of the HTML list of fish from the objects in your fish collection, so that you never have to copy/paste the HTML directly when a fish dies, or a fish is added.

## Remove Hard-Coded HTML

Open `index.html` and delete the `<section class="fishList">` element and all of the children fish elements. Refresh the browser and you should now see an empty fish list.

Now you can move on to creating your automated fish making machine.

## Defining the Components

There are two components to this process.

1. **Individual fish**. This will create an HTML representation of each fish to be rendered in the list container.
1. **List of fish**. This will create an HTML container element and have instructions for rendering the individual fish component for each fish in the collection.

Since each of these components have a different responsibility, then each one must be created in its own module.

### Single Fish Component

> **`scripts/fish/fish.js`**

```js
/**
 *  Fish which renders individual fish objects as HTML
 */
const fishHTMLRepresentation = (fishObject) => {
    return `
        <div class="fish">
            <div>
                <img class="fish__image" src="${fishObject.image}" alt="">
            </div>
            <div class="fish__name">${fishObject.name}</div>
            <button id="button--${fishObject.name}">Details</button>

            <dialog class="dialog--fish" id="details--${fishObject.name}">
                <div>Species: ${fishObject.species}</div>
                <div>Location: ${fishObject.location}</div>
                <div>Length: ${fishObject.size}</div>
                <div>Food: ${fishObject.food.join(",")}</div>

                <button class="button--close">Close Dialog</button>
            </dialog>
        </div>
    `
}
```

### Fish List Component

> **`scripts/fish/fishList.js`**

```js
/**
 *  FishList which renders individual fish objects as HTML
 */
const fishList = () => {

    // Get a reference to the `<article class="content">` element
    const contentElement = document.querySelector("insert selector here")

    // Add to the existing HTML in the content element
    contentElement.innerHTML += `
        <section class="fishList">
            All the fish go here!
        </section>
    `
}
```

## Rendering the List in Main Module

> **Reminder:** The `main.js` module should be the last JavaScript file included at the bottom of `index.html`.

Since we want the fish to be immediately rendered when the page loads, then that falls within the responsibility of the `main.js` module. Import the list component into main and invoke the component function.

```js
/*
    This is the only code needed. It starts the task of
    making the list of fish. The function is *defined* in
    fishList.js, but here is where you *invoke* the function
*/
fishList()
```

Refresh your browser again and you should see the following message in the middle of the screen.

![fish container with default message](./images/fish-list-no-for-loop.png)

Hooray!! Your fish list component got rendered to the browser. Next is to render all the fish.

You need the `fish()` component function to do that. That function is in the `fish.js` module, so you need to make sure that the `fish.js` script is included before the `fishList.js` script in your `index.html` file.

Now you can write a `for..of` loop to generate all of the individual fish HTML representations, and keep appending the HTML to a variable. After the loop is done, you have one, long string containing all the HTML.

> **`scripts/fish/fishList.js`**

```js
/**
 *   fishList which renders individual fish objects as HTML
 */
const fishList = () => {

    const contentElement = document.querySelector(".content")

    // Generate all of the HTML for all of the fish
    let fishHTMLRepresentations = ""
    for (const fishObject of fishes) {
        /*
            In this loop, invoke the fish() function
            and pass the current fish object as an argument.
            Each time, add the return value to the
            fishHTMLRepresentations variable with `+=`
        */
    }

    // Add a section, and all of the fish to the DOM
    contentElement.innerHTML += `
        <section class="fishList">
            ${fishHTMLRepresentations}
        </section>
    `
}
```

Now refresh your browser again and all of your fish should be back.

![dynamically rendered fish components](./images/fish-list-with-for-loop.png)

## Ok, So, What Just Happened

You may have understood each step as you did it, or you may not have.

You may have understood how all the pieces connect, or you may not have.

With our years of experience introducing beginners to these abstract concepts, we know that somewhere between 90% to 100% of your entire cohort simply is not capable of understanding the big picture here. You can make sense of each tree, but you can't understand how the forest works as a single ecosystem that is made up of individual trees.

There are several abstract concepts at play here, and your brain's neural network has not been tuned to understand these complex connections yet. That doesn't mean your mind **can't** do it.

It just can't do it **yet**.

## Practice: Argumentative

Understanding how arguments and parameters work with functions - especially when the functions are defined in a different module that where they are used - is something that is hard to understand. In this practice exercise, you are going to explore this concept.

First, in the following line of code in the **`fishList`** module...

```js
fishHTMLRepresentations += fish(fishObject)
```

Remove the fish argument that is being passed to the **`fish`** function.

```js
fishHTMLRepresentations += fish()
```

Refresh your browser. Make sure your developer console is open and you will see the following exception.

![no argument exception](./images/fish-component-no-argument.png)

The exception tells you exactly where it occurred. Line 8 of the `fish.js` module (_**Note:** your line number may be different if you have comments or different amounts of whitespace_). If you open that module and go the the line specified, you will see this.

```js
src="${fish.image}"
```

The key term is `'image' of undefined`. Whenever you see an exception like that, look to the left of the property being accessed. In this case, look to the left of `'image'`. You will see the variable `fish`. That's undefined.

Why is it undefined? It's because you removed the argument that you were passing in when you invoked the function. This component function defines a parameter.

```js
const fish = (fishObject) => {
```

Since you invoked this function without a corresponding argument...

```js
fishHTMLRepresentations += fish()
```

Then the parameter never gets assigned a value to reference. Therefore, it's undefined, and you can't access an `.image` property of something that is undefined.

Now put the argument back in when you invoke the component function and it should all work again.

## Practice: Information Organization

In the following exercises, you are going to building module and components for tips, and locations. You need to separate all of those modules into sub-directories so that you don't end up with dozens of JavaScript files all in one directory. It's confusing.

In the `scripts` directory, create the `fish`, `tips`, and `locations` sub-directories and move all of your current files for automating fish into their `scripts/fish` directory.

This will have the side effect of changing how you import the modules, since their path has changed. You will need to clean up all of your import paths.

## Practice: Automate Martin's Tips

Create a data module, a tip list component, and a tip component to automate the rendering of Martin's fish care tips.

Suggested files to create:

* `scripts/tips/tipData.js`
* `scripts/tips/tipList.js`
* `scripts/tips/tip.js`

## Practice: Automate Martin's Locations

Create a data module, a location list component, and a location component to automate the rendering of Martin's locations for the location page.

Suggested files to create:

* `scripts/locations/locationData.js`
* `scripts/locations/locationList.js`
* `scripts/locations/location.js`

repository: RobMixon/client-side-mastery

repo_name: RobMixon/client-side-mastery


text:
# Pseudolachnea hispidula (Schrad.) B. Sutton, 1977 SPECIES

#### Status
ACCEPTED

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

#### Published in
Mycol. Pap. 141: 167 (1977)

#### Original name
Peziza hispidula Schrad.

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# `itsdangerous-rs`

[![Build Status](https://travis-ci.org/discordapp/itsdangerous-rs.svg?branch=master)](https://travis-ci.org/discordapp/itsdangerous-rs)
[![License](https://img.shields.io/github/license/discordapp/itsdangerous-rs.svg)](LICENSE)
[![Documentation](https://docs.rs/itsdangerous/badge.svg)](https://docs.rs/itsdangerous)
[![Cargo](https://img.shields.io/crates/v/itsdangerous.svg)](https://crates.io/crates/itsdangerous)

A rust re-implementation of the Python library [itsdangerous](https://github.com/pallets/itsdangerous/).

Essentially, this crate provides various helpers to pass data to untrusted environments
and get it back safe and sound. Data is cryptographically signed to ensure that it has
not been tampered with.

## Basic Usage

Add this to your `Cargo.toml`:

```toml
[dependencies]
itsdangerous = "0.3"
```

Next, get to signing some dangerous strings:

```rust
use itsdangerous::{default_builder, Signer};

fn main() {
    // Create a signer using the default builder, and an arbitrary secret key.
    let signer = default_builder("secret key").build();

    // Sign an arbitrary string, and send it somewhere dangerous.
    let signed = signer.sign("hello world!");

    // Unsign the string and validate that it hasn't been tampered with.
    let unsigned = signer.unsign(&signed).expect("Signature was not valid");
    assert_eq!(unsigned, "hello world!");
}
```

For more in-depth examples, check out the [documentation](https://docs.rs/itsdangerous)!

## License

Licensed under the [MIT license](LICENSE).

repository: Rapptz/itsdangerous-rs

repo_name: Rapptz/itsdangerous-rs


text:
## Goal

The goal of this exercise is to teach the student the Concept of Classes in C#.

## Learning objectives

- Know what classes are.
- Know what encapsulation is.
- Know what fields are.
- Know how to create an object.
- Know how to update state through methods.
- Know about the `void` type.

## Out of scope

- Reference equality.
- Reference parameter passing.
- Constructors.
- Interfaces.
- Inheritance.
- Properties.
- Indexers.
- Structs.
- Destructors.
- Method overloading.
- Pattern matching.

## Concepts

This Concepts Exercise's Concepts are:

- `classes`: know what classes are; know what encapsulation is; know what fields are; know how to create an object; know how to update state through methods; know about the `void` type.

## Prequisites

This Concept Exercise's prerequisites Concepts are:

- `basics`: know how to define a basic class with basic methods.
- `strings`: know how to do basic string interpolation.
- `numbers`: know how to compare numbers.
- `conditionals`: know how to do conditional logic.

## Representer

This exercise does not require any specific representation logic to be added to the [representer][representer].

## Analyzer

This exercise does not require any specific logic to be added to the [analyzer][analyzer].

[analyzer]: https://github.com/exercism/csharp-analyzer
[representer]: https://github.com/exercism/csharp-representer


text:
# Yii2-magnific-popup

This widget is wrapper for awesome jQuery plugin Magnific Popup By Dmitry Semenov http://dimsemenov.com/plugins/magnific-popup/

Magnific Popup is a responsive lightbox & dialog script with focus on performance and providing best experience for user with any device
(for jQuery or Zepto.js).

## Installation
The preferred way to install this extension is through [composer](http://getcomposer.org/download/).

Either run
```sh
$ php composer.phar require --prefer-dist loveorigami/yii2-magnific-popup "@dev"
```
or add
```
"loveorigami/yii2-magnific-popup": "@dev"
```
to the require section of your composer.json file.

## Simple usage
in view file
```html
	<a href="original.jpg" title="Caption text"><img  src="/thumb_img.jpg" alt="Alt"></a>
```
```php
use lo\widgets\magnific\MagnificPopup;

echo MagnificPopup::widget(
	[
		'target' => '#mpup',
		'options' => [
			'delegate'=> 'a',
		]
	]
);
```

for gallery
```html
<div class="col-md-6" id="mpup">
	<a href="original.jpg" title="Caption for first"><img  src="/thumb_img.jpg" alt="Alt"></a>
	<a href="original2.jpg" title="Caption for second"><img  src="/thumb_img2.jpg" alt="Alt"></a>
</div>
```

```php
echo MagnificPopup::widget(
	[
		'target' => '#mpup',
		'options' => [
			'delegate'=> 'a',
		],
		'effect' => 'with-zoom' //for zoom effect
	]
);
```


text:
# Notebooks EC-estimation Collab
Temporary Jupyter Notebooks to showcase integration of EC estimation methods into EBRAINS.

Find the dedicated EBRAINS Collab in: [https://wiki.ebrains.eu/bin/view/Collabs/effective-connectivity-estimation/](https://wiki.ebrains.eu/bin/view/Collabs/effective-connectivity-estimation/)


text:
![logo](/branding/logo/logo.svg)
# BasstatPL
BasstatPL is a package for performing different tabulations and calculations for descriptive statistics.
It provides:
- Frequency table constructors for simple and grouped data
- Centralization measures
- Position measurements
- Measures of dispersion

### Requirements 📋
The required packages are pandas, numpy, and matplotlib.
```
python -m pip install pandas
python -m pip install numpy
python -m pip install matplotlib
```
_Some packages like numpy get installed when you install pandas_

### Supported Python Versions
Python >= 3.6

### Installation 🔧

Using pip you can install the necessary packages, if you don't have them installed, then basstatPL will be installed
```
python -m pip install basstatpl
```
## License
MIT

repository: angcoder-c/basstatpl

repo_name: angcoder-c/basstatpl


text:
This zip file bundles the dashboard web application with manifests for running
as a Docker container and deploying to a Cloud Foundry PaaS such as IBM Bluemix.

## First, a note on stability and security

The dashboard web application requires a kernel provisioner API such as tmpnb or
IPython Notebook itself. It then uses Thebe to communicate with this kernel
service. Deploying a kernel service, properly configuring a dashboard to talk to
it, securing access, ensuring availability of all assets required for proper
code execution, etc. are all very much works in progress.

Treat this code as proof of concept. Do not use it in production settings. Take
care to avoid privacy violations and exposing other data accessible to the
kernel service.

## Configurating the dashboard

The dashboard contains copies of code cells that need to be executed. A pair of
environment variables determine where the execution kernels come from, as well
as the API used to control them:

* KERNEL_SERVICE_URL - the IPython server that the dashboard will leverage
* TMPNB_MODE - boolean for whether the kernel service is a multi-user tmpnb
               setup (_true_), rather than a single IPython notebook server
               (_false_)

## Running in a Docker Container

The provided Dockerfile can be used to run the dashboard application as-is. Doing
so will serve the application on port 9500 of the Docker host. The Dockerfile
specifies KERNEL_SERVICE_URL and TMPNB_MODE values for the notebook server that
generated this zip file bundle. When changed, the container should be killed and
rerun.

## Running in a Cloud Foundry PaaS

The accompanying manifest.yml file specifies the
KERNEL_SERVICE_URL and TMPNB_MODE values for the notebook server that
generated this zip file bundle. If being pushed using the `cf` CLI, the zip file
must be unpacked and its contents pushed from the filesystem. As of this writing,
 `cf` will not make use of a manifest within a zip file when pushing that zip
file. If modified in the manifest.yml, the app must be pushed again. If modified
using `cf set-env`, the app must be restaged using `cf restage <appname>` to update
its environment.

repository: SimonBiggs/dashboards

repo_name: SimonBiggs/dashboards


text:
---
layout: page
title: Hi there! I’m Layale
---

I'm an **Android Engineer** and a **Community Lover**.

Android
-------

I'm based in Beirut, Lebanon 🇱🇧 and working for [Neo Mena Technologies](https://neo.ae) 🇰🇼.

I've been developing for Android for over 5 years now (using Koltin for the last 2 years). I’m a huge advocate of Kotlin and functional programming.
 And I'm an enthusiast about mentorship, open source and knowledge sharing within the community.

Community & Public Speaking
---------------------------

I enjoy connecting developers around me. I am currently co-organizing Tech events at [GDG Coast Lebanon](https://gdg.community.dev/gdg-coast-lebanon/) where I plan lots of cool mobile events.

I also enjoy public speaking and sharing my experience with everyone.
 You can checkout some of my slides and videos in the [Talking](/menu/talking.html) page.
 Are you looking for speakers? Feel free to [email<EMAIL_ADDRESS>with details!

Questions? Feedback? Or just a chat? You can find me on [Twitter](https://twitter.com/yalematta).


text:
---
title: GitLab
sidebar_order: 6
---

Sentry’s new GitLab integration helps you find and fix bugs faster by using data from your GitLab commits. Additionally, you can streamline your triaging process by creating a GitLab issue directly from Sentry. _Note: this feature is currently available for Early Adopters. You can become an Early Adopter by navigating to your Organization Settings > General Settings._

## Configure GitLab

1. In Sentry, navigate to Organization Settings > Integrations. _Note: only users with Owner and Manager permissions have access._

1. Within Integrations, find the GitLab icon and click ‘Install.’

    {% asset gitlab/integration-pg.png alt="Sentry integrations page showing GitLab integration icon and install button." %}

1. In the resulting modal, click ‘Add Installation.’

    {% asset gitlab/add-installation.png alt="Sentry integrations page showing GitLab integration and how to connect Sentry to a GitLab instance." %}

1. In the pop-up window, complete the instructions to create a Sentry app within GitLab. Once you’re finished, click ‘Next.’

    {% asset gitlab/configuration-modal.png alt="Sentry integrations page showing GitLab configuration modal and Sentry app within GitLab." %}

1. Fill out the resulting GitLab Configuration form with the following information:

    1. The GitLab URL is the base URL for your GitLab instance. If using gitlab.com, enter https://gitlab.com/

    1. Find the GitLab Group Path in your group’s GitLab page.

        {% asset gitlab/gitlab-groups.png alt="GitLab group's page showing group path." %}

    1. Find the GitLab Application ID and Secret in the Sentry app within GitLab.

        {% asset gitlab/gitlab-app-id.png alt="GitLab application id and secret in Sentry app within GitLab." %}

    1. Use this information to fill out the GitLab Configuration and click ‘Submit.’gitlab

        {% asset gitlab/gitlab-configuration.png alt="GitLab configuration form." %}

1. In the resulting panel, click ‘Authorize.’

1. In Sentry, return to Organization Settings > Integrations. You’ll see a new instance of GitLab underneath the list of integrations.

1. Next to your GitLab Instance, click ‘Configure.’ _Note: It’s important to configure to receive the full benefits of commit tracking._

    {% asset gitlab/configure-gitlab-instance.png alt="GitLab instance with connected group and highlighted configure button." %}

1. On the resulting page, click ‘Add Repository’ to select which repositories you’d like to begin tracking commits.

    {% asset gitlab/add-repo.png alt="GitLab instance with connected group and highlighted configure button." %}

repository: brongko/sentry-docs

repo_name: brongko/sentry-docs