text:
# Fish Sound Detector

[![DOI](https://zenodo.org/badge/506380623.svg)](https://zenodo.org/badge/latestdoi/506380623)

This repo is a collection of data, a Python library to work with Raven annotation files and generate spectrograms, and a model to detect
the vocalization of fish sounds from spectrograms generated from hydrophones as part of a collaboration between [Mote Marine Laboratory & Aquarium](https://mote.org), [Southeast Coastal Ocean Observing Regional Association](https://secoora.org), and [Axiom Data Science](https://axiomdatascience.com).

## Components

### Data

Included in the repo is a training set of spectrograms created from an annotated dataset of fish vocalizations labeled by domain experts and volunteers.
The provided annotation files are located in `data/acoustic-data-annotations` which were summarized in `data/acoustic-data-annotations/mote-samples.csv`.  See `data/README.md` for more information.

### Helper scripts / library

A Python package composed of various helpful scripts was created to reorganize and standardize the provided raw data and to generate training sets from which detector models could be trained.  The package can be installed via `pip`, e.g.

```bash
src/acoustic-tools> pip install -e .
```

### Notebooks

A Jupyter notebook `train-resetnet101-fastai.ipynb` is included which demonstrates how to train a neural network (ResNet101 implemented in fast.ai in the
example) to detect fish sounds using the provided labeled data.  The model has an accuracy of ~0.875 when training for 25 epochs using the selected
subset of annotated data that both undersamples classes with many examples and oversamples classess with few examples.

### Models

The model created in the notebook `train-resetnet101-fastai.ipynb` is saved in `models` and available from [Huggingface Hub](https://huggingface.co/axds/classify-fish-sounds) (`models/axds/classify-fish-sounds`).

### Demo

A running demo of the model is available on [Huggingface Spaces](https://huggingface.co/spaces/axds/classify-fish-sounds) (`src/classify-fish-sounds`).


text:
---
title: Development Roadmap
keywords: development,
tags: [engage,development,fhir]
sidebar: overview_sidebar
permalink: design_development_roadmap.html
summary: ITK3 eDischarge roadmap outlines the development schedule for the RESTful APIs.

---

[<i class="fa fa-arrow-left" aria-hidden="true"/> Back to ITK3 eDischarge - Introduction.](index.html)

{% include important.html content="All development phases outlined below are indicative and subject to on-going review." %}

repository: nhsconnect/ITK-FHIR-Digital-Medicines

branch_name: refs/heads/master

extension: md

gha_language: HTML

license_type: permissive

repo_name: nhsconnect/ITK-FHIR-Digital-Medicines


text:
# Change log for SPSWakeUp

The format is based on and uses the types of changes according to [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).

## [2.7.2] - 2023-06-15

### Changed

- SPSWakeUP.ps1
  - BREAKING CHANGE: Remove Add-HostsEntry function
  - Using the CmdLet Add-Content for update HOSTS file

## [2.7.1] - 2023-05-10

### Changed

- SPSWakeUP.ps1
  - Add ErrorAction parameter for SPWeb CmdLet
- release.yml
  - Use softprops/action-gh-release@v1 action for release step
  - Add github.ref for release name
  - Remove actions/upload-artifact@v3

### Added

- Add RELEASE-NOTES.md file

## [2.7.0] - 2023-05-08

### Changed

- README.md
  - BREAKING CHANGE: Windows Management Framework 5.0 is required
  - Remove SharePoint Server 2013 from supported versions
- Remove azure-pipelines.yml and SPSWakeUp.psd1 files
- SPSWakeUP.ps1
  - BREAKING CHANGE: Remove InputFile and OnlyRootWeb switch parameters and update examples
  - Add Transcript boolean parameter and update examples
  - BREAKING CHANGE: Remove logging functions and logging variables
  - Replace Write-LogContent function with Write-Output CmdLet
  - BREAKING CHANGE: Remove functions :
    - Add-RASharePoint, Add-SystemWeb, Disable-IEESC, Disable-IEFirstRun,
    - Backup-HostsFile, Restore-HostsFile, Add-SPSSitesUrl, Get-SPSHSNCUrl
  - Update Disable-LoopbackCheck, Add-HostsEntry, Get-SPSSitesUrl and Get-SPSWebAppUrl functions
  - Remove unnecessary comments
  - Add Get-SPSAdminUrl function to improve central admin urls warmup

## [2.6.1] - 2023-01-18

### Changed

- SPSWakeUp.ps1
  - Replaced if-elseif-else logic with pseudo ternary operator to get throttle value.

## [2.6.0] - 2022-10-27

### Added

- Add release.yml file

### Changed

- SPSWakeUP.ps1
  - Update SPSWakeUp Version
- README.md
  - Add SharePoint Server Subscription Edition support
  - Remove SharePoint 2010 support
  - Update minimum PowerShell version supported

## [2.5.1] - 2022-10-14

### Changed

- SPSWakeUP.ps1
  - Remove duplicate entries before writing in HOSTS File

## [2.5.0] - 2021-07-21

### Changed

- SPSWakeUP.ps1
  - Check if Web Application Url contains One of SPServer and remove it from HOSTS

## [2.4.0] - 2020-02-20

### Added

- SPSWakeUP.ps1
  - Add Uninstall and OnlyRootWeb parameters
  - Add Remove-SPSTask function
  - Add reporting: Memory Usage for each worker process

### Changed

- SPSWakeUP.ps1
  - Update Get-SPSSitesUrl function with Service Application Urls and SPWeb urls

### Removed

- SPSWakeUP.ps1
  - Remove functions: Get-SPSWebRequest, Add-IETrustedSite and Clear-IECache
- README.md
  - Remove Internet Explorer information

## [2.3.1] - 2020-02-20

### Changed

- SPSWakeUP.ps1
  - Fix issue "You cannot call a method on a null-valued expression" when InstallAccount variable is null

## [2.3.0] - 2019-11-27

### Changed

- README.md
  - Add SharePoint 2019 support
- SPSWakeUP.ps1
  - Remove sitemaster-[GUID] urls in Get-SPSSitesUrl and Get-SPSHSNCUrl functions
  - For SharePoint 2016 or higher, check if local server has Search MinRole
  - Check if HOSTS File already contains Urls of All Web Applications or HSNC
  - Security Fix: Change UserName and Password parameters by InstallAccount parameter

### Removed

- Remove Modules folder

## [2.2.1] - 2019-11-27

### Changed

- README.md
  - Latest release date, Total downloads and Issues opened
- SPSWakeUP.ps1
  - Add Try-Catch exception in Get-SPSThrottleLimit function
  - Fix issue on Get-SPSThrottleLimit when CimInstance returns an array

### [2.2.0] - 2018-03-07

### Changed

- SPSWakeUP.ps1
  - Support of Form Based Authentication (XML element removed from SPSWakeUP.xml)
  - Update description of script
- Readme.md
  - Add Download link for latest release

### Added

- Add SPSWakeUp.psd1 file to replace xml file
- SPSWakeUP.ps1
  - Add Write-VerboseMessage function
  - Add UserName and Password parameter for installation process
  - Update ps1 for the input file psd1
  - Update parameter of script
- Improved code styling by following PowerShell guidelines:
  - Changing alias to its full content
  - Function Names Must Use Approved Verbs
  - Using Named Parameters Instead of Positional Parameters
  - Rename logfolder by scriptRootPath
  - Remove variable not used

### Removed

- SPSWakeUP.ps1
  - Remove all global variables
  - Remove Get-SPSUserPassword function
  - Remove mailLogContent variable
  - Rename Add-LogContent function to Write-LogContent
- Remove SPSWakeUP.xml file
- Remove Internet Explorer warmup in ps1 and psd1 files

### [2.1.4] - 2016-10-14

### Changed

- SPSWakeUP.ps1
  - Fix Exception log
  - Update function Get-SPSWebAppUrl: Check if url contains computername
  - Check if hostEntries variable is not null before change HOST system file
  - Improved code styling by following PowerShell guidelines

### Removed

- SPSWakeUP.xml
  - Delete CustomUrls and ExcludeUrls XML Elements
  - Delete FBA.ServiceAccount XML Element

### [2.1.3] - 2016-10-13

### Added

- SPSWakeUP.ps1
  - Add functions: Get-SPWebServicesUrl, Backup-HostsFile, Restore-HostsFile and Clear-HostsFileCopy
  - Add variables for HOSTS and Backup Hosts file with today's date: hostsFile and hostsFileCopy
  - Improved code styling by following PowerShell guidelines

### [2.1.2] - 2016-10-12

### Added

- SPSWakeUP.ps1
  - Add psVersion variable that contains the actual PowerShell version
  - Add function Get-SPSVersion
  - Check support between PSVersion and SharePoint Server 2010
  - Improved code styling by following PowerShell guidelines

### [2.1.1] - 2016-10-11

### Added

- Initial public release of SPSWakeUp on Github
- SPSWakeUP.ps1
  - All Supported version of SharePoint (2010, 2013 and 2016)
  - Automatic Installation in Task Scheduler
  - Multi-Threading for better performance
  - Output-Cache for Publishing Sites
  - Works with FBA if Windows authentication is enabled on the same web application
  - Use Internet Explorer to download JS, CSS and Pictures files
  - All site collection (HSNC include) for all web applications are included in warm-up
  - Disable IE ESC, Disable LoopBackCheck : *Secure* or *Less Secure*,
  - Add Web application Urls in HOSTS file and in Internet Options Security,
  - Add User Account in User Policy for Each Web Application,
  - Clear Cache Internet Explorer.
  - Logging: Log script results in log file, Cleaning log files after 30 days by default.
- SPSWakeUP.xml
  - Email notifications : SMTP settings
  - Add or/and remove urls from warm-up
  - Central Administration can be include or exclude

license: MIT

repository: luigilink/spswakeup

branch_name: refs/heads/main

gha_language: PowerShell

gha_license_id: MIT

repo_name: luigilink/spswakeup


text:
---
layout: post
title: "Leaving your Job"
category: Blog
tags: startups life
year: 2012
month: 7
day: 31
published: true
summary:
---

Most often when we talk about career risk it's in a relatively short time context. If I leave my job tomorrow, I won't be able to afford rent next month. If I just stay and work a few more 60 hour weeks, a promotion or raise is right around the corner.

For our jobs, risk is all about balancing an unknown future with a certain present. Our friends, social life, and title at our jobs are all obvious and manageable. Our future job role, salary, and influence are not.

Since we work best with a known set of data, we tend to make decisions to maximize our short-term stability. Instead of leaving everything we know for an uncertain future, we tend to stay put and *wait*.

This waiting game is seen as less risky than not waiting. When in reality, it's actually *far* riskier.

Perhaps my favorite exploration of career risk is [The Startup Spouse: On Risks, Trade-Offs And Never Sleeping On The Floor](http://onstartups.com/tabid/3339/bid/86543/The-Startup-Spouse-On-Risks-Trade-Offs-And-Never-Sleeping-On-The-Floor.aspx). In this wonderful post, the husband of the author leaves his job to start a startup, which is deemed almost certainly risky by her social circle. They all wonder what got in to him, and why he's "jeopardizing [their] financial security."

When asked "Why are we starting a company now?" the husband responds

> Risk is about evaluating trade-offs, and evaluating trade-offs requires the consideration of opportunity costs: if I do this, then I can't do that. I could stay at my finance job, continue earning a salary, and insulate myself against the risk of [my company's] failure. But what about the opportunity cost of my time?
> Although it seems counterintuitive at first, staying at my day job offers very limited upside financially and professionally. __I think that's actually the riskier path__.

I have experienced this first hand. The few times I've left my job were very difficult decisions. Why am I doing this? I'm getting paid well, isn't it enough? Why would I throw this all away to start over somewhere else? What will my girlfriend think? What will future employers think about my job history?

In the end, each time I have been better off. I've dramatically improved my earning potential, learned a ton of new things, worked with really experienced people, and expanded my professional network many times over. I can safely say my value increased each time much more than if I had stayed at my job.

In fact, staying at my job each time has been much riskier than leaving, I just couldn't see what the future held.

Final Thoughts
-----------

Here are some thoughts that helped me finally make the leap. For each of these, if the answer lies beyond your current job, seriously consider the opportunity cost to ignore the problem.

 1. Picture yourself in your dream "job" (this could be self-employment). Is it what you're doing now?

 2. What if you moved all the way up in this job, would you feel satisfied?

 3. Will employers really care if you left your job, as long as it's not a pattern of consistent quitting? Would you even want to work for them if they did?

 4. Are you significantly underpaid compared to average earners in your field? Do you feel taken advantage of? Are you respected by your employers?

 5. Do you feel like you could be learning more? Do you want a bigger challenge?

__What about you? Have you left a job and wish you did it sooner? Or did you regret it? How did you reconcile your choice given the other options?__

extension: markdown


text:
Warehouse React.js

#### you will also need to install and run RESTful-API- server  https://github.com/polinazolotukhina/RESTful-API

Clone :
```javascript
$ git clone https://github.com/polinazolotukhina/developer-exercise.git
```

..........................................................................

Go to the folder:
```javascript
$ cd developer-exercise
```

..........................................................................

Run:
```javascript
$ npm install
$ npm start
```

..........................................................................

#### you will also need to install and run RESTful-API- server  https://github.com/polinazolotukhina/RESTful-API

repository: polinazolotukhina/developer-exercise

repo_name: polinazolotukhina/developer-exercise


text:
project_path: /web/_project.yaml
book_path: /web/updates/_book.yaml
description: Chrome Beta has landed its native support for <dialog> element

{# wf_updated_on: 2014-07-23 #}
{# wf_published_on: 2014-07-23 #}
{# wf_tags: news,dialog,semantics #}

# dialog element shipped in Chrome 37 Beta {: .page-title }

{% include "web/_shared/contributors/agektmr.html" %}

Chrome Beta has landed its native support for <dialog> element without needing "Enable experimental Web Platform features." flag turned on.

Check out more sample codes and how it works in detail with [a live demo](http://demo.agektmr.com/dialog/){: .external }.

There are a few changes applied to the implementation since [the last announcement](http://updates.html5rocks.com/2013/09/dialog-element-Modals-made-easy) but notable one is:

* Non-modal <dialog> is no longer vertically centered in the viewport. It has no special positioning behavior beyond its default CSS styling.

If you are curious about further details on the spec update, check out diffs [here](http://html5.org/r/8448) and [here](http://html5.org/r/8457).

{% include "comment-widget.html" %}

repository: shanselman/WebFundamentals

repo_name: shanselman/WebFundamentals


text:
# Grants Round 11 Hackathon - Fluence
## Follow The Fluence Quickstart Guide (Beginner)

- [x] *Extend the Fluence Quickstart, https://github.com/fluencelabs/examples/tree/main/quickstart/3-browser-to-service, with a distributed character count service deployed to at least one Fluence peer. Display a message's character count at the end of the message, e.g., (char count: 123 chars). You should accurately count characters.*
**[https://github.com/amrosaeed/fluence/tree/master/quickstart/4-char-count-service]**

- [x] *Document your solution and submit it via a Github or GitLab repo with MIT or Apache 2.0 license.* **[https://github.com/amrosaeed/fluence/tree/master/quickstart/4-char-count-service#readme]**

# Examples

This repo holds a collection of examples on how to build distributed applications with the Fluence stack.

The `aqua-examples` directory contains examples demonstrating the use of Aqua to compose decentralized applications from distributed services, whereas the `marine-examples` directory contains examples with respect to the development of Rust Wasm modules.

If you encounter a problem, please post an Issue or open a PR. If you want to contribute an example, please contact us by opening an Issue or a draft PR. See the [contribution guidelines](https://github.com/fluencelabs/fluence/blob/master/CONTRIBUTING.md).

## License

Unless otherwise indicated, the applicable license is [Apache 2.0](https://github.com/fluencelabs/fluence/blob/master/LICENSE).

repository: amrosaeed/fluence

repo_name: amrosaeed/fluence


text:
## AutoDH

[![Build Status](https://travis-ci.org/EdsterG/AutoDH.svg?branch=master)](https://travis-ci.org/EdsterG/AutoDH)
[![Coverage Status](https://coveralls.io/repos/github/EdsterG/AutoDH/badge.svg?branch=master)](https://coveralls.io/github/EdsterG/AutoDH?branch=master)

A library for automatic extraction of Denavit-Hartenberg parameters from a robot model.

### Install
To install AutoDH run:
```
$ pip install autodh
```

### OpenRAVE Script
To generate DH parameters from OpenRAVE models use `scripts/openrave.py`.

Here's an example for Puma from link `Base` to link `Puma6`:
```
$ python scripts/openrave.py robots/pumaarm.zae Base Puma6
```
Another example for PR2 from link `base_link` to link `r_gripper_palm_link`:
```
$ python scripts/openrave.py robots/pr2-beta-static.zae base_link r_gripper_palm_link
```

### Run Tests
Install test suite dependencies before running unit tests:
```
$ pip install autodh[test]
$ pytest autodh
```

#### References:

- Chittawadigi et. al. “Automatic Extraction of DH Parameters of Serial Manipulators using Line Geometry.” _The 2nd International Conference on Multibody System Dynamics_, 2012.
- Lipkin H. “A Note on Denavit-Hartenberg Notation in Robotics.“ _International Design Engineering Technical Conferences and Computers and Information in Engineering Conference, Volume 7: 29th Mechanisms and Robotics Conference, Parts A and B_, 2005.

repository: EdsterG/AutoDH

repo_name: EdsterG/AutoDH


text:
---
layout: default
title: Researchers
has_children: true
permalink: /docs/Researchers
nav_order: 5
---

# Researchers
{: .no_toc }

## Table of contents
{: .no_toc .text-delta }

1. TOC
{:toc}

---

## Research Labs

1. [Myers Lab](https://myerslab.mpi-cbg.de/)
    - [Robert Haase](https://myerslab.mpi-cbg.de/robert-haase/)

2. [Angel Alfonso](https://sites.google.com/site/aacruzr/)

3. [Network of Europian bio-image analysts ](http://eubias.org/NEUBIAS/) has lots of resources on this topic.

4. [Carpenter Lab](https://carpenterlab.broadinstitute.org/) - Creators of cell profiler.

## Forums

1. [Image SC](https://forum.image.sc/) allows you to discuss specific image analysis tasks and get help on how to get them done using different kind of tools.

repository: Amit-Tomar/bioimage-analysis

repo_name: Amit-Tomar/bioimage-analysis


text:
# DormHub

> CMPT 354 - Database Systems 1 Project

## Requirements

- MySQL
- NodeJS
- ReactJS

## Start

Edit `api.js` to reflect your MySQL database connection parameters
> You may need to create a new database. By default `api.js` connects to the `prod` database.

```
npm i // To install the API dependencies
cd app
npm i // To install the ReactJS App dependencies
ce ..
npm start // Start the API/App concurrently
```

## Automated Deployment

Automated deployment is set up to automatically pull updates from a GitHub repo whenever it is pushed to. This is done by utilizing GitHubs Webhook functionality. Automated Deployment requires an ssh keypair to be generated on the server and added to your GitHub profile's keys.

## Sample Data

To load `SampleData.json` into the SQL database call `/populate` route. This will drop, create and then insert the `SampleData.json` tuples into each table

gha_language: JavaScript


text:
# VF Cash
VF Cash has no proof-of-work (PoW) and blockchain file that grows at a rate 76% less than Bitcoin.

The project started on the 23rd of April 2019. It has no proof-of-work (PoW) rather it has a finders-keeps distribution system similar to mining and a transaction rate limit per address / public key of three seconds for the confirmation period. This prevents the sender of a transaction from making any further transactions during this period. The chain is unordered, and the networking uses UDP. The Digital Signature algorithm uses secp256r1.

Divisible to three decimal places, mineable, written in C, compiled with GCC, 256-bit key length.

Transactions are free, there is no charge for making a transaction on the network.

VFC is a private decentralised network, consequently you will need control of some currency before the wider network considers your node viable for indexing. The usual method is to mine some VFC using the `vfc mine` command. Also you can transfer VFC to your node's reward address `vfc reward` will identify your reward public key / address once your reward address has some VFC your node will automatically verify itself within the hour.

An IPv4 address is required to operate a node. IPv4 was chosen because it has a small enough address range to make port scanning for other nodes practical which is a more decentralised manner of finding other VFC nodes in the case that the single DNS seed node was compromised or no longer functioning.

Additionally to the information provided in this document is an [FAQ here](https://github.com/vfcash/VFC-Core/blob/master/FAQ.md) and a [Medium article here](https://james-william-fletcher.medium.com/creating-a-digital-currency-f970fc0f1dce).

# Installation & Running a Node

**Linux (Debian/Ubuntu) Compile & Install Instructions (Full Node & Client Wallet):**
```
git clone https://github.com/vfcash/VFC-Core && cd VFC-Core
chmod 0777 compile.sh
sudo ./compile.sh

vfc cdn_resync
```
Then use the `vfc help` command in the console for a full command list.

```> vfwallet```

```> cminer```

```
> vfc help

-----------------------------
vfc update                    - Updates node
vfc <address public key>      - Get address balance
vfc out <address public key>  - Gets sent transactions
vfc in <address public key>   - Gets received transactions
vfc all <address public key>  - Recv & Sent transactions
vfc top <address> <num>       - Top Recv & Sent transactions
-----------------------------

Send a transaction:
vfc <sender public key> <reciever public key> <amount> <sender private key>

--------------------------------------
vfc new <optional seed>                 - Create a new Address / Key-Pair
vfc new <seed1> <seed2> <seed3> <seed4> - Four random seed(uint64), Key-Pair
--------------------------------------
vfc qsend <amount> <receiver address>   - Send transaction from rewards address
vfc claim <optional file path>          - Claims private keys to rewards addr
vfc reward                              - Your awarded or mined VFC
--------------------------------------
-------------------------------
vfc mine <optional num threads>  - CPU miner for VFC
vfc peers                        - List locally indexed peers
vfc deadpeers                    - List locally indexed dead peers
vfc flushpeers                   - Removes all indexed peers
vfc getpub <private key>         - Get Public Key from Private Key
vfc issub <public key>           - Is supplied public address a subG address
-------------------------------
vfc spread                       - Map of difficulty values
vfc difficulty                   - Network mining difficulty
-------------------------------
vfc sync <optional num peers>    - Trigger blockchain sync from your peers
vfc cdn_resync                   - Trigger blockchain resync from the master
vfc reset_chain                  - Reset blockchain back to genesis state
vfc scan                         - Scan for peers in the IPv4 range.
-------------------------------
vfc replaypeer <peer ip address> - Manually replay from specific peer
vfc addpeer <peer ip address>    - Manually add a peer
vfc printtrans 1000 1010         - Print transactions[start,end] on chain
vfc findtrans <transaction uid>  - Find a transaction by it's UID
-------------------------------
vfc dump                         - List all transactions on chain
vfc dumptop <num trans>          - List top x transactions on chain
vfc dumpbad                      - List all detected double spend attempts
vfc clearbad                     - Clear all detected double spend attempts
-------------------------------
----------------
vfc version      - Node version
vfc agent        - Node user-agent
vfc config       - Node configuration
vfc high         - Returns node [ blocks.dat size / num transactions ]
vfc circulating  - Circulating supply
vfc minted       - Minted supply
vfc unclaimed    - Lists all unclaimed addresses from your minted.priv
vfc claim        - Claims the contents of minted.priv to your rewards address
vfc makecache    - Make local cache of wallet balances for faster TX
vfc deletecache  - Delete local cache of wallet balances
----------------
vfc single       - Launches the VFC node as single threaded
vfc multi        - Launches the VFC node as multi threaded
----------------

To get started running a dedicated node, execute ./vfc on a seperate screen.
```

By default your data-dir is ~/.vfc if you would like to set a custom path please set the envionment variable VFCDIR, for example if running as root choose a directory such as /srv

**Windows Install Instructions (Full Node & Client Wallet):**

For a Windows installation you can follow the steps above via the Ubuntu Console, install the Ubuntu Terminal software for Windows: https://www.microsoft.com/en-us/p/ubuntu/9nblggh4msv6

**To become an active part of the network make sure UDP Port 8787 is forwarded.** You will need to hold VFC in your rewards address `vfc reward` to register on the network. You can mine using the `vfc mine` command. Be patient and once VFC has been mined your node will be indexed by other peers.

# Mining Difficulty
All nodes re-calculate the difficulty once an hour at exactly 0 minutes UTC of the hour.

To increase the difficulty towards 0.031 pay VFC into:
- **q15voteVFC**f7Csb8dKwaYkcYVEWa2CxJVHm96SGEpvzK

To decrease the difficulty towards 0.240 pay VFC into:
- **24KvoteVFC**7JsTiFaGna9F6RhtMWdB7MUa3wZoVNm7wH3

If the balance of **24KvoteVFC** is higher than **q15voteVFC** the difficulty will be 0.240, otherwise the difference between the balance of the two addresses will be used to reduce the difficulty from 0.240 to 0.031.

Use the command ```vfc difficulty``` for more information.

# Configuration File
- **multi-threaded 1**  - Uses all CPU Cores
- **multi-threaded 0**  - Uses only one CPU Core
- **replay-threads 32** - Replays blockchain data to a maximum of 32 peers simultaneously.
- **replay-delay 1000** - Uses less TX bandwidth (microseconds between each transaction replayed)
- **replay-delay 1**    - Uses more TX bandwidth
- **peer-trans-limit-per-min 180** - Limits the amount of transactions a peer can send per minute, by default this value is 180, it is not recommended to set this value lower than 60.

# Expose a gateway
VF Cash is a private decentralised network, this means that the only people who get access to the network are node operators. The only way a regular client can access the network is by using one of the running nodes as a gateway to access the network.

This is why it is important that you expose some kind of gatway for end-users, at minimum this would mean installing NGINX, PHP-FPM and exposing the [php rest api](https://github.com/vfcash/VFC-PHP-API/blob/master/rest.php) for public use by copying the rest.php file to `/var/www/html` the default configured nginx www/html path.

# Third-Party Dependencies
- CRC64.c  - Salvatore Sanfilippo
- Base58.c - Luke Dashjr
- SHA3.c   - Andrey Jivsov
- ECC.c    - Kenneth MacKay

repository: vfcash/VFC-Core

gha_language: C

repo_name: vfcash/VFC-Core


text:
# Hackenbush

An application to play Red-Blue Hackenbush, with a collection of related classes.

## Getting Started

This was developed in the NetBeans IDE, in which the steps to get this running are as follows:
1. Create a new project using 'File->New Project...'
    1. Select 'Java' and 'Java Application' for the project type.
    1. Give the project an appropriate name and location.
1. Clone the repo to your computer.
1. Copy the contents of 'src' into '/YourProject/src/'.
1. Set 'YourProject' as the main project in NetBeans, and let 'my.hackenbushapplication.main' be the main class.
1. Run it with NetBeans 'Run' button. In the window, you can make whatever Hackenbush game you like. For further directions, see the next section.
Better and more general instructions will follow in a later update. Right now I'm just fighting with NetBeans.

## Using the GUI

The window contains two text fields, in which you can enter adjacency matrices for the red and blue sticks of a Hackenbush game. To see what this game actually looks like, press the 'Update Graph' button.

Adjacency matrices must be symmetric, the same size, and contain only non-negative integers. Edges not connected to the ground will be automatically deleted when the graph is updated.

This is clearly not the most intuitive way to play a Hackenbush game, and adjustments will be made in later updates.

## Combinatorial Game Values

For more information about how combinatorial game values are calculated, I would suggest http://www.geometer.org/mathcircles/hackenbush.pdf.

Right now, calculation of game values is only enabled when the graph in question is a tree.

## Acknowledgements

* This project began as an undergraduate thesis under the direction of Prof. Adam Landsberg at the Keck Science Department, who directed me to resources on combinatorial game values and suggested Red-Blue Hackenbush as an area of study.

repository: mbulkow/Hackenbush

repo_name: mbulkow/Hackenbush


text:
# ExFunctions2

Exercise heavily inspired from _Programming Elixir_ by Dave Thomas, chapter 5 but directly with named function and proper unit test.

Create and run the functions that do the following:

* Write a function `fizzbuzzer` that takes three arguments. If the first two are zero, return “FizzBuzz.” If the first is zero, return “Fizz.” If the second is zero, return “Buzz.” Otherwise return the third argument. Do not use any language features that we haven’t yet covered in this book.

* The operator rem(a, b) returns the remainder after dividing a by b. Write a function `fizzbuzz` that takes a single integer (n) and calls the function in the previous exercise, passing it rem(n,3), rem(n,5), and n. Call it seven times with the arguments 10, 11, 12, and so on. You should get “Buzz, 11, Fizz, 13, 14, FizzBuzz, 16.”

## Installation

If [available in Hex](https://hex.pm/docs/publish), the package can be installed
by adding `ex_functions_2` to your list of dependencies in `mix.exs`:

```elixir
def deps do
  [
    {:ex_functions_2, "~> 0.1.0"}
  ]
end
```

Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc)
and published on [HexDocs](https://hexdocs.pm). Once published, the docs can
be found at [https://hexdocs.pm/ex_functions_2](https://hexdocs.pm/ex_functions_2).

repository: TGITS/programming-workouts

repo_name: TGITS/programming-workouts


text:
Snowball Ukrainian
================

This package implements the
[Ukrainian language Snowball stemmer](http://snowball.tartarus.org/algorithms/ukrainian/stemmer.html).

## Ukrainian overview

Russian has 32 letters, 10 Vowels, 20 consonants
and 2 unpronounced signs.  The capital letters
look the same as the lower case letters, with
the exception of cursive capital letter and
lower case.

## Implementation

The Ukrainian language stemmer comprises preprocessing, a number of steps.
Each of these is defined in a separate file in this
package.  All of the steps operate on a `SnowballWord` from the
`snowballword` package and *modify the word in place*.

repository: grecod-oss/snowball

gha_language: Go

repo_name: grecod-oss/snowball


text:
# Test runner metrics

![grafana](https://user-images.githubusercontent.com/1105133/106182950-a2e53200-61b0-11eb-9615-f892fa879c84.png)

Metrics available at:

`$namespace.testrunner.$projectName.$instrumentationConfigName.`

### `devices.living`

Sum of all time from creation of device till finishing across all devices

```mermaid
graph LR
    subgraph ef1[Living]
    id1[Device started] --> id2[Device finished]
    end
```

### `devices.working`

Sum of all time when device executing tests across all devices

```mermaid
graph LR
    id1[Device started] --> id2
    subgraph ef1[working]
    id2[Received a test intention] --> id3[Test started] --> id4[Test finished]
    end
    id4 --> id5[Waiting for another intention] --> id6
    subgraph ef2[working]
    id6[Another test run]
    end
    id6 --> id7[Device finished]

```

### `devices.idle`

Sum of all time when device do nothing across all devices

```mermaid
graph LR
    id1[Device started] --> id2
    id2[Received a test intention] --> id3[Test started] --> id4[Test finished] --> id5
    subgraph ef2[idle]
    id5[Waiting for another intention] --> id6[Device finished]
    end
```

### `initial-delay`

Single stat per test suite (instrumentation configuration)

```mermaid
graph LR
    id1[Test runner start] -->|ms|id2[First test execution start]
```

### `end-delay`

Single stat per test suite

```mermaid
graph LR
    id1[Last test execution ended] -->|ms|id2[Test Runner finished]
```

### `queue-median`

Median of tests queue time

```mermaid
graph LR
    id1[Test runner start] -->|ms|id2[Test claimed a device]
```

### `install-median`

Median of installation times

```mermaid
graph LR
    id1[Test claimed a device] -->|ms|id2[Test execution start]
```

### `suite`

Single stat per test suite

```mermaid
graph LR
    id1[First test execution start] -->|ms|id2[Last test execution ended]
```

### `total`

Single stat per test suite

```mermaid
graph LR
    id1[Test runner start] -->|ms|id2[Test runner finished]
```

## `tests.status.lost.`

Tests count with lost status with categorized reasons:

### `not-reported`

Don't know exact reason, delta between initial test suite and reported tests

### `no-file`

Test report data pulled from device and then pushed to report service.
These are cases when file was not found on device for some reason

### `instr-parsing`

If fail when parse `am instrument` output

### `instr-start`

If fail when staring `am instrument`

### `instr-timeout`

If fail with timeout when executing `am instrument`

### `instr-unexpected`

If catch unexpected error when executing `am instrument`

## `adb`

Lower level metrics from AdbDevice, to observe device connection issues.
It is count metrics, aggregated by time windows

### `get-sdk-property`.[ `success` / `error` / `failure` ]

### `install-application`.[ `success` / `error` / `failure` ]

### `get-alive-device`.[ `success` / `error` / `failure` ]

### `clear-package`.[ `success` / `error` / `failure` ]

### `pull`.[ `success` / `error` / `failure` ]

### `clear-directory`.[ `success` /  `error` / `failure` ]

### `list`.[ `success` / `error` / `failure` ]

### `run-test`.[ `passed` / `ignored` / `error` / `infrastructure-err` / `failed-on-start` / `failed-instrum-parse` ]

repository: avito-tech/avito-android

branch_name: refs/heads/develop

gha_language: Kotlin

repo_name: avito-tech/avito-android


text:
---
layout: post
title: The Wolf Report - January 18th, 2017
---

- [🎉 webpack 2.2: The Final Release 🎉 – webpack – Medium](https://medium.com/webpack/webpack-2-2-the-final-release-76c3d43bf144#.8x8vhjk4h)
- [Introduction to Akka.Cluster.Sharding in Akka.NET - Petabridge](https://petabridge.com/blog/introduction-to-cluster-sharding-akkadotnet/)
- [A Taste from Angular Version 4 – NetanelBasal](https://netbasal.com/a-taste-from-angular-version-4-50be1c4f3550#.d6kz4dgwy)
- [React at 60fps – Andrey Okonetchnikov –<EMAIL_ADDRESS>- [How to pass parameters to a view component](http://andrewlock.net/passing-variables-to-a-view-component/)
- [The Stark Programming Language Experiment - xoofx](http://xoofx.com/blog/2017/01/17/the-stark-programming-language-experiment/)
- [You don't need a tutorial for every-freaking-thing - Gosha Arinich](https://goshakkk.name/no-tutorial-for-everything/)
- [Angular 2 – Module and Route Structures](http://jsdiaries.com/2017/01/16/angular-2-module-and-routes-structure/)
- [Using BEM (Block Element Modifier) And Emulated View Encapsulation In Angular 2.4.1](https://www.bennadel.com/blog/3213-using-bem-block-element-modifier-and-emulated-view-encapsulation-in-angular-2-4-1.htm)
- [Winton Technology Blog - Configuring .NET Core Applications using Consul](https://tech.winton.com/blog/2016/12/configuring-net-core-applications-using-consul)


text:
---
layout: default
---

# 1996-02-05 - Jim Bell - Murderous Terrorist

## Header Data

From<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 97ad5bce2e3489281fc99d9b8b7b65a43038bd4a469035c54976d66291e818ba

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-02-05 06:01:33 UTC

Raw Date: Mon, 5 Feb 1996 14:01:33 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>Date: Mon, 5 Feb 1996 14:01:33 +0800
To<EMAIL_ADDRESS>Subject: Jim Bell - Murderous Terrorist
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Dr. Vulis writes:

AO> Alan Olsen<EMAIL_ADDRESS>writes:

AO> I consider Mr. Bell to be a crank and a loon.

DV> You're certainly entitled to your opinion. You might be interested to know that
DV> I consider Jim Bell to be highly intelligent, knowledgeable, and overall nice
DV> person. I'm particularly impressed by his calm and restrained response to your
DV> provocations. I've also formed a rather negative opinion of you, based on your
DV> actions in this incident.

Jim Bell has advocated nothing less than paid death squads using crypto as a
means to hide payment to these murderous terrorists.  If you can find a conspirator
of murder as " highly intelligent, knowledgeable, and overall nice person" then
you also are in need of immediate mental health intervention.

Should the mainstream media ever get wind of Bell's lunacy it will be one more
nail in the crypto-coffin spurring the Feds and international anti-crypto efforts to
a frenzy.    One is as bad as the other.  To quote your own
words to Mr. Olsen; " I've also formed a rather negative opinion of you, based
on your actions in this incident."

AO> He has no interest in any sort of honest discussion.

DV>  Honest or dishonest, the discussion of Jim's political views has nothing
DV> to do with encryption.

His plans for death squads success DEPENDS on the anonymity provided by
CRYPTO!

AO> He wishes to draw in others in the hope of "punishing me".

 You've kicked Jim off of "your" mailing list, pushing the
DV> flame war that you've started to this list. I don't appreciate this.

And you think YOU have credibility here?  Sounds like you are cut from
the same murderous cloth as Jim Bell.

I pray that if by some freak of anarchy Bell's plan ever comes to
fruition both you and Bell will be the first victims of your own murderous
madness.

{% endraw %}
```

## Thread

+ Return to [February 1996](/archive/1996/02)

+ Return to "[jdoe-0007@alpha.c2.org](/authors/jdoe0007_at_alpha_c2_org)"

+ 1996-02-05 (Mon, 5 Feb 1996 14:01:33 +0800) - Jim Bell - Murderous Terrorist -<EMAIL_ADDRESS>


text:
Automatic Train Station Names
=============================

This mod allows to automatically set train station names after a certain
pattern. If a train station name contains parentheses `()`, they will be
automatically filled with the position of the train stop. If the name
contains brackets `[]`, they will be filled with a number which is one
larger than the largest number of all other train stations with the same
name pattern. The station name pattern will be taken either from a blueprint
or from the mod settings, where a default name pattern can be set.

Example patterns:

* `Station []`: The stations will be called `Station [1]`, `Station [2]`, ...
* `Mine at ()`: A station will be called e.g. `Mine at (-31,103)`
* `Station [] at ()`: A station will be called e.g. `Station [2] at (21,17)`
  when there already is a station called `Station [1] at (11,-7)`

Example
-------

The following blueprint contains several train stations with different names:

    0eNqtldFqgzAUhl9FztUGEZrUauo79GqXpQxbszagUUy6VcR3XzRQNurYD9uViXq+L5yTkwx0rK6q7bRxlA+kT42xlO8Hsvpsimp65/pWUU7aqZoYmaKeZl2hKxoZaVOqG+V8PDBSxmmnVYifJ/2rudZH1fkf7pHOh5rYuqb1tLaxPqQxk8djYsmo9w/hyaXu1Cl8SxlZV4Qx7bRR0f4QFS56evZLeFAJTJX8g2oNqVa/m17CyMuWNAmkSf6q2UAaiWs+tLtEb/qmymgGLzjTu9NO0vPFxfPWeqwXD2lcffeKBWYGMyWKlDAyRZFbGJmgyClFIFPATI4y4fpwgSLxVa5RJJ7MBEXCJecbFAlvTA430E/94w/u+WjPv9wEjN5VZ0Njy0wIyberTIzjJ7kCCeI=

gha_language: Lua


text:
#Template.js#
A light-weight client-side Javascript templating engine

Template.js is small (4KB uncompressed) and extremely fast. It can be easily integrated into your favorite Javascript framework or used as a standalone. Template.js is great for small and large projects.

##How to use it##
```javascript
Template.initialize('[example]Hello #{$place}, my name is #{$name}.[/example]');

var view =
{
	place: 'world',
	name: 'Archie'
}
var output = Template.render('example', view); // Hello world, my name is Archie.
```

Above is a basic example of initializing Template.js with a small template containing one `block` ([example]...[/example]) that contains two `tokens`. The template is then rendered via the `Template.render()` function that takes two parameters - the name of the block (`'example'`) and the view object (`view`) containing the values for the tokens.

**Please note:** Template.js is just a templating engine and will not load template texts for you, so you'll have to do it manually using ajax or any other technique to retrieve large ammounts of text. Here's an example using [*jQuery's*](http://jquery.com) ajax implementation:
```javascript
$.get('my_template.tpl', function(result)
{
	Template.initialize(result);
	var output = Template.render('...', view);
});
```

##Blocks##
Templates are made of blocks. Blocks are slices of HTML and Template.js tags and tokens. Output is made by combining blocks or by using each block induvidualy via the `Template.render()` function.
Its best to regard blocks as functions (which they are by the way), they can accept view structures and can be linked inside other blocks.

Let's take a simple template made from 3 blocks: `body`, `header` and `footer`
```html
[body]
	<@header/>
	<h1>#{$title}</h1>
	<p>The is the body of the website</p>
	<@footer {year: new Date().getYear()}/>
[/body]

[header]
	<div>Hello, #{$name}</div>
[/header]

[footer]
	<div>The year is: #{$year}</div>
[/footer]
```
As we can see, the `body` block have [linked block tags](#linked-block-tag) to blocks `header` and `footer`, effectively placing their content inside the `body` block.

We'll initialize Template.js with this template (we'll assign it to `templateText` variable):
```javascript
Template.initialize(templateText);
```

Now, that we have our template compiled, we'll render it with the data from the `view` structure:
```javascript
var view =
{
	title: 'My first real template'
	header:
	{
		name: 'Archie'
	}
};

var output = Template.render('templateText', view);
```
The resulting value of the `output` variable will be:
```html
<div>Hello, Archie</div>
<h1>My first real template</h1>
<p>The is the body of the website</p>
<div>The year is: 2013</div>
```
**Please note:** Template.js is just a templating engine and will not escape, validate or in any way transform the data you provide it with. It is up to you to make sure the data is properly handeled before providing it to the `Template.render()` function.

##Tokens##
Tokens are basic template constructs. Tokens contain [variables](#variables) and can include basic logical and mathematical operations or even Javascript functions.
Here are some of the possible operations you can do with tokens:
* `#{$variable}` and `#{$variable.childVariable}` The most basic token construct, outputs the value of `variable` or `variable.childVariable` to the template or an empty string if not set, false or null.
* `#{$variable || 'default value'}` Same as the previous, but will return '*default value*' string if `variable` not set, empty false or null.
* `#{Math.abs($variable1 + $variable2)}` Will return the absolute sum of `variable1` and `variable2`.
* `#{$light == 'red' ? 'stop' : 'go'}` Will return '*stop*' if `light` equals '*red*', otherwise will return '*go*'.
* `#{$text.replace(/\b(https?:\/\/.+?)\b/gim, '<a href="$1">$1</a>')}` Will replace all urls in `text` with anchor tags.

Other combinations are also possible, just use your imagination.

##Variables##
Variables represent values of the view structure where the name of the variable represents the corresponding key name in the view structure. Variables can be set, modified, removed and searched for. Variables are discarded once `Template.render()` completed its job. To preserve variables and their values in the template, Template.js has a "global" variables structure `Template.vars` that is used to keep values over multiple render operations.
Possible variable types:
* `$variable`, `$variable.childVariable` or `$variable['childVariable']` **Local variable**, will take the value of the corresponding key in the [scope](#scope) of the provided view structure
* `@variable` **Inherited variable**, will recursively search for the corresponding key up the view substructure tree and finaly in the `Template.vars` structure. Read more about [variable scoping](#scope)
* `^variable`, `^variable.childVariable` or `^variable['childVariable']` **Global template variable**, will take the value of the corresponding key in the `Template.vars` structure. Changes made to global template variables are kept over multiple render operations.
* `variable` a regular Javascript variable defined in the global scope of `window` or the current [tag](#tags)

##Tags##
Template.js supports several tags that enable you to dynamicaly modify or add content to the rendered block. Tags allow logical operations, looping and block linking.
**Please note:** All tags are functions that perform at runtime, therefore excesive or incorrect usage may penalty rendering performance. Use them wisely.

###IF, ELSE IF, ELSE tags###
```html
<if $light == 'red'>
	Wait angrilly
</if>
<else if $light == 'yellow'>
	Start honking the guy infront of you
</if>
<else>
	Drive
</else>
```
`id`, `else if` and `else` tags can be nested

###FOR and FOR IN loops ###
```html
<ul>
	<for var i=0; i<10; i++>
		<li>I am number #{i}</li>
	</for>
</ul>

<ul>
	<for var index in $people>
		<li>My name is #{$people[index].name}</li>
	</for>
</ul>
```

###FOREACH loop ###
The `foreach` loop allows you to quickly iterate over the desired view substructure array. The `foreach` loop tag is somewhat different than the other loop tags as it will shift the [scope](#scope) to the provided view substructure array item.
Let's create a simple view structure with nested substructure array for our `foreach` tag to iterate on:
```javascript
var view =
{
	people:
	[
		{name: 'John', age: 31},
		{name: 'Jim', age: 42},
		{name: 'Jake', age: 25},
	]
}
```

There are 3 ways to itterate over substructures.
```html
<ul>
	<foreach $people>
		<li>My name is #{$name}, my age is #{$age}</li>
	</foreach>
</ul>
```
In this example we provide a single `$people` array to the `foreach` tag to itterate over.

```html
<ul>
	<foreach $index in $people>
		<li>#{$index}. My name is #{$name}, my age is #{$age}</li>
	</foreach>
</ul>
```
Here we have assigned a name to our itterator index (`$index`) so now we can use it as a [local variable](#variables) in the [scope](#scope) of our current substructure array item. If the index name is not set, it will take a default name `$_index`.

```html
<ul>
	<foreach $index in $people as $person>
		<li>#{$index+1}. My name is #{$name}, my age is #{$person['age']}</li>
	</foreach>
</ul>
```
We have added an additional variable `$person` to our `foreach` tag. This variable is our current array item, so we can access its keys explicitly within the tag or any nested tags or [linked blocks](#linked-block-tag).

Once again, the `foreach` loop will shift the [scope](#scope) to the current substructure array item, so in order to access values from the parent structure, we need to use [inherited variables](#variables) (`@variable`).

###Linked block tag###
As their name suggests, `linked blocks` are [template blocks](#blocks) that render inside the block we are currently rendering.

Consider the following view structure:
```javascript
var view =
{
	name: 'Archie',
	place: 'somewhere',
	header:
	{
		place: 'world'
	},
	foo:
	{
		year: 2013
	}
}
```
Now, let's look at our template:
```html
[main]
	<@header>
	<div>My name is #{$name}</div>
	<@footer>
[/main]

[header]
	<h1>Hello, #{$place}!</h1>
[/header]

[footer]
	<div>The year is: #{$year}</div>
[/footer]
```

When rendered, linked tags will try to use a view substructure with the `linked block's` name as its key. If no such substructure exists, the `linked block` will use the parent structure, so the resulring output will be:
```html
<h1>Hello, world!</h1>
<div>My name is Archie</div>
<div>The year is:</div>
```
But, if we are to remove the `header` substructure from our view, the result will be:
```html
<h1>Hello, somewhere!</h1>
<div>My name is Archie</div>
<div>The year is:</div>
```

We can also explicitlly assign structure data to our `linked block`:
```html
<@header {place: 'here'}>
<div>My name is #{$name}</div>
<@header $foo>
```
Will result in:
```html
<h1>Hello, here!</h1>
<div>My name is Archie</div>
<div>The year is: 2013</div>
```


text:
# containerExecuteStructureTests

## Description

In this step [Container Structure Tests](https://github.com/GoogleContainerTools/container-structure-test) are executed.

This testing framework allows you to execute different test types against a Docker container, for example:

* Command tests (only if a Docker Deamon is available)
* File existence tests
* File content tests
* Metadata test

## Prerequisites

Test configuration is available.

## Parameters

| name | mandatory | default | possible values |
|------|-----------|---------|-----------------|
| `containerCommand` | no | `/busybox/tail -f /dev/null` |  |
| `containerShell` | no | `/busybox/sh` |  |
| `dockerImage` | no | `ppiper/container-structure-test` |  |
| `dockerOptions` | no | `-u 0 --entrypoint=''` |  |
| `failOnError` | no | `true` | `true`, `false` |
| `pullImage` | no |  | `true`, `false` |
| `script` | yes |  |  |
| `stashContent` | no | `[tests]` |  |
| `testConfiguration` | no |  |  |
| `testDriver` | no |  |  |
| `testImage` | no |  |  |
| `testReportFilePath` | no | `cst-report.json` |  |
| `verbose` | no |  | `true`, `false` |

* `containerCommand` - Kubernetes only: Allows to specify start command for container created with dockerImage parameter to overwrite Piper default (`/usr/bin/tail -f /dev/null`).
* `containerShell` - Kubernetes only: Allows to specify the shell to be used for execution of commands.
* `dockerImage` - Name of the docker image that should be used. If empty, Docker is not used and the command is executed directly on the Jenkins system.
* `dockerOptions` - Docker options to be set when starting the container (List or String).
* `failOnError` - Defines the behavior, in case tests fail.
* `pullImage` - Only relevant for testDriver 'docker'.
* `script` - The common script environment of the Jenkinsfile running. Typically the reference to the script calling the pipeline step is provided with the `this` parameter, as in `script: this`. This allows the function to access the `commonPipelineEnvironment` for retrieving, e.g. configuration parameters.
* `stashContent` - Specific stashes that should be considered for the step execution.
* `testConfiguration` - Container structure test configuration in yml or json format. You can pass a pattern in order to execute multiple tests.
* `testDriver` - Container structure test driver to be used for testing, please see https://github.com/GoogleContainerTools/container-structure-test for details.
* `testImage` - Image to be tested
* `testReportFilePath` - Path and name of the test report which will be generated
* `verbose` - Print more detailed information into the log.

## Step configuration

We recommend to define values of step parameters via [config.yml file](../configuration.md).

In following sections of the config.yml the configuration is possible:

| parameter | general | step/stage |
|-----------|---------|------------|
| `containerCommand` |  | X |
| `containerShell` |  | X |
| `dockerImage` |  | X |
| `dockerOptions` |  | X |
| `failOnError` |  | X |
| `pullImage` |  | X |
| `script` |  |  |
| `stashContent` |  | X |
| `testConfiguration` |  | X |
| `testDriver` |  | X |
| `testImage` |  | X |
| `testReportFilePath` |  | X |
| `verbose` | X | X |

## Dependencies

The step depends on the following Jenkins plugins

* [docker](https://plugins.jenkins.io/docker)
* [kubernetes](https://plugins.jenkins.io/kubernetes)
* [pipeline-utility-steps](https://plugins.jenkins.io/pipeline-utility-steps)
* [workflow-basic-steps](https://plugins.jenkins.io/workflow-basic-steps)
* [workflow-cps-global-lib](https://plugins.jenkins.io/workflow-cps-global-lib)
* [workflow-durable-task-step](https://plugins.jenkins.io/workflow-durable-task-step)

The kubernetes plugin is only used if running in a kubernetes environment.
Transitive dependencies are omitted.

The list might be incomplete.

Consider using the [ppiper/jenkins-master](https://cloud.docker.com/u/ppiper/repository/docker/ppiper/jenkins-master)
docker image. This images comes with preinstalled plugins.

## Example

```
containerExecuteStructureTests(
  script: this,
  testConfiguration: 'config.yml',
  testImage: 'node:latest'
)
```

repository: bertpersyn/jenkins-library

repo_name: bertpersyn/jenkins-library


text:
# Activity Tracker Application

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 11.2.6.

Activity Tracker is an application for monitoring Tasks.
It takes different tasks(study, workout, etc) as Input and Maintains the tasks list for the user. In Real-time user can modify the list by adding new tasks, mark the tasks as complete and also clear the whole list.

# Project Output
![](https://github.com/rutuja1302/Activity-Tracker/blob/main/src/assets/activity-tracker-output.gif)

## Pre-requisites:
- Install Node js : https://nodejs.org/en/
- Install Angular CLI : https://angular.io/cli
- Install a Suitable IDE: https://code.visualstudio.com/download

## Development server

Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app will automatically reload if you change any of the source files.

## Code scaffolding

Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.

## Build

Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory. Use the `--prod` flag for a production build.

## Running unit tests

Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).

## Running end-to-end tests

Run `ng e2e` to execute the end-to-end tests via [Protractor](http://www.protractortest.org/).


text:
# Publishing serverless applications using the AWS SAM CLI

To make your AWS SAM application available for others to find and deploy, you can use the AWS SAM CLI to publish it to the AWS Serverless Application Repository\. To publish your application using the AWS SAM CLI, you must define it using an AWS SAM template\. You also must have tested it locally or in the AWS Cloud\.

Follow the instructions in this topic to create a new application, create a new version of an existing application, or update the metadata of an existing application\. \(What you do depends on whether the application already exists in the AWS Serverless Application Repository, and whether any application metadata is changing\.\) For more information about application metadata, see [AWS SAM template Metadata section properties](serverless-sam-template-publishing-applications-metadata-properties.md)\.

## Prerequisites

Before you publish an application to the AWS Serverless Application Repository using the AWS SAM CLI, you must have the following:
+ The AWS SAM CLI installed\. For more information, see [Installing the AWS SAM CLI](serverless-sam-cli-install.md)\. To determine whether the AWS SAM CLI is installed, run the following command:

  ```
  sam --version
  ```
+ A valid AWS SAM template\.
+ Your application code and dependencies that the AWS SAM template references\.
+ A semantic version, required only to share your application publicly\. This value can be as simple as 1\.0\.
+ A URL that points to your application's source code\.
+ A `README.md` file\. This file should describe how customers can use your application and how to configure it before deploying it in their own AWS accounts\.
+ A `LICENSE.txt` file, required only to share your application publicly\.
+ If your application contains any nested applications, you must have already published them to the AWS Serverless Application Repository\.
+ A valid Amazon Simple Storage Service \(Amazon S3\) bucket policy that grants the service read permissions for artifacts that you upload to Amazon S3 when you package your application\. To set up this policy, do the following:

  1. Open the Amazon S3 console at [https://console\.aws\.amazon\.com/s3/](https://console.aws.amazon.com/s3/)\.

  1. Choose the name of the Amazon S3 bucket that you used to package your application\.

  1. Choose **Permissions**\.

  1. On the **Permissions** tab, under **Bucket policy**, choose **Edit**\.

  1. On the **Edit bucket policy** page, paste the following policy statement into the **Policy** editor\. In the policy statement, make sure to use your bucket name in the `Resource` element and your AWS account ID in the `Condition` element\. The expression in the `Condition` element ensures that AWS Serverless Application Repository has permission to access only applications from the specified AWS account\. For more information about policy statements, see [IAM JSON policy elements reference](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) in the *IAM User Guide*\.

     ```
      1. {
      2.     "Version": "2012-10-17",
      3.     "Statement": [
      4.         {
      5.             "Effect": "Allow",
      6.             "Principal": {
      7.                 "Service":  "serverlessrepo.amazonaws.com"
      8.             },
      9.             "Action": "s3:GetObject",
     10.             "Resource": "arn:aws:s3:::<your-bucket-name>/*",
     11.             "Condition" : {
     12.                 "StringEquals": {
     13.                     "aws:SourceAccount": "123456789012"
     14.                 }
     15.             }
     16.         }
     17.     ]
     18. }
     ```

  1. Choose **Save changes**\.

## Publishing a new application

### Step 1: Add a `Metadata` section to the AWS SAM template

First, add a `Metadata` section to your AWS SAM template\. Provide the application information to be published to the AWS Serverless Application Repository\.

The following is an example `Metadata` section:

```
Metadata:
  AWS::ServerlessRepo::Application:
    Name: my-app
    Description: hello world
    Author: user1
    SpdxLicenseId: Apache-2.0
    LicenseUrl: LICENSE.txt
    ReadmeUrl: README.md
    Labels: ['tests']
    HomePageUrl: https://github.com/user1/my-app-project
    SemanticVersion: 0.0.1
    SourceCodeUrl: https://github.com/user1/my-app-project

Resources:
  HelloWorldFunction:
    Type: AWS::Lambda::Function
      Properties:
        ...
        CodeUri: source-code1
        ...
```

For more information about the `Metadata` section of the AWS SAM template, see [AWS SAM template Metadata section properties](serverless-sam-template-publishing-applications-metadata-properties.md)\.

### Step 2: Package the application

Run the following AWS SAM CLI command, which uploads the application's artifacts to Amazon S3 and outputs a new template file called `packaged.yaml`:

```
sam package --template-file template.yaml --output-template-file packaged.yaml --s3-bucket <your-bucket-name>
```

You use the `packaged.yaml` template file in the next step to publish the application to the AWS Serverless Application Repository\. This file is similar to the original template file \(`template.yaml`\), but it has a key difference—the `CodeUri`, `LicenseUrl`, and `ReadmeUrl` properties point to the Amazon S3 bucket and objects that contain the respective artifacts\.

The following snippet from an example `packaged.yaml` template file shows the `CodeUri` property:

```
MySampleFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: s3://bucketname/fbd77a3647a4f47a352fcObjectGUID

...
```

### Step 3: Publish the application

To publish a private version of your AWS SAM application to the AWS Serverless Application Repository, run the following AWS SAM CLI command:

```
sam publish --template packaged.yaml --region us-east-1
```

The output of the `sam publish` command includes a link to your application on the AWS Serverless Application Repository\. You can also go directly to the [AWS Serverless Application Repository landing page](https://serverlessrepo.aws.amazon.com/applications) and search for your application\.

### Step 4: Share the application \(optional\)

By default, your application is set to private, so it isn't visible to other AWS accounts\. To share your application with others, you must either make it public or grant permission to a specific list of AWS accounts\.

For information about sharing your application using the AWS CLI, see [AWS Serverless Application Repository Resource\-Based Policy Examples](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/security_iam_resource-based-policy-examples.html) in the *AWS Serverless Application Repository Developer Guide*\. For information on sharing your application using the AWS Management Console, see [Sharing an Application](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-how-to-publish.html#share-application) in the *AWS Serverless Application Repository Developer Guide*\.

## Publishing a new version of an existing application

After you've published an application to the AWS Serverless Application Repository, you might want to publish a new version of it\. For example, you might have changed your Lambda function code or added a new component to your application architecture\.

To update an application that you've previously published, publish the application again using the same process detailed previously\. In the `Metadata` section of the AWS SAM template file, provide the same application name that you originally published it with, but include a new `SemanticVersion` value\.

For example, consider an application published with the name `SampleApp` and a `SemanticVersion` of `1.0.0`\. To update that application, the AWS SAM template must have the application name `SampleApp` and a `SemanticVersion` of `1.0.1` \(or anything other than `1.0.0`\)\.

## Additional topics
+ [AWS SAM template Metadata section properties](serverless-sam-template-publishing-applications-metadata-properties.md)

repository: philbasford/aws-sam-developer-guide

repo_name: philbasford/aws-sam-developer-guide


text:
---
layout: post
title:  "Getting started with images"
date:   2017-02-20
---

To get started with Julia, I wanted to learn more about the ecosystem of image support in Julia. Until now, my tools of choice for manipulating images was [numpy](http://www.numpy.org/) in Python and [OpenCV](http://opencv.org/). Instead, Julia has the [JuliaImages](http://juliaimages.github.io/latest/) ecosystem of packages for image support.

<!--more-->

Now I've included the notebook I used to install and play with basic images:

{% include notebook.html name='01-getting-started-with-images' %}

Any comments for me?

repository: mprat/learningjulia

repo_name: mprat/learningjulia


text:
# Exercise Set (B)

For all of these exercises, do **not** hand them in, just ensure your teacher sees the work, and that you can communicate your understanding of the work related to the learning goals.

It is highly suggested that you complete these 3 exercises **prior** to attempting [Processing - Assignment 2](Processing-Assignment-2)

## Exercise 6
_Estimated time to complete: 2-4 classes_

1. Recreate the image below. You will need to use the ```%``` operator and ```while``` loops to complete this task.

![here](http://mrseidel.com/images/Processing/3U/Exercise6_3U.gif)

## Exercise 7
_Estimated time to complete: 1-3 classes_

1. Recreate the image below. Use ```for``` loops to complete this task.  You can technically complete this task using ```while``` loops, but it is expected that you practice using ```for``` loops.

![here](http://mrseidel.com/images/Processing/3U/Exercise7_3U.png)

## Exercise 8
_Estimated time to complete: 1 class_

1. Create a copy of Assignment #1.
2. In your new copy, change the flow of your program into separate functions.

## Learning Goals and Success Criteria

The [Overarching Learning Goal](./images/ICS3U.jpg) for this is _Programming Concepts_.
The specific Learning Goal(s) for this include:
  * We are learning to design and organize a computer program.
  * We are learning to create simple computer programs.

| Success Criteria for
 _We are learning to design and organize a computer program_ | Met | Not Met | Learning and Improvement Comments |
| ----------- | --- | ------ | ------- |
| I can use workplace and professional conventions correctly to write programs and internal documentation | | | |
| I can interpret error messages at different times during the software development process | | | |

| Success Criteria for
 _We are learning to create computer programs_ | Met | Not Met | Learning and Improvement Comments |
| ----------- | --- | ------ | ------- |
| I can use constants and variables correctly in my programs | | | |
| I can use assignment statements correctly with both arithmetic and string expressions | | | |
| I can use arithmetic operators in a program | | | |
| I can use comparison operators in a program  | | | |
| I can use selection control structures in a program  | | | |
| I can use repetition control structures in a program  | | | |
| I can write custom subprograms that use parameter passing and appropriate scope to perform specific tasks in a program  | | | |
| I can work independently using support documentation to write functioning computer programs | | | |

repository: mrseidel-classes/archives

repo_name: mrseidel-classes/archives


text:
---
layout:     post
title:      "Solving Partial Differential Equations"
subtitle:   "In this post, we will look at the implementation of PDE simulation in Theano."
date:       2018-11-18 18:08
author:     "bakera1"
header-img: "img/pde.jpg"
image: /img/pde.jpg
category:   techblog
tags:       [pde, theano, numpy]
---

We all know Theano as a forefront library for Deep Learning research. However, it should be noted that Theano is a general purpose numerical computing library, like Numpy. Hence, in this post, we will look at the implementation of PDE simulation in Theano.

The Laplace Equation

We will look at a simple PDE example, the [Laplace Equation](https://en.wikipedia.org/wiki/Laplace's_equation):

$$ \nabla^2 \phi = 0 $$

In other words, this is an second order PDE, as, recall that Laplacian in calculus is the divergence of gradient of a function:

$$ \nabla \cdot \nabla \phi = 0 $$

particularly, in two dimension:

$$ \frac{\partial^2 \phi}{\partial x^2} + \frac{\partial^2 \phi}{\partial y^2} = 0 $$

This simple equation could be solved by using Finite Difference scheme [1].

Note that in this example, we are ignoring the boundary value problem.

Solving Laplace Equation in Numpy

The Finite Difference solution of Laplace Equation is to repeatedly averaging the neighbors of a particular point:

$$ \phi_{i, j} = \frac{1}{4} \left( \phi_{i+1, j} + \phi_{i+1, j} + \phi_{i, j+1} + \phi_{i, j-1} \right) $$

This iterative solution is very simple to implement in Numpy. But first, let's give this problem an initial condition:

$$ \phi = -5 \, \exp (x^2 + y^2) $$

Visualizing the function:

![Initial]({{ site.baseurl }}/img/2017-01-08-theano-pde/initial.png)

Now, let's implement this. First, we create the mesh, the solution space:

``` python
# Create 21x21 mesh grid
m = 21
mesh_range = np.arange(-1, 1, 2/(m-1))
x, y = np.meshgrid(mesh_range, mesh_range)

# Initial condition
U = np.exp(-5 * (x**2 + y**2))
```

We then create an indexing scheme that select the point north, west, south, and east of any given point. We do this so that we could implement this in vectorized manner.

References

[Mitra, Ambar K. "Finite difference method for the solution of Laplace equation." preprint.](http://www.public.iastate.edu/~akmitra/aero361/design_web/Laplace.pdf)


text:
# Android Architecture Components Extensions
[![License](https://img.shields.io/hexpm/l/plug.svg)]()

This is the Android Architecture Components extension library available for kotlin.

I used kotlin infix notation for the following code.

```
ViewModelProviders.of(this, object : ViewModelProvider.Factory {
    override fun <T : ViewModel?> create(modelClass: Class<T>?): T {
        return MyViewModel(..., ..., ...) as T
    }
}).get(MyViewModel::class.java)
```

## Library version

It can be used jcenter(), as follows

### AndroidX package

[ ![Download](https://api.bintray.com/packages/taehwandev/thdev.tech/lifecycle-extensions/images/download.svg) ](https://bintray.com/taehwandev/thdev.tech/lifecycle-extensions/_latestVersion)

```
implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.3.10'
implementation 'androidx.appcompat:appcompat:1.0.2'

implementation 'androidx.lifecycle:lifecycle-extensions:2.0.0'
implementation "tech.thdev.lifecycle:lifecycle-extensions:$latestVersion"
```

### Legacy package

[ ![Download](https://api.bintray.com/packages/taehwandev/thdev.tech/lifecycle-extensions-legacy/images/download.svg) ](https://bintray.com/taehwandev/thdev.tech/lifecycle-extensions-legacy/_latestVersion)

```
implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.3.10'
implementation 'com.android.support:appcompat-v7:27.1.1'

implementation 'android.arch.lifecycle:extensions:1.1.1'
implementation "tech.thdev.lifecycle:lifecycle-extensions-legacy:$latestLegacyVersion"
```

## Diagram

![](./images/AAC-ViewModel.png)

## Blog

한글 Post - [Android Architecture Components ViewModel을 간단하게 초기화 하려면?](https://thdev.tech/androiddev/2018/08/05/Android-Architecture-Components-ViewModel-Inject/)

## Use api

### [Guide AAC - ViewModel](README_VIEW_MODEL.md)

```kotlin
class MainActivity : AppCompatActivity() {

    private val viewModel: MyViewModel
            by lazyInjectViewModel(/* @Option customKey = "custom key" */) {
        // create Your ViewModel
        MyViewModel(..., ..., ...)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        // Maybe init view model
        viewModel ...
    }
}
```

### [Guide AAC - LifecycleObserver](README_LIFECYCLE_OBSERVER.md)

```kotlin
class MainActivity : AppCompatActivity() {

    private val observer: MyLifecycleObserver by injectAutoLifecycle {
        // create Your Observer
        MyLifecycleObserver(..., ..., ...)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        // use lifecycle
    }
}
```

## License

```
Copyright 2017-2018 Tae-hwan

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```

repository: taehwandev/LifecycleExtensions

repo_name: taehwandev/LifecycleExtensions


text:
# LSTM noise detection

## Description

Project developed in order to use LSTM (RNN) models for noise detection into synthesis images.

## Installation

```bash
git clone --recursive https://github.com/prise-3d/LSTM-noise-detection.git
```

```bash
pip install -r requirements.txt
```

## Prepare data and train model

### Precompute the whole expected features
First you need to generate data using thresholds file (file obtained from SIN3D app):

```bash
python processing/prepare_data_file.py --dataset /path/to/folder --thresholds file.csv --method svd  --params "0,200" --imnorm 0 --output output
```

- `--output`: save automatically output into `data/generated`.
- `--params`: associated params to selected method.
- `--imnorm`: specified if image is normalized or not before computing method.

### Well compare models
In order to well compare models, you need to set the training and testing zones used for your dataset:

```bash
python processing/generate_selected_zones_file.py --dataset /path/to/folder --n_zones 12 --output file --thresholds file.csv
```

- `--output`: save automatically output into `data/learned_zones`

Each image is cut out into 16 zones, then you need to use the `n_zones` parameter to set you number of zones selected for training part.

The generated output file contains information for each scene about indices used for training and testing sets.

### Generate your dataset

Then, you can generate your dataset:

```bash
python processing/prepare_dataset_zones.py --data data/generated/output --selected_zones data/learned_zones/file --sequence 5 --output data/datasets/name
```

- `--data`: specify the output data folder path generated when precomputing features (saved into `data/generated`).
- `--selected_zones`: the previous output file generated in order to set (if specified `n_zones` is not used).
- `--sequence`: sliding window size to use as sequence input.
- `--n_zones`: number of zones to take if ramdomly zones choice.
- `--output`: save automatically output into `data/datasets`.

### Train your model

You can now use your dataset to train your model:

```bash
python train_lstm_weighted_v2.py --train data/datasets/dataset/dataset.train --test data/datasets/dataset/dataset.train --output modelv1 --seq_norm 1
```

- `--data`: specify the dataset name (without .train and .test generated extension) obtained from previous script.
- `--output`: save automatically output into `data/saved_models`.
- `--seq_norm`: set normalization of data by feature for sequence

## Simulations

### Obtained model simulation on scene

```bash
python display/display_thresholds_scene_file.py --model data/saved_models/modelv1.joblib --method svd --params "0,200" --sequence 5 --imnorm 1 --scene /path/to/scene --selected_zones data/learned_zones/file --thresholds filename.csv --save_thresholds simulation.csv --label_thresholds "Simulate modelv1"
```

- `--folder`: scene folder to simulate on.
- `--save_thresholds`: save estimated thresholds into file.
- `--label_thresholds`: label to use for this model into the saved file.

## Contributors

* [jbuisine](https://github.com/jbuisine)

## License

[MIT](LICENSE)


text:
+++
title = "D2C SUSHI CUISINE"
categories = ["d2c"]
tags = ["food", "japan", "consumer"]
weight = 12
+++

# D2C SUSHI CUISINE

---

## Mission

BRING THE AUTHENTIC SUSHI EXPERIENCE TO EVERYONE, ANYWHERE, ANYPLACE

---

## Problem

- The quality of sushi in the states is vastly volatile
- Very difficult to enjoy fresh sushi at home
- The experience of sushi cuisine is not authentic

---

## Solution

- Cutting-solution through luxurious authentic experiences
- Deliver to anytime, anywhere, anyplace in LA
- Provide an authentic, natural & unique experience to all

repository: shunkakinoki/pitch

repo_name: shunkakinoki/pitch


text:
# Polyporus roseus var. ceratophora (Hoffm.) Pers., 1825 VARIETY

#### Status
SYNONYM

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

#### Published in
Mycol. eur. (Erlanga) 2: 79 (1825)

#### Original name
Boletus ceratophorus Hoffm., 1794

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Gloeophyllales/Gloeophyllaceae/Gloeophyllum/Gloeophyllum odoratum/ Syn. Polyporus roseus ceratophora/README.md

repo_name: mdoering/backbone


text:
# THREE.UpdatableTexture

An extended `THREE.Texture` to provide support for partial updates, via [`texSubImage2D`](https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/texSubImage2D).

`UpdatableTexture` lets you update only a part of a texture: it's useful for incremental loads of large images, for tiled resources, etc.

Check a [demo of partially updated texture](https://spite.github.io/THREE.UpdatableTexture/).

[![UpdatableTexture Demo](https://raw.githubusercontent.com/spite/THREE.UpdatableTexture/master/about/updatabletexture.jpg)](https://spite.github.io/THREE.UpdatableTexture)

The demo uses a 512x512 texture updated with blocks of 32x32. The best texture size and tile size it's a bit up to your target performance.

#### How to use ####
Include three.js lib and the script in your project:
```html
<script src="three.js"></script>
<script src="UpdatableTexture.js"></script>
```

You can create `UpdatableTexture` like any other `THREE.Texture`:
```js
// UpdatableTexture has the same signature as THREE.Texture
let a = texture = new UpdatableTexture();
```
You have to attach a `renderer` to it (*this will change if this textures makes into three.js core*)
```js
texture.setRenderer( renderer );
```
You can modify the `UpdatableTexture` attributes the same way you do with `THREE.Texture`
```js
texture.minFilter = texture.magFilter = THREE.NearestFilter;
texture.generateMipmaps = false;
```
Since the `UpdatableTexture` will be updated from one or more pieces, first you need to set the size:
```js
texture.setSize( width, height );
```
From then on, you can use to update a part of the texture:
```js
texture.update( source, x, y );
```
`source` can be an `ArrayBufferView`, an `ImageData`, an `HTMLImageElement`, an `HTMLCanvasElement`, an `HTMLVideoElement` or an `ImageBitmap`.

`x` and `y` are the offsets inside the big texture in which to draw the smaller texture. The width and height of the smaller texture is read from the resource. Make sure offset plus dimensions is not bigger than the large texture dimensions.

#### So how do I actually use it? ####

This will let you update parts of the texture, the rest is up to your ideas and needs. For instance, you can pre-tile your assets and load them via `Fetch` and `createImageBitmap`, and update the final texture in a scheduled fashion. Or you can download a large image, and then update parts. Right now you need to create an intermediate canvas to hold the partial part of the image, since WebGL methods don't have cropping features, but they do in WebGL2.

### License ####

MIT licensed

Copyright (C) 2017 Jaume Sanchez Elias, http://www.clicktorelease.com


text:
# Implementing a planning search  <!-- omit in toc -->

This is the second project of Artificial Intelligence Nanodegree at Udacity, aiming to solve deterministic logistics planning problems for an Air Cargo transport system using a planning search agent.

***Note:** Read Chapter 10 of "**Artificial Intelligence: A modern Approach**" 3rd edition by Peter Norvig on planning available [here](AIMA-3rd-ed.pdf) before starting this project.*

Find the official Readme for the project [here](default%20instructions.md)

## Index  <!-- omit in toc -->

- [Setting up Anaconda environment](#setting-up-anaconda-environment)
    - [1. Download the AIND Anaconda environment](#1-download-the-aind-anaconda-environment)
    - [2. Create the environment](#2-create-the-environment)
    - [3. Activate the Environment](#3-activate-the-environment)
      - [Installation Errors](#installation-errors)
    - [4. Installing `pypy`](#4-installing-pypy)
    - [5. Run test](#5-run-test)
- [Exercise Details](#exercise-details)
  - [Example Problem](#example-problem)
  - [Test](#test)
    - [Running the test](#running-the-test)
- [Results](#results)
  - [Find the Results here](#find-the-results-here)

## Setting up Anaconda environment

***(Note: The Recommended Python Version by Udacity is 3.5 or 3.6)***

#### 1. Download the AIND Anaconda environment

Enter the following command in your Linux terminal:
```
wget https://video.udacity-data.com/topher/2018/May/5afdeed0_aind-universal-v3/aind-universal-v3.yml
```

or directly download for windows from [here](aind-universal-v3.yml).

*(Note for Windows users: Some browsers will automatically append a ".txt" extension to the yml file; if your browser does this, then you will need to remove the extension or alter the creation command to correct it.)*

#### 2. Create the environment

Open a Conda activated terminal or Anaconda Prompt and run:

```
conda env create -f aind-universal-v3.yml
```

#### 3. Activate the Environment

- Windows: `activate aind`
- Linux/Mac: `source activate aind`

##### Installation Errors

*WARNING: SOME OPERATING SYSTEMS MAY PRODUCE ERRORS WHILE INSTALLING Z3 -- DO NOT PANIC.*

It can be challenging to configure Z3, particularly on some versions of Windows. You may use the information below to attempt installing Z3 on Windows, but that platform is not well-supported by the Z3 library maintainers.

NOTE: You may need a C/C++ compiler to build some of the required packages if your system cannot find an installable binary. OSX & Linux users can use gcc & g++/clang *(OSX users will need the XCode Command Line Tools available by running `xcode-select --install` from a Terminal.)* Windows users can download & install Visual C++ Build Tools [here](http://landinghub.visualstudio.com/visual-cpp-build-tools).

Activate the conda environment (source activate aind or activate aind, depending on your OS), then try installing with pip:

```
pip install z3-solver
```

#### 4. Installing `pypy`

`pypy` is an alternative to the standard `cPython`  runtime that tries to optimize and selectively compile your code for improved speed, and it can run 2-10x faster for this project. There are binaries available for Linux, Windows, and OS X. Simply download and run the appropriate `pypy` binary installer *(make sure you get version 3.5)* or use the package manager for your OS. When properly installed, any `python` commands can be run with `pypy` instead. (*You may need to specify `pypy3` on some OSes.)*

```
conda install pypy3
```

#### 5. Run test

After completing the code, run
```
pypy3 -m unitttest -v
```

## Exercise Details

### Example Problem

Run the example problem *(based on the cake problem from Fig 10.7 in Chapter 10.3 of [AIMA](AIMA-3rd-ed.pdf))*

```
pypy3 example_have_cake.py
```

### Test

The run_search.py script allows you to choose any combination of eleven search algorithms (*three uninformed and eight with heuristics)* on four air cargo problems. The cargo problem instances have different numbers of airplanes, cargo items, and airports that increase the complexity of the domains.

You should run all of the search algorithms on the first two problems and record the following information for each combination:

- Number of actions in the domain
- Number of new node expansions
- Time to complete the plan search

Use the results from the first two problems to determine whether any of the uninformed search algorithms should be excluded for problems 3 and 4. You must run at least one uninformed search, two heuristics with greedy best first search, and two heuristics with A* on problems 3 and 4.

#### Running the test

To run the test, enter:
```
pypy3 run_search.py -m
```

To select the problems and search algorithm inline, enter the problem and search number separated by spaces like this:
```
pypy3 run_search.py -p 1 2 3 -s 1 2 3 4 5
```

## Results

### Find the Results [here](report.md)

The file `report.pdf` includes all of the figures (charts and tables) and written responses to the questions below.

1. Use a table or chart to analyze the number of nodes expanded against number of actions in the domain
2. Use a table or chart to analyze the search time against the number of actions in the domain
3. Use a table or chart to analyze the length of the plans returned by each algorithm on all search problems
4. Use your results to answer the following questions:

    - Which algorithm or algorithms would be most appropriate for planning in a very restricted domain (i.e., one that has only a few actions) and needs to operate in real time?

    - Which algorithm or algorithms would be most appropriate for planning in very large domains (e.g., planning delivery routes for all UPS drivers in the U.S. on a given day)

    - Which algorithm or algorithms would be most appropriate for planning problems where it is important to find only optimal plans?

<!-- ![Progression air cargo search](/images/Progression.PNG) -->


text:
---
hrs_structure:
  division: '1'
  volume: '7'
  title: '21'
  chapter: '378'
  section: 378-72
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0378-0072
    parent: HRS0378
    name: 378-72 Leave of absence for domestic or sexual violence
weight: 71205
title: Leave of absence for domestic or sexual violence
full_title: 378-72 Leave of absence for domestic or sexual violence
---
[B.] Victims Leave

Note

Sections 378-72 to 378-74 designated as Subpart B by L 2011, c 206, §3(3).

**[§378-72] Leave of absence for domestic or sexual violence.** (a) An employer employing fifty or more employees shall allow an employee to take up to thirty days of unpaid victim leave from work per calendar year, or an employer employing not more than forty-nine employees shall allow an employee to take up to five days of unpaid leave from work per calendar year, if the employee or the employee's minor child is a victim of domestic or sexual violence; provided the leave is to either:

(1) Seek medical attention for the employee or employee's minor child to recover from physical or psychological injury or disability caused by domestic or sexual violence;

(2) Obtain services from a victim services organization;

(3) Obtain psychological or other counseling;

(4) Temporarily or permanently relocate; or

(5) Take legal action, including preparing for or participating in any civil or criminal legal proceeding related to or resulting from the domestic or sexual violence, or other actions to enhance the physical, psychological, or economic health or safety of the employee or the employee's minor child or to enhance the safety of those who associate with or work with the employee.

(b) An employee's absence from work that is due to or resulting from domestic abuse or sexual violence against the employee or the employee's minor child as provided in this section shall be considered by an employer to be a justification for leave for a reasonable period of time, not to exceed the total number of days allocable for each category of employer under subsection (a).

"Reasonable period of time" as used in this section means:

(1) Where due to physical or psychological injury to or disability to the employee or employee's minor child, the period of time determined to be necessary by the attending health care provider, considering the condition of the employee or employee's minor child, and the job requirements; and

(2) Where due to an employee's need to take legal or other actions, including preparing for or participating in any civil or criminal legal proceeding, obtaining services from a victim services organization, or permanently or temporarily relocating, the period of time necessary to complete the activity as determined by the employee's or employee's minor child's attorney or advocate, court, or personnel of the relevant victim services organization.

(c) Where an employee is a victim of domestic or sexual violence and seeks leave for medical attention to recover from physical or psychological injury or disability caused by domestic or sexual violence, the employer may request that the employee provide:

(1) A certificate from a health care provider estimating the number of leave days necessary and the estimated commencement and termination dates of leave required by the employee; and

(2) Prior to the employee's return, a medical certificate from the employee's attending health care provider attesting to the employee's condition and approving the employee's return to work.

(d) Where an employee has taken not more than five calendar days of leave for non-medical reasons, the employee shall provide certification to the employer in the form of a signed statement within a reasonable period after the employer's request, that the employee or the employee's minor child is a victim of domestic or sexual violence and the leave is for one of the purposes enumerated in subsection (a). If the leave exceeds five days per calendar year, then the certification shall be provided by one of the following methods:

(1) A signed written statement from an employee, agent, or volunteer of a victim services organization, from the employee's attorney or advocate, from a minor child's attorney or advocate, or a medical or other professional from whom the employee or the employee's minor child has sought assistance related to the domestic or sexual violence; or

(2) A police or court record related to the domestic or sexual violence.

(e) If certification is required, no leave shall be protected until a certification, as provided in this section, is provided to the employer.

(f) The employee shall provide the employer with reasonable notice of the employee's intention to take the leave, unless providing that notice is not practicable due to imminent danger to the employee or the employee's minor child.

(g) Nothing in this section shall be construed to prohibit an employer from requiring an employee on victim leave to report not less than once a week to the employer on the status of the employee and intention of the employee to return to work.

(h) Upon return from leave under this section, the employee shall return to the employee's original job or to a position of comparable status and pay, without loss of accumulated service credits and privileges, except that nothing in this subsection shall be construed to entitle any restored employee to the accrual of:

(1) Any seniority or employment benefits during any period of leave, unless the seniority or benefits would be provided to a similarly situated employee who was on leave due to a reason other than domestic or sexual violence; or

(2) Any right, benefit, or position of employment to which the employee would not have otherwise been entitled.

(i) All information provided to the employer under this section, including statements of the employee, or any other documentation, record, or corroborating evidence, and the fact that the employee or employee's minor child has been a victim of domestic or sexual violence or the employee has requested leave pursuant to this section, shall be maintained in the strictest confidence by the employer, and shall not be disclosed, except to the extent that disclosure is:

(1) Requested or consented to by the employee;

(2) Ordered by a court or administrative agency; or

(3) Otherwise required by applicable federal or state law.

(j) Any employee denied leave by an employer in wilful violation of this section may file a civil action against the employer to enforce this section and recover costs, including reasonable attorney's fees, incurred in the civil action. [L 2003, c 60, pt of §2]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# Apps-Engine

## Purpose

The Rocket.Chat Apps Team is responsible for the Apps-Engine framework, which allows developers to make plugins \(apps\) to extend Rocket.Chat's functionality without having to deep dive into the core codebase. Along with the framework itself, we work on official integrations through the Apps-Engine, maintain the tooling around it and integrate Rocket.Chat with our Marketplace.

## Processes

We're running some experiments on how to run your development processes, based on some practices from the Agile methodologies.

Currently, we have a 2-week sprint - within which we have a **Planning**, a **Retrospective**, and **Daily** sessions.

* **Planning - Mondays at** [**10am \(BRT\)**](http://mytime.io/10am/BRT) **-** On the first Monday of the sprint, we go over our ClickUp backlog, selecting what we think fits into our Sprint. On the _second_ Monday of the sprint, we just have a check-in for the overall progress and try to identify any point we might need to pivot.
* **Dailies - Every day at** [**9:45am \(BRT\)**](http://mytime.io/9:45am/BRT) **-** We follow the "standard" format of the Scrum Daily ceremony. Every team member shares the progress they had in their tasks in the previous day, the plans for advancing in the current day, and if there are any blockers. **NOTE:** Whenever the daily "conflicts" with any other call we have, we'll just merge it into the other call.
* **Retrospective - Every other Friday at** [**10am \(BRT\)**](http://mytime.io/10am/BRT) **-** We do it at the end of every Sprint. We go over the accomplishments of that specific Sprint, and then discuss what has worked and what can be improved in the process, coming up with action items we need to achieve those improvements.

### Other Calls

We have some things that are not in Agile methodologies:

* **Tuesdays** [**09:45am \(BRT\)**](http://mytime.io/09:45am/BRT) **- Engineering Session -** Topics discussed here can vary. Firstly we discuss the approaches we're going with when dealing with tasks/investigations. Then, we can move to discussing proposals of new APIs, automations, plans for the future, etc. Anything Engineering.

### **Important notes**

* You SHOULD check Rocket.Chat for announcements or to answer any pending questions when you start working and before you finish your shift **at least**. You are, of course, encouraged to engage in any conversation on your channels whenever you like. Please note you are not expected to be _always_ active in chat. Everyone needs time to focus on the task at hand, this is just a rule of thumb so you don't miss out or leave anyone hanging/blocked.
 This way, if anything critical happens, someone else can take over the task you were working on if needed.

## Contribution Workflow

### Github

New contributions will most likely start with a new git branch. We don't have strict rules for naming a branch, but here are some suggestions:

* `feat/*` ****if you'll be working in new feature
* `fix/*` if you'll be working on a fix
* `regression/*` if you'll be working on a regression in the current release
* just use a custom name, without the "folder format", if it doesn't fit the suggestions above

When opening a PR in any of our repositories, follow the guidelines in [Development Guidelines](development/development-guidelines.md#choosing-a-good-pr-title).

### Multiple Repos

Often we'll need to open a PR in more than one of the Org's repos when introducing a new feature. That happens, for instance, when adding a new feature to the Apps-Engine, because it hooks itself into many points in Rocket.Chat so they can provide Rocket.Chat Apps with functionalities.

Whenever you have to commit code to more than one repo, keep in mind the following guidelines:

* **Start your PRs as a draft when they depend on modifications from other repos.** Example: You're changing an API in the Apps-Engine, which also requires you to change how Rocket.Chat handles it. The PR in Rocket.Chat needs to be started as a draft and can only be ready for review **once the Apps-Engine version has been updated to the latest version containing the API change** __\(either a _patch_ or an _alpha_\).
* **Make sure the PRs reference each other in their descriptions.** Reviewers will need the full context of your contribution to properly review them, so they need to know the PRs in the other repos.

####

repository: RocketChat/handbook

gha_language: TypeScript

gha_license_id: NOASSERTION

repo_name: RocketChat/handbook