text:
# CHANGELOG

## 1.0.0

- add Calendar App Client. (refs #28)
- rename `TimeTree::OAuthApp::Client` from `TimeTree::Client`.

## 0.3.2

- remove zeitwerk dependency. (refs #29)

## 0.3.1

- fix rubocop warnings.

## 0.3.0

- refs #25 fix dependencies.
- remove minitest-reporter.

## 0.2.1

- do refactor
  - use `respond_to?(setter)` instead of `instance_methods.include?(setter)`.
  - use getter method instead of instant variables if defined it.

## 0.2.0

- organize model classes.

## 0.1.7

- refs #16 correct a mistake codecov badge url on README

## 0.1.6

- refs #16 add code coverage to readme.
- refs #17 update deprecated `version` for `ruby-version` on gem-push.yml.

## 0.1.5

- refs #6 setup GitHub Actions.

## 0.1.4

- updates comments.

## 0.1.3

- refs #7 #9 make the code coverage 100%.

## 0.1.2

- refs #1 fix typo Event#recurrences to recurrence
- refs #2 add a note for debugging guide on README

## 0.1.1

- set current version on this gem's documentation_uri.
- fixed typo on README.

## 0.1.0

- did refactor and wrote comments.
- started to use zeitwerk.
- wrote README.

## 0.0.1

- Initial release

repository: koshilife/timetree-api-ruby-client

gha_language: Ruby

repo_name: koshilife/timetree-api-ruby-client


text:
<!--
#
# Licensed to the Apache Software Foundation (ASF) under one or more contributor
# license agreements.  See the NOTICE file distributed with this work for additional
# information regarding copyright ownership.  The ASF licenses this file to you
# 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.
#
-->

# Publish the release artifacts to the staging directory

After the artifacts are generated and signed, you can run the following script under the folder _tools_, to upload them
into the staging directory:

```
$ ./upload_artifacts.sh <WORK_DIR>
```

The <WORK_DIR> should be the same one used to download the source code. This script will create a remote directory named
openwhisk-\<version\>-\<pre_release_version\> under the staging directory, and push all the files available locally under openwhisk-\<version\>-\<pre_release_version\>
upstream. It will overwrite the old files or directories, if the directory openwhisk-\<version\>-\<pre_release_version\> is available as a svn folder.

repository: csantanapr/incubator-openwhisk-release

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: csantanapr/incubator-openwhisk-release


text:
# Azure Kinect Fastpointcloud Example

## Introduction

The Azure Kinect Fastpointcloud example computes a 3d point cloud from a depth map. The example precomputes a lookup table
by storing x- and y-scale factors for every pixel. At runtime, the 3d X-coordinate of a pixel in millimeters is derived
by multiplying the pixel's depth value with the corresponding x-scale factor. The 3d Y-coordinate is obtained by
multiplying with the y-scale factor.

This method represents an alternative to calling k4a_transformation_depth_image_to_point_cloud() and lends itself
to efficient implementation on the GPU.

## Usage Info

```shell
fastpointcloud.exe <output file>
```

Example:

```shell
fastpointcloud.exe pointcloud.ply
```

license: MIT

branch_name: refs/heads/develop

gha_license_id: MIT


text:
# GitSearch

#### GitSeaarch is a simple search application that relays repositiories and Github users at lightning fast speed.

Current Version 02/04/2019

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

## 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.

#### By **Augustine Ochieng**

## Description

GitSeaarch is a simple search application that relays repositiories and Github users at lightning fast speed

## Setup/Installation Requirements

- Type in Github username
- View repositories

## Known Bugs

There are currently no known bugs but in case of any inconvenience experienced reach out to me through my email address<EMAIL_ADDRESS>
## Technologies Used

- HTML
- CSS
- Google Fonts
- Coolors.co
- Typescript
- Angular
- Material Design Bootstrap

## Support and contact details

Everyone interested is most welcome to fork this code and modify it for updates. In case of any inconvenience experienced reach out to me through my email address<EMAIL_ADDRESS>
## Behaviour Driven Development

| Expected Behaviour            | Input                                 | Output                                 |
| ----------------------------- | ------------------------------------- | -------------------------------------- |
| Accept name                   | Github username                       | Show existing Github Usernames of same |
| Display User and Repositories | Existing users and Repositories shown | Access repositories                    |

## Deployed Link

To check out and try out the application click upon this link https://augustineochieng.github.io/Quotes/

## 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/).

*MIT License*
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sub-license, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY , WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

To adopt MIT License, enter your details. You’ll have a chance to review before committing a LICENSE file to a new branch or the root of your project.

Year
2019
Full name
Augustine Ochieng
Copyright (c) 2018 **Augustine Ochieng**

## Further help

To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI README](https://github.com/angular/angular-cli/blob/master/README.md).

repository: AugustineOchieng/GitSearch

repo_name: AugustineOchieng/GitSearch


text:
# Talk To

I have been having lots of calls, meetings, and appointments lately, and scheduling those has become annoying, with lots of messages exchanged between me and other people to agree on a good time to meet. Especially that I have to check my personal calendar, our family's calendar, and my work calendar, which usually are not accessible from one device. I tried [Calendly](calendly.com), it was nice, but in order for me to use it well with it figuring out my availability and cross it with multiple calendars, then I'd have to pay for it's ultimate subscription, and still maybe I'd have to do a lot of manual work to set it up. So I wrote this simple web application.

This web application loads multiple calendars, the calendars must be exposed as `.ics` URLs on the web, this works pretty well with Google Calendars as it allows you to get an `.ics` URL for your calendar. It refreshes those calendars periodically. You can set up your default weekly availability hours, and the application will cross those with the events on your calendar to determine when you should be available.

You can view it live here on my own page: https://talk-to.mpcabd.xyz/

You can make a copy of this application, make your own configuration, build an image, and deploy it to some cloud of your liking.

## Configuration

Check [`config.json`](config.json) to see the configuration file. The `weekday_availability` key is an array that sets your default daily availability, each item in `weekday_availability` is the availability for a day, first day is Monday, each day is also an array of time-ranges, each range is an array of two timestamps `HH:MM`. For example:

```javascript
"weekday_availability": [
  // Monday 9am to 6pm with a lunch break between 1pm and 2pm
  [["09:00", "13:00"], ["14:00", "18:00"]],

  // Tuesday 9am to 6pm with a lunch break between 1pm and 2pm
  [["09:00", "13:00"], ["14:00", "18:00"]],

  // Wednesday 9am to 6pm with a lunch break between 1pm and 2pm
  [["09:00", "13:00"], ["14:00", "18:00"]],

  // Thursday 9am to 6pm with a lunch break between 1pm and 2pm
  [["09:00", "13:00"], ["14:00", "18:00"]],

  // Friday 9am to 6pm with a long break between 12pm and 2.30pm and a long break between 3pm and 5pm
  [["09:00", "12:00"], ["14:30", "15:00"], ["17:00", "18:00"]],

  // Saturday not available
  [],

  // Sunday not available
  []
]
```

You can define as many time-ranges as you like per day, just make sure they don't intersect.

## In production

### `hypercorn.prod.toml`
```
debug = false
use_reloader = false
startup_timeout = 60
loglevel = 'ERROR'
server_names = 'my.domain.tld'
accesslog = '/path/to/access.log'
errorlog = '/path/to/error.log'
```

### `prod.env`:
```
QUART_APP=__init__.py
QUART_ENV=production
QUART_SECRET_KEY=<SECRET KEY>
QUART_SERVER_NAME=my.domain.tld
QUART_PREFERRED_URL_SCHEME=https
QUART_LOG_LEVEL=ERROR
PORT=80
PYTHONDONTWRITEBYTECODE=1
PYTHONUNBUFFERED=1
HYPERCORN_CONFIG_FILE=hypercorn.prod.toml
```

You can obtain a secret key like this: `docker run python:3-alpine python -c 'import secrets; print(secrets.base64.b64encode(secrets.token_bytes(50)))'`

You might want to run this behind nginx or traefik so that they'd handle the secure connection for you.

The file [`docker-compose.prod.yml`](docker-compose.prod.yml) is only provided as a reference, you should be able to change anything to your liking and deploy it the way you want.

If you've changed the `config.json` file and don't want to do a full rollout, you can do a `POST` request to `/reload` and the app will reload the config and refresh its calendars.

## Decisions made

* Used [Quart](https://pgjones.gitlab.io/quart/) instead of [Flask](https://flask.palletsprojects.com/) because I wanted to use `asyncio` to run routines in the background.
* Used [Vue](https://v3.vuejs.org/) for the frontend because it's the easiest way I know to do DOM binding.
* Used [Bootstrap](https://getbootstrap.com/) because I am bad at anything front-end.
* Used [axios](https://github.com/axios/axios) because I wanted the simplest way to do HTTP calls without writing too much.
* Used [luxon](https://moment.github.io/luxon/) because I have used momentjs before and I still don't know how to do dates, times, and timezones well in JavaScript.
* Made my own calendar widget because I didn't want to use another library.
* Default user photo is taken from [here](https://www.pexels.com/photo/men-s-wearing-black-suit-jacket-and-pants-937481/)

Can it be made much better? **Certainly!** but this was a quick and dirty solution to an annoying problem, not meant to be a product for the general public.

## An honest apology for all front-end developers

As you probably can tell, my front-end skills are outdated and probably bad, so I apologise for all front-end developers who look at my code and feel rage boiling up because of how bad it is. Please take some time if you're reading this to maybe propose a better way of doing the front-end work. I have very quickly read some Vue documentation to be able to put this together, but in no way is that a representative of how I code the backend 😅

## License

This work is licensed under
[MIT License](https://opensource.org/licenses/MIT).

repository: mpcabd/talk-to

branch_name: refs/heads/main

gha_language: Python

repo_name: mpcabd/talk-to


text:
# MRAugment
This is the PyTorch implementation of MRAugment, a physics-aware data augmentation pipeline for accelerated MRI that can greatly improve reconstruction quality when training data is scarce.
> [**Data augmentation for deep learning based accelerated MRI reconstruction with limited data**](http://proceedings.mlr.press/v139/fabian21a.html),
> Zalan Fabian, Reinhard Heckel, Mahdi Soltanolkotabi
> International Conference on Machine Learning (ICML), 2021
> *arXiv preprint ([arXiv:2106.14947](https://arxiv.org/abs/2106.14947))*

![](assets/recons.gif)

This repository contains code to train and evaluate a [VarNet](https://arxiv.org/abs/2004.06688) model on publicly available MRI reconstruction datasets, however MRAugment can be used with any deep learning model.

![](assets/mraugment_flowchart.png)

Adding MRAugment data augmentation to existing training scripts only takes a couple of lines of extra code. See example usage on fastMRI data [here](mraugment_examples/train_varnet_fastmri.py).

## Requirements
CUDA-enabled GPU is necessary to run the code. We tested this code using:
- Ubuntu 18.04
- CUDA 11.1
- Python 3.8.5

## Installation
To install the necessary packages, create a new virtual environment and run
```bash
git clone --recurse-submodules https://github.com/z-fabian/MRAugment
cd MRAugment
./install.sh
```

## Datasets
### fastMRI
FastMRI is an open dataset, however you need to apply for access at https://fastmri.med.nyu.edu/. To run the experiments from our paper, you need the download the fastMRI knee dataset with the
following files:
- knee_singlecoil_train.tar.gz
- knee_singlecoil_val.tar.gz
- knee_multicoil_train.tar.gz
- knee_multicoil_val.tar.gz

After downloading these files, extract them into the same directory. W Make sure that the directory contains exactly the following folders:
- singlecoil_train
- singlecoil_val
- multicoil_train
- multicoil_val

### Stanford datasets
Please follow [these instructions](data/stanford/README.md) to batch-download the Stanford datasets.
Alternatively, they can be downloaded from http://mridata.org volume-by-volume at the following links:
- [Stanford 2D FSE](http://mridata.org/list?project=Stanford%202D%20FSE)
- [Stanford Fullysampled 3D FSE Knees](http://mridata.org/list?project=Stanford%20Fullysampled%203D%20FSE%20Knees)

After downloading the .h5 files the dataset has to be converted to a format compatible with fastMRI modules. To create the datasets used in the paper please follow the instructions [here](data/stanford/README.md).

## Training
### fastMRI knee
To train a VarNet model on the fastMRI knee dataset, run the following in the terminal:
```bash
python mraugment_examples/train_varnet_fastmri.py \
--config_file PATH_TO_CONFIG \
--data_path DATA_ROOT \
--default_root_dir LOG_DIR \
--gpus NUM_GPUS
```
- `PATH_TO_CONFIG`: path do the `.yaml` config file containing the experimental setup and training hyperparameters. Config files to each experiment in the paper can be found in the `mraugment_examples/experiments` folder. Alternatively, you can create your own config file, or directly pass all arguments in the command above.
- `DATA_ROOT`: root directory containing fastMRI data (with folders such as `multicoil_train` and `multicoil_val`)
- `LOG_DIR`: directory to save the log files and model checkpoints. Tensorboard is used as default logger.
- `NUM_GPUS`: number of GPUs used in DDP training assuming single-node multi-GPU training.

### Stanford datasets
Similarly, to train on either of the Stanford datasets, run
```bash
python mraugment_examples/train_varnet_stanford.py \
--config_file PATH_TO_CONFIG \
--data_path DATA_ROOT \
--default_root_dir LOG_DIR \
--gpus NUM_GPUS
```
In this case `DATA_ROOT` should point directly to the folder containing the *converted* `.h5` files.

**Note**: Each GPU is assigned whole volumes of MRI data for validation. Therefore the number of GPUs used for training/evaluation cannot be larger than the number of MRI volumes in the validation dataset. We recommend using 4 or less GPUs when training on the Stanford 3D FSE dataset.

## Experiment selection
Config files for different experiments can be found [here] (`mraugment_examples/experiments`). In general, the config files are named as `{TRACK}_train{SIZE}_{DA}.yaml`, where
- `TRACK` is either `singlecoil` or `multicoil`
- `SIZE` describes the percentage of training data used (for example `train10` uses 10% training data)
- `DA` denotes that data augmentation is turned on

Furthermore, for scanner transfer experiments `{TRAIN}T{VAL}T` denotes the field strength of scanners in the train and val datasets.

## Evaluating models
### fastMRI knee
To evaluate a model trained on fastMRI knee data on the validation dataset, run
```bash
python mraugment_examples/eval_varnet_fastmri.py \
--checkpoint_file CHECKPOINT \
--data_path DATA_DIR \
--gpus NUM_GPUS \
--challenge TRACK
```
- `CHECKPOINT`: path to the model checkpoint `.ckpt` file
- `TRACK`: must be `singlecoil` or `multicoil` and has to match the acquisition type the model has been trained on

**Note**: by default, the model will be evaluated on 8x acceleration.

### Stanford datasets
To evaluate on one of the Stanford datasets run
```bash
python mraugment_examples/eval_varnet_stanford.py \
--checkpoint_file CHECKPOINT \
--data_path DATA_DIR \
--gpus NUM_GPUS \
--train_val_split TV_SPLIT \
--train_val_seed TV_SEED
```
- `TV_SPLIT`: portion of dataset to be used as training data, rest is used for validation. For example if set to `0.8` (default), then 20% of data will be used for evaluation now.
- `TV_SEED`: seed used to generate the train-val split. By default, the config files for the various experiments use `0` for training.

## Custom training
To experiment with different data augmentation settings see all available training options by running
```bash
python mraugment_examples/train_varnet_fastmri.py --help
```
Alternatively, the `.yaml` files in `mraugment_examples/experiments` can be customized and used as config files as described before.
You can also take a look at the configurable parameters with respect to data augmentation in `mraugment/data_augment.py`.

## Implementation differences
Slight differences from the published results is possible due to some implementation differences. This repository uses `torchvision==0.9.1` for data augmentations, whereas the original code used the `skimage` library.
- `torchvision==0.9.1` doesn't support bicubic interpolation (as in the paper) for the affine transform on tensors. Instead, bilinear interpolation is used.
- The affine transform in `torchvision` is parameterized by a single scaling parameter and shearing along the x and y axes. The results in the paper were generated using a single shearing parameter and scaling along x and y axes (isotropic/anisotropic scaling).

## License
MRAugment is MIT licensed, as seen in the [LICENSE](LICENSE) file.

## Citation
If you find our paper useful, please cite
```bibtex
@inproceedings{fabian2021data,
  title={Data augmentation for deep learning based accelerated MRI reconstruction with limited data},
  author={Fabian, Zalan and Heckel, Reinhard and Soltanolkotabi, Mahdi},
  booktitle={International Conference on Machine Learning},
  pages={3057--3067},
  year={2021},
  organization={PMLR}
}
```

## Acknowledgments and references
- [fastMRI repository]( https://github.com/facebookresearch/fastMRI)
- **fastMRI**: Zbontar et al., *fastMRI: An Open Dataset and Benchmarks for Accelerated MRI, https://arxiv.org/abs/1811.08839*
- **Stanford 2D FSE**: Joseph Y. Cheng, https://github.com/MRSRL/mridata-recon/
- **Stanford Fullysampled 3D FSE Knees**: Epperson K, Sawyer AM, Lustig M, Alley M, Uecker M., *Creation Of Fully Sampled MR Data Repository For Compressed Sensing Of The Knee. In: Proceedings of the 22nd Annual Meeting for Section for Magnetic Resonance Technologists, 2013*


text:
# methpipe-docker
Unofficial Docker image for the MethPipe package from the Smith Lab in the Molecular and Computational Biology section, Division of Biological Sciences at University of Southern California.

This Docker image was created by Rick M. Tankard at Murdoch University, Perth, WA, Australia.

For updates to later MethPipe versions, please either make an issue or make a pull-request to https://github.com/trickytank/methpipe-docker. The Docker Hub repository is configured for automated builds.

# References

  - MethPipe website: http://smithlabresearch.org/software/methpipe/
  - MethPipe Github project: https://github.com/smithlabcode/methpipe/
  - Song Q, Decato B, Hong E, Zhou M, Fang F, Qu J, Garvin T, Kessler M, Zhou J, Smith AD (2013) A reference methylome database and analysis pipeline to facilitate integrative and comparative epigenomics. PLOS ONE 8(12): e81148

repository: trickytank/methpipe-docker

repo_name: trickytank/methpipe-docker


text:
---
breadcrumbs:
- - /chromium-os
  - Chromium OS
- - /chromium-os/chromiumos-design-docs
  - Design Documents
page_name: verify-prebuilts-using-content-hashing
title: 'Design proposal: Verify prebuilts using content hashing'
---

# Verify prebuilts using content hashing

Proposal status: Implemented and in production

Author: David James <davidjames@>

## Summary

I'd like to propose a small change to the way we verify prebuilts. This change
is intended to ensure that developers do not need to build packages from source
if they have not modified them locally. This should shave significant time off
developer builds (e.g., up to 20 minutes, if the developer syncs at a busy
time).

## What needs to be changed?

Right now, we only use prebuilts for builds if the SHA1 of the commit that we
tested exactly matches the SHA1 in the remote repository. This is needed for
correctness, as explained below in the “Why is prebuilt verification needed at
all?” section.

Unfortunately, in practice, the SHA1 of the commit we tested often differs from
the SHA1 in the remote repository. This happens because when the commit queue
submits a change, Gerrit adds in new metadata to the commit message, causing the
prebuilts to become invalid.

Currently, the commit queue accounts for this problem by just rebuilding any
packages with incorrect SHA1s on the next run. This doesn’t help, though, if
developers sync during the day, when many changes are being pushed by the commit
queue. In that case, this problem causes developer builds to slow down
significantly, as they need to rebuild many packages from source.

## Proposed solution

We should use the SHA1 of the contents of the source tree to validate the
prebuilts. Unlike the commit hash, this SHA1 is unaffected by the history of the
repository, or by commit messages. This ensures that users always have correct
prebuilts, without causing unnecessary rebuilds.

### Implementation

1.  First, add the SHA1 of the contents of the source tree into the
            ebuild as `CROS_WORKON_TREE`. This can be calculated instantly using
            the following command:
    `git log -1 --format=%T`
2.  Next, add `CROS_WORKON_TREE_$CROS_WORKON_TREE` to `IUSE` in
            `cros-workon.eclass`.
3.  Finally, remove `CROS_WORKON_COMMIT_$CROS_WORKON_COMMIT` from `IUSE`
            from `cros-workon.eclass`.

## Why is prebuilt verification needed at all?

Besides the above proposal, another option for speeding up builds would be to
eliminate verification of SHA1s in ebuilds entirely. This would speed up builds,
but would open up developers to race conditions where they might have incorrect
builds.

Example: If one developer sends a change through the commit queue, and another
developer bypasses the commit queue at the same time, the ebuild will be marked
with the latest SHA1 (including both change), but the prebuilt may only include
the first change. This results in developers (and bots that use binaries) never
picking up the ‘chump’ change.

There are also other race conditions. Example:

1.  A chump change is pushed to power_manager.
2.  The incremental builder kicks off.
3.  Another chump change is pushed to power_manager.
4.  The commit queue kicks off and marks both changes as stable.
5.  The incremental builder kicks off again, and doesn’t notice any
            changes, because its local prebuilt has the same version number as
            the one that was pushed by the commit queue.

Based on the above problems, I think that we should not eliminate prebuilt
verification of SHA1s, and instead use the proposed solution above.

repository: iridium-browser/iridium-browser

repo_name: iridium-browser/iridium-browser


text:
# Hackintosh on Gigabyte GA-Z87X-OC Force
## Switch to OpenCore from Clover: Z87, i7-4770K, R9-280X running Mojave
Generally followed the [Opencore Vanilla Desktop Guide](https://khronokernel-2.gitbook.io/opencore-vanilla-desktop-guide/) and the OpenCore Configuration.pdf - The parts I configured different from the Guide are mostly noted below.

### Specs
* CPU: Intel Core i7-4770K @ 3.50GHz 4-Core Processor
* MB: Gigabyte GA-Z87X-OC Force
* RAM: 4x8GB G.SKILL Ripjaws X Series DDR3 1600
* SSD: Crucial M550 256GB 2.5"
* GPU: Sapphire Radeon Toxic R9 280X with dual 1080p monitors
* WIFI: TP-LINK TL-WDN4800

### Working
- Audio, Video, Ethernet, USB, NVRAM, Wifi, both Ethernet ports
- Messages, iCloud
- USB2 & USB3 ports
- Sleep (somewhat)
- upgrading to 10.14.6 and security updates ran smoothly
- press Option key to see OpenCore boot menu

## Download OpenCore & Tools
* [acidanthera/OpenCorePkg: OpenCore front end](https://github.com/acidanthera/OpenCorePkg)
* [acidanthera/AppleSupportPkg Drivers · GitHub](https://github.com/acidanthera/AppleSupportPkg/releases)

* [Hackintool - InsanelyMac Forum](https://www.insanelymac.com/forum/topic/335018-hackintool-v283/)
	* [Download Hackintool](http://headsoft.com.au/download/mac/Hackintool.zip)
	* [headkaze/Hackintool: The Swiss army knife of vanilla Hackintoshing](https://github.com/headkaze/Hackintool)
* [PlistEdit Pro – Advanced Mac plist editor](https://www.fatcatsoftware.com/plisteditpro/)

## BIOS settings
### Disable
	- [x] Fast Boot
	- [x] CSM
	- [ ] CFG Lock (MSR 0xE2 write protection)
### Enable
	- [x] VT-x
	- [x] Hyper Threading
	- [x] Execute Disable Bit
	- [x] EHCI/XHCI Hand-off
	- [x] OS type: other OS (otherwise no second monitor)

## Mount EFI
Used Hackintool to mount EFI

## Download Kexts & UEFI Shell
* [acidanthera/Lilu · GitHub](https://github.com/acidanthera/Lilu/releases)
* [acidanthera/VirtualSMC · GitHub](https://github.com/acidanthera/VirtualSMC/releases)
* [acidanthera/WhateverGreen · GitHub](https://github.com/acidanthera/WhateverGreen/releases)
* [acidanthera/IntelMausi · GitHub](https://github.com/acidanthera/IntelMausi/releases)
* [acidanthera/AppleALC: Native macOS HD audio](https://github.com/acidanthera/AppleALC)
* [RehabMan/USB-Inject-All: Kext to inject all USB ports](https://github.com/RehabMan/OS-X-USB-Inject-All)
	* [Download USBInjectAll 0.7.1 — Bitbucket](https://bitbucket.org/RehabMan/os-x-usb-inject-all/downloads/)
* [acidanthera/OpenCoreShell · GitHub](https://github.com/acidanthera/OpenCoreShell/releases)
* Install `AirPortAtheros40` for TP-LINK TL-WDN4800 from
	* [Atheros installer for macOS Mojave and Catalina - LAN and Wireless - InsanelyMac Forum](https://www.insanelymac.com/forum/files/file/956-atheros-installer-for-macos-mojave-and-catalina/)
	* or with Hackintool (Tools -> Atheros)

## Edit config.plist (Haswell section)
### Device Properties
* 0x04120004 - this is used when the iGPU is only used for compute tasks and doesn't drive a display
### Kernel
* remember to add path to kexts!
* ThirdPartyTrim: YES
### Misc - Boot
* ConsoleMode [blank]
* PollAppleHotKeys: YES (UsbKbDxe.efi did not work)
* Resolution: 1920x1080@32
### Misc - Tools
* Added UEFI Shell

## Cleaning out  Clover gunk
* deleted all clover related files

## Map USB Ports
* Used Hackingtool (USB-Info) and followed the built in guide
```
-uia_exclude_ss
-uia_exclude_hs uia_include=HS11,HS12
```
* installed `USBPorts.kext`

## Upgrading to OpenCore-X.Y.Z-RELEASE
* keep a backup on a USB-Stick
* replace `BOOTx64.efi` and `OpenCore.efi`
* replace drivers from updated AppleSupport `ApfsDriverLoader.efi`, `FwRuntimeServices.efi`, `VBoxHfs.efi`
* check for updated kexts on [Acidanthera · GitHub](https://github.com/acidanthera) or with the Hackintool (Installed Kexts - Download)
* read OpenCore Docs Differences.pdf and apply in config.plist, as needed

path: /Gigabyte GA-Z87X-OC Force/README.md


text:
# NextBus Card

A card which displays multiple public transit routes using the [NextBus sensors](https://www.home-assistant.io/integrations/nextbus/). This improves on a generic entity display making it appear more akin to a mobile phone widget, giving you more than just the next route's countdown.

![Screenshot](/screenshot.png?raw=true 'Example Card')

[![GitHub Release][releases-shield]][releases]
[![License][license-shield]](LICENSE.md)
[![hacs_badge](https://img.shields.io/badge/HACS-Custom-orange.svg?style=for-the-badge)](https://github.com/custom-components/hacs)

![Project Maintenance][maintenance-shield]
[![GitHub Activity][commits-shield]][commits]

## Options

| Name     | Type     | Requirement  | Description              | Default          |
| -------- | -------- | ------------ | ------------------------ | ---------------- |
| type     | string   | **Required** | `custom:nextbus-card`    |
| name     | string   | **Optional** | Card name                | `Public Transit` |
| entities | string[] | **Optional** | List of nextbus entities | `none`           |

## Developing with [devcontainer][devcontainer]

1. Fork and clone the repository.
2. Open the [devcontainer][devcontainer] and run `npm start` when it's ready.
3. The compiled `.js` file will be accessible on
   `http://<IP_ADDRESS>:5000/nextbus-card.js`.
4. On a running Home Assistant installation add this to your Lovelace
   `resources:`

```yaml
- url: 'http://<IP_ADDRESS>:5000/nextbus-card.js'
  type: module
```

_Change "<IP_ADDRESS>" to the IP of your development machine._

### Bonus

If you need a fresh test instance you can install a fresh Home Assistant instance inside the devcontainer as well.

1. Run the command `dc start`.
2. Home Assistant will install and will eventually be running on port `9123`

repository: dcramer/lovelace-nextbus-card

gha_language: TypeScript

repo_name: dcramer/lovelace-nextbus-card


text:
You are given a tree with vertices numbered from  `0`to  `N - 1`. The tree is input as an array  `parent`where  `parent[i]`  is the parent of the  _ith_  node of the tree. The root of the tree is the vertex number  `0`and it is its own parent.

You are to paint some of the tree vertices in such a way that the painted vertices along with the edges between them form a  full binary tree. What is the maximum possible  size  of such tree?

Note that the edges' orientations after painting remain the same, so the highest painted vertex will be a new root.

Example

For  `parent = [0, 0, 1, 4, 1]`, the output should be
`largestFullBinaryTree(parent) = 3`.

The only possible way to make a full binary of size larger than  `1`  is to leave vertices  `1`,  `2`  and  `4`. Here it is:

![](https://codefightsuserpics.s3.amazonaws.com/tasks/largestFullBinaryTree/img/example.png?_tm=1530801828488)

Input/Output

-   **[execution time limit] 0.5 seconds (cpp)**

-   **[input] array.integer parent**

    Array of parents.

    _Guaranteed constraints:_
    `1 ≤ parent.length ≤ 25`,
    `0 ≤ parent[i] ≤ 20`.

-   **[output] integer**

repository: M-Ekrim/codeSignal

repo_name: M-Ekrim/codeSignal


text:
Update Handler
==============

Form Handler Events
-------------------

Default form handler `Oro\Bundle\FormBundle\Model\FormHandler` triggers events that allow developer to modify processing data
or even stop form processing.

There are two type of events:

- **FormProcessEvent** (`Oro\Bundle\FormBundle\Event\FormHandler\FormProcessEvent`) - triggered during form processing,
can stop further form processing via `interruptFormProcess` method.
- **AfterFormProcessEvent** (`Oro\Bundle\FormBundle\Event\FormHandler\FormProcessEvent`) - triggered after form
processing during saving of form data.

And there are four events triggered in form handler:

- **BEFORE_FORM_DATA_SET** (`Oro\Bundle\FormBundle\Event\FormHandler\Events::BEFORE_FORM_DATA_SET`) - uses
FormProcessEvent, triggered in the very beginning of form processing right before input data set to form instance.
- **BEFORE_FORM_SUBMIT** (`Oro\Bundle\FormBundle\Event\FormHandler\Events::BEFORE_FORM_SUBMIT`) - uses FormProcessEvent,
triggered only for valid form methods (POST or PUT) before request submitting to form instance.
- **BEFORE_FLUSH** (`Oro\Bundle\FormBundle\Event\FormHandler\Events::BEFORE_FLUSH`) - uses AfterFormProcessEvent,
triggered right before flushing of object manager.
- **AFTER_FLUSH** (`Oro\Bundle\FormBundle\Event\FormHandler\Events::AFTER_FLUSH`) - uses AfterFormProcessEvent,
triggered right after flushing of object manager.

If developer wants to use custom form handler then he should trigger these events in custom handler
to support form processing consistency.

Update Handler Facade Service
------------------------------------------------------
Service<EMAIL_ADDRESS>
Class: `Oro\Bundle\FormBundle\Model\UpdateHandlerFacade`

The default common way to handle forms in Oro packages is to use `Oro\Bundle\FormBundle\Model\UpdateHandlerFacade::update`
method from the service with your custom arguments provided.

Among usual arguments there are two most valuable from the point of reuse.

 The `handler` - for custom handler purpose:
- `string` - an alias of registered by tag `oro_form.form.handler` `Oro\Bundle\FormBundle\Form\Handler\FormHandlerInterface` implementation service
- `callable` - a callback to perform handling (see FormHandlerInterface::process() for arguments)
- `Oro\Bundle\FormBundle\Form\Handler\FormHandlerInterface` - an instance of handler itself
- `null` - to use `default` registered under tag `oro_form.form.handler` handler service that implements interface above

  The `dataProvider` - for custom template data purpose:

    @param FormTemplateDataProviderInterface|string|callable|null $resultProvider to provide template data
- `string` - an alias of registered by tag `oro_form.form_template_data_provider` service that implements `Oro\Bundle\FormBundle\Form\Handler\FormHandlerInterface`
- `callable` - callback to provide data (see FormTemplateDataProviderInterface::getData() for arguments)
- `Oro\Bundle\FormBundle\Provider\FormTemplateDataProviderInterface` - an instance of provider itself
- `null` - to use `default` registered provider (usually it returns `['form' => FormView $instance]`)

 Custom TemplateDataProvider and FormHandler can be reused in different parts of platform, such as
 [WorkflowBundle Custom Form Configuration](https://doc.oroinc.com/backend/entities-data-management/workflows/transition-forms.html#custom-form-type-example).

 **Example of custom handler and data provider services registration and usage:**

 Services:
 ```YML
 services:
    my_bundle.form.user_handler:
        class: MyBundle\Form\UserHandler
        tags:
            - { name: oro_form.form.handler, alias: user_handler }
    my_bundle.form.user_update_data_provider:
        class: MyBundle\Form\UserUpdateDataProvider
        public: false
        tags:
            - { name: oro_form.form_template_data_provider, alias: user_update_data }
 ```
 A pseudo controller:
 ```PHP
 class UserController {
    public function createAction(Request $reqeust)
    {
        return $this->get('oro_form.update_handler')->update(
            new User(),
            $this->get('form_factory')->create(\MyBundle\Form\UserType::class),
            'Success! User created!',
            $request,
            'user_handler', //using an alias tagged my_bundle.form.user_handler service
            'user_update_data' //using an alias tagged my_bundle.form.user_update_data_provider service
        );
    }
 }
 ```

 The separating of responsibilities above (such as division of usual controller update process parts) is a powerful
 feature that might help you to use all OroPlatform-based functionality easier.

repository: successmarket/oroinc-platform

gha_license_id: NOASSERTION

repo_name: successmarket/oroinc-platform


text:
This is my attempt to implement a semantic segmentation network on darknet framework.

I implement a modified version of U-Net (https://arxiv.org/abs/1505.04597) to detect road surface.

Input to model: 224 x 224 x 3 images

Output: 224 x 224 binary label

I added a bunch of code to the darknet source files for data pre processing.

I recommend using cscope to browse through the code, makes life easier!

Sample data to train and test can be found in data/unet folder. (Note that I have only added 5 pairs of images to get you started)

**Notes:**
The main program that I implemented is unet_segmenter.c please browse through the code to understand it.

Inorder to run this version of darknet for unet segmentation you need to build the code using makefile build system and then run:

./darknet unet_segmenter train unet.data unet.cfg

Also kindly note that you need to update the train.list and labels.list to reflect the path to the train and labels folder on your local file system.

With the provided samples the network will not train completely as the train size is too small just 5 images. You need to add your own data in the same format as per the samples provided.

Once successfully trained the weights file will be saved under the name unet.backup under the main folder. Then you can run the prediction by using this command:
./darknet unet_segmenter test

Here is my trained weights file copy it under the main folder and you can directly test the unet segmenter:
https://www.dropbox.com/s/uq5xhv6egkl7rh0/unet.backup?dl=0

Feel free to adapt the code to your needs.

**Additional Notes:**
The input images have to be reshaped to 224x224x3 (RGB) and the output label is a binary image (0's & 1's) as I only predict one class. If you want to use a different size image or multi-class prediction you need to the change the shape of input and output layer accordingly in the config file.

I normalize the image channel-wise using the mean for each channel, if you want use different normalization you have to the change the **ipl_into_image** function in the src/image.c file.

All the Unet specific code that I added to darknet has been commented with "Unet code" so you can easily track the changes.

Cheers!

Sample:

![input image](data/unet/test/5.png)
![output image](data/unet/result/5.png.png)

license: Unlicense


text:
# TESTING

## Docker setup for integration tests

* Install docker and docker-compose
* Install pytest and pytest-docker-compose via pip
* Generate a ssh keypair and place it in tests with `ssh-keygen -t rsa -f tests/id_rsa_tests`
* In tests: Copy docker-compose.example.yml to docker-compose.yml and replace the public key
* Put something like the following in your ~.ssh/config

    Host docker-test
    Hostname localhost
    Port 2222
    IdentityFile tests/id_rsa_tests
    StrictHostKeyChecking no

* Run `make test` in the automatix root directory.

repository: seibert-media/automatix

repo_name: seibert-media/automatix


text:
# R2RT, Recurrent Neural Networks in Tensorflow I
http://r2rt.com/recurrent-neural-networks-in-tensorflow-i.html
_It won't hurt to lookup cross entropy of probabilities as well as backpropagation algorithm(e.g. truncated backpropagation)_
#reccurent-neural-networks/r2rtRNNinTF

In this post, we’ll be building a no frills RNN that accepts a binary sequence X and uses it to predict a binary sequence Y. The sequences are constructed as follows:
	* Input sequence (X): At time step Xt  has a 50% chance of being 1 (and a 50% chance of being 0). E.g., X might be [1, 0, 0, 1, 1, 1 … ].
	* Output sequence (Y): At time step t, Yt has a base 50% chance of being 1 (and a 50% base chance to be 0).
		* The chance of Yt being 1 is increased by 50% (i.e., to 100%) if Xt−3 is 1, and decreased by 25% (i.e., to 25%) if Xt−8 is 1. If both Xt−3 and Xt−8 are 1, the chance of Yt being 1 is 50% + 50% - 25% = 75%.

# Model architecture
The model will be as simple as possible:
	* at time step t, for t ∈ {0,1,…n} the model accepts:
		* a (one-hot) binary Xt vector
		* and a previous state vector, St−1, as inputs
	* and produces:
		* a state vector, St,
		* and a predicted probability distribution vector Pt, for the (one-hot) binary vector Yt.

Formally, the model is:
![](R2RT,%20Recurrent%20Neural%20Networks%20in%20Tensorflow%20I/16527E28-FFC8-403C-A1BF-9DBEDB3456DC.png)

#### How wide should our Tensorflow graph be?

To build models in Tensorflow generally, you first represent the model as a graph, and then execute the graph.
 _A critical question we must answer when deciding how to represent our model is_: **how wide should our graph be? How many time steps of input should our graph accept at once?**

There are two cases:
1. Each time step is a duplicate, so it might make sense to have our graph, G, represent a single time step: G(Xt,St−1)↦(Pt,St).
	* We can then execute our graph for each time step, feeding in the state returned from the previous execution into the current execution.
	* This would work for a model that was already trained, but there’s a problem with using this approach for training:
		* the gradients computed during backpropagation are graph-bound. We would only be able to backpropagate errors to the current timestep; we could not backpropagate the error to time step t-1.
		* this mean we won't be able to learn long-term dependency for our model.
2. We might make our graph as wide as our data sequence:
	* This often works, except that in this case, we have an arbitrarily long input sequence, so we have to stop somewhere.
	* Let’s say we make our graph accept sequences of length 10,000. This solves the problem of graph-bound gradients, and the errors from time step 9999 are propagated all the way back to time step 0.
	* **Unfortunately, such backpropagation is not only (often prohibitively) expensive, but also ineffective, due to the vanishing / exploding gradient problem**:
		* it turns out that backpropagating errors over too many time steps often causes them to vanish (become insignificantly small) or explode (become overwhelmingly large).

So we have to find a trade-off between these two.

**The usual pattern for dealing with very long sequences is therefore to “truncate” our backpropagation by backpropagating errors a maximum of n steps.**
 _We choose n as a hyperparameter to our model, keeping in mind the trade-off_:
	* higher n lets us capture longer term dependencies, but is more expensive computationally and memory-wise.

**A natural interpretation of backpropagating errors a maximum of n steps means that we backpropagate every possible error n steps.**
That is, if we have a sequence of length 49, and choose n=7, we would backpropagate 42 of the errors the full 7 steps.
**This is not the approach we take in Tensorflow. Tensorflow’s approach is to limit the graph to being n units wide.**

This means that:
	* we would take our sequence of length 49,
	* break it up into 7 sub-sequences of length 7
	* that we feed into the graph in 7 separate computations,
	* and that only the errors from the 7th input in each graph are backpropagated the full 7 steps. Therefore, even if you think there are no dependencies longer than 7 steps in your data, it may still be worthwhile to use n>7 so as to increase the proportion of errors that are backpropagated by 7 steps.

**Our graph will be n units (time steps) wide where each unit is a perfect duplicate, sharing the same variables.**
 The easiest way to build a graph containing these duplicate units is to build each duplicate part in parallel. This is a key point: **the easiest way to represent each type of duplicate tensor (the rnn inputs, the rnn outputs (hidden state), the predictions, and the loss) is as a list of tensors.**

## Model

```
"""
Placeholders
"""

x = tf.placeholder(tf.int32, [batch_size, num_steps], name='input_placeholder')
y = tf.placeholder(tf.int32, [batch_size, num_steps], name='labels_placeholder')
init_state = tf.zeros([batch_size, state_size])

"""
RNN Inputs
"""

# Turn our x placeholder into a list of one-hot tensors:
# rnn_inputs is a list of num_steps tensors with shape [batch_size, num_classes]
x_one_hot = tf.one_hot(x, num_classes)
# x_one_hot.shape --> 200, 5 , 2
# so we have a batch size of 200, trunctated_step of 5, and one_hot =2 (which is either 0 or 1)

rnn_inputs = tf.unstack(x_one_hot, axis=1)
# what we do here is unroll/unstack x_one_hot into a list each of those which (200,2).
# i.e. list of 5 --> 200, 2
```

- - - -

## Sum up of the process

1. define parameters:
```
num_steps = 5 # number of truncated backprop steps ('n' in the discussion above)
batch_size = 200
num_classes = 2
state_size = 4
learning_rate = 0.1
```

In details:
	* `learning_rate` - parameter for gradient descent algorithm or another approach.
	* `num_classes `  - number of classes (for one-hot encryption)
	* `batch_size` - batch size to train on
	* `state_size`  - the size of the RNN cell state. Should be big if truncated back-propagation required more steps to propagate back in order to store appropriate amount of information.
	* `num_steps` - number of truncated backdrop steps, is dependent of how deep one wants to propagate error, hence how deep you think data dependency should be
2. define the model:
	* define placeholder for input data as well as for the labels
	* define initial state
	* Define static model without tf api:
		* turn the input into one-hot tensors
		* unstack the input data into list of `num_steps` tensors with shape `[batch_size, num_classes]`
		* define RNN cell:
			* define weights and biases
			* define `tahn`  connected layer or with any function.
		* build a graph:
```
			state = init_state
			rnn_outputs = []
			for rnn_input in rnn_inputs:
			    state = rnn_cell(rnn_input, state)
			    rnn_outputs.append(state)
			final_state = rnn_outputs[-1]
```
	* Define loss function and predictions:
```
#logits and predictions
with tf.variable_scope('softmax'):
    W = tf.get_variable('W', [state_size, num_classes])
    b = tf.get_variable('b', [num_classes], initializer=tf.constant_initializer(0.0))
logits = [tf.matmul(rnn_output, W) + b for rnn_output in rnn_outputs]
predictions = [tf.nn.softmax(logit) for logit in logits]

# Turn our y placeholder into a list of labels
y_as_list = tf.unstack(y, num=num_steps, axis=1)

#losses and train_step
losses = [tf.nn.sparse_softmax_cross_entropy_with_logits(labels=label, logits=logit) for \
          logit, label in zip(logits, y_as_list)]
total_loss = tf.reduce_mean(losses)
train_step = tf.train.AdagradOptimizer(learning_rate).minimize(total_loss)
```
	* Train the network:
```
def train_network(num_epochs, num_steps, state_size=4, verbose=True):
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        training_losses = []
        for idx, epoch in enumerate(gen_epochs(num_epochs, num_steps)):
            training_loss = 0
            training_state = np.zeros((batch_size, state_size))
            if verbose:
                print("\nEPOCH", idx)
            for step, (X, Y) in enumerate(epoch):
                tr_losses, training_loss_, training_state, _ = \
                    sess.run([losses,
                              total_loss,
                              final_state,
                              train_step],
                                  feed_dict={x:X, y:Y, init_state:training_state})
                training_loss += training_loss_
                if step % 100 == 0 and step > 0:
                    if verbose:
                        print("Average loss at step", step,
                              "for last 250 steps:", training_loss/100)
                    training_losses.append(training_loss/100)
                    training_loss = 0

    return training_losses
```

Using the tensor flow api this will look following:
```
cell = tf.contrib.rnn.BasicRNNCell(state_size)
rnn_outputs, final_state = tf.contrib.rnn.static_rnn(cell, rnn_inputs, initial_state=init_state)
```
So we don't create a connected layer by ourselves, but instead using class BasicRNNCell to create a cell and passing desired the size of state.

```
Final model using static api:
"""
Placeholders
"""

x = tf.placeholder(tf.int32, [batch_size, num_steps], name='input_placeholder')
y = tf.placeholder(tf.int32, [batch_size, num_steps], name='labels_placeholder')
init_state = tf.zeros([batch_size, state_size])

"""
Inputs
"""

x_one_hot = tf.one_hot(x, num_classes)
rnn_inputs = tf.unstack(x_one_hot, axis=1)

"""
RNN
"""

cell = tf.contrib.rnn.BasicRNNCell(state_size)
rnn_outputs, final_state = tf.contrib.rnn.static_rnn(cell, rnn_inputs, initial_state=init_state)

"""
Predictions, loss, training step
"""

with tf.variable_scope('softmax'):
    W = tf.get_variable('W', [state_size, num_classes])
    b = tf.get_variable('b', [num_classes], initializer=tf.constant_initializer(0.0))
logits = [tf.matmul(rnn_output, W) + b for rnn_output in rnn_outputs]
predictions = [tf.nn.softmax(logit) for logit in logits]

y_as_list = tf.unstack(y, num=num_steps, axis=1)

losses = [tf.nn.sparse_softmax_cross_entropy_with_logits(labels=label, logits=logit) for \
          logit, label in zip(logits, y_as_list)]
total_loss = tf.reduce_mean(losses)
train_step = tf.train.AdagradOptimizer(learning_rate).minimize(total_loss)
```

## Using a dynamic RNN
Above, we added every node for every time-step to the graph before execution. This is called “static” construction. <u>We could also let Tensorflow dynamically create the graph at execution time, which can be more efficient.<u>
>  To do this, instead of using a list of tensors (of length num_steps and shape  `[batch_size, features]`), we keep everything in a single 3-dimnesional tensor of shape ` [batch_size, num_steps, features]`, and use Tensorflow’s `dynamic_rnn` function. This is shown below.

url: https://raw.githubusercontent.com/monapasan/bachelor-thesis/e166ab5c224bb6c67aa343f13229ca5b9807e7e1/notes/RNN/R2RT, Recurrent Neural Networks in Tensorflow I.md

repository: monapasan/bachelor-thesis

repo_name: monapasan/bachelor-thesis


text:
# chumakeveryday

Text-On-Image generator
created with .NET Core

Requires: .NET Core, NodeJS, yarn

Compile frontend:
```bash
#in frontend dir
yarn
yarn typings
yarn compile
```

How to run:

```bash
dotnet restore
dotnet run
```

Real-time coding:
```
yarn compile:watch
```

repository: mackerels/chumakeveryday

gha_language: C#

repo_name: mackerels/chumakeveryday


text:
# Change Log

## v2.0.0

- **New feature**
    1. Add serilport console.
    2. Separate third party device from bundle pack. now support modify third party device without rebuild the project.
    3. Optimize the block's disable logic in different programming modes.
    4. Now in realtime mode, you can select the realtime mode extension.
    5. If a block is not connected into the effective tree. it's setup and define and others code will not generate.
    6. Optimize the structure of the code generated by Arduino code generator to make it more consistent with Arduino native code format.
    7. The project file will save the current programming mode and automatically switch to the saved mode after loading.
    8. In programming mode, blocks can no longer be click executed and glow.
    9. After the realtime mode communication is successfully established, there will be no atert. Instead, it will indicate whether the communication is successful by dimming the communication icon on the right side of the connection icon. A alter will pop up and prompt to download the real-time mode firmware only after the communication attempt fails.
    10. After the firmware is downloaded and the real-time communication is established successfully, the alert of real-time mode failure warning will automatically disappear.

- **Fix bug**
    1. When loading a project file with multiple large extensions, the toolbar area will repeatedly display the contents of multiple extensions, and some other errors.
    2. The button to download firmware is not disabled when there is no connected device.
    3. Shorten the window of upload to fix the problem of incomplete display on some pc.
    4. Fixed a number of potential problems with realtime mode communication.
    5. The code window is not re rendered after resizing, resulting in a missing display.
    6. After switching programming mode, the sprite will disappear in some times.
    7. Arduino and microbit do not hide all the unsupported building blocks in programming mode.
    8. Microbit's buttonIsPressed block transcoding function should have written n for b when button is B.
    9. Microbit custom variable name exception.
    10. Arduino UNO mega2560 serial port 0 translation code is incorrect.
    11. Number parsing error of data_changevariableby block.
    12. Cancel the 1.05x interface zoom setting and directly enlarge the font to fix the problem of blurred font in the toolbar menu.

## v1.2.2beta

- **New feature**
    1. Add hide code stage button.
    2. Change the ui of upload button.
    3. Change the description of some boards.
    4. Add a 1.05 scale to fix the problem of fuzzy font.
    5. Change project file extension from .sb3 to .ob.

- **Fix bug**
    1. Microbit generator error.
    2. The pin menu of arduino set digital out does not have analog pin items.

## v1.2.1beta

- **Fix bug**

	1. Third party's block which from vm code generator error.

## v1.2.0beta

- **New feature**

	1. Now most alert will automaticly disapear after 5s.
	2. Completed the blocks of microbit.
	3. Add a servo extension as demo for microbit.
	4. After installing the new version of the software, the old cache will be cleared automatically.

- **New  device/kit**

	1. Arduino Mini
	2. QDP Robot(齐护机器人) kit

- **Fix bug**

	1. Error usb hardware id of cp2102.
	2. Error translation of microbit.
	3. Cannot scan to devices after loading a project.
	4. The loaded device extension still exists after switching the device selection.

## v1.1.0beta

- **New feature**

	1. Blocks could over flow the flyout boundary when mouse enter.
	2. Extension can be auto loaded when device selected.

- **New device/kit**

	1. microbit
	2. iron robot kit


text:
---
title: "How to get RBTC using RSK’s built in PowPeg"
description: "Learn how the RSK Powpeg works and how to use it to get RBTC via the peg-in and peg-out process"
tags: rbtc, rsk, powpeg, 2-way peg, defi, exchange, crypto, buy, peg-in, peg-out, how-to
layout: "rsk"
---

![Powpeg Banner](/assets/img/kb/get-crypto-on-rsk/powpeg-banner.jpg)

If you want to get RBTC,
there are a number of different ways to do it,
ranging from exchanges, decentralised exchanges,
and even peer-to-peer swaps -
These are generally easier to use.

The RSK blockchain protocol itself supports a method built into its
blockchain protocol that allows for two-way swaps between BTC and RBTC:
The RSK PowPeg.
This is generally more difficult to use,
and is intended for those with a more technical background.

Even if you intend to use those other services to obtain RBTC,
it is still important to know about the PowPeg,
as these other services ultimately rely on the PowPeg themselves.

## What the RSK PowPeg does

A two-way peg (2WP) protocol is a protocol that allows transfers of
a cryptocurrency from a main blockchain
to a secondary blockchain and vice versa.
It requires low third party trust.

In the case of RSK, the main blockchain is Bitcoin,
and the secondary blockchain is RSK.
Every RBTC (or fraction of RBTC) unlocked in the RSK platform
requires BTC to be locked on the Bitcoin blockchain.
This mechanism ensures there is a one-to-one relationship
between BTC and RBTC (1 BTC = 1 RBTC),
which is guaranteed by the RSK protocol.

When a user wants to swap between BTC and RBTC,
they need to send the cryptocurrency to the address
specified by the PowPeg,
triggering a peg-in or a peg-out,
which we will describe in more detail below.

## How the RSK PowPeg works

There are some restrictions and validations done when
a peg-in or peg-out transaction is made, such as:

- minimum values accepted,
- supported BTC address formats to do a peg-in,
- maximum amount of Bitcoins that can be locked in the PowPeg concurrently

Users cannot choose what address they will receive their assets on,
instead the receiving address is determined
using the public key of the sender,
so that both accounts are controlled by the same private key.

> Note that in the upcoming RSK release (IRIS-3.0),
> this is partially changing.
> The PowPeg will allow the user to specify the
> receiving address for peg-ins (BTC → RBTC).

The process of peg-ins and peg-outs are done completely using
Bitcoin wallet software and RSK wallet software.
The onus to perform the necessary checks and validations
for compliance with the rules of the PowPeg lies on the user,
as there is no application or tool to perform this.

> Warning: The user needs to be aware of this lack of “guard rails”,
> and accept the risk that transactions may be rejected
> or transferred amounts may be burnt (permanently lost),
> if they perform errors during the process.
> Hence, we encourage only users with technical expertise
> to perform peg-ins and peg-outs on their own.

**Pros**:

- Non custodial, users don’t give any third party custody
  of the transferred funds.
- No peg in fees (except for the fees of the BTC transaction).
- Can process larger transactions amounts.
- No registration or KYC required.

**Cons**:

- High wait time.
  - For security reasons, a significant number of transaction
    confirmations need to occur before funds are released.
- Minimum peg-in/ peg-out transaction values allowed are high
  - Currently, amounts must exceed 0.01 BTC and 0.008 RBTC, respectively
- Hard to use for regular users without technical expertise.
- Bitcoin network fees for peg-outs can be high.

## Receiving RBTC (peg-in)

Peg-in is the standard term for the process that
transfers bitcoins from the Bitcoin network to the RSK network.

To perform a peg-in send the bitcoins (BTC)
to the PowPeg address on the Bitcoin network,
and subsequently inform the Bridge about this transaction.
The Powpeg subsequently releases bitcoins (RBTC) on the RSK network.

![Peg-In](/assets/img/kb/get-crypto-on-rsk/Bitcoin-RSK-Peg-In.gif)

To summarise, a peg-in:

- Converts BTC to RBTC
- Locks BTC on the Bitcoin network
- Releases RBTC on the RSK network

> For a step-by step guide of the process, check out the
[peg-in guide](/rsk/rbtc/conversion/networks/mainnet/#btc-to-rbtc-conversion)
(BTC → RBTC)

## Sending RBTC (peg-out)

Peg-out is the standard term for the process that transfers
bitcoins from the RSK network to the Bitcoin network.

To perform peg-outs, send the bitcoins (RBTC) to the Bridge.
Then wait for the required number of confirmation blocks,
after which the Bridge builds the transaction
to release bitcoins (BTC) on the Bitcoin network.

![Peg-Out](/assets/img/kb/get-crypto-on-rsk/RSK-Bitcoin-Peg-Out.gif)

To summarise, a peg-out:

- Converts RBTC to BTC
- Locks RBTC on the RSK network
- Releases BTC on the Bitcoin network

> For a step-by step guide of the process, check out the
[peg-out guide](/rsk/rbtc/conversion/networks/mainnet/#rbtc-to-btc-conversion)
(RBTC → BTC)

## Get RBTC using PowPeg

Watch this demo video showing a conversion
between BTC and RBTC using the PowPeg protocol.

## Next

Be sure to check out our next article in this series,
about how to get the RSK cryptocurrency, RBTC,
by using wallets: [How to get RBTC using Wallets](/kb/get-crypto-on-rsk/rbtc-wallets/)


text:
---
title: "Predicting Forest Fires with Spark Machine Learning"
date: 2021-01-14T05:41:09.346Z
author: Ian Downard
tags: ["hpe-ezmeral-data-fabric","MapR","k-means"]
authorimage: "/img/blogs/Avatar4.svg"
featuredBlog: false
priority:
thumbnailimage:
---
**Editor’s Note:** MapR products and solutions sold prior to the acquisition of such assets by Hewlett Packard Enterprise Company in 2019, may have older product names and model numbers that differ from current solutions. For information about current offerings, which are now part of HPE Ezmeral Data Fabric, please visit [https://www.hpe.com/us/en/software/data-fabric.html](https://www.hpe.com/us/en/software/data-fabric.html)

## Original Post Information:

```
"authorDisplayName": "Ian Downard",
"publish": "2018-07-26T10:45:00.000",
"tags": "use-case"
```

---

Anytime you have lat/long coordinates, you have an opportunity to do data science with k-means clustering and visualization on a map. This is a story about how I used geo data with k-means clustering on a topic that has affected me personally - wildfires!

Every summer wildfires become front of mind for thousands of people who live in the West, Pacific Northwest, and Northern Rockies regions of the United States. Odds are, if you don't see the flames first hand, you will probably see smoke influenced the weather, road closures, and calls for caution by local authorities.

I've lived in Oregon for about 10 years. In that time I've had more than one close encounter with a forest fire. The summer of 2017 was especially bad. A fire in the Columbia River Gorge blew smoke and ash through my neighborhood. Earlier in the year, I crossed paths with firefighters attempting to control a fire in steep rugged terrain in southern Washington. I was stunned to see the size of their equipment and trucks so badass they could be in a Mad Max movie.

Fire fighting is expensive! [Wildland fire suppression costs exceeded $2 billion in 2017](https://www.usda.gov/media/press-releases/2017/09/14/forest-service-wildland-fire-suppression-costs-exceed-2-billion), making it the most expensive year on record for the U.S. Forest Service. Fires also have a tendency to explode in size. It's not at all unusual for fires to grow by 50,000 acres in one day when winds are high and the terrain is steep. Take a moment to conceptualize those numbers. $2 billion! More than 50,000 acres, burned in one day!

## A Beckoning to Data Science

I focused my study on optimizing against the following two constraints:

1.  The cost it takes to move water tanks and other heavy equipment.
2.  The propensity for fires to explode in size if not suppressed quickly.

Both of these things can be minimized by staging equipment as close as possible to where fires are likely to occur.

## The Problem

Minimize the cost and time to respond to fires by staging firefighting assets as close as possible to where fires are likely to occur.

## The Solution

![](https://hpe-developer-portal.s3.amazonaws.com/uploads/media/2020/12/image10-1610603073723.png)

My goal is to predict where forest fires are prone to occur by partitioning the locations of past burns into clusters whose centroids can be used to optimally place water tanks and heavy fire fighting equipment as near as possible to where fires are likely to occur. The k-means clustering algorithm is aptly suited for this purpose.

## The Data

The U.S. Forest Service provides datasets that describe forest fires that have occurred in Canada and the United States since the year 2000. That data can be downloaded from the Forest Service at [https://fsapps.nwcg.gov/gisdata.php](https://fsapps.nwcg.gov/gisdata.php). For my purposes, this dataset is provided in an inconvenient [shapefile](http://doc.arcgis.com/en/arcgis-online/reference/shapefiles.htm) format. It needs to be transformed to CSV in order to be easily analyzed with Apache Spark (no pun intended). Also, the records after 2008 have a different schema than prior years, so, after converting the shapefiles to CSV, they'll need to be ingested into Spark using separate user-defined schemas.

By the way, this complexity is typical. Raw data is hardly ever suitable for machine learning without cleansing. The process of cleaning and unifying messy data sets is called data wrangling, and it frequently comprises the bulk of the effort involved in real-world machine learning.

## The Science

![](https://hpe-developer-portal.s3.amazonaws.com/uploads/media/2020/12/image7-1610603093049.png)

The data wrangling that precedes machine learning typically involves writing expressions in R, SQL, Scala, and/or Python to join and transform sampled datasets. Often, getting these expressions right involves a lot of trial and error. Ideally, you want to test those expressions without the burden of compiling and running a full program. Data scientists have embraced web-based notebooks such as Apache Zeppelin for this purpose because they allow you to interactively transform datasets and let you know right away if what you're trying to do will work properly.

The Zeppelin notebook I wrote for this study contains a combination of Bash, Python, Scala, and Angular code. A screenshot of the Zeppelin notebook I created for this study is shown [here](https://github.com/iandow/iandow.github.io/blob/master/img/firenotebook.png) and the notebook file can be downloaded [here](https://raw.githubusercontent.com/iandow/iandow.github.io/master/_includes/Forest%20Fire%20Prediction.json). Essentially, I used Zeppelin to accomplish the following tasks:

1.  Download historical forest fire data
2.  Transform raw data into a desirable format
3.  Identify lat/long feature columns for k-means clustering
4.  Load data into Spark ML and train a k-means model
5.  Map the clusters showing regions where fires have been concentrated in the past

The code and documentation I wrote for this study is available here:

[https://github.com/mapr-demos/mapr-sparkml-streaming-wildfires](https://github.com/mapr-demos/mapr-sparkml-streaming-wildfires)

## Code Walkthrough

Here's the bash code I use to download the dataset:

![](https://hpe-developer-portal.s3.amazonaws.com/uploads/media/2020/12/image2-1610603101302.png)

Here's the Python code I used to convert the downloaded datasets to CSV files:

![](https://hpe-developer-portal.s3.amazonaws.com/uploads/media/2020/12/image9-1610603111027.png)

Here's the Scala code I use to ingest the CSV files and train a k-means model with Spark libraries:

![](https://hpe-developer-portal.s3.amazonaws.com/uploads/media/2020/12/image12-1610603119677.png)

The resulting cluster centers are shown below. Where would you stage fire fighting equipment?

![](https://hpe-developer-portal.s3.amazonaws.com/uploads/media/2020/12/image3-1610603128020.jpg)

These circles were calculated by analyzing the locations for fires that have occurred in the past. These points can be used to help stage fire fighting equipment as near as possible to regions prone to burn, but how do we know which staging area should respond when a new forest fire starts? We can use our previously saved model to answer that question. The Scala code for that looks like this:

![](https://hpe-developer-portal.s3.amazonaws.com/uploads/media/2020/12/image4-1610603136768.png)

## Operationalizing This Model as a Real-Time "Fire Response" App

The previous code excerpt shows how the model we developed could be used to identify which fire station (i.e., centroid) should be assigned to a given wildfire. We could operationalize this as a real-time fire response application with the following ML pipeline:

![](https://hpe-developer-portal.s3.amazonaws.com/uploads/media/2020/12/image1-1610603349597.png)

Most machine learning applications are initially architected with a synchronous pipeline like the one shown above, but there are limitations to this simplistic approach. Since it is only architected for a single model, your options are limited when it comes to the following:

*   How do you A/B test different versions of your model?
*   How do you load balance inference requests?
*   How do you process inference requests with multiple models optimized for different objectives (e.g., speed versus accuracy)?

In order to do these things, the model must be a modular component in the pipeline, and model results should rendezvous at a point where they can be compared, monitored, and selected based upon user-defined criteria. This design pattern can be achieved with an architecture called the rendezvous architecture.

## The Rendezvous Architecture

The rendezvous architecture is a machine learning pipeline that allows multiple models to process inference requests and rendezvous at a point where user-defined logic can be applied to choose which ML result to return to the requester. Such logic could say, "Give me the fastest result," or "give me the highest confidence score after waiting 10 seconds." The rendezvous point also gives us a point where models can be monitored and requests can be captured where model results significantly disagree with each other.

![](https://hpe-developer-portal.s3.amazonaws.com/uploads/media/2020/12/image5-1610603365540.png)

Note the emphasis on streams. Streams buffer requests in an infinite, resilient, and replayable queue. This makes it easy to hotswap models and scale ML executors in a microservices fashion. It also guarantees traceability for every inference request and response.

If you'd like to learn more about the rendezvous architecture, read the highly recommended Machine Learning Logistics by Ted Dunning and Ellen Friedman. It was published in 2017 and [is available as a free downloadable eBook](https://www.oreilly.com/library/view/machine-learning-logistics/9781491997628/).

## Conclusion

This was a story about how I used geo data with k-means clustering that relates to a topic that deeply affects a lot of people - wildfires! Anytime you have lat / long coordinates you have an opportunity to do data science with k-means clustering and visualization on a map. I hope this example illustrates the basics of k-means clustering and also gives some perspective on how machine learning models can be operationalized in production scenarios using streaming interfaces.

repository: hpe-dev-incubator/hpe-dev-portal

gha_language: HTML

repo_name: hpe-dev-incubator/hpe-dev-portal


text:
# eLfH-PHM-RiskStrat
Risk Prediction - A practical example in R to accompany the e-LfH module.

This worked example was created by PHE, NHSE&I and NHSx to accompany the Risk Stratification e-Learning for Health Module, available at https://portal.e-lfh.org.uk .

Most instructions and guided explanation are given within the R file itself. The dataset and the generic analysis flow diagram mentioned in the module are also provided.

#### OPENING THE EXISTING R PROJECT (GIT) ####

If using Git, you can either choose to download the project manually or - if familiar with Git and R integration - clone it into R Studio:

#### Download manually ####
1) Access the git via the url provided
2) Click on the green button saying 'Code'
3) Click 'Download ZIP'
4) Unzip as folder in appropriate location
5) In R Studio, choose File --> Open Project ... --> navigate to .Rproj file in unzipped folder

or

#### Clone from Git ####
1) Access the git via the url provided
2) Click on the green button saying 'Code' and copy the 'HTTPS' link provided
3) In R Studio, choose File --> New Project --> Version Control --> Git and paste the url provided. Click 'Create new project'

More information on using Github and connecting RStudio and Git can be found in this resource: https://happygitwithr.com/rstudio-git-github.html

repository: nhsx/eLfH-PHM-RiskStrat

repo_name: nhsx/eLfH-PHM-RiskStrat


text:
[![Build Status](https://travis-ci.org/openconf/jschat.png?branch=master)](https://travis-ci.org/openconf/jschat)
jschat
======

frontend community chat

## installation
node 0.10.17, npm 1.3.8 checked!

```
$ sudo npm install;
$ npm run setup
```

## scripts

* npm start - just starts server
* npm test - runs server tests
* npm run compile - compiles client folder
* npm run watch - watches client folder changes and refresh browser - server is also running
* npm run compilemob - same for mobile
* npm run watchmod - same for mobile

repository: EpanchinE/jschat

repo_name: EpanchinE/jschat


text:
---
layout: page
title: Voice Over Services by Video Game Voice Actor Joey Camen
permalink: /voice-over-services/
tags:
---

# Are you looking for professional voice acting?

* I'm most recognizable as the voice for the original McGruff the Crime Dog. "Take a bite outta crime."
* Kids these days know me as Shark Shooter Terrafin from the Skylanders video game. "It's feedin' time!"
* I'm super versatile when it comes to voice over. Try me for your role!

### If you are in need of voice over services for your production, please contact:

For animation, video games & commercials:

Tom Lawless

VOX USA

Los Angeles, CA

323-951-4534

<a href="mailto:tlawless@voxusa.net?subject=Re: Joey Camen"<EMAIL_ADDRESS>

Promos & ADR:

Jeff Jones

323-556-2486

<a href="mailto:jjones@voxusa.net?subject=Re: Joey<EMAIL_ADDRESS>

You can see Joey's voice over acting bio here.

… and here's Joey on IMDb.

### Thanks for stopping by!

😜 😜 😜


text:
# Unsupervised color image segmentation using Region Growing and Region Merging

This project is reimplementation of research on color image segmentataion using region growing and region merging respectively [1]. We prepared a demo code that you can load flower image and see 4 different level of region growing results from coarsed one to refined one. After you can see how the region merging has an effect on refined version of region growing. Here is the original input, all 4 level of region growing results and also final segmentation result. In this demo we feed region merging function with scale1 region growing results. But note you can feed the region merging function with either sclae 2, scale 3 or scale 4.

![Sample image](Outputs/result.jpg?raw=true "Title")

To run provided demo, please run Demo script as follows;

```
> Demo
```

## Reference
[1] Balasubramanian, Guru Prashanth, et al. "Unsupervised color image segmentation using a dynamic color gradient thresholding algorithm." Human Vision and Electronic Imaging XIII. Vol. 6806. International Society for Optics and Photonics, 2008.


text:
# ***Hey! I am Mainak Chakraborty, and I am pursuing my B.Tech in IT at NETAJI SHUBHASH ENGINEERING COLLEGE!😊😉*** #

## Basic Details: ##

- **City** - Kolkata

- **Schooling** - Hirendra Leela Patranavis School

- **College** - Netaji Subhash Engineering College, Garia, Kolkata

## Skills and Interests ##
| Skills | Hobbies | Interests |
|---|---|---|
| Java | Poetry | Machine Learning |
| Python | 90s Music | Statistics |
| HTML | Reading history | Automation |
| C/C++ | Sketching | Cloud |

## Languages ##
- English
- Bengali
- Hindi

## LinkedIn ##
[](https://www.linkedin.com/in/mainak-chakraborty-23414921b)


text:
# Objects Searching

### Command Format

**NameSpace**.**name**(_**requiredParameters**_, [_optionalParameters=defaultValue_]);

***

flags - search filters:

- fast - the search stops on the first found object;

- near - search for the nearest object to the character;

- mobile - search only for alive creatures;

- item - search only inanimate objects;

- human - search only for humanoid creatures, types: 0x0190-0x0193, 0x03DB, 0x03DF and 0x03E2;

- live - search only for living creatures;

- dead - search only for dead creatures, types: 0x0192 and 0x0193.

- injured - Searching for a friend with lowest HP (works only for FindFriend/FindEnemy).

- next - Searching for next object (works only for FindFriend/FindEnemy).

- ignorefriends - ignores friends.

- ignoreenemies - ignores enemies.

_When using human, live или dead - mobile flag is set automatically.

_When using next - fast flag is set automatically.

***

notoriety - Wickedness of the desired character.

- innocent/blue

- friendly/green

- gray

- criminal

- enemy/orange

- murderer/red

- invulnerable/yellow

***

distance - The search distance.

In addition to numerical values, it can take string constants: finddistance, usedistance, opencorpsedistance.

***

- void Client.UseType('graphic', ['color'=0xFFFF], ['container'=self], [recurse=true]);

Search for an object by type and color in the container.

- - graphic - Type or list of types. 0xFFFF is ignored.

- - color - The color or list of colors. 0xFFFF is ignored.

- - container - The container in which the search is performed.

- - recurse - Recursive search for sub-containers.

***

- void Client.UseFromGround('graphic', ['color'=0xFFFF], ['distance'=useObjectsDistance], ['flags']);

Search for an object by type and color on the ground.

- - graphic - Type or list of types. 0xFFFF is ignored.

- - color - The color or list of colors. 0xFFFF is ignored.

- - distance - The search distance.

- - flags - Search filter flags.

***

- bool Client.UseTypeList('listName', ['container'=self], [recurse=true]);

Search for an object from the find list in the container.

- - listName - The name of the find list.

- - container - The container in which the search is performed.

- - recurse - Recursive search for sub-containers.

Result: true if the object was found and used.

***

- bool Client.UseFromGroundList('listName', ['distance'=useObjectsDistance], ['flags']);

Search for an object on the find list on the ground.

- - listName - The name of the find list.

- - distance - The search distance.

- - flags - Search filter flags.

Result: true if the object was found and used.

***

- StringList Client.FindType('graphic', ['color'=0xFFFF], ['container'=backpack], ['flags'], ['distance'=searchObjectsDistance], ['notoriety'], [recurse=true]);

Search for an object by type and color.

- - graphic - Type or list of types. 0xFFFF is ignored.

- - color - The color or list of colors. 0xFFFF is ignored.

- - container - The container in which the search is performed.

- - flags - Search filter flags.

- - distance - The search distance.

- - notoriety - Wickedness of the desired character.

- - recurse - Recursive search for sub-containers.

Result: List of found serials.

***

- void Client.Ignore('serial', [state=true]);

Set / remove the ignore flag on the serial object.

***

- void Client.IgnoreReset();

Remove the ignore flag from all objects.

***

- GameObject Client.FindObject('serial');

Result: an object of type GameObject or null.

***

- int Client.Count('graphic', ['color'=0xFFFF], ['container'=self], ['distance'=searchObjectsDistance], [recurse]);

Returns the total number of items (the number of items, not the number of objects found).

- - graphic - Type or list of types. 0xFFFF is ignored.

- - color - The color or list of colors. 0xFFFF is ignored.

- - container - The container in which the search is performed.

- - distance - The search distance.

- - recurse - Recursive search for sub-containers.

Result: the amount of items.

***

- void Client.ResetIgnoreList();

Reset the use of the ignore list.

***

- void Client.UseIgnoreList('listName');

Use ignore list listName.

***

- StringList Client.FindList('listName', ['container'=backpack], ['flags'], ['distance'=searchObjectsDistance], ['notoriety'], [recurse=true]);

Search for an object in the find list.

- - listName - The name of the find list.

- - container - The container in which the search is performed.

- - flags - Search filter flags.

- - distance - The search distance.

- - notoriety - Wickedness of the desired character.

- - recurse - Recursive search for sub-containers.

***

- GameObject Client.ObjAtLayer('layerName', ['serial'=self]);

Result: an object of type GameObject in the specified layer of the object 'serial' or null.

***

- String Client.FindFriend(['flags'=fast], ['distance'=searchObjectsDistance]);

Searching for a friend serial from friends list.

- - flags - Searching filter flags.

- - distance - Searching distance.

***

- String Client.FindEnemy(['flags'=fast], ['distance'=searchObjectsDistance]);

Searching for an enemy serial from enemies list.

- - flags - Searching filter flags.

- - distance - Searching distance.

repository: crossuo/book

repo_name: crossuo/book


text:
---
layout: post
title: Cloud adoption and organisation culture
subtitle: Understanding the ability of an organisation to adapt to cross functional level changes
share-img: /img/assets/company_culture.jpeg
comments: true
---
I have the fine opportunity to work with multiple large enterprises to help them get started with their journey on cloud. Typically the ones that are very early in the journey take one of the few possible starting points:
* They have a specific use-case for their business objectives and want to see if cloud can help address it.
* Alt; They endlessly evaluate cloud providers without a specific goal in mind - this is mostly to bring themselves up to speed with what's latest in the cloud space

![Company Culture](/img/assets/company_culture.jpeg )

However, whichever route they tend to take, it's interesting how some organisations just get on with adoption while others just don't seem to make a huge amount of progress despite the number of interactions.

I did wonder what sort of frame of reference could we look at an organisation with - in order to better understand how we could help the slow/never starters to make progress as they fundamentally believe it was the right thing to do but just struggled because of the way their organisation was structured.

Reading the [State of devops report for 2018](https://cloudplatformonline.com/2018-state-of-devops.html) I spotted a theory around measuring the culture of an organisation which seems to have a direct correlation to how quickly they adopt changes. Using cloud is one of those fundamental shifts as well that impacts a big chunk of the organisation not just IT.

[Nicole](https://www.linkedin.com/in/nicolefv/) and her team mentions an academic paper written by Ron Westrum, an American sociologist who originally published in Quality and Safety in Health Care, an international peer-reviewed journal for health professionals, “A Typology of Organisational Cultures”.

Interestingly she uses this culture typology approach to evaulate the rate of adoption of devops but I assume it could equally be applicable to identify cultural shift required to support the changes required for cloud adoption.

### What is 'westrum typology' then?
It is a grouping, around the way organisations function, especially based on the focus of management and the response of the workforce to the focus. It can be used by organisations as a pulse check to see if there are aspects of the culture that need more focus than others.

The typology identifies three different categories
*  **Pathological** - characterized by large amounts of fear and threat. People often hoard information for political reasons or distort to make themselves look better
*  **Bureaucratic** - protect departments. Maintain their turf, insist on their own rules and follow them
*  **Generative** - focus on the mission - everything is subordinate to good performance.

![Westrum Typology](/img/assets/westrum_typology.png)

Interestingly while an organisation fits in an overall bucket - each department has its own culture and interestingly sometimes, its culture also varies based on the leadership at the point in time. Identifying and addressing areas, moving aspects of the culture left to right would help with:
*  Organisational performance overall
*  Strong predictor of job satisfaction and initiative taking
*  High trust - generative culture for a safe working environment to try out new ideas (e.g. changing the way things have fundamentally worked)

Perhaps with frameworks like [GCAF](https://services.google.com/fh/files/misc/adoption_framework_whitepaper_nov12_final.pdf) we should also look at the culture maturity framework as well that can help organisations build a roadmap aligned to initiatives that require cross functional change.

How has cloud adoption been for your organisation? I would love to hear more about the real challenges that you have encountered and how you approached to get them addressed.


text:
---
layout: default
---

# 1996-10-16 - Re: extortion via digital cash

## Header Data

From: "Timothy C. May"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 724cb2954719f810d12fb8a6d0dceef438d62141d790a3a60cc2462235f22ed1

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-10-16 06:49:18 UTC

Raw Date: Tue, 15 Oct 1996 23:49:18 -0700 (PDT)

## Raw message

```
{% raw  %}From: "Timothy C. May"<EMAIL_ADDRESS>Date: Tue, 15 Oct 1996 23:49:18 -0700 (PDT)
To<EMAIL_ADDRESS>Subject: Re: extortion via digital cash
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

At 11:01 PM -0400 10/15/96, Rabid Wombat wrote:

>Also - in order to communicate back to the perpetrator, the victim needs
>to communicate to the first step in the chain. The operator of that chain

BlackNet-type pools eliminate the chain. There is no "first step in the
chain," only a message pool or Usenet group which is propagated to tens of
thousands of sites around the world (and even available via one's satellite
dish and local cable, a la DirectPC, @Home, etc.).

>and abetting a crime is another. What's to keep the authorities from
>following the trail of crubs back to the perpetrator, other than the
>usual threats of "don't call the cops" and "you have 24 hours to respond?"
>A few hops through some generally uncooperative jurisdictions might do,
>but perhaps El Dictator of Little Bannana Republic might just decide to
>hold the perpetrator's "payment" hostage ...

Remailers, message pools, and untraceable cash are much more robust against
these sorts of attacks than you are portraying here.

>
>Sounds like the making of a good movie script. Can we get Tom Cruise and
>one of those Thinking Machines laptops??  ;)

Hollywood is too naive. I was interviewed by a screenwriter who came to a
Cypherpunks meeting, circa early 1994. She took copious notes and seemed
very interested in these sorts of things. From the plot she was tentatively
working on, I think the eventual outcome was "The Net," but it's possible
her script never got made, or was used for background, or whatever. In any
case, "The Net" (and "Hackers") had essentially nothing very sophisticated
in it.

--Tim May

"The government announcement is disastrous," said Jim Bidzos,.."We warned IBM
that the National Security Agency would try to twist their technology."
[NYT, 1996-10-02]
We got computers, we're tapping phone lines, I know that that ain't allowed.
---------:---------:---------:---------:---------:---------:---------:----
Timothy C. May              | Crypto Anarchy: encryption, digital money,
<EMAIL_ADDRESS>408-728-0152 | anonymous networks, digital pseudonyms, zero
W.A.S.T.E.: Corralitos, CA  | knowledge, reputations, information markets,
Higher Power: 2^1,257,787-1 | black markets, collapse of governments.
"National borders aren't even speed bumps on the information superhighway."

{% endraw %}
```

## Thread

+ Return to [October 1996](/archive/1996/10)

+ Return to "[Andrew Loewenstern <andrew_loewenstern@il.us.swissbank.com>](/authors/andrew_loewenstern_andrew_loewenstern_at_il_us_swissbank_com_)"
+ Return to<EMAIL_ADDRESS>(Ian Goldberg)](/authors/iang_at_cs_berkeley_edu_ian_goldberg_)"
+ Return to "[Jamie Lawrence <foodie@netcom.com>](/authors/jamie_lawrence_foodie_at_netcom_com_)"
+ Return to "[Rabid Wombat <wombat@mcfeely.bsfs.org>](/authors/rabid_wombat_wombat_at_mcfeely_bsfs_org_)"
+ Return to "[Scott McGuire <svmcguir@syr.edu>](/authors/scott_mcguire_svmcguir_at_syr_edu_)"
+ Return to "[scottb@aca.ca](/authors/scottb_at_aca_ca)"
+ Return to "["Timothy C. May" <tcmay@got.net>](/authors/timothy_c_may_tcmay_at_got_net_)"

+ 1996-10-15 (Tue, 15 Oct 1996 08:41:27 -0700 (PDT)) - [extortion via digital cash](/archive/1996/10/c63e2956596666cf73e9699138b0c183af6abe092151bf0bb87b58aa04878866) -<EMAIL_ADDRESS>  + 1996-10-15 (Tue, 15 Oct 1996 10:58:54 -0700 (PDT)) - [Re: extortion via digital cash](/archive/1996/10/ae8b838a9127b580993b4f3bf54b60c3a06f3e41a169ef5b32b89cb38e5eadcf) - _"Timothy C. May"<EMAIL_ADDRESS>  + 1996-10-16 (Tue, 15 Oct 1996 21:06:18 -0700 (PDT)) - [Re: extortion via digital cash](/archive/1996/10/0edbfe0a7888f394668592923657ebe6c7741ed3b595ea7d455a7bd83f40d1af) - _Andrew Loewenstern<EMAIL_ADDRESS>  + 1996-10-16 (Tue, 15 Oct 1996 21:10:25 -0700 (PDT)) - [Re: extortion via digital cash](/archive/1996/10/5d02a22ff87fce5ac989bbaef8a82ee02c85e007e267f781087ee7194abe52d1) - _Rabid Wombat<EMAIL_ADDRESS>  + 1996-10-16 (Tue, 15 Oct 1996 23:14:51 -0700 (PDT)) - [Re: extortion via digital cash](/archive/1996/10/88eb41decfd9c7810ea28b28aa19e37d193dac69d1cc3f84741daa380fe734ef) -<EMAIL_ADDRESS>(Ian Goldberg)_
  + 1996-10-16 (Tue, 15 Oct 1996 23:49:18 -0700 (PDT)) - Re: extortion via digital cash - _"Timothy C. May"<EMAIL_ADDRESS>    + 1996-10-16 (Wed, 16 Oct 1996 09:42:24 -0700 (PDT)) - [Re: extortion via digital cash](/archive/1996/10/e09cf3fcab1503cfa09ccc539156b564d9b1df3d672559df826c8179f66d7fa6) - _Rabid Wombat<EMAIL_ADDRESS>    + 1996-10-20 (Sat, 19 Oct 1996 21:09:38 -0700 (PDT)) - [Usenet and Re: extortion via digital cash](/archive/1996/10/70cb007a69fc0ff946bfd17cb79f5c2baf7bb0573683ea1a0f09eab095cbc4a4) - _Scott McGuire<EMAIL_ADDRESS>    + 1996-10-20 (Sat, 19 Oct 1996 23:26:21 -0700 (PDT)) - [Re: Usenet and Re: extortion via digital cash](/archive/1996/10/ffd7ab125b6a492fe6d9748698e292bf77eeb83beb8cfcd21e2827a48e6da329) - _Jamie Lawrence<EMAIL_ADDRESS>


text:
## Edge Machine Learning - C++ Library

This library consists of two machine learning algortihms **Bonsai** and **ProtoNN** implemented in C++ for speed and scalability.

### Requirements
* Linux:
  * gcc version 5.4. Other gcc versions above 5.0 could also work.
  * We developed the code on Ubuntu 16.04LTS. Other linux versions could also work.
  * You can either use the Makefile in the root, or cmake via the build directory (see below).

* Windows 10:
  * Visual Studio 2015. Use cmake (see below).
  * For Anniversary Update or later, one can use the Windows Subsystem for Linux, and the instructions for Linux build.

* On both Linux and Windows 10, you need an implementation of BLAS, sparseBLAS and vector math calls.
  We link with the implementation provided by the [Intel(R) Math Kernel Library](https://software.intel.com/en-us/mkl).
  Please download later versions (2017v3+) of MKL as far as possible.
  The code can be made to work with other math libraries with a few modifications.

### Building using Makefile

After cloning this repository, set compiler and flags appropriately in `config.mk`. Then execute the following in bash:

```bash
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:<MKL_PATH>:<EDGEML_ROOT>
make -Bj
```
Typically, MKL_PATH = /opt/intel/mkl/lib/intel64_lin/, and EDGEML_ROOT is '.'.

This will build four executables _BonsaiTrain_, _BonsaiPredict_, _ProtoNNTrain_ and _ProtoNNPredict_ in <EDGEML_ROOT>.
Sample data to try these executables is not included in this repository, but instructions to do so are given below.

### Building using CMake

For Linux, in the <EDGEML_ROOT> directory:

```bash
mkdir build
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:<MKL_PATH>
cd build
cmake ..
make -Bj
```

For Windows 10, in the <EDGEML_ROOT> directory, modify `CMakeLists.txt` file to change <MKL_ROOT> by changing the
line
```set(MKL_ROOT "<MKL_ROOT>")```

Then, generate Visual Studio 2015 solution using:

```mkdir build
cd build
cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_BUILD_TYPE=Release ..
```
Finally, open `EdgeML.sln` in VS2015, build and run.

For both Linux and Windows10, cmake builds will generate four executables _BonsaiTrain_, _BonsaiPredict_, _ProtoNNTrain_ and _ProtoNNPredict_ in <EDGEML_ROOT>.

### Download a sample dataset
Follow the bash commands given below to download a sample dataset, USPS10, to the root of the repository. Bonsai and ProtoNN come with sample scripts to run on the usps10 dataset. EDGEML_ROOT is defined in the previous section.

```bash
cd <EDGEML_ROOT>
mkdir usps10
cd usps10
wget http://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/multiclass/usps.bz2
wget http://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/multiclass/usps.t.bz2
bzip2 -d usps.bz2
bzip2 -d usps.t.bz2
mv usps train.txt
mv usps.t test.txt
mkdir ProtoNNResults
cd <EDGEML_ROOT>
```
This will create a sample train and test dataset, on which
you can train and test Bonsai and ProtoNN algorithms. As specified, we create an output folder for ProtoNN. Bonsai on the other hand creates its own output folder.
For instructions to actually run the algorithms, see [Bonsai Readme](docs/README_BONSAI_OSS.md) and [ProtoNN Readme](docs/README_PROTONN_OSS.ipynb).

### Makefile flags
You could change the behavior of the code by setting these flags in `config.mk` and rebuilding with `make -Bj` when building with the default Makefile in <EDGEML_ROOT>. When building with CMake, change these flags in `CMakeLists.txt` in <EDGEML_ROOT>. All these flags can be set for both ProtoNN and Bonsai.
The following are supported currently by both ProtoNN and Bonsai.

    SINGLE/DOUBLE:  Single/Double precision floating-point. Single is most often sufficient. Double might help with reproducibility.
    ZERO_BASED_IO:  Read datasets with 0-based labels and indices instead of the default 1-based.
    TIMER:          Timer logs. Print running time of various calls.
    CONCISE:        To be used with TIMER to limit the information printed to those deltas above a threshold.

The following currently only change the behavior of ProtoNN, but one can write corresponding code for Bonsai.

    LOGGER:         Debugging logs. Currently prints min, max and norm of matrices.
    LIGHT_LOGGER:   Less verbose version of LOGGER. Can be used to track call flow.
    XML:            Enable training with large sparse datasets with many labels. This is in beta.
    VERBOSE:        Print additional informative output to stdout.
    DUMP:           Dump models after each optimization iteration instead of just in the end.
    VERIFY:         Legacy verification code for comparison with Matlab version.

Additionally, there is one of two flags that has to be set in the Makefile:

    MKL_PAR_LDFLAGS: Linking with parallel version of MKL.
    MKL_SEQ_LDFLAGS: Linking with sequential version of MKL.

### Microsoft Open Source Code of Conduct
This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode<EMAIL_ADDRESS>with any additional questions or comments.

Copyright (c) Microsoft Corporation. All rights reserved.

Licensed under the MIT license.


text:
---
title: Self Access Permissions
book: userguide
chapter: roles-and-permissions
slug: selfaccesspermissions
weight: 40
---
The **Self Access Permission** checkbox provides a way for "submissions" to access their own records regardless of their role or other permissions assigned to the form. This is useful when you have User submissions created on behalf of the user, and then at a later time, they are onboarded in the system and need to have access to their own record. In this specific case, they are logged in as that submission, but are not the "owner" of the submission (since they didn't create their record). This checkbox allows them to have access to their record since the ```_id``` of the record is the same as the ```_id``` they provide in the Authenticaiton token as the User ID.

gha_language: JavaScript


text:
# [Uncrustify Code Beautifier](https://chocolatey.org/packages/uncrustify)

## Introduction
The goals of this project are simple: Create a highly configurable, easily modifiable source code beautifier.

## Features
- Indent code, aligning on parens, assignments, etc
- Align on '=' and variable definitions
- Align structure initializers
- Align #define stuff
- Align backslash-newline stuff
- Reformat comments (a little bit)
- Fix inter-character spacing
- Add or remove parens on return statements
- Add or remove braces on single-statement if/do/while/for statements
- Supports embedded SQL 'EXEC SQL' stuff
- Highly configurable - 655 configurable options as of version 0.68
- See some example [output](http://uncrustify.sourceforge.net/examples/example.c).

repository: chtof/chocolatey-packages

gha_language: PowerShell

repo_name: chtof/chocolatey-packages


text:
---
work: en-sogeti
organization: en-airbus-helicopters
role: Technical leader & Senior Web Software Developer
startDate: "2020-09-01"
endDate: "2021-04-01"
projects: ["R&R"]
tags: []
skills: [PHP, Symfony, Git, JavaScript, jQuery, Bootstrap, Linux, Bash, Debian, Docker, DevOps, CI-CD, agile, Scrum, MySQL, HTML, CSS, PHPUnit, GitLab, XML, Project Management, REST]
lang: en
---

# Mission

Realization of a functional model for Airbus Helicopters allowing them to centralize informative data
about the organizations composing it, to guarantee a complete and coherent description of the roles and responsibilities
of each organization and their managers, to synthesize the organizational chars and the associated functions, to know
the entry of information state of progress by the persons in charge, to be kept automatically up to date and to notify each actor of its related resources.

- Implementation of a containerized CI/CD via docker under Gitlab-CI (builds, tests & quality gates, security, publication & staging/prod deployment, reporting)
- Developers and testers team supervision
- Customer workshops for the project development over the water
- PSR compliance, with Symfony 4 framework compliance ++
- Code quality & code coverage optimization

gha_language: Twig