text:
# Bus Control

![6502_locator_bus_control](/BreakingNESWiki/imgstore/6502/6502_locator_bus_control.jpg)

Bus control is most of all "scattered" around the processor surface. It is easiest to describe all the bus [control commands](context_control.md) first, and then to look at the corresponding circuits individually.

Bus control commands:

|Command|Description|
|---|---|
|External address bus control||
|ADH/ABH|Set the high 8 bits of the external address bus, in accordance with the value of the internal bus ADH|
|ADL/ABL|Set the low-order 8 bits of the external address bus, in accordance with the value of the internal bus ADL|
|ALU connection to SB, DB buses||
|AC/DB|Place the AC value on the DB bus|
|SB/AC|Place the value from the SB bus/BCD correction circuit into the accumulator|
|AC/SB|Place the AC value on the SB bus|
|Control of the SB, DB and ADH internal buses||
|SB/DB|Connect the SB and DB buses|
|SB/ADH|Connect SB and ADH buses|
|0/ADH0|Forced to clear the ADH\[0\] bit|
|0/ADH17|Forced to clear the ADH\[1-7\] bits|
|External data bus control||
|DL/ADL|Write the DL value to the ADL bus|
|DL/ADH|Write the DL value to the ADH bus|
|DL/DB|Exchange the value of the DL and the internal bus DB. The direction of the exchange depends on the operating mode of the external data bus (read/write)|

The motive of all the circuits is roughly as follows:
- The control circuits get a lot of input from the decoder and other auxiliary signals
- All circuits are mostly combinatorial (no triggers, just a mess of gates)
- The outputs from the control circuits go to the output latches of the commands to control the lower part of the processor.

## Auxiliary Signals

Circuits for obtaining auxiliary signals:

|NOADL, IND|JSXY|
|---|---|
|![bus_noadl_ind_tran](/BreakingNESWiki/imgstore/6502/bus_noadl_ind_tran.jpg)|![bus_jsxy_tran](/BreakingNESWiki/imgstore/6502/bus_jsxy_tran.jpg)|

In the `IND` circuit the decoder output X90 is additionally modified by the Push/Pull signal (X129).

The other auxiliary and intermediate signals that can be found in the schematics in this section:

|Signal|Description|
|---|---|
|RTS/5|Decoder X84|
|RTI/5|Decoder X26|
|STXY|Comes from [register control circuitry](regs_control.md)|
|BR0|Decoder X73. Additionally modified with the /PRDY signal|
|T6 RMW|Comes from the cycle counter of long instructions|
|T7 RMW|Comes from the cycle counter of long instructions|
|PGX|Output signal from ADL/ABL circuit|
|JSR/5|Decoder X56|
|T2|Decoder X28|
|!PCH/PCH|Comes from the [PC control circuitry](pc_control.md)|
|SBA|The signal comes out of the #SB/ADH circuit, used in the #ADH/ABH circuit|
|/ready|Global internal processor readiness signal|
|BR3|Decoder X93|
|0/ADL0|Comes from the interrupt vector setting circuit|
|AND|Comes from the [ALU control](alu_control.md) circuit|
|STA|Decoder X79|
|STOR|Intermediate signal from the dispatcher|
|#SBXY|Comes from a register control circuit (not to be confused with STXY)|
|T1|Comes from the PC increment circuit (see [dispatcher](dispatch.md))|
|BR2|Decoder X80|
|ZTST|Output signal for [flags control](flags_control.md) from SB/DB circuit|
|ACRL2|One of the ACR Latch outputs|
|T0|Comes from the cycle counter of short instructions|
|ABS/2|Decoder X83. Additionally modified with Push/Pull signal (X129)|
|JMP/4|Decoder X101|
|IMPL|Decoder X128. Additionally modified with Push/Pull (X129) and IR0 signals.|
|JSR2|Decoder X48|
|/JSR|Inversion of JSR2 for the register control circuit|
|BRK6E|Comes from the [interrupts processing](interrupts.md) circuit|
|INC_SB|Comes from the ALU control circuit|
|DL/PCH|Comes from the PC control circuitry|

The signals are arranged in the order they appear in the schematics.

## External Address Bus Control

Circuits for the generation of intermediate signals:

|#ADL/ABL|#ADH/ABH (1)|#ADH/ABH (2)|
|---|---|---|
|![bus_adlabl_tran](/BreakingNESWiki/imgstore/6502/bus_adlabl_tran.jpg)|![bus_adhabh_tran1](/BreakingNESWiki/imgstore/6502/bus_adhabh_tran1.jpg)|![bus_adhabh_tran2](/BreakingNESWiki/imgstore/6502/bus_adhabh_tran2.jpg)|

The first piece of the #ADH/ABH circuit is to the right of flag B, the second piece is in the interrupt address generation circuitry. The #ADH/ABH signal connects directly between these two pieces.

The output latches of the ADL/ABL and ADH/ABH control commands:

![bus_addr_bus_commands_tran](/BreakingNESWiki/imgstore/6502/bus_addr_bus_commands_tran.jpg)

## ALU Connection to SB, DB

Circuits for the generation of intermediate signals:

|#AC/DB|#SB/AC, #AC/SB|
|---|---|
|![bus_acdb_tran](/BreakingNESWiki/imgstore/6502/bus_acdb_tran.jpg)|![bus_acsb_tran](/BreakingNESWiki/imgstore/6502/bus_acsb_tran.jpg)|

AC/DB, SB/AC, AC/SB control command output latches:

![bus_alu_commands_tran](/BreakingNESWiki/imgstore/6502/bus_alu_commands_tran.jpg)

## SB, DB, ADH Control

Circuits for generating intermediate signals (for 0/ADH0 you get the control command at once):

|#SB/DB (also #0/ADH17)|0/ADH0|#SB/ADH|
|---|---|---|
|![bus_control_tran1](/BreakingNESWiki/imgstore/6502/bus_control_tran1.jpg)|![bus_0adh0_tran](/BreakingNESWiki/imgstore/6502/bus_0adh0_tran.jpg)|![bus_sbadh_tran](/BreakingNESWiki/imgstore/6502/bus_sbadh_tran.jpg)|

SB/DB, SB/ADH, 0/ADH17 control command output latches:

![bus_sb_commands_tran](/BreakingNESWiki/imgstore/6502/bus_sb_commands_tran.jpg)

(0/ADH0 above)

## External Data Bus Control

Circuits for the generation of intermediate signals:

|#DL/ADL|#DL/DB (1)|#DL/DB (2)|
|---|---|---|
|![bus_dladl_tran](/BreakingNESWiki/imgstore/6502/bus_dladl_tran.jpg)|![bus_dldb_tran](/BreakingNESWiki/imgstore/6502/bus_dldb_tran.jpg)|![bus_dldb_tran2](/BreakingNESWiki/imgstore/6502/bus_dldb_tran2.jpg)|

The first piece of #DL/DB circuitry is next to the ACR Latch, the second piece is right inside the ALU control circuitry. The #DL/DB signal connects directly between these two pieces.

DL/ADL, DL/ADH, DL/DB control command output latches:

![bus_data_latch_commands_tran](/BreakingNESWiki/imgstore/6502/bus_data_latch_commands_tran.jpg)

## Logic

![bus_control_logisim](/BreakingNESWiki/imgstore/logisim/bus_control_logisim.jpg)

## Optimized Schematics

![7_bus_control_logisim](/BreakingNESWiki/imgstore/6502/ttlworks/7_bus_control_logisim.png)

repository: ogamespec/breaks

repo_name: ogamespec/breaks


text:
# haniwa-lazy-load
Fast and customizable lazy loader for images and iframes with vanilla js

## Features
- Lazy loading of images and iframes;
- Custom selectors for elements that should be lazy loaded;
- You can specify src attribute of lazy elements;
- Loading process customization/visualization;
- Error handling/visualization;
- You can disable lazy loading without any pain and changing HTML;

## installation
npm i haniwa-lazy-load

## Usage example
For basic usage, look example directory.

You can always detach lazy loading with:
```javascript
lazyLoader.detach();
```

and attach it later with:
```javascript
lazyLoader.attach();
```

If you load your images dynamically, you can always add new elements to be lazy loaded:
```javascript
lazyLoader.updateWithSelectors(["img[data-src]", "iframe"]);
lazyLoader.lazyLoad();
```

## LazyLoader Options
- selectors[array][required] - selectors for elements that should be lazy loaded(example: ["img", "iframe"]);
- loadHandler[func][not required] - function (element) => function;
      called before an element starts loading, should return a function that will be called when the element will be completely loaded;
      accepts the element itself;
      you can build default loadHandler with LazyLoader.buildDefaultLoadHandler, that accept two arguments: selector for loading container and selector for loading inner;
- errorHandler[func][not required] - function(element) => void;
      does something with the element on a loading error;
- advance[number][not required][default = 50] - pixels before an image starts loading;
- setNaturalSizeAfterLoad[bool][not required][default = true] - if true, will set real image size after it will have loaded;
- lazyAttribute[string][not required][default = 'data-src'] - attribute in which real 'src' is stored. When content is loaded, 'src' value will be filled from this attribute's value.

## UnlazyLoader Options
- selectors[array][required];
- setNaturalSizeAfterLoad[bool][not required][default = true];
- lazyAttribute[string][not required][default = 'data-src']

## Licension
MIT

license: MIT

repository: onyazuka/haniwa-lazy-load

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: onyazuka/haniwa-lazy-load


text:
---
layout: post
title: "What Jar files do I need to use Stax?"
category: "Blog"
date: 2011-01-17
---

I have been getting a lot of questions about which libraries need to be installed in order for the Stax [sample code](http://www.fekke.com/XMLandStAXExamples.zip) to work. All of the Stax libraries are available from the [Codehaus.org](http://woodstox.codehaus.org/Download) site.

Here is a list of the Jar files I have installed in my web-inf/lib directory;

<div class="code">jsr173_1.0_api.jar

jsr173_1.0_examples.jar

jsr173_1.0_javadoc.jar

jsr173_1.0_ri.jar

jsr173_1.0_src.jar

wstx-asl-3.0.1.jar

stax2.jar

</div>

extension: markdown

gha_language: HTML

gha_license_id: MIT


text:
## Convert Sorted Array to Binary Search Tree
### Illustrate
<https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree>

Given an array where elements are sorted in **ascending order**, convert it to a **height balanced** BST.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

### Example
```c
Given the sorted array: [-10,-3,0,5,9],

One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:

      0
     / \
   -3   9
   /   /
 -10  5
```

### Testcase
`height balanced BST` is not unique, so my solution is also passed.

```c
Your Input: [-10,-3,0,5,9]
Output: [0,-10,5,null,-3,null,9]
Expected: [0,-3,9,-10,null,5]
```

### Code
```c++
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return convert(nums, 0, nums.size() - 1);
    }

    /*
     * convert: build BST recursively
     * @nums: the ascended sorted array
     * @left: index range [left, right]
     * @right: right included
     * @return the root pointer of the (sub)tree
     */
    TreeNode* convert(vector<int> &nums, int left, int right) {
        if(left > right) {
            return NULL;
        }
        int mid = left + (right - left) / 2;
        TreeNode *root = new TreeNode(nums[mid]);
        root->left  = convert(nums, left, mid - 1);
        root->right = convert(nums, mid + 1, right);
        return root;
    }
};
```

url: https://raw.githubusercontent.com/xiangp126/Algorithm/0bd2f5d6b3e5f9837fd60b9057f35c7d5760481d/binaryTree/Convert Sorted Array to Binary Search Tree.md


text:
LxGraph
=======

This is a prototype of source code
graph generator developed as a part of
course work. The name is temporary.

It is trying to generate a nice graph
in a graphviz dot format.

At the moment it is possible to exclude
parts of the graph via confiuration either
via specifing different roots or adding
them to exclude lists.

Duplicate edges are collapsed to clean-up
the graph and turned into wider edges.

It is still generates quite messy graphs
for the large code bases and probably needs
custom layout engine that takes into account
modules and files.
The idea is to lay out graphs from to to bottom
laying out file first and then laying out functions
within each file.

## Building and dependencies

The only direct dependency is `libclang` (tested with gcc 10 and libclang 11).
You also need to have graphviz installed to render the graph.

To build:

    make -j

## Running

To see available configuration options run `./lxgraph -h`

### Linux kernel

To run it on linux kernel, you first need to compile the kernel (tested with version 5.4)
and generate `compile_commands.json` with `scripts/gen_compile_commands.py`
shipped with the kernel. Then you can run this generator:

    cd /path/to/the/kernel
    make defconfig
    make -j$(nproc)
    ./scripts/gen_compile_commands.py
    cd -
    ./lxgraph -p /path/to/the/kernel -C contrib/lxgraph.linux.conf
    dot -Tsvg graph.dot > graph.svg

### NSST

To run it on other programs you also need to generate `compile_commands.json`.
This can be done for example with [Bear](https://github.com/rizsotto/Bear).
The example generation for [nsst termintal](https://github.com/summaryInfo/nsst):

    cd /path/to/nsst
    bear make force -j
    cd -
    ./lxgraph -p /path/to/nsst -C contrib/lxgraph.nsst.conf
    dot -Tsvg graph.dot > graph.svg

## TODO

* Support configuring files-to-modules correspondance and
  take is into account while generating the graph.

* Implement custom layout engine.

* Generate links to the parts of the graph to make it more navigatable.

* Remove non-essential parts to reduce the noise

* Add option to remove static/inline functions from the graph

repository: summaryInfo/lxgraph

repo_name: summaryInfo/lxgraph


text:
# Get the PID of the last run command

If the previous command is still running, it's possible to get the PID of the last run commad using the `$!` variable.

```bash
➜ til git:(master)  sleep 15 &
[1] 7652
➜ til git:(master)  kill $!
[1]+  Terminated              sleep 15
```

This also works if the command has terminated.

```bash
➜ til git:(master)  sleep 2
➜ til git:(master)  echo $!
7652
```

license: Unlicense

repository: codemicro/til

repo_name: codemicro/til


text:
# UD615: Scalable Microservices with Kubernetes

This is the code for [Scalable Microservices with Kubernetes](https://www.udacity.com/course/scalable-microservices-with-kubernetes--ud615).  In this course you will learn how to:

* Provision a complete Kubernetes using [Google Container Engine](https://cloud.google.com/container-engine)
* Deploy and manage Docker containers using kubectl

Kubernetes Version: 1.2.2

## Course Description

Kubernetes is all about applications and in this course you will utilize the Kubernetes API to deploy, manage, and upgrade applications. In this part of the workshop you will use an example application called "app" to complete the labs.

App is an example [12 Factor application](http://12factor.net/) that we'll be using throughout the course. During this course you will be working with the following Docker images:

* [udacity/example-monolith](https://hub.docker.com/r/udacity/example-monolith) - Monolith includes auth and hello services.
* [udacity/example-auth](https://hub.docker.com/r/udacity/example-auth) - Auth microservice. Generates JWT tokens for authenticated users.
* [udacity/example-hello](https://hub.docker.com/r/udacity/example-hello) - Hello microservice. Greets authenticated users.
* [nginx](https://hub.docker.com/_/nginx) - Frontend to the auth and hello services.

## Links

  * [Kubernetes](http://googlecloudplatform.github.io/kubernetes)
  * [gcloud Tool Guide](https://cloud.google.com/sdk/gcloud)
  * [Docker](https://docs.docker.com)
  * [etcd](https://coreos.com/docs/distributed-configuration/getting-started-with-etcd)
  * [nginx](http://nginx.org)

gha_language: Go


text:
# TypeScript in the Browser

> Note: The ability to both transpile and execute TypeScript code in the browser
> has since been added to the TypeScript Playground:
> https://www.typescriptlang.org/play

This repository is an experiment in transpiling TypeScript in the browser.

[**DEMO**](https://tomashubelbauer.github.io/typescript-in-browser)

How does it work?

1. The page loads `typescript.js` (`typescript/lib/`) in some way (CDN, `node_modules`)
2. The page has the `TypeScript` and `ts` objects available on `window`
3. The [TypeScript API](https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API) can be used
4. This demo transpiles TypeScript source text to JavaScript source text based on the
   [demo in the TypeScript wiki](https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#transpiling-a-single-file)

```js
const { outputText, diagnostics, sourceMapText } = ts.transpileModule('const x: number = 5;', { compilerOptions: { target: 'esnext' } });
```

## Running

Remotely, [**see the online demo**](https://tomashubelbauer.github.io/typescript-in-browser)

Locally, run `index.html`

## To-Do

### Make TSX work in the Monaco editor

### Add TS compiler options controls: types, target etc.

Investigate how loading typings could work

repository: TomasHubelbauer/typescript-in-browser

branch_name: refs/heads/main

repo_name: TomasHubelbauer/typescript-in-browser


text:
# The Avengers League
Becuase the some problems require the Avengers and the Justice League to solve.

### The Avengers League - Angular App Link
https://github.com/sebas-vn/TheAvengersLeague-Frontend

### Project Description
The backend rest api for The Avenger's League card game. Handles account managment and multiplayer gameplay.

### Technologies Used
Spring MVC
Hibernate
AWS Codepipeline and Elastic Beanstalk for deployment

### Features
- Create account, login, logout, and manage account
- Save game data to account, like the Hero and Villain Decks
- Play a multiplayer board/card game using the decks built by the player

### To-do list:
- Friends list with direct queue options
- More gameplay elements like more cards, special items, and balancing
- Better security, probably using Spring Security features

## Contributors
- Michael Weathery
- John Pham
- Sevastian Villegas
- Noah Gaston

gha_language: Java


text:
# PWABuilder: pwa-simulator
A [web component](https://medium.com/pwabuilder/building-pwas-with-web-components-33f986bf8e4c) that allows you to preview your PWA on Windows 11, based on your app's `manifest.json` file!

## Built with
- [Lit](https://lit.dev/)
- [Typescript](https://www.typescriptlang.org/)
- The project generator from [Open Web Components](https://open-wc.org/docs/development/generator/)

## Using this component
### Modes
The `pwa-simulator` can be used in 2 ways:
1. **You can enter the PWA's URL in the initially rendered form**, and via the [`pwabuilder-manifest-finder` API](https://github.com/pwa-builder/pwabuilder-manifest-finder), the component fetches the corresponding web manifest.
2. **The site's URL can be passed as a property to the component**, together with the web manifest. Note that the PWA's URL is still needed in this mode to display the icons and other images.

### Configuration
All properties are optional and have default values, but for the optimal experience these should be modified as needed.
Note that in the HTML markup, property names should be all in lowercase. For more information refer to [lit's documentation](https://lit.dev/docs/components/properties/#attributes).

- `siteUrl`: The PWA's URL. If not defined, the component will initially display a form to input the site's URL (see [mode 1](#modes) above).
- `manifest`: The input manifest object. The `siteUrl` property should be defined if a manifest is given as input.
  - Default:
  ```
  {
    name: 'PWA App',
    background_color: '#FFF',
    theme_color: '#E3CEF6',
    categories: [],
    shortcuts: [],
    display: 'standalone',
    description: 'An amazing progressive web app!',
    icons: [
      {
        src: '/assets/icons/icon_512.png',
        sizes: '512x512',
        type: 'image/png'
      }
    ]
  }
  ```
- `hideEditor`: If true, the code editor is hidden and only the preview window is displayed.
  - Default: `false`
- `explanations`: Object containing the explanation messages that are displayed when the user interacts with the previewer. `initial` is the starting message (can be used to suggest an initial action to the user). `appWindow`, `startMenu`, `jumpList` and `store` are all shown when the respective window is open. If a value isn't specified, the default message is used.
  - Default:
  ```
  {
    initial: "Do you see something familiar on the taskbar?",
    appWindow: "The background color, theme color and display attributes determine several UI aspects of your PWA, such as the titlebar.",
    startMenu: "The application's name and icon are used in the start menu.",
    jumpList: "The actions listed on the shortcuts attribute define a context menu that is displayed when right-clicking on the taskbar icon.",
    store: "Screenshots, a complete description and categories will enhance your app's listing in the Microsoft Store."
  }
  ```
- `explanationDisplayTime`: The duration (in milliseconds) of the explanation message display, after which it fades out.
  - Default: 5000 (5 seconds)

## Styling
This component can also be styled according to the needs of your application.

The simulator exposes the parts below for customization with the [CSS ::part() pseudo-element](https://css-tricks.com/styling-in-the-shadow-dom-with-css-shadow-parts/):
Part name | Description
----------|------------
`background` | The simulator's main container.
`content` | The container of both the text editor and platform window.
`input-form` | The form for entering the PWA's URL.
`input-title` | The title of the form for entering the PWA's URL.
`input-field` | The text field for entering the PWA's URL.
`input-button` | The button that submits the form for entering the PWA's URL.
`status-message` | The text that announces changes in the preview manifest.

The following [CSS variables](https://developer.mozilla.org/en-US/docs/Web/CSS/--*) can also be provided:
Variable name | Description | Default
--------------|-------------|--------
`--font-family` | The component's main font family. | Arial
`--font-color` | The component's main font color. | `#292C3A`
`--background` | The CSS background of the entire component. | `linear-gradient(252.83deg, #5039A8 2.36%, #6AA2DB 99.69%)`
`--pwa-background-color` | Fallback background color to use in case it is not defined in the manifest. | `#FFF`
`--pwa-theme-color` | Fallback theme color to use in case it is not defined in the manifest. | `#E3CEF6`

repository: pwa-builder/pwa-simulator

repo_name: pwa-builder/pwa-simulator


text:
ember-addon-broccoli-test-helper
==============================================================================

Test helpers for Ember Addons that make testing build and rebuild behavior
dead simple and diff friendly. It provides a similar API to
[broccoli-test-helper][bth] and helpers for scaffolding out a temporary
Ember CLI application.

Has TypeScript declarations and supports async/await style testing.

Installation
------------------------------------------------------------------------------

```
npm install --save-dev ember-addon-broccoli-test-helper
```
or
```
yarn add --dev ember-addon-broccoli-test-helper
```

How It Works
------------------------------------------------------------------------------

Using `createTempDir()`, `Input#installDependencies`, and the fixture builders,
you can set up a temp directory like this:

```
/tmp/abcd1234/
  application/
    app/
    config/
    package.json
  my-addon/
    addon/
    index.js
  node_modules/
    ember-cli/
    ember-source/
```

The `my-addon` and `node_modules` directories are symlinks to your addon and its
dependencies.

The `application` directory contains a simplified Ember application scaffold
that references the `my-addon` directory in its package.json for Ember CLI
to discover when it builds the application.

After calling `output.build()`, you can inspect the results with the same
[broccoli-test-helper][bth] API.

Usage Examples
------------------------------------------------------------------------------

See [test/acceptance.test.ts](test/acceptance.test.ts) for an example usage.

Contributing
------------------------------------------------------------------------------

### Installation

* `git clone <repository-url>`
* `cd ember-addon-broccoli-test-helper`
* `yarn install`

### Linting

* `yarn lint`
* `yarn lint --fix`

### Running tests

* `yarn test`

License
------------------------------------------------------------------------------

This project is licensed under the [Apache-2.0 License](LICENSE.md).

[bth]: https://github.com/broccolijs/broccoli-test-helper

gha_language: TypeScript

gha_license_id: NOASSERTION


text:
---
layout: page
title: "iMessage New Device Sec"
subheadline: ""
teaser: "You know when you add a new Apple device to your lineup, you inevitably get a message about a new device added to iMessage? Seems ridiculous doesn't it? I know I added the device, I was there. I always thought it was a bug, a remnant in iOS and OS X from the early days when iMessage was being developed. As they say, it's not a bug, it's a feature."
author: Morgan
categories:
  - apple
breadcrumb: true
---

You know when you add a new Apple device to your lineup, you inevitably get a message like this one? Seems ridiculous doesn't it? I know I added the device, I was _there_. I always thought it was a bug, a remnant in iOS and OS X from the early days when iMessage was being developed. As they say, it's not a bug, it's a feature. Rich Mogull explains on [Securosis](https://securosis.com/mobile/how-imessage-distributes-security-to-block-phantom-devices/full):

> It turns out you can’t add devices to an iCloud account without triggering an alert because that analysis happens on your device, and doesn’t rely (totally) on a push notification from the server. Apple put the security logic in each device, even though the system still needs a central authority. Basically, they designed the system to not trust them.

So you get that alert on _every_ device, because _every_ device sees the new device on it's own, independent from all the other Apple devices you own. Here's why:

> iMessage is a centralized system with a central directory server. If someone could compromise that server, they could add “phantom devices” to tap conversations (or completely reroute them to a new destination). To limit this Apple sends you a notification every time a device is added to your iCloud account.

Because of how the devices are set up (each notifying you when a new iMessage device is added), the group of them act as your own personal iMessage canary.

> ...if they were deeply compromised (okay, forced by a government) to alter their system, the notification could be faked, but that isn’t how it works. Your device checks its own registry of keys, and pops up an alert if it sees a new one tied to your account.

If you added a new device and _didn't_ observe this popup, you could naturally assume that iMessage, or at the very least **your** iMessage account had been compromised.

For reference, every iMessage you send is encrypted end-to-end using public key crypto. You don't share a single key among your devices, each device has its own keys. Every message you send is encrypted with public keys for _each_ iMessage device you own. This means that a given message may have 4 or 5 keys attached to it. When you add a new device, it send its public key to Apple, and when Apple pushes that key to your other devices - thus you get this popup.

---

Typed on AEKII


text:
# Numerical method

## Two-scale formulation

First, rewrite equation (1) using the variable change $w(t)=\exp(-(t-t_{0})A/\varepsilon) u(t)$ to obtain

$$\frac{d w(t)}{dt} = F\Big( \frac{t-t_{0}}{\varepsilon}, w(t) \Big), \;\;\; w(t_{0})=u_{0}, \;\; \varepsilon\in ]0, 1],$$

where the function $F$ is expressed from the data of the original problem (1)

$$F\Big( \frac{s}{\varepsilon}, w \Big) = \exp(-sA/\varepsilon) \; f( \exp(sA/\varepsilon), \; w).$$

We then introduce the function $U(t, \tau), \tau\in [0, 2 \pi]$ such that $U(t, \tau=(t-t_{0})/\varepsilon) = w(t)$. The two-scale function is then the solution of the following equation

$$\frac{\partial U}{\partial t} + \frac{1}{\varepsilon} \frac{\partial U}{\partial \tau} =  F( \tau, U), \;\;\; U(t=t_{0}, \tau)=\Phi(\tau), \;\; \varepsilon\in ]0, 1], \;\;\;\;\;\;\;\;\;\; (2)$$

where $\Phi$ is a function checking $\Phi(\tau=0)=u_{0}$ chosen so that the $U$ solution of (2) is regular (see [chartier2015](@cite) and [chartier2020](@cite).

## Discretization

The numerical method is based on a suitable time discretization of equation (2). In the direction $\tau$, a spectral method is used, while for the time $t$, an exponential Adams-Bashforth method allows to build a high order method (see [chartier2020](@cite)). The suitable choice of the initial condition is required to ensure high order accuracy. From a numerical point of view, a "butterfly" technique is introduced here (going back and forth around the initial time).

### Initialization

Let r be the order of the method $AB_r$.\
Let $\Delta t$ the time step, for $i \in \{r, -(r-1), \ldots, r-1, r\}$,
we note $u_i = u(t_0+i \Delta t)$.\
Let $r'$ be the orders of the intermediate AB methods we will use.\
If $u_{k}$ is known with a precision of ${\mathcal O}(\Delta t^{r'+1})$, and for $r' \geq 2, u_{k-1}, \ldots, u_{k-r'+1}$ are known with a precision of ${\mathcal O}(\Delta t^{r'})$ then we can calculate $u_{k+1}$ with a precision of ${\mathcal O}(\Delta t^{r'+1})$ with the method $AB_{r'}$.\
Similarly, if $u_{k}$ is known with a precision of ${\mathcal O}(\Delta t^{r'+1})$, and for $r' \geq 2, u_{k+1}, \ldots, u_{k+r'-1}$ are known with a precision of ${\mathcal O}(\Delta t^{r'})$ then we can calculate $u_{k-1}$ with a precision of ${\mathcal O}(\Delta t^{r'+1})$ with the method $AB_{r'}$.

### Algorithm

- With the method $AB_1$, from $u_0$ we calculate $u_{-1}$ with a precision of ${\mathcal O}(\Delta t^2)$
- With the method $AB_2$, starting from $u_{0}$ and $u_{-1}$, we calculate $u_{1}$ with a precision of ${\mathcal O}(\Delta t^3)$
- For $r' = $3 to $r' = r$.
    - For $k=1$ to $k=r'-1$
        - With the method $AB_{r'-1}$, from $u_{1-k}, u_{2-k}, \ldots,u_{r'-1-k}$, we calculate $u_{-k}$ with a precision of ${\cal O}(\Delta t^{r'})$
    - For $k=1$ to $k=r'-1$
         - With the method $AB_{r'}$, from $u_{k-1}, u_{k-2}, \ldots,u_{k-r'}$, we calculate $u_{k}$ with a precision of ${\mathcal O}(\Delta t^{r'+1})$

At the end of this algorithm, the values $u_0, u_1, \ldots u_{r-1}$ are known with a precision of ${\mathcal O}(\Delta t^{r+1})$, we can launch the algorithm $AB_r$.

### The Adams-Bashforth Method
For an Adams-Bashforth method of order $r$ in time and spectral $\tau$, we first introduce a mesh in the $\tau$ direction.\
$\tau_{\ell} = \ell \Delta \tau, \ell = 0, \ldots, N_{\tau}-1$. Where $N_{\tau}$ is the number of points of discretization. If we apply the Fourier transform to the two-scale equation, we obtain

$$\frac{\partial \hat{U}_\ell}{\partial t} + \frac{i\ell}{\varepsilon}\hat{U}_\ell = \hat{F}_\ell(t), \;\; \ell=-N_\tau/2, \dots, N_\tau/2-1,$$

with

$$U(t, \tau_k) = \sum_{\ell=-N_{\tau}/2}^{N_{\tau}/2-1} \hat{U}_{\ell}(t) e^{i\ell k 2\pi/N_{\tau}} \;\;\; \text{ and } F(\tau_k, U(t, \tau_k)) = \sum_{\ell=-N_{\tau}/2}^{N_{\tau}/2-1} \hat{F}_{\ell}(t) e^{i\ell k 2\pi/N_\tau}.$$

and the inverse (discrete) Fourier transform formulae

$$\hat{U}_{\ell}(t) = \frac{1}{N_{\tau}}\sum_{k=0}^{N_{\tau}-1} U(t, \tau_k) e^{-i\ell k 2\pi/N_{\tau}}\;\;\; \text{ and } \hat{F}_{\ell}(t) = \frac{1}{N_{\tau}}\sum_{k=0}^{N_{\tau}-1} F(\tau_k, U(t, \tau_k))e^{-i\ell k 2\pi/N_{\tau}}.$$

If we wish to calculate $\hat{F}_{\ell}$ from $\hat{U}_{\ell}$ we have the following formula

$$F(\tau_k,U(t, \tau_k)) = e^{-\tau_k A}f(e^{\tau_k A}U(t, \tau_k)) \;\;$$

from which the Fourier transform is calculated in $\tau$ from the discrete Fourier transform formulas above.

Now, given a time step $\Delta t>0$ and a discretization in time $t_n=n\Delta t$, we can write the following Duhamel formula ($n\geq 0$)

$$\hat{U}_{\ell}(t_{n+1})
= e^{-i\ell\Delta t/\varepsilon}\hat{U}_{\ell}(t_{n})  + \int_0^{\Delta t} e^{-i\ell(\Delta t -s)/\varepsilon} \hat{F}_\ell(t_n+s)ds.$$

Thus, to obtain a $(r+1)$ scheme, we can
approaches the function $\hat{F}_\ell(t_n+s)$ by the Lagrange polynomial of order $r$ interpolator at points $t_{n-j}, j=0, \dots, r$. This polynomial is written

$$\hat{F}_\ell(t_n+s) \approx \sum_{k=0}^r \Big(\Pi_{j=0, j\neq k}^r \frac{s+j \Delta t}{(j-k)\Delta t} \Big) \hat{F}_\ell(t_n-t_j), \;\; n\geq 0.$$

Thus, from this approximation, we integrate exactly, which requires the following formulas

$$p^{[r]}_{\ell, j} = \int_0^{\Delta t}e^{-i\ell(\Delta t -s)/\varepsilon}\Big( \Pi_{j=0, j\neq k}^r \frac{s+j \Delta t}{(j-k)\Delta t}\Big) ds,$$

for each $j$ and $\ell$ such that $0\leq j\leq r, \; \ell=-N_\tau/2, \dots, N_\tau/2-1$. These coefficients $p^{[r]}_{\ell, j}$ can be pre-calculated and stored once and for all. Thus, the schema is finally written

$$\hat{U}_{\ell}^{n+1}= e^{-i\ell\Delta t/\varepsilon}\hat{U}_{\ell}^n + \sum_{j=0}^r p^{[r]}_{\ell, j} \hat{F}_\ell^{n-j},$$

with $\hat{U}_{\ell}^n \approx \hat{U}_{\ell}(t_n)$ and $\hat{F}_\ell^{n-j}\approx \hat{F}_\ell(t_{n-j})$.

We can verify that the truncation error in this schema is  ${\mathcal O}(\Delta t^{r+1})$, once the initial values  $\hat{U}_\ell^1, \dots, \hat{U}_\ell^r$ have been calculated.

## Non-homogeneous case $f(u, t)$
Here we consider the case where $f$ depends on the variable $t$.

$$\frac{d u(t)}{dt} = \frac{1}{\varepsilon} A u(t) + f(u(t), t), \;\;\; u(t=t_{0})=u_{0}, \;\; \varepsilon\in ]0, 1] \;\;\;\; (3)$$

The non-homogeneous case (3) falls under (1), by entering the variable
$\theta : t \in [t_{0}, t_{\text{end}}] \mapsto \theta(t) = t\in \mathbb{R}$
which allows us to reformulate the non-homogeneous case (3) into a homogeneous problem of the form (1).
Indeed, we rephrase (3) as follows

$$\begin{aligned}
\frac{d u(t) }{dt}  & = \frac{1}{\varepsilon} Au(t) + f(u(t), \theta(t)), \\
\frac{d \theta(t) }{dt}  & = 1
\end{aligned}\;\;\;\;(4)$$

with the initial condition  $u(t_{0})=u_{0}, \theta(t_{0})=t_{0}$. Thus, the problem (4) is rewritten into an equation\
satisfied by $y: t\in [t_{0}, t_{fin}] \mapsto y(t) =(u(t), \theta(t))\in \mathbb{R}^{n+1}$

$$\frac{d y}{dt} = \frac{1}{\varepsilon} \tilde{A} y + g(y), \;\; y(t_{0})=(u_{0}, t_{0}),$$

with $\tilde{A}\in{\mathcal M}_{n+1, n+1}(\mathbb{R})$

$$\tilde{A}=
\left(
\begin{array}{cccc}
   &    &     & 0 \\
   & A &     & 0 \\
   &    &    & 0 \\
0 & 0 & 0 &  0
\end{array}
\right) \;\;\;\; \text{ and } \;\;\;\;
g(y)=g(u, \theta) = \left(
\begin{array}{cccccc}
f(u, \theta) \\
1
\end{array}
\right) \in \mathbb{R}^{n+1}.$$

# Use
## Input parameters
The input arguments use the same format as the ODE package.

Thus, first of all, we must define the arguments necessary to construct the problem (1), namely

- the $f$ function (in the form *Julia*)
- the initial condition $u_{0}$.
- the initial time $t_{0}$ and final time $t_{fin}$.
- the second parameter of the
- the $A$ matrix
-  $\varepsilon \in ]0, 1]$

```jl
pkg'add https://gitlab.inria.fr/ua/HiOscSolver.jl.git'
using HiOscSolver
A=[0 0 1 0 ; 0 0 0 0 ; -1 0 0 0 ; 0 0 0 0]
fct = (u,p,t) ->  [ 0, u[4], 2*u[1]*u[2], -u[2] - u[1]^2 + u[2]^2 ]
epsilon= 0.0001
t_min=0.0
t_max=3.0
u0 = [0.55, 0.12, 0.03, 0.89]
prob = HiOscODEProblem(fct, u0, (t_min,t_max), missing, A, epsilon)
```

From the ```prob``` problem, we can now switch to its digital resolution.

To do this, the numerical parameters are defined
- the number of time slots $N_t$ which defines the time step $\Delta t = \frac{t_{\text{end}}-t_0}{N_t}$
- the $r$ order of the method
- the number of $N_\tau$ points in the $\tau$ direction...
- the order of preparation $q$ of the initial condition

The default settings are : $N_t=100$, $r=4$, $N_\tau=32$ and $q=r+2=6$
To solve the problem with the default parameters, just call the `solve` command with the problem already defined as parameter
```jl
sol = solve(prob)
```
Which is equivalent to this call
```jl
sol = solve(
    prob;
    nb_tau=32,
    order=4,
    order_prep=6, # by default : order + 2
    dense=true,
    nb_t=100,
    getprecision=true, # by default : dense
    verbose=100,
    par_u0=missing,
    p_coef=missing,
)
```
### Exhaustive definition of the parameters
- `prob` : problem defined by `HiOscODEProblem`
- `nb_tau=32` : $N_{\tau}$
- `order=4` : order $r$ of the method
- `order_prep=order+2` : order of preparation of initial data
- `dense=true` : indicates whether or not to keep the data from the fourier transform, if `dense=false`, processing is faster but interpolation can no longer be done.
- `nb_t=100` : $N_t$
- `getprecision=dense` : indicates whether the accuracy is calculated, the method used to calculate the accuracy multiplies the processing time by 2.
- `verbose=100` : trace level, if `verbose=0` then nothing is displayed.
- `par_u0` : If we have to make several calls to `solve` with the same initial data and in the same order, we can pass in parameter the already calculated data.
- `p_coef` : table with the coefficients of the Adams-Bashforth method. This array can be used to optimize several calls with the same parameters.
## Exit arguments
As an output, a structure of type `HiOscODESolution`.
This structure can be seen as a function of t, it can also be seen as an array of size $N_t + 1$. This structure also contains the `absprec` and `relprec` fields which are the absolute and relative precisions, respectively, calculated.
### Example
```jl
julia> sol = solve(prob);
solve function prob=HiOscODEProblem with uType Array{Float64,1} and tType Float64. In-place: nothing
timespan: (0.0, 3.0)
u0: [0.55, 0.12, 0.03, 0.89],
 nb_tau=32, order=4, order_prep=6, dense=true,
 nb_t=100, getprecision=true, verbose=100

x 100/100

 99/99

julia> t=2.541451547
2.541451547

julia> sol(t)
4-element Array{Float64,1}:
 -0.536667845897295
  1.593257176840297
 -0.12420061944907212
  0.7184374612958457

julia> sol[end]
4-element Array{Float64,1}:
  0.36316109321808354
  2.0379196624858955
 -0.4141248638226731
  1.3087136174628513

julia> sol(3.0)
4-element Array{Float64,1}:
  0.36316109321808626
  2.037919662485913
 -0.4141248638226772
  1.308713617462862

julia> sol.absprec
2.4721022528746903e-5

julia> sol.relprec
9.952927361881597e-6

```
To view the result, you can also use Plot, for example
```jl
using Plots
plot(sol)
```
This results in

![](img/first.png)

If you want to save the result in a file (pdf or png) here are the commands
```jl
using Plots
p = plot(sol)
savefig(p,"out/plot.png")
```

# Examples
## Hénon-Heiles
We consider the system of Hénon-Heiles satisfied by $u(t)=(u_1, u_2, u_3, u_4)(t)$.

$$\frac{d u }{dt} = \frac{1}{\varepsilon} Au + f(u), \;\;\; u(0)=u_0\in\mathbb{R}^4,$$

where $A$ and $f$ are selected as follows

$$A=
\left(
\begin{array}{cccc}
0 & 0 & 1 & 0  \\
0 & 0 & 0 & 0  \\
-1 & 0 & 0 & 0  \\
0 & 0 & 0 & 0
\end{array}
\right) \;\;\;\; \text{ and } \;\;\;\;
f(u) = \left(
\begin{array}{cccc}
0 \\
u_4\\
-2 u_1 u_2\\
-u_2-u_1^2+u_2^2
\end{array}
\right).$$

one chooses for example, $\varepsilon=0.001$
and $u_0 = (0.12, 0.12, 0.12, 0.12)$
```jl
using HiOscSolver
A=[0 0 1 0 ; 0 0 0 0 ; -1 0 0 0 ; 0 0 0 0]
fct = (u,p,t) ->  [ 0, u[4], 2*u[1]*u[2], -u[2] - u[1]^2 + u[2]^2 ]
epsilon= 0.001
t_min=0.0
t_max=1.0
u0 = [0.12, 0.12, 0.12, 0.12]
prob = HiOscODEProblem(fct, u0, (t_min,t_max), missing, A, epsilon)
sol = solve(prob);
using Plots
plot(sol)
```

![](img/henon_heiles.png)

## Charged particle

A system of charged particles under the effect of an external electro-magnetic field is considered to be
$(E(t, x), B(t, x))\in \mathbb{R}^6$.\
Particles are dynamically described by their position
$x(t)\in\mathbb{R}^3$ and their speed $v(t)\in\mathbb{R}^3$. We'll index by $i$ the $i$-th component of a vector.
Newton's equations applied to a particle can be written as

$$\begin{aligned}
\frac{d x(t) }{dt}&= v(t) \\
\frac{d v(t) }{dt}&= \frac{e}{m} \left[E(t, x(t)) + v(t)\times B(t, x(t))\right].
\end{aligned}$$

We will assume that the magnetic field is written $B(t, x)=(0, 0, 1)^T$ and under a certain scaling, we consider the following equation

$$\begin{aligned}
\frac{d x_1(t) }{dt} &= \frac{1}{\varepsilon}v_1(t) \\
\frac{d x_2(t) }{dt} &= \frac{1}{\varepsilon} v_2(t) \\
\frac{d x_3(t) }{dt} &= v_3(t) \\
\frac{d v_1(t) }{dt} &= E_1(t, x(t)) + \frac{1}{\varepsilon}v_2(t)\\
\frac{d v_2(t) }{dt} &= E_2(t, x(t)) - \frac{1}{\varepsilon}v_1(t)\\
\frac{d v_3(t) }{dt} &= E_3(t, x(t))
\end{aligned}$$

which is rewritten as follows

$$\frac{d u(t) }{dt}= \frac{1}{\varepsilon}A u(t) + F(t, u(t)),$$

where the unknown vector $u(t)=(x(t), v(t))\in\mathbb{R}^6$, $A$ is a square matrix of size $6\times 6$
and $F$ is a function with a value in $\mathbb{R}^6$. $A$ and $F$ are given by

$$A=
\left(
\begin{array}{cccccc}
0 & 0 & 0 & 1 & 0 & 0 \\
0 & 0 & 0 & 0 & 1 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 1 & 0 \\
0 & 0 & 0 & -1 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0
\end{array}
\right) \;\;\;\; \text{ and } \;\;\;\;
F(t, u(t)) = \left(
\begin{array}{cccccc}
0 \\
0\\
u_6(t)\\
E_1(t, u_1(t), u_2(t), u_3(t))\\
E_2(t,  u_1(t), u_2(t), u_3(t)\\
E_3(t,  u_1(t), u_2(t), u_3(t)
\end{array}
\right).$$

We can consider the following $E=(E_1, E_2, E_3)$ function

$$E(t, x) =
\left(
\begin{array}{ccc}
\cos(x_1/2)\sin(x_2)\sin(x_3)/2\\
\sin(x_1/2)\cos(x_2)\sin(x_3)\\
\sin(x_1/2)\sin(x_2)\cos(x_3)
\end{array}
\right)$$

```jl
using HiOscSolver
A = [0 0 0 1 0 0; 0 0 0 0 1 0;0 0 0 0 0 0; 0 0 0 0 1 0; 0 0 0 -1 0 0; 0 0 0 0 0 0]
function fparticle(u, p, t)
    s1, c1 = sincos(u[1]/2)
    s2, c2 = sincos(u[2])
    s3, c3 = sincos(u[3])
    return [0, 0, u[6], c1*s2*s3/2, s1*c2*s3, s1*s2*c3]
end
epsilon= 0.05
t_min=0.0
t_max=1.0
u0 = [1.0, 1.5, -0.5, 0, -1.2, 0.8]
prob = HiOscODEProblem(fparticle, u0, (t_min,t_max), missing, A, epsilon)
sol=solve(prob)
plot(sol)
```
![](img/particle.png)

## Linear non-homogeneous case
The following non-homogeneous linear system is considered to be satisfied by $u(t)=(u_1, u_2, u_3, u_4)(t)$

$$\frac{d u }{dt} = \frac{1}{\varepsilon} Au + f(t, u), \;\;\; u(0)=u_0\in\mathbb{R}^4,$$

where $A$ and $f$ are selected as follows

$$A=
\left(
\begin{array}{cccc}
0 & 0 & 1 & 0  \\
0 & 0 & 0 & 0  \\
-1 & 0 & 0 & 0  \\
0 & 0 & 0 & 0
\end{array}
\right) \;\;\; \text{ and } \;\;\;
f(t, u) = Bu +\alpha t +\beta \;\; \text{ with  } \;\;
B\in {\mathcal M}_{4, 4}(\mathbb{R}), \alpha, \beta \in \mathbb{R}^4,$$

 $B, \alpha, \beta$ are chosen randomly.

We wish to obtain a high precision, so we will use BigFloat real numbers, they are encoded on 256 bits by default which gives a precision bound of about $2^{-256}. \approx 10^{-77}$.\
At the end, we compare a calculated result with an exact result.

```jl
using HiOscSolver
using Random
Random.seed!(1111)
A=[0 0 1 0 ; 0 0 0 0 ; -1 0 0 0 ; 0 0 0 0]
B = 2rand(BigFloat, 4, 4) - ones(BigFloat, 4, 4)
alpha = 2rand(BigFloat, 4) - ones(BigFloat, 4)
beta = 2rand(BigFloat, 4) - ones(BigFloat, 4)
fct = (u,p,t)-> B*u + t*p[1] +p[2]
u0 = [big"0.5", big"-0.123", big"0.8", big"0.7"]
t_min=big"0.0"
t_max=big"1.0"
epsilon=big"0.017"
prob = HiOscODEProblem(fct, u0, (t_min,t_max), (alpha, beta), A, epsilon, B)
sol = solve(prob, nb_t=10000, order=8)
sol.absprec
t=big"0.9756534187771"
sol(t)-getexactsol(sol.par_u0.parphi, u0, t)
using Plots
Plots.plot(sol.t,sol.u_tr)
```
### Calculation of the exact solution
This involves calculating the exact solution $u(t)$ of the following equation at the instant $t$

$$\frac{d u }{dt} = \frac{1}{\varepsilon} Au + Bu +\alpha t +\beta, \;\;\; u(0)=u_0\in\mathbb{R}^4\text{, } A \text{ and }B \text{ are defined above }$$

Let

$$\begin{aligned}
    M &= \frac{1}{\varepsilon} A + B\\
    C &= e^{-t_0 M}u_0 +M^{-1} e^{-t_0 M} (t_0\alpha+\beta)+ M^{-2} e^{-t_0 M} \alpha\\
    C_t &= -M^{-1} e^{-t M} (t\alpha+\beta)-M^{-2} e^{-t M} \alpha\\
    u(t) &= e^{t M} ( C + C_t)
\end{aligned}$$

Which, translated into Julia language, gives the code of the function `getexactsol` :
```julia
function getexactsol(par::PreparePhi, u0, t)
    @assert !ismissing(par.matrix_B) "The debug matrix is not defined"
    sparse_A = par.sparse_Ap[1:(end-1),1:(end-1)]
    m = (1/par.epsilon)*sparse_A+par.matrix_B
    t0 = par.t_0
    if ismissing(par.paramfct)
        return exp((t-t0)*m)*u0
    end
    a, b = par.paramfct
    mm1 = m^(-1)
    mm2 = mm1^2
    e_t0 = exp(-t0*m)
    C = e_t0*u0 + mm1*e_t0*(t0*a+b)+mm2*e_t0*a
    e_inv = exp(-t*m)
    e = exp(t*m)
    C_t = -mm1*e_inv*(t*a+b)-mm2*e_inv*a
    return e*C+e*C_t
end

```

## Accuracy of the result according to the time interval
### Linear problem
From a problem of the previous type, as long as we can calculate the exact solution, it is possible to know exactly what the error is.
The initialization data being
```jl
using HiOscSolver
A=[0 0 1 0 ; 0 0 0 0 ; -1 0 0 0 ; 0 0 0 0]
u0 = BigFloat.([-34//100, 78//100, 67//100, -56//10])
B = BigFloat.([12//100 -78//100 91//100 34//100
    -45//100 56//100 3//100 54//100
    -67//100 09//100 18//100 89//100
    -91//100 -56//100 11//100 -56//100])
alpha =  BigFloat.([12//100, -98//100, 45//100, 26//100])
beta =  BigFloat.([-4//100, 48//100, 23//100, -87//100])
epsilon = 0.015
t_max = big"1.0"
fct = (u,p,t)-> B*u + t*p[1] +p[2]
prob = HiOscODEProblem(fct,u0, (big"0.0",t_max), (alpha, beta), A, epsilon, B)
```
Note that the floats are coded on 512 bits.\
By varying $\Delta t$ from $10^{-2}$ to $5.10^{-6}$ (i.e. `nb_t` from `100` to `204800`) on a logarithmic scale, for odd orders from 3 to 17 we get these errors

#### Precision of the result with ε = 0.015
![](img/error_order.png)

Now with the same initial data, order being setted to 6, and $\varepsilon = 0.15, 0.015, \ldots, 1.5\times 10^{-7}$.\
Here floats are coded on 256 bits.

#### Precision of the result with order = 6
![](img/error_epsilon.png)

### Problem with Hénon-Heiles function

```jl
    u0=BigFloat.([90, -44, 83, 13]//100)
    t_max = big"1.0"
    epsilon=big"0.0017"
    fct = u -> [0, u[4], -2u[1]*u[2], -u[2]-u[1]^2+u[2]^2]
    A = [0 0 1 0; 0 0 0 0;-1 0 0 0; 0 0 0 0]
    prob = HiOscODEProblem(fct, u0, (big"0.0",t_max), missing, A, epsilon)
```
The float are coded on 512 bits.

#### Precision of the result with ε = 0.0017

![](img/error_order_hh.png)

Now with the same initial data, order being setted to 6, and $\varepsilon = 0.19, 0.019, \ldots, 1.9\times 10^{-8}$.\
Here floats are coded on 256 bits.

#### Precision of the result with ordre = 6

![](img/error_epsilon_hh.png)

## Future work
- precision on parameter.
- exponential runge-kutta method

### The "classical" Runge-Kutta method (order 4) adapted to the exponential (not yet implemented)

Notations :
- We denote by $G$ the function which transforms $\hat{U}$ to $\hat{f}$, so $G(\hat{U}) = \hat{f}$.
- We denote by $S_{t_0}^{t_1}(t_2,\ell)$ the intégral $S_{t_0}^{t_1}(t_2,\ell) = \int_{t_0}^{t_1} e^{- i \ell (t_2 - s)/\varepsilon} ds = ( i \varepsilon / \ell) ( e^{- i \ell (t_2 - t_1)/\varepsilon}-e^{- i \ell (t_2 - t_0)/\varepsilon})$

Here are the calculations

-  $u_{1,\ell} = \hat{U}_{n, \ell}$
-  $u_{2,\ell} = e^{- i \ell h_n /(2 \varepsilon)}\hat{U}_{n, \ell} + S_0^{h_n /2} ( h_n /2,\ell ) G_{\ell}(u_1)$
-  $u_{3,\ell} = e^{- i \ell h_n /(2 \varepsilon)}\hat{U}_{n, \ell} + S_0^{h_n /2} ( h_n /2,\ell )  G_{\ell}(u_2)$

-  $u_{4,\ell} = e^{- i \ell h_n /(2\varepsilon)}u_{2,\ell} + S_0^{h_n/2} ( h_n/2,\ell )[ 2 G_{\ell}(u_3)-G_{\ell}(u_1)]$ (see (28) of [cox2002](@cite), with $c=-i \ell h_n /\varepsilon$)

From (29) of [cox2002](@cite), with $c=-i \ell h_n /\varepsilon$, we have

$$\hat{U}_{n+1, \ell} = e^{- i \ell h_n /\varepsilon}\hat{U}_{n, \ell} +  G_{\ell}(u_1) [-4+i \ell h_n /\varepsilon + e^{-i \ell h_n /\varepsilon}(4+3i \ell h_n /\varepsilon+(i \ell h_n /\varepsilon)^2]\\+ (2 G_{\ell}(u_2) + G_{\ell}(u_3) )[-2-i \ell h_n /\varepsilon+e^{-i \ell h_n /\varepsilon}(2-i \ell h_n /\varepsilon)]\\ + G_{\ell}(u_4)[-4+3i \ell h_n /\varepsilon -(i \ell h_n /\varepsilon)^2 + e^{-i \ell h_n /\varepsilon}(4+i \ell h_n /\varepsilon)]/(h_n^2 (i \ell h_n /\varepsilon)^3)$$


text:
# Bulletproof Node.js architecture 🛡

This is the example repository from the blog post ['Bulletproof node.js project architecture'](https://softwareontheroad.com/ideal-nodejs-project-structure?utm_source=github&utm_medium=readme)

Please read the blog post in order to have a good understanding of the server architecture.

Also, I added lots of comments to the code that are not in the blog post, because they explain the implementation and the reason behind the choices of libraries and some personal opinions and some bad jokes.

The API by itself doesn't do anything fancy, it's just a user CRUD with authentication capabilities.
Maybe we can transform this into something useful, a more advanced example, just open an issue and let's discuss the future of the repo.

## Development

We use `node` version `10.15.0`

```
nvm install 10.15.0
```

```
nvm use 10.15.0
```

The first time, you will need to run

```
npm install
```

Then just start the server with

```
npm run start
```

It uses nodemon for livereloading :peace-fingers:

# API Validation

By using celebrate the req.body schema becomes clary defined at route level, so even frontend devs can read what an API endpoint expects without need to writting a documentation that can get outdated quickly.

```js
route.post(
  '/signup',
  celebrate({
    body: Joi.object({
      name: Joi.string().required(),
      email: Joi.string().required(),
      password: Joi.string().required()
    })
  }),
  controller.signup
);
```

**Example error**

```json
{
  "errors": {
    "message": "child \"email\" fails because [\"email\" is required]"
  }
}
```

[Read more about celebrate here](https://github.com/arb/celebrate) and [the Joi validation API](https://github.com/hapijs/joi/blob/v15.0.1/API.md)

# TODO

- [x] unify config: typeorm, mongodb, nodeenv => config.ts
- [ ] setup CI/CD
- [x] polish up logging with winston
- [ ] write tests
- [x] check if user exists upon registration
- [ ] implement verify-token endpoint to be used in microservice architecture
- [ ] make feature initilization modular (e.g.: mailing, agenda)
- [ ] add dependency injection for typeORM repositories in services
- [ ] adjust readme
- [x] clean up repository files
- [x] prevent committing code that doesn't compile using pre hooks and tsc (with husky, lint-staged, prettier and tsc)

# Roadmap

- [x] API Validation layer (Celebrate+Joi)
- [ ] Unit tests examples
- [ ] [Cluster mode](https://softwareontheroad.com/nodejs-scalability-issues?utm_source=github&utm_medium=readme)
- [x] The logging _'layer'_
- [ ] Add agenda dashboard
- [x] Continuous integration with CircleCI 😍
- [ ] Deploys script and docs for AWS Elastic Beanstalk and Heroku
- [ ] Integration test with newman 😉
- [ ] Instructions on typescript debugging with VSCode

repository: alexreiling/express-typeorm-scaffold

repo_name: alexreiling/express-typeorm-scaffold


text:
# Generate License File

This CLI generates a text file containing all the licences for your production 3rd-party dependencies.

## Installation and Usage (CLI)

```
$ npm install generate-license-file -g

$ generate-license-file --input package.json --output 3rd-party-licenses.txt --eol posix
```

- Input: The package.json for the project you want to target
- Output: The file to be created
- Eol: Which line endings to use (optional)

If either required flag is omitted the CLI will prompt you for the inputs.

If you don't supply an input file, and the CLI is able to detect a package.json in the folder you run the command from, the it will allow you to run the command using the detected file.

## Installation and Usage (Programmatic use)

```
$ npm install generate-license-file
```

```js
const generateLicenseFile = require("generate-license-file");

// get licenses for the current project (assuming this file is on the same level as the package.json)
generateLicenseFile
  .getProjectLicenses("./")
  .then(licenses => {
    // do stuff with licenses...
  })
  .catch(error => {
    // do stuff with error...
  });
```

```ts
import * as generateLicenseFile from "generate-license-file";

const licenses = await generateLicenseFile.getProjectLicenses("./");
```

license: ISC


text:
# Facebook Authenticator

The Facebook authenticator is configured as a federated authenticator in
WSO2 Identity Server to authenticate Facebook users to log in to your
organization’s applications.

![](attachments/68686695/76746162.png)

### Getting started

To get started with the authenticator, go to [Configuring Facebook
Authenticator](_Configuring_Facebook_Authenticator_). Once you have
completed your configurations, you can perform authentication with the
Facebook authenticator.

### Additional information

To download the authenticator and other artifacts, go to
<https://store.wso2.com/store/assets/isconnector/details/9edb106b-05ee-4810-8d47-81d0639f8c2b>
.

repository: IsurangaPerera/docs-is

repo_name: IsurangaPerera/docs-is


text:
# Caddy Server with PHP-FPM

This creates a Docker container running PHP on Alpine Linux.

## Why another container?

I just wanted all the PHP libraries I tend to use.  Consider
this the kitchen-sink version of the parent container by abiosoft.

It also supports running commands before and after starting PHP-FPM and running
`composer install` before running PHP-FPM.

## Run Example

- `docker run -p 80:80 -p 443:443 -v /var/www/html:/srv stevepacker/caddy-php`

## Docker Environment Variables

- `PHP_BEFORE`: command(s) to run prior to running `composer install` and `php-fpm`
- `PHP_COMPOSER_FLAGS`: flags to include with `composer install` (ex: --prefer-dist --no-dev)
- `PHP_AFTER`: command(s) to run after `composer install` and `php-fpm`

## Docker Volumes

- `/srv`: Base directory.  If a `composer.lock` is in this directory,
    `composer install` will automatically run prior to starting `php-fpm`
- `/root/.caddy`: When an SSL is generated, files are stored here by Caddy.
- `/etc/Caddyfile`: If you intend to include your own Caddyfile, mount it here.

## Caddy Extensions:

- git
- ipfilter

## PHP Extensions:

- composer
- php-fpm
- php-cli
- php-curl
- php-gd
- php-json
- php-iconv
- php-mcrypt
- php-intl
- php-ctype
- php-pdo_mysql
- php-pdo_sqlite
- php-posix
- php-sockets
- php-imap
- php-openssl
- php-phar

repository: cguentherTUChemnitz/docker-containers

repo_name: cguentherTUChemnitz/docker-containers


text:
# `choices`

Use `choices` in conjunction with the `boolean`, `checkbox`, and `select` fields to define the choices that a user will see. The `choices` array should be an array of objects with `label` and `value` properties. `value` is what winds up in the database, `label` is what the user sees.

## `showFields`

The `showFields` sub-option can be used to show and hide other fields based on the choice that was made. This is a very powerful way to make forms more user-friendly.

### `boolean` Example

```javascript
{
  type: 'boolean',
  name: 'housing',
  label: 'Do you require housing?',
  mandatory: 'Sorry, you need to have housing!',
  choices: [
    {
      value: true,
      showFields: [
        'dormPreference', 'vegetarian'
      ]
    }
  ]
}
```

When "Yes" is selected, the `value` becomes `true`, and the fields named `dormPreference` and `vegetarian` will be visible. At all other times they will not be.

### `checkboxes` Example

```javascript
{
  type: 'checkboxes',
  name: 'preferences',
  label: 'Preferences (check one or more)',
  choices: [
    {
      label: 'Big',
      value: 'big'
    },
    {
      label: 'Friendly',
      value: 'friendly',
      showFields: [ 'friends' ]
    },
    {
      label: 'Furry',
      value: 'furry'
    }
  ]
}
```

In this example, the value of the `preferences` property of the data object will be an array of strings. Each string is the `name` property of a choice that was checked. If no boxes are checked, the value is an empty array.

When "Friendly" is one of the selected checkboxes, the field named `friends` becomes visible. Otherwise that field is hidden.

### `select` Example

```javascript
{
  type: 'select',
  name: 'housing',
  label: 'Where will you be staying?',
  choices: [
    {
      label: 'On Campus',
      value: 'on-campus',
      showFields: [
        'accessible', 'vegetarian'
      ]
    },
    {
      label: 'Off Campus',
      value: 'off-campus'
    }
  ]
}
```

When the "On Campus" choice is selected, the schema fields named `accessible` and `vegetarian` will be visible.

A cursor filter method is added automatically for all fields of type `select`. This means joins to pieces containing a `select` type field can be filtered by the field's value;

```javascript
{
  name: '_post',
  type: 'joinByOne',
  filters: {
    postType: 'event',
  }
}
```

## Fetching choices dynamically from APIs

What if the choices change and can't be hardcoded in your code? You can fetch them dynamically.

First, set the `choices` option to the name of a method in your module. Pass a string, the name of the method — do not pass a function.

Second, implement that function to take a single `(req)` argument and return an array of choices in the usual format. You may use an async function, or return a promise that will resolve to the array. That means you can reach out to APIs using modules like `axios` or `request-promise`.

It is usually a good idea to perform at least short-term caching in your choices method, in order to limit the impact on performance when editing.

repository: apostrophecms/apostrophe-documentation

gha_language: Shell

repo_name: apostrophecms/apostrophe-documentation


text:
# Twanonymous

A Chrome extension to hide profile pictures, names and usernames in Twitter feeds, searches and profiles. I made this as part of an internal Hack Week as a thought experiment for what it would be like to browse Twitter without knowing the identities of people Tweeting.

### How to install

1. Download this folder
2. Go to chrome://extensions and check the 'Developer mode' checkbox in the top right hand corner
3. Click 'Load an unpacked extension...' and select the Twanonymous folder you've downloaded onto your computer to install the extension

## How does it work?

Once you've activated the Chrome Extension, Twanonymous will automatically hide names, usernames and replace avatars with the default twitter avatar.

An icon (the default Twitter avatar) will appear to the right in your address bar. You can toggle anonymisation on and off by clicking the icon. When it's blue, Twanonymous is on.

repository: JennyBrennan/twanonymous

repo_name: JennyBrennan/twanonymous


text:
---
layout: layouts/post.njk
date: 2013-02-27T17:41:00.000Z
slug: why-no-directorieslib-in-node-the-less-snarky
title: 'Why No directories.lib in Node (the less snarky, too-long-for-twitter version)'
tumblrid:<PHONE_NUMBER>7
type: text
---

This question comes up in Node occasionally:

Node peoples… is there any way to specify a root directory for my
  npm package so that I don’t need require(“mypackage/lib/foo”)?

— wycats

In other words, you have a package directory structure like this:

./package.json
./README.md
./test/some-tests.js
./lib/main.js  <-- this is the package.json "main"
./lib/some-other-module.js
./lib/util/a-utility-module.js
./lib/etc....

Now, let’s say that this package’s name is foo.  You want to be able
to use foo’s some-other-module.js file, outside of foo.

The way to do this in node is do write:

var blah = require('foo/lib/some-other-module.js');

What Yehuda
would like to see is:

var blah = require('foo/some-other-module.js');

The “how” here is simple: If you want a module in the root of your
package namespace, put the file in the root of your package folder.
It’s a 1:1 mapping, so it’s not hard to figure out how to get that
result.

But I don’t want to have so many files in the root of my package folder

Ok.  So don’t have so many files in
the root of your package folder.

If you must export multiple modules from a single package, then you
have a choice:

Use an extra 4 characters in your require() statements, or

Just don’t have so many exports.

Many of us would suggest that in general you may want to consider
if those things actually are a part of the “foo” package, or if they
belong in a dependency, with their own tests, name, version, etc.

I am not personally so die-hard about “one package = one file”.
Occasionally there are internal things, and it’s not so bad.  But, in
general, I tend to be of the opinion that if a module requires
its own individual unit tests, it probably should be its own package,
if only so that I can think of it as a separate thing and give it the
attention it clearly deserves.  If I’m intending it to be used outside
of the main package, then it most likely needs its own tests, and
I’ll package it up and make it a dep.

Note all the weasel words in the above paragraph!  There are lots of
exceptions to this rule.  But they don’t fit on twitter, and in fact,
even the weasel words put my response way over 140 characters, and
so with the qualifications stripped out, it looks like a capricious
religion, unbound to factual realities of the imperfect world in which
real software development happens.

The world being imperfect as it is, you may well find yourself in a
state where you have multiple exports, and you don’t have the time or
inclination to split them up into separate packages.  Sometimes the
Inappropriate Intimacy smell is less bad than the alternatives, it’s
true.  Sometimes it’s just a simple business decision; sometimes it’s
less important to make it work right, than to make it work right now.

In that case, put "lib/" in your require() statement.  It’s not
that hard, really.

But WHY, cats?

The argument to require() maps directly to a file path.  If it
doesn’t start with ./ or ../ and isn’t absolute (ie, starts with a
/ on unix, or any of a half dozen weird things on windows), then
node finds the closest node_modules folder with a thing by that
name, and that’s the prefix.  But everything after the prefix is just
a direct filename.

(Aside: For historical reasons we do make the filename extension
optional, which is a deeply regrettable accident of history that I
would not repeat, given the chance.)

Let’s look at the benefits, and the costs.

Aesthetics

The first benefit is removing 4 extra chars in some of the lines at
the top of some files.  This is rather small.  Even if you have 100
requires at the top of a module (which is very very many), and every
single one of them is diving into some other package’s guts, you’re
still talking about pushing the average line length out by 4 chars.
It’s not adding extra lines; it’s not pushing the line length out that
much.

If you cannot accept that, then put the files in the root of your
package.  If that is too ugly, well, then weigh the ugliness of
file clutter against the ugliness of lines that are 4 whole characters
longer.

The fact that this seems ugly is actually great, in my opinion.  You
usually shouldn’t be writing programs like this.  Packages should be
exporting an interface that is designed for a purpose, and you should
be using them for that purpose.    There may be reasons to do the
ugly thing, of course, and no one is saying that you’re a bad person
for doing it, but the ugliness of the code should be a thing that you
notice, so that you can avoid ignoring the ugliness of the design.
There is a reason we evolved to find plump brightly colored fruit more
appealing than wrinkled moldy fruit.  There is a reason we evolved to
be more able to ignore pleasure than pain.

In other words, your aesthetics are trying to help you.  Saying “it’s
ugly” is an argument against adding this feature, not for it.

(Alleged) Portability

Let’s say that you want to have something like this:

./lib/node/module.js
./lib/browser/module.js
./lib/ringo/module.js
./lib/narwhal/module.js

Then, I want to say “Node should use lib/node, Ringo should use
lib/ringo, and the browser should use lib/browser, so when I do
require('foo/module.js'), I get the right one for my environment.

First of all, that’s very trivial to do without making the mapping of
require arguments to filenames any more complicated.  Create a file
like this:

// module.js
switch(getPlatform()) {
  case 'node':
    module.exports = require('./node/module.js');
    break;
  case 'ringo':
    module.exports = require('./ringo/module.js');
    break;
  case 'narwhal':
    module.exports = require('./narwhal/module.js');
    break;
  default:
    module.exports = require('./browser/module.js');
    break;
}

// This can of course be simplified.
// Usually something like this is sufficient:
// if (typeof window === 'object')
//   return module.exports = require('./browser.js');

If you find yourself doing this a lot, maybe ask yourself if you’re
using the best abstractions, or maybe trying to make something
portable that is fundamentally platform-specific.  Maybe try
supporting fewer platforms.

Or, maybe, just do the ugly thing, and let it be ugly, and accept that
it’s a net benefit in your case.  But if your request is "Make
platform-specific module behavior forking less ugly”, then we’re back
to aesthetics, and my answer is, “Ew.  No.  That’s gross, and it
should look gross.”

Priorities

The cost of adding this feature is that the mapping from your
require() statements to the actual file with the code in it, is more
complicated.

Yes, it’s “only one extra file to look in”.  But “looking in files”
isn’t the hard part.  The hard part is remembering which packages
mapped in which ways, and thus knowing where to follow the train of
logic, when you’re juggling a bunch of other peoples’ code in your
head for the first time, while trying to debug a problem as fast as
possible because it’s preventing actual human beings from doing what
they are trying to do, and they give exactly zero fucks about the
ugliness of your require() statements.

Adding “one extra file to look in” doubles the number of files to look
in, and much more than doubles the cognitive overhead of debugging
problems in code you didn’t write.

Debugging problems in code you did write is pretty easy.  That’s not
what I’m talking about.  I’m talking about the case where I’m
debugging your code, because I’m using your module in my website,
and my website is misbehaving.

If this seems like a trivial complaint, then you have either never
been in this situation, or you are smarter than I am.  Either way,
consider yourself blessed, because it’s a shitty situation, and I’ve
been in it, and I’m not smart enough for it to be trivially solved,
and I wrote most of the code that did all this shit.

Few remember, because the node community was about 1/100th the size at
the time, but npm used to support this feature (and also the “modules”
hash, which allowed arbitrary mapping of module names to files, and
was significantly worse.)  Even fewer people were actually running
production sites at the time in Node, and of those that were, most
just wrote everything from scratch, because there was much less of an
ecosystem to draw on.

Ryan and I were among the people building things in Node at Joyent,
and trying to actually Do The Right Thing, and use npm and the
community module ecosystem in the way it was intended.  The first time
we had to debug something like this, where a few modules actually used
directories.lib, we both were convinced that it was a terrible idea,
and had to go.

Around that time, we started conceiving the module system for Node
v0.4, which is what we have now.  We moved the node_modules lookup
stuff into node core, and stripped out the module hash and
directories.lib features from npm.  Moving node_modules lookup into
core meant that npm could stop using symlinks and shims all over the
place to implement isolated deps.

Again, if you think that this cost is not relevant, then I have
nothing but respect and blessings for you.  Either you’re much better
at this stuff than I am, or you’ve suffered less of the hell of other
peoples’ bugs.  Either way, mad props.

Making the node module system any more complicated than it is will
make my life noticeably worse, and I don’t think I am alone in this.
As I am in a position to prevent that reduction in Node quality of
life, and as that is my job, I will prevent it.

The Node module system is
frozen
for a reason.  It will not change to add new features, ever.  It’s
done, and not open for discussion.

Addendum:

@izs Would like to hear more about why omitting the filename
  extension in require statements was a mistake.

— jimmycuadra

Answer:

It quadruples the number of stat(2) calls, makes the 1:1 mapping
more vague, and complicates implementation. Slower, greater
complexity, etc.

However, the cost of removing this feature is nowhere near the benefit
of not having it, so it stays for backwards compatibility.  C'est la vie.

gha_language: JavaScript


text:
# Jumpaku Dinner

https://dinner.jumpaku.net

## Environments

| environment | default         | required | description |
|-------------|-----------------|----------|-------------|
|`SERVER_NAME`| `localhost`     | no       | value of ServerName of httpd |

## Example

Execute `docker-compose up` with the following `docker-compose.yml` and open `localhost:8080`.

```yml
version: '3'

services:

  jumpaku-dinner:
    container_name: 'jumpaku-dinner'
    image: 'jumpaku/jumpaku-dinner'
    restart: 'always'
    environment:
        - 'SERVER_NAME=localhost'
    ports:
        - '8080:80'
```

repository: Jumpaku/JumpakuDinner

repo_name: Jumpaku/JumpakuDinner


text:
---
title: "Yandex"
description: "Yandex Disk"
versionIntroduced: "v1.26"
---

# {{< icon "fa fa-space-shuttle" >}} Yandex Disk

[Yandex Disk](https://disk.yandex.com) is a cloud storage solution created by [Yandex](https://yandex.com).

## Configuration

Here is an example of making a yandex configuration.  First run

    rclone config

This will guide you through an interactive setup process:

```
No remotes found, make a new one?
n) New remote
s) Set configuration password
n/s> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Yandex Disk
   \ "yandex"
[snip]
Storage> yandex
Yandex Client Id - leave blank normally.
client_id>
Yandex Client Secret - leave blank normally.
client_secret>
Remote config
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes
n) No
y/n> y
If your browser doesn't open automatically go to the following link: http://<IP_ADDRESS>:53682/auth
Log in and authorize rclone for access
Waiting for code...
Got code
--------------------
[remote]
client_id =
client_secret =
token = {"access_token":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","token_type":"OAuth","expiry":"2016-12-29T12:27:11.362788025Z"}
--------------------
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y
```

See the [remote setup docs](/remote_setup/) for how to set it up on a
machine with no Internet browser available.

Note that rclone runs a webserver on your local machine to collect the
token as returned from Yandex Disk. This only runs from the moment it
opens your browser to the moment you get back the verification code.
This is on `http://<IP_ADDRESS>:53682/` and this it may require you to
unblock it temporarily if you are running a host firewall.

Once configured you can then use `rclone` like this,

See top level directories

    rclone lsd remote:

Make a new directory

    rclone mkdir remote:directory

List the contents of a directory

    rclone ls remote:directory

Sync `/home/local/directory` to the remote path, deleting any
excess files in the path.

    rclone sync --interactive /home/local/directory remote:directory

Yandex paths may be as deep as required, e.g. `remote:directory/subdirectory`.

### Modified time

Modified times are supported and are stored accurate to 1 ns in custom
metadata called `rclone_modified` in RFC3339 with nanoseconds format.

### MD5 checksums

MD5 checksums are natively supported by Yandex Disk.

### Emptying Trash

If you wish to empty your trash you can use the `rclone cleanup remote:`
command which will permanently delete all your trashed files. This command
does not take any path arguments.

### Quota information

To view your current quota you can use the `rclone about remote:`
command which will display your usage limit (quota) and the current usage.

### Restricted filename characters

The [default restricted characters set](/overview/#restricted-characters)
are replaced.

Invalid UTF-8 bytes will also be [replaced](/overview/#invalid-utf8),
as they can't be used in JSON strings.

{{< rem autogenerated options start" - DO NOT EDIT - instead edit fs.RegInfo in backend/yandex/yandex.go then run make backenddocs" >}}
### Standard options

Here are the Standard options specific to yandex (Yandex Disk).

#### --yandex-client-id

OAuth Client Id.

Leave blank normally.

Properties:

- Config:      client_id
- Env Var:     RCLONE_YANDEX_CLIENT_ID
- Type:        string
- Required:    false

#### --yandex-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

- Config:      client_secret
- Env Var:     RCLONE_YANDEX_CLIENT_SECRET
- Type:        string
- Required:    false

### Advanced options

Here are the Advanced options specific to yandex (Yandex Disk).

#### --yandex-token

OAuth Access Token as a JSON blob.

Properties:

- Config:      token
- Env Var:     RCLONE_YANDEX_TOKEN
- Type:        string
- Required:    false

#### --yandex-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

- Config:      auth_url
- Env Var:     RCLONE_YANDEX_AUTH_URL
- Type:        string
- Required:    false

#### --yandex-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

- Config:      token_url
- Env Var:     RCLONE_YANDEX_TOKEN_URL
- Type:        string
- Required:    false

#### --yandex-hard-delete

Delete files permanently rather than putting them into the trash.

Properties:

- Config:      hard_delete
- Env Var:     RCLONE_YANDEX_HARD_DELETE
- Type:        bool
- Default:     false

#### --yandex-encoding

The encoding for the backend.

See the [encoding section in the overview](/overview/#encoding) for more info.

Properties:

- Config:      encoding
- Env Var:     RCLONE_YANDEX_ENCODING
- Type:        MultiEncoder
- Default:     Slash,Del,Ctl,InvalidUtf8,Dot

{{< rem autogenerated options stop >}}

## Limitations

When uploading very large files (bigger than about 5 GiB) you will need
to increase the `--timeout` parameter.  This is because Yandex pauses
(perhaps to calculate the MD5SUM for the entire file) before returning
confirmation that the file has been uploaded.  The default handling of
timeouts in rclone is to assume a 5 minute pause is an error and close
the connection - you'll see `net/http: timeout awaiting response
headers` errors in the logs if this is happening.  Setting the timeout
to twice the max size of file in GiB should be enough, so if you want
to upload a 30 GiB file set a timeout of `2 * 30 = 60m`, that is
`--timeout 60m`.

Having a Yandex Mail account is mandatory to use the Yandex.Disk subscription.
Token generation will work without a mail account, but Rclone won't be able to complete any actions.
```
[403 - DiskUnsupportedUserAccountTypeError] User account type is not supported.
```

repository: rclone/rclone

repo_name: rclone/rclone


text:
### consider how to integrate RNAseq data

For every gene (20,000 in the genome), get the chromHMM bins within 200 kb.

If the bin size is 1kb:

For one gene:

```
        bin1  bin2  bin3  ....  bin400  response
s1_gene1            Low
s2_gene1            Low
s3_gene1            High
...

```

We need to first categorize the gene expression to Low and High for each gene.

First convert raw counts to TPM, then do a upper-quantile normalization.

How to label Low vs High still needs to be discussed. After visually browser the same gene
for different samples with quite different expression. I tend to label the gene as high across
samples.

first, check if TPM is above median.

```
gene1    1.5  3.4 5 100 300
gene2

```

### subset the raw counts of the RNAseq data

```{r}
library(tidyverse)
library(here)

sub_meta<- read_tsv(here("data/epigenome_Roadmap/sample_with_rnaseq.txt"), col_names = T)

head(sub_meta)

rna_seq<- read_tsv(here("data/epigenome_Roadmap/rnaseq/57epigenomes.counts.tsv"), col_names =T)

```

```{r}
#source("https://bioconductor.org/biocLite.R")
#biocLite("EnsDb.Hsapiens.v75")  # this is still hg19, GRCh37. v86 is GRCh38.
# make sure you use the right genome!!!

#create a tx2gene.txt table
library(EnsDb.Hsapiens.v75)
edb <- EnsDb.Hsapiens.v75

genes_ensemble <- genes(edb)

gene_length<- as.data.frame(genes_ensemble) %>% dplyr::select(gene_id, gene_name, width)

gene_length_in_df<- left_join(data.frame(gene_id = rna_seq$gene_id), gene_length) %>% filter(!is.na(width))

rna_seq_sub<- rna_seq %>% filter(gene_id %in% gene_length_in_df$gene_id)
## now, just use gene_length instead of effective length. effective length = gene length - fragment_length

all.equal(rna_seq_sub$gene_id, gene_length_in_df$gene_id)

countToTpm <- function(counts, effLen)
{
    rate <- log(counts + 1) - log(effLen)
    denom <- log(sum(exp(rate)))
    exp(rate - denom + log(1e6))
}

### quantile normalization?

rna_mat<- as.matrix(rna_seq_sub[, -1])
rownames(rna_mat)<- rna_seq_sub$gene_id

### There are many 0s in the matrix
### get rid of 0s for calculating the median for each sample.

remove_zero_counts_get_TPM_median<- function(x){
        ind<- x !=0
        x[ind] %>% countToTpm(effLen =  gene_length_in_df$width[ind]) %>% median()
}

remove_zero_counts_get_TPM_median(rna_mat[,1])

apply(rna_mat, 2, remove_zero_counts_get_TPM_median)

rna_TPM<- apply(rna_mat, 2, countToTpm, effLen = gene_length_in_df$width )

## before normalization
boxplot(log2(rna_TPM), las = 2)

library(preprocessCore)

#do a upper-quantile normalization
rna_TPM_norm <- normalize.quantiles(rna_TPM)
rownames(rna_TPM_norm)<- rownames(rna_TPM)
colnames(rna_TPM_norm)<- colnames(rna_TPM)
boxplot(log2(rna_TPM_norm), las = 2)

## now all sampels have the same median of 4.027
apply(rna_TPM_norm, 2, median)

rna_TPM_categorized<- ifelse(rna_TPM_norm >=4.027441, "High", "Low")
rownames(rna_TPM_categorized)<- rownames(rna_TPM)
colnames(rna_TPM_categorized)<- colnames(rna_TPM)

rownames(rna_TPM_norm )<- rownames(rna_TPM)
colnames(rna_TPM_norm )<- colnames(rna_TPM)

TPM_df<- as.data.frame(rna_TPM_categorized) %>% rownames_to_column("gene_id") %>%
        left_join(gene_length)

TPM_numeric<- as.data.frame(rna_TPM_norm)  %>% rownames_to_column("gene_id") %>%
        left_join(gene_length)

View(TPM_df)
View(TPM_numeric)
```

### subset the samples we have

```{r}
TPM_df_sub<- TPM_df %>% dplyr::select(one_of(sub_meta$sample),gene_id, gene_name)
sub_meta

## remove genes with only Low or only High across samples.

TPM_only<- dplyr::select(TPM_df_sub, -gene_id, -gene_name)

## test if every column has the same string for every row

apply(TPM_only, 1, function(x) length(unique(x)) == 1) %>% table()

## require at least 4 Low and 4 High in every row

filter_row<- function(x){
        High_num <- sum(x== "High")
        Low_num <- sum( x == "Low")
        return(High_num >=4 & Low_num>=4)
}

ind<- apply(TPM_only, 1, filter_row)

## only 4505 genes left.
TPM_df_sub<- TPM_df_sub[ind, ]

write_tsv(TPM_df_sub, "data/epigenome_Roadmap/rnaseq/response_rnaseq_sub.txt")
```

get the bins within 200 kb upstream and downstream of each gene.

```

                   |--------->
                   |
-------------------|-----------------------
                  TSS

```

`EnrichedHeatmap` has a function for that. I do not need to do it by myself:)

```{r}
library(EnsDb.Hsapiens.v75)
library(EnrichedHeatmap)
library(rtracklayer)
edb <- EnsDb.Hsapiens.v75

genes_ensemble <- genes(edb)

genes_GR<- genes_ensemble[genes_ensemble$gene_id %in% TPM_df_sub$gene_id]

genes_TSS<- promoters(genes_GR, upstream = 0, downstream = 1)

## change to UCSC chr+
seqlevelsStyle(genes_TSS)<- "UCSC"

states<- import("E027_15_coreMarks_segments.bed", format = "BED")

## relevel the states
states$name = factor(states$name, levels =paste0("E", 1:15))

mat<- normalizeToMatrix(states, genes_TSS, value_column = "name")

mat<- normalizeToMatrix(states, genes_TSS, value_column = "name", extend = 200000, w = 1000)

```


text:
# eform-sdk-delphi

A Delphi SDK for integrating with the Microting eForm API v1.

## Support Platforms

 - .NET Framework 4.5+
 - Windows 7 SP1
 - MS SQL 2016

## Setup

1) Get eform-dsk-delphiwrapper from github and build eFormSdk.Wrapper project
2) Get eform-sdk-dephi from github
3) Add following paths to Tools > Options > Environment Options > Delphi Options > Library: eformdelphi, eformdelphi/rest, eformdelphi/dto, eformdelphi/model, eformdelphi/model/reply
4) After user builds his app put into Win32/Debug (Win32/Release) folder binaries from previosly built eFormSdk.Wrapper project

## Get access token

You need to create an account for Microting API and get your access credentials.

 - Call Microting at +45 66 11 10 66 to get started.

## Docs

[SDK documentation can be found here (beta)](https://microting.github.io/eform-sdk-documentation/?pascal#)

## License

The MIT License (MIT)

Copyright (c) 2007-2018 microting

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, sublicense, 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.

repository: microting/eform-sdk-delphi

repo_name: microting/eform-sdk-delphi


text:
## TRAVELLIFY

Travellify is a map based application which allows the user to plan his trip in a two-step process: Select his trip by specifying source and destination and get recommendations of spots he can visit by making small detours.

A fast way to get started with the [Google Maps Android API v2](http://developers.google.com/maps/documentation/android).
![Analytics](https://maps-ga-beacon.appspot.com/UA-12846745-20/hellomap-android/readme?pixel)

#### Current version of library dependencies:

  * Google Play Services Maps 8.4.0

# TOC

  * [Features](#features)
  * [Motivation](#motivation)
  * [Requirements](#requirements)
  * [Android Studio](#android-studio)
    * [Download Android Studio](#download-android-studio)
    * [Open the project](#open-the-project)
    * [Add your API key](#add-your-api-key)
    * [Run the app](#run-the-app)
    * [Troubleshooting](#troubleshooting)

# Features

 *  Easy Signup and login using Google Authentication
 * Place search
 * Retrieve Place Details
 * Route Finder
 * Geocode addresses
 * Upload images to server
 * Download and browse through user uploaded images
 * Tag suggestions for images clicked
 * Search images by tags

# Motivation

This map application is built for travelers. Plan your summer road trip with friends or find an amazing place nearby you never knew existed. You're always 5 minutes away from something awesome!

Discover millions of places, like local diners and quirky roadside attractions, or scenic points, national parks, and hotels.
Plan trips directly from the app and know how much time it would take to complete the trip and how much distance you would be travelling. Upload images on your road trip if you find something interesting and tag your friends in those images.

Note: Content currently USA focused only. Continued use of GPS running in the background can decrease battery life.

# Requirements

Java Development Kit (JDK) [Download](http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html)

Android SDK [Download](http://developer.android.com/sdk/index.html)

# Android Studio

## Download Android Studio
Download Android Studio (http://developer.android.com/sdk/index.html)

## Open the project
  1. On the welcome screen, select "Open an existing Android Studio project" or if you have a project open, choose "File->Open...""
  2. Navigate to the checked out project
  3. Press "Ok"

## Add your API key
  1. Navigate to google_maps_api.xml
  2. Replace "your_api_key" with an API key generated using [these instructions]
  (https://developers.google.com/maps/documentation/android/start#the_google_maps_api_key)

## Run the app
  1. Ensure your phone is in plugged in, developer mode enabled and screen unlocked
  2. Press the green arrow, or choose Run>Run

## Contributors

* Vishalsingh Hajeri : https://github.com/vsh15
* Careena Braganza : https://github.com/cmb499
* Vikti Desai : https://github.com/viktidesai
* Aneesh Abhyankar : https://github.com/aneesh1993

## Troubleshooting
### I see a grey map
Follow the instructions under "Add your API key" and try again. The logcat output will also
provide useful information if there is a configuration issue with the package name, signing
certificate or API key.

## Licensing
Copyright 2016 Travellify

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

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

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


text:
# CTKFlagPhoneNumber

CTKFlagPhoneNumber is a phone number textfield with a fancy country code picker.

[![CI Status](http://img.shields.io/travis/grifas/CTKFlagPhoneNumber.svg?style=flat)](https://travis-ci.org/chronotruck/CTKFlagPhoneNumber)
[![Version](https://img.shields.io/cocoapods/v/CTKFlagPhoneNumber.svg?style=flat)](http://cocoapods.org/pods/CTKFlagPhoneNumber)
[![License](https://img.shields.io/cocoapods/l/CTKFlagPhoneNumber.svg?style=flat)](http://cocoapods.org/pods/CTKFlagPhoneNumber)
[![Platform](https://img.shields.io/cocoapods/p/CTKFlagPhoneNumber.svg?style=flat)](http://cocoapods.org/pods/CTKFlagPhoneNumber)
[![Language](https://img.shields.io/badge/language-swift-brightgreen.svg?style=flat)](https://developer.apple.com/swift)

## Screenshot
![sample](Screenshot/screenshot.gif)

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

CTKFlagPhoneNumber is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod "CTKFlagPhoneNumber"
```

## Usage

You can programmatically change the choosen flag:
```swift
phoneNumberTextField.setFlag(with: "FR")
```

and the phone number:
```swift
phoneNumberTextField.set(phoneNumber: "0600000001")
```

You can also get the phone number to E164 format:
```swift
print(phoneNumberTextField.getPhoneNumber())
// Output: +33600000001
```

## Conception
This library is high inspired of MRCountryPicker library and use libPhoneNumber-iOS library.
https://github.com/xtrinch/MRCountryPicker / https://github.com/iziz/libPhoneNumber-iOS

## Author

grifas<EMAIL_ADDRESS>
Don't hesitate to contact me or make a pull request to upgrade this library.

## License

CTKFlagPhoneNumber is available under the Apache license. See the LICENSE file for more info.

repository: fvolchyok/CTKFlagPhoneNumber

repo_name: fvolchyok/CTKFlagPhoneNumber


text:
---
title: Books
permalink: /books
layout: page
comments: false
published: true
---
## Books I loved reading and recommend

I was never a big fan of reading books. I tried my hand at reading books earlier, but then it stopped after some time. It is over the last couple of years that I have started reading. Thanks to social media and the people I follow who constantly talk about ideas from books and keep updating about books they read,I too started with the habit of reading books.

I tried [Blinkist](https://dinakaran.dev/blog/Blinkist-Speed-reading-for-the-Digital-World/) for some time, but the idea did not resonate with me much after a month or so. I prefer physical books because it helps to reduce screen time.

Listed below some of the interesting books that I read and would gladly recommend to others

**Atomic Habits by James Clear (Productivity)**

This book is a revelation in terms of trying to understand habits and the necessary systems needed in place to keep them going. I would suggest subscribing to James Clear's weekly newsletter too.

I have written more about the book [here](https://dinakaran.dev/blog/Atomic-Habits-by-James-Clear-Dummies-guide-to-Habit-Formation/)

[Link](https://jamesclear.com/atomic-habits)

**Super Thinking by Gabriel Weinberg and Lauren McCann (Critical Thinking)**

This book helps us to understand the day-to-day life situations and find patterns amidst them and help us to build a mental model so that we can recognize repeated patterns and improve our decision-making skills quickly.

[Link](https://www.goodreads.com/book/show/41181911-super-thinking)

**No Rules Rules by Reed Hastings, Erin Meyer (Leadership)**

This is one of the best books that I have read about Leadership. This book delves deep into the culture of reinvention at Netflix. Must read for anyone at the senior/executive leadership levels.

[Link](https://www.goodreads.com/book/show/49099937-no-rules-rules)

**The Psychology of Money by Morgan Housel (Investing/Financial Independence)**

This book took an entirely different approach to the idea of Money and it is not about data-driven analysis but delves into the psychology of how humans view and deal with money. This is no high concept funda around Investing. I loved the author's take on the idea of Financial Independence.

[Link](https://www.goodreads.com/book/show/41881472-the-psychology-of-money)

**Shoe Dog by Phil Knight (Autobiography)**

This book is essentially a memoir by the Creator of Nike is an uplifting and inspiring tale narrated excellently around the founding story, struggles and success around building the iconic shoe brand.

[Link](https://www.goodreads.com/book/show/41881472-the-psychology-of-money)

**Sapiens by Yuval Noah Harari (History)**

This book revisits the history of our civilizations of mankind - the path we came across over the last 2000 years to where we are, raises pertinent questions around what we take for granted.

[Link](https://www.goodreads.com/book/show/23692271-sapiens)

**Other honourable mentions**

**Radical Candor** by Kim Malone Scott (Leadership/Coaching) [Link](https://www.goodreads.com/book/show/29939161-radical-candor)

**Ikigai** by Hector Garcia Puigcerver,  Francesc Miralles,  Meik Wiking and  Linnea Dunne ( Self Help / Philosophy) [Link](https://www.goodreads.com/book/show/40534545-ikigai)

**The Almanack of Naval Ravikant** by Eric Jorgenson ( Self Help / Philosophy) [Link](https://www.goodreads.com/book/show/54898389-the-almanack-of-naval-ravikant)

**Grit** by Angela Duckworth ( Self Help/Psychology) [Link](https://www.goodreads.com/book/show/27213329-grit)

There are other books that I have enjoyed too but have not been mentioned here. I use the Twitter thread to document all the books that I read. You can follow this to keep track of my reading.

Below is the list for 2022.

2022 Book Reading Thread...

Hoping to capture some key takeaways after reading every book

(1/n) Start with Why by Simon Sinek pic.twitter.com/oAoRhlc7ce
— Dinakaran aka Master Of None (@dinquisitively) January 3, 2022

Below is the list for 2021.

2021 Book Reading Thread

(1/n) The Pyschology Of Money by Morgan Housel.

And this section about Freedom hits me close to home.

"Controlling your time is the highest dividend money pays" pic.twitter.com/nlyLttrcEH
— Dinakaran aka Master Of None (@dinquisitively) January 3, 2021

repository: dinakaranonline/blog

repo_name: dinakaranonline/blog


text:
Please refer to
https://github.com/chef-cookbooks/community_cookbook_documentation/blob/master/TESTING.MD

# Integration testing with kitchen-dokken
This cookbook attempts to fully integrate automated testing using the travis-ci testing framework. This
speeds up testing and ensures consistent results. However, chrony requires privileged access to the linux kernel,
which is not a supported feature of Travis-CI.

To this end, this cookbook provides two yaml configurations for Test Kitchen. One is based on a
vagrant VM testing model, which can be found in kitchen.yml, and the second one is based on kitchen-dokken,
which is found in kitchen.dokken.yml. Travis-CI will be configured to run tests against `kitchen.dokken.yml`.
The kitchen-dokken configuration will have chronyd not attempt to make updates to the system clock in order
to pass automated tests.

*Future contributors* should be aware that relying on travis-ci and the kitchen-dokken configuration
will not ensure that chronyd can be fully started/restarted during the exercise of test kitchen. An extra
step in your testing workflow should be to make sure that you run `kitchen verify` against the kitchen.yml
configuration. The latter, as of this writing, is able to start and restart chronyd in a vagrant VM.

repository: haidangwa/chrony

repo_name: haidangwa/chrony


text:
# E-Commerce

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Week 13 homework for UNH Full-Stack Web Development Boot Camp

***

## Description

The goal of this project was to build the back-end for an e-commerce site by modifying starter code and configuring a working Express.js API to use Sequelize to interact with a MySQL database that allows the user to:

- Add, Update and Delete Categories, Products and Tags
- View All or View by ID any of the Categories, Products or Tags

***

## Table of Contents

- [Technology Used](#technology-used)

- [Repository](#repository)

- [Link to Full Video](#link-to-full-video)

- [Screenshots/GIF](#screenshots/gif)

- [Installation](#installation)

- [Usage](#usage)

- [Credits](#credits)

- [Questions](#questions)

- [License](#license)

***

## Technology Used

- [Visual Studio Code](https://code.visualstudio.com/)
- [Node.js](https://nodejs.org/en/)
- [Express package](https://www.npmjs.com/package/express)
- [Sequelize package](https://www.npmjs.com/package/sequelize)
- [nodemon package](https://www.npmjs.com/package/nodemon)
- [dotenv package](https://www.npmjs.com/package/dotenv)
- [MySQL2 package](https://www.npmjs.com/package/mysql2)
- [MySQL Workbench](https://www.mysql.com/products/workbench/)
- [Insomnia REST](https://insomnia.rest/)
- [GitHub GUI](https://desktop.github.com/)
- [GitHub](https://www.github.com)

***

## Repository

- [GitHub Repository](https://github.com/tracye1083/E-Commerce)

***

## Link to Full Video

[Link to view Full Video of Application](https://drive.google.com/file/d/1Yw3THCa5YC3TE3p9XBJwqBFooaF1NtwJ/view)

***

## Screenshots/GIF

![Animated GIF of Application in Use](Assets/E-Commerce.gif)

***

## Installation

~~~javascript
npm install
~~~

Open your MySQL Workbench, open and run the schema.sql file then return to your terminal and run the below command

~~~javascript
npm run seed
~~~

***

## Usage

~~~javascript
npm start
~~~

Navigate using the keyboard arrow keys to make your selections and updates.

***

## Credits

My full-stack web development course is being offered as a collaboration between Trilogy Education Services and UNH Professional Development and Training.

- Instructor - Benjamin Hutchins [GitHub](https://github.com/benhutchins)
- TA - Andrew Hatfield

***

## Questions

If you have any questions about the repo you can open an issue.

You can find more of my work at [Github](https://www.github.com/tracye1083)

***

## License

This project is licensed under the [MIT License](https://choosealicense.com/licenses/mit).

Copyright (c) 2021 Tracy Angell

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, sublicense, 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.