text:
# DescribeReplicationJobs

Queries the details of one or more migration tasks.

## Description

-   You can specify multiple request parameters. The parameters that you specify have logical AND relations. If you leave a parameter empty, this parameter is not included in the conditions to filter query results.
-   You can migrate source servers to Docker container images. SMC allows you to migrate containerized applications to Container Registry at low costs. For more information, see [Container Registry](~~60744~~).

## Debugging

[OpenAPI Explorer automatically calculates the signature value. For your convenience, we recommend that you call this operation in OpenAPI Explorer. OpenAPI Explorer dynamically generates the sample code of the operation for different SDKs.](https://api.aliyun.com/#product=smc&api=DescribeReplicationJobs&type=RPC&version=2019-06-01)

## Request parameters

|Parameter|Type|Required|Example|Description|
|---------|----|--------|-------|-----------|
|Action|String|Yes|DescribeReplicationJobs|The operation that you want to perform. Set the value to DescribeReplicationJobs. |
|SourceId.N|RepeatList|No|s-bp1e2fsl57knvuug\*\*\*\*|The ID of a source server. Maximum value of N: 50. |
|JobId.N|RepeatList|No|j-bp19vlwm0tyigbmj\*\*\*\*|The ID of a migration task. Maximum value of N: 50. |
|Name|String|No|testMigrationTaskName|The name of a migration task. |
|RegionId|String|No|cn-hangzhou|The ID of the destination Alibaba Cloud region.

 For example, if you want to migrate the source server to Shanghai, set the value to `cn-shanghai`. You can call [DescribeRegions](~~25609~~) to query the latest list of Alibaba Cloud regions. |
|Status|String|No|Ready|The main status of the migration task. Valid values:

 -   Ready
-   Running
-   Stopped
-   InError
-   Finished
-   Waiting
-   Expired
-   Deleting |
|BusinessStatus|String|No|Preparing|The business status of the migration task. Valid values:

 -   Preparing
-   Syncing
-   Processing
-   Cleaning |
|PageNumber|Integer|No|1|The number of the page to return. Page numbers start from 1.

 Default value: 1. |
|PageSize|Integer|No|10|The number of entries returned on each page. Maximum value: 50.

 Default value: 10. |

## Response parameters

|Parameter|Type|Example|Description|
|---------|----|-------|-----------|
|PageNumber|Integer|1|The number of the page returned. |
|PageSize|Integer|10|The number of entries returned on each page. |
|ReplicationJobs|Array| |A list of migration tasks. |
|ReplicationJob| | | |
|BusinessStatus|String|Preparing|The business status of the migration task. |
|ContainerNamespace|String|testNamespace|The namespace of the Docker container image. |
|ContainerRepository|String|testRepository|The repository that stored a Docker container image. |
|ContainerTag|String|CentOS:v1|The tag of a Docker container image. |
|CreationTime|String|2014-07-24T13:00:52Z|The time when the migration task was created. |
|DataDisks|Array| |A list of data disks on the destination ECS instance. |
|DataDisk| | | |
|Index|Integer|1|The index number of the data disk. |
|Parts|Array| |A list of partitions in the data disk. |
|Part| | | |
|Block|Boolean|true|Indicates whether block replication was enabled for a partition in the destination data disk. |
|Device|String|0\_1|The device ID of the data disk partition. |
|SizeBytes|Long|21474836480|The size of a partition in the destination data disk. Unit: bytes. |
|Size|Integer|40|The size of the data disk. Unit: GiB. |
|Description|String|This is my migration task.|The description of the migration task. |
|EndTime|String|2019-06-04T16:00:52Z|The time when a migration task was completed. |
|ErrorCode|String|InternalError|The error code returned during a migration task. |
|Frequency|Integer|15|The interval at which the incremental migration task runs. Unit: hours. Valid values: 1 to 168. |
|ImageId|String|m-o6w3gy99qf89rkga\*\*\*\*|The ID of the destination image. |
|ImageName|String|testAliCloudImageName|The name of the destination image. |
|InstanceId|String|i-bp1ff25rzvnul6kr\*\*\*\*|The ID of the destination ECS instance. |
|InstanceRamRole|String|SMCAdmin|The RAM role that was attached to the intermediate instance. |
|InstanceType|String|ecs.sn1ne.large|The type of the intermediate instance. |
|JobId|String|j-bp19vlwm0tyigbmj\*\*\*\*|The ID of the migration task. |
|LaunchTemplateId|String|lt-launchtemplateid|The ID of the launch template. |
|LaunchTemplateVersion|String|1|One or more launch template versions. |
|MaxNumberOfImageToKeep|Integer|8|The maximum number of images retained for the incremental migration task. Valid values: 1 to 10. |
|Name|String|testMigrationTaskName|The name of the migration task. |
|NetMode|Integer|0|The network mode used for data transmission. |
|Progress|Float|55.45|The progress of the migration task. |
|RegionId|String|cn-hangzhou|The ID of the destination Alibaba Cloud region. |
|ReplicationJobRuns|Array| |A list of the logs of migration tasks. |
|ReplicationJobRun| | | |
|EndTime|String|2019-10-04T13:35:00Z|The time when a migration was complete. |
|ImageId|String|m-o6w3gy99qf89rkga\*\*\*\*|The ID of the destination image. |
|StartTime|String|2019-10-01T13:35:00Z|The time when a migration task was started. |
|Type|String|Schedule|The method used to run the migration task. Valid values:

 -   Manual: A migration task is manually started.
-   Schedule: A migration task is started at a scheduled time or at a specified interval. |
|ReplicationParameters|String|BandWidthLimit:0|A string of key-value pairs to configure a replication driver. |
|RunOnce|Boolean|true|Indicates whether incremental migration was disabled for a source server. Valid values:

 -   true: disables incremental migration. Incremental data of a source server is not synchronized.
-   false: enables incremental migration. SMC synchronizes incremental data to Alibaba Cloud at a specified `Frequency`. |
|ScheduledStartTime|String|2019-06-04T13:35:00Z|The time when the migration task was performed. |
|SourceId|String|s-bp1e2fsl57knvuug\*\*\*\*|The ID of the source server. |
|StartTime|String|2019-06-04T14:40:52Z|The time when the migration task was started. |
|Status|String|Running|The main status of the migration task. |
|StatusInfo|String|statusinfo|The migration status information. |
|SystemDiskParts|Array| |The information of system disk partitions. |
|SystemDiskPart| | | |
|Block|Boolean|true|Indicates whether block replication was enabled for a partition in the destination system disk. |
|Device|String|0\_1|The device ID of the system disk partition. |
|SizeBytes|Long|254803968|The size of a partition in the destination system disk. Unit: bytes. |
|SystemDiskSize|Integer|40|The system disk size of the destination ECS instance. |
|TargetType|String|image|The type of the destination image. |
|TransitionInstanceId|String|i-bp1ff25rzvnul6kr\*\*\*\*|The ID of the intermediate instance. |
|VSwitchId|String|vsw-bp1ddbrxdlrcbim46\*\*\*\*|The ID of the VSwitch in the specified VPC. |
|ValidTime|String|2019-06-08T14:40:52Z|The time when the migration task expired. |
|VpcId|String|vpc-bp1vwnn14rqpyiczj\*\*\*\*|The ID of a VPC for which you have configured Express Connect or VPN Gateway. |
|RequestId|String|6E1187E8-843A-4850-B97E-2F17F00D48F7|The ID of the request. |
|TotalCount|Integer|5|The total number of migration tasks. |

## Examples

Sample requests

```
http(s)://smc.aliyuncs.com/? Action=DescribeReplicationJobs
&RegionId=cn-hangzhou
&<Common request parameters>
```

Sample success responses

`XML` format

```
<DescribeReplicationJobsResponse>
      <TotalCount>1</TotalCount>
      <ReplicationJobs>
            <ReplicationJob>
                  <Status>Running</Status>
                  <Progress>75</Progress>
                  <TransitionInstanceId>i-bp1ff25rzvnul6kr****</TransitionInstanceId>
                  <DataDisks>
                        <DataDisk>
                              <Parts>
                                    <Part>
                                          <Device>2_0</Device>
                                          <Block>true</Block>
                                          <SizeBytes>5334102016</SizeBytes>
                                    </Part>
                              </Parts>
                              <Size>20</Size>
                              <Index>2</Index>
                        </DataDisk>
                  </DataDisks>
                  <SystemDiskSize>20</SystemDiskSize>
                  <NetMode>0</NetMode>
                  <SourceId>s-bp1e2fsl57knvuug****</SourceId>
                  <SystemDiskParts>
                        <SystemDiskPart>
                              <Device>0_0</Device>
                              <Block>true</Block>
                              <SizeBytes>21466120192</SizeBytes>
                        </SystemDiskPart>
                  </SystemDiskParts>
                  <StartTime>2020-05-14T12:01:24Z</StartTime>
                  <BusinessStatus>Processing</BusinessStatus>
                  <Name>testMigrationTaskName</Name>
                  <ValidTime>2020-06-13T12:01:24Z</ValidTime>
                  <RunOnce>true</RunOnce>
                  <TargetType>Image</TargetType>
                  <CreationTime>2020-05-14T12:01:24Z</CreationTime>
                  <RegionId>cn-hangzhou</RegionId>
                  <ErrorCode></ErrorCode>
                  <JobId>j-bp19vlwm0tyigbmj****</JobId>
            </ReplicationJob>
      </ReplicationJobs>
      <RequestId>6E1187E8-843A-4850-B97E-2F17F00D48F7</RequestId>
      <PageSize>10</PageSize>
      <PageNumber>1</PageNumber>
</DescribeReplicationJobsResponse>
```

`JSON` format

```
{
  "TotalCount": 1,
  "ReplicationJobs": {
    "ReplicationJob": [
      {
        "Status": "Running",
        "Progress": 75.0,
        "TransitionInstanceId": "i-bp1ff25rzvnul6kr****",
        "DataDisks": {
          "DataDisk": [
            {
              "Parts": {
                "Part": [
                  {
                    "Device": "2_0",
                    "Block": true,
                    "SizeBytes":<PHONE_NUMBER>
                  }
                ]
              },
              "Size": 20,
              "Index": 2
            }
          ]
        },
        "SystemDiskSize": 20,
        "NetMode": 0,
        "SourceId": "s-bp1e2fsl57knvuug****",
        "SystemDiskParts": {
          "SystemDiskPart": [
            {
              "Device": "0_0",
              "Block": true,
              "SizeBytes":<PHONE_NUMBER>2
            }
          ]
        },
        "StartTime": "2020-05-14T12:01:24Z",
        "BusinessStatus": "Processing",
        "Name": "testMigrationTaskName",
        "ValidTime": "2020-06-13T12:01:24Z",
        "RunOnce": true,
        "TargetType": "Image",
        "CreationTime": "2020-05-14T12:01:24Z",
        "RegionId": "cn-hangzhou",
        "ErrorCode": "",
        "JobId": "j-bp19vlwm0tyigbmj****"
      }
    ]
  },
  "RequestId": "6E1187E8-843A-4850-B97E-2F17F00D48F7",
  "PageSize": 10,
  "PageNumber": 1
}
```

## Error codes

For a list of error codes, visit the [API Error Center](https://error-center.alibabacloud.com/status/product/smc).

repository: hglakfs/smc

repo_name: hglakfs/smc


text:
---
layout: post
title: Those Things about Memory Mapping ... / Memory Mapping 的那些事
date: '2012-11-11T11:40:00.000+08:00'
author: mjtsai
tags: program
modified_time: '2012-11-11T11:40:05.053+08:00'
blogger_id: tag:blogger.com,1999:blog-6729751024593483406.post-5162476766366666538
blogger_orig_url: https://mongala-memo.blogspot.com/2012/11/those-things-about-memory-mapping.html
---

I have just learned computer architecture but OS so never linked them at all. These days I finished tracing a sample bootcode and read the arm programming guide. A sentence caught my eye which means every process has its own memory mapping, there are many page tables on runtime. I was too stupid to think there was only one page table where one program occupied part of memory and the code followed the rules in the part of memory, instructions on the bottom, stack on the top... Another impact was that it could allocate new memory by updating the page tables. I never knew it.
<!--more-->

Several days after that day, I continuously construct the imagination of the code arrangement in the memory mapping, how the OS deals with the page tables. I only know that one program must ask the OS to get more space.

Discussing with one of my colleagues in SW team and looking for some information, my imagination is very close to the real case but remains some problems to solve, e.g. share libraries. [Understanding Memory](http://www.ualberta.ca/CNS/RESEARCH/LinuxClusters/mem.html#mmap) describes very clearly.

My Descriptions

Codes in a process are mapped to whole virtual memory space, i.e. 4GB in 32b system. OS finds unused spaces and updates the page table to map these codes to appropriate spaces. When it needs to allocate more space, OS searches free spaces in memory then update the page table of the process so that it can access the spaces.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
layout: blog
title: "M-Lab is Turning 10!"
author: "Georgia Bullen"
date: 2018-07-21
breadcrumb: blog
categories:
  - event
  - community
  - bigquery
  - research
  - data
  - performance
---

![M-Lab 10 Year Anniversary Graphic]({{ site.baseurl }}/images/blog/M_Lab_10Year.png)

* **When:** Aug. 7, 2018 - Aug. 8, 2018, 9AM - 5PM
* **Where:** New America, 740 15th St NW #900, Washington, D.C. 20005

Measurement Lab is turning 10! On August 7 and 8, we look forward to gathering the Measurement Lab community to showcase how the platform has evolved, learn from you about how you are using M-Lab, and discuss how we plan for the next 10 years of measuring the Internet and providing public data to the world. So much has changed over the last 10 years (*and that’s not just our expanding volume of longitudinal data!*), come celebrate, brainstorm, analyze, and share with us.

<!--more-->

Over the conference days, participants will have the chance to hear from leaders in the Internet measurement space and participate in workshops to learn more about Measurement Lab’s platform. Other highlights include:

* Opening keynote on August 7 from Vint Cerf.
* Workshops on developing Internet measurement experiments, data analysis techniques, and connecting data to larger policy concerns.
* Talks on the evolution of the M-Lab project and technology platform, and the future of Internet measurement.
* A chance to celebrate at a reception (birthday party!) on the evening of August 7.

You can view the current agenda [here](https://www.newamerica.org/documents/2385/M-Lab_agenda.pdf).

> [**RSVP**](http://newamerica.cvent.com/d/7gqm0x/4W?_ga=2.121174539.2091418.1531860945-1759573491.1487868208)

If you'll be coming to D.C. to participate, you can book a hotel room at the Washington Plaza Hotel. A 12-minute walk from the New America offices, book through [this link](http://www.cvent.com/events/mproc.aspx?m=248213b5-9d5c-4dae-aa99-4fe6d7b08f85&u=https%3a%2f%2fwww.reservations-page.com%2fC00519%2fH11149%2fov.aspx%3fpc%3dNEWAM&l=this+link) to receive 15% off of your stay.

If you have done work based on M-Lab data and would like it to be showcased, please email us at<EMAIL_ADDRESS>We hope you’ll be able to join us!

repository: FangfanLi/website

repo_name: FangfanLi/website


text:
ReconWithKSAE

See the TMI paper "Iterative low-dose CT reconstruction with priors trained by nerual networks", by Dufan Wu, Kyungsang Kim, Geoges El Fakhri, and Quanzheng Li, 2017.

The code is in python with tensorflow 1.1.

The code uploaded here is only for the network training and deploying. The core GPU code for the image reconstruction (forward and backward model) was not included, because I am not the sole author for that piece of code. However, the reconstruction python code should give enough explanation on how to integrate the neural network into the reconstruction algorithm (SQS in our case).

The KSAE is an unsurpervised learning algorithm, please keep this in mind when doing comparison studies with other neural network based methods like ADMM-net.

About the folder:

Autoencoders/ - the KSAE codes, training codes, and deploying codes

FileOps/ - some IO operations

SQS/ - 2D image reconstruction sample

SQS3D/ - 3D image reconstruction sample

pythonWrapper/ - python interface for image reconstruction. The core CUDA code is not included here.

repository: wudufan/KSAERecon

repo_name: wudufan/KSAERecon


text:
# Burger-Logger

Burger is a restaurant app that lets users input the names of burgers they'd like to eat. The burger logger uses MySQL, Node, Express, Handlebars and a homemade ORM.

* Whenever a user submits a burger's name, the app displays the burger in the list of burgers not devoured -- waiting to be devoured.

* Each burger in the waiting area also has a `Devour it!` button. When the user clicks it, the burger will move to the list of devoured burgers.

The deployed app is accessible at, https://warm-plains-66976.herokuapp.com

repository: idrisxa/Burger-Logger

gha_language: JavaScript

gha_license_id: MIT

repo_name: idrisxa/Burger-Logger


text:
# pyraycaster
Raycaster built with Python

# How to run

1. Switch to desired branch:

* `git switch main` for 2D Raycaster
* `git switch 3D` for 3D Raycaster

1. Install dependencies:

`pip install -r requirements.txt`

1. Run the project:

`python -m pyraycaster`

# How to use

* Move mouse around to move the rays

repository: SnkSynthesis/pyraycaster

branch_name: refs/heads/main

repo_name: SnkSynthesis/pyraycaster


text:
Svelte bindings for Makina

## Installation

```shell
npm i @ezy/svelte-makina
```

## Usage

`counter.ts`
```ts
import { createBase, Filterables } from '@ezy/makina';
import "@ezy/svelte-makina"

class Counter extends createBase()<number> {

  constructor(initialState = 0) {
    super(initialState);
  }

  public get display() {
    return `Times clicked: ${this.state}`;
  }

  public increment() {
    this.commit('increment', this.state + 1);
  }

  public decrement() {
    this.commit('decrement', this.state - 1);
  }
}

const counter: Filterables<Counter> = Counter.create();

export default counter;
```

`Counter.svelte`
```html
<script lang="ts">
	import counter from "./counter"
</script>

<h1>The count is {$counter.display}</h1>

<button on:click={counter.increment}>+</button>
<button on:click={counter.decrement}>-</button>
```

### On mutation

Svelte being based on mutation,
you will pretty quickly run into mutating your app state directly from your components, which destroy the entire point of having a state machine.

to avoid that kind of issues please consider to freeze the state of your state machine, [see here](https://www.npmjs.com/package/@ezy/makina#immutable-state-guarantee).

## Links

[Makina](https://www.npmjs.com/package/@ezy/makina)

repository: ezylean/svelte-makina

repo_name: ezylean/svelte-makina


text:
# OSINT Tools

## Tools

### Github

- [Gitrecon](https://github.com/GONZOsint/gitrecon): OSINT tool to get information from a Github and Gitlab profile and find user's email addresses leaked on commits.
- [GitStalk](https://github.com/un1k0n/GitStalk): OSINT tool to get information from a Github and Gitlab profile.

### Google

- [Ghunt](https://github.com/mxrch/GHunt): GHunt is an OSINT tool to extract information from any Google Account using an email.

### Other

- [DataSploit](https://github.com/DataSploit/datasploit): An OSINT Framework to perform various recon techniques on Companies, People, Phone Number, Bitcoin Addresses, etc., aggregate all the raw data, and give data in multiple formats.
- [OSINT Framework](https://github.com/lockfale/OSINT-Framework):OSINT framework focused on gathering information from free tools or resources.
- exiftool
- dirb
- nmap

## Services
- [spyse](https://spyse.com/) - all in one recon service. scans the entire internet using OSINT and collects all the data in its own DB for instant access. Scanned info: ipv4 host, AS, DNS, sub/domains, whois/site info, ports/banners/protocols etc...
- [Namechk.sh](https://github.com/HA71/Namechk): Osint tool based on namechk.com for checking usernames on more than 100 websites, forums and social networks.
- [shodan](https://shodan.io): Shodan is a search engine for Internet-connected devices.
- [phonebook.cz](https://phonebook.cz/): Get emails by domain search.

## Lists and documentation
- [awesome-osint](https://github.com/jivoi/awesome-osint): A curated list of amazingly awesome OSINT.
- [IntellTechniques](https://inteltechniques.com/menu.html): IntelTechniques Search Tool


text:
# נָקַר

<!-- Status: S2="NeedsEdits" -->
<!-- Lexica used for edits:   -->

## Word data

* Strongs: H5365

* TWOT: 1418

* BDB Reference: [נָקַר](rc://en/bdb/dict/n.fk.aa)

* Alternate spellings:

* Principal Parts:

* Part of Speech:

Verb

* Instances in Scripture: TBS

## Etymology:

* Related Language glosses:

* Time Period/Ancient Authors:

* Related words:

* Antonyms for all senses:

* Synonyms for all senses:

## Senses

### Sense 1.0:

#### Definition:

#### Glosses:

boring; picking out;

#### Explanation:

#### Citations:

### Sense 2.0:

#### Definition:

#### Glosses:

boring out;

#### Explanation:

#### Citations:

### Sense 3.0:

#### Definition:

#### Glosses:

ye were digged;

#### Explanation:

#### Citations:

repository: mandolyte/uw-obsidian

repo_name: mandolyte/uw-obsidian


text:
# virusTotalShim
Quick and Dirty Virustotal Script

## How to use

``virusTotalShim.py *filenamehere*``

Make sure you have a file called "api.ini" with your API key inside.

repository: GarnetSunset/virusTotalShim

repo_name: GarnetSunset/virusTotalShim


text:
# Mobile-kivy-01
Kivy is a free and open source Python library for developing mobile apps and other multitouch application software with a natural user interface. It is distributed under the terms of the MIT License, and can run on Android, iOS, Linux, OS X, and Windows.

Following tutorial will guide you how to install kivy on your computer.

# what you need for this
1. Install python:
> https://www.python.org/ftp/python/3.7.3/python-3.7.3.exe
2. install pip

3. install and upgrade wheel
```
   python -m pip install --upgrade pip wheel setuptools
```

4. install sd12 and packages
```
    >python -m pip install docutils pygments pypiwin32 kivy.deps.sdl2 kivy.deps.glew --extra-index-url https://kivy.org/downloads/packages/simple/
```
5. install kivy
```
    >pip install kivy
```

gha_language: Python


text:
# ResponsivePortfolio

![React](https://img.shields.io/badge/React-20232A?style=for-the-badge&logo=react&logoColor=61DAFB)

## Description

As a student of the UCSD Coding Bootcamp this is my portfolio site to display my work, and provide a contact page. I created this site using HTML, CSS, and Bootstrap. Using Bootstraps grid system, I designed this page mobile first. Click [here](https://veryfaye.github.io/React-Portfolio/#/) to view the deployed application.

There are three pages of this site:
 * The Home page is an about me page, with a short description of myself.
 * The Portfolio page has a collection of the assignments I am most proud of at this point of the course.
 * The Contact page has links to my GitHub, LinkedIn, Resume, Email Address, and Phone Number.

## License

Copyright <2020> Amanda LeMoine

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: veryfaye/React-Portfolio

repo_name: veryfaye/React-Portfolio


text:
---
layout: post
title: "Natural Numbers - Axioms, Addition, Recursion"
date: 2016-01-08 09:54:13 +0530
comments: true
categories:
---

We see, following the __text__ how to axiomatize the natural numbers and define addition and multiplication from these. We elaborate on only one result, namely one allowing us to make recursive definitions.

**Theorem:** Let $X$ be a set, let $x_0\in X$ and let $g(n, x)$ be a function $g: \mathbb{N} \times X \to X$. There is a unique function $f: \mathbb{N}\to X$ such that $f(0)= x_0$ and $\forall n \in\mathbb{N}\ f(n++) = g(n, f(n))$.

**Proof:** The idea is to construct the graph of $f$ as the smallest set containing a specified starting point and closed under a shift.

Let $\mathcal{U} = \\{S \subset \mathbb{N}\times X : (0, x_0)\in S,\ (n, x)\in S\Rightarrow (n++, g(n++, x))\in S\\}$. Note that $\mathcal{U}$ is non-empty as $\mathbb{N}\times X \in \mathcal{U}$.

Consider the set

$$S_0 = \bigcap\limits_{S \in \mathcal{U}} S$$

It is easy to see that $S_0\in \mathcal{U}$.

**Lemma:** For every $n\in \mathbb{N}$, there exist a unique $x_n\in X$ such that $(n, x_n) \in S_0$.

**Proof:** We prove this by induction on $n$. First, let $n=0$. Note that $(0, x_0)\in S$ for all $S\in \mathcal{U}$, and so $(0, x\_0) \in S\_0$. Now suppose $(0, x\_0')\in S\_0$ with $x\_0'\neq x_0$. Let $S = \\{(n, x) \in S\_0: (n, x) \neq (0, x\_0')$. We claim that $S\in \mathcal{U}$.

Firstly, as $(0, x_0) \in S_0$ and $x_0' \neq x_0$, $(0, x_0)\in S$. Next, suppose $(n, x)\in S \subset S_0$, then  $(n++, g(n++, x))\in S_0$. Further, as $n++ \neq 0$, we see that $(n++, g(n++, x)) \neq (0, x_0')$. Hence $(n++, g(n++, x))\in S$. Thus $S\in \mathcal{U}$.

By definition of $S\_0$, as $S\in \mathcal{U}$, $S\_0 \subset S$. But $(0, x\_0')$ is in $S\_0$ but not $S$, a contradiction. This shows that $x\_0\in X$ is the unique point $x \in X$ such that $(0, x)\in S_0$.

The induction step is similar. Assume $(n, x_n)\in S_0$ and this is unique, i.e., $(n, x)\in S_0 \implies x = x_n$. Then $(n, x_n)\in S$ for all $S \in \mathcal{U}$, from which we deduce that $(n++, g(n++, x))\in S_0$. To show uniqueness, suppose $x\_{n++}'\in X$ is a point with $(n++, x\_{n++}')\in S\_0$ but $x\_{n++}' \neq x\_{n++} := g(n++, x)$. Let $S = S_0 \setminus \\{(n++, x_{n++}')\\}$. We again show that $S \in \mathcal{U}$ and obtain a contradiction to $S_0 \subset S$.

Namely, as $(0, x_0) \in S_0$ and $n++ \neq 0$, $(0, x_0)\in S$. Next, suppose $(m, x)\in S \subset S_0$, then  $(m++, g(m++, x))\in S_0$. If $(m++, g(m++, x)) \notin S$, then we must have $(m++, g(m++, x)) = (n++, x\_{n++}')$. Hence $n = m$, so $x = x\_n$. It follows that $x\_{n++}' = g(m++, x) = g(n++, x\_n)$, a contradiction. Thus, if $(m, x)\in S$, $(m++, g(m++, x)) \in S$, completing the proof that $S\subset \mathcal{U}$, and contradicting $S_0 \subset S$.

This completes the proof of the lemma.

$$\tag*{$\square$}$$

To prove the theorem, we define the function $f$ by $f(n) = x_n$. As we will see, in terms of set theory the function just corresponds to the set $S_0$. It is straightforward to show by induction than $f$ indeed has the desired properties, and is the unique such function.

$$\tag*{$\square$}$$

repository: siddhartha-gadgil/BasicAnalysisCourse

extension: markdown

repo_name: siddhartha-gadgil/BasicAnalysisCourse


text:
# Windows Virtual Shields for Arduino (Universal Windows App)

This project lets your Arduino sketch control your Windows 10 device (phone). The only code you write is to an Arduino sketch.

This repository is a Universal Windows Application which exposes sensors and capabilities to a [Windows Virtual Shields for Arduino library](https://github.com/ms-iot/virtual-shields-arduino/).

Windows Virtual Shields for Arduino is an open-source library primarily for the Arduino UNO which communicates with this open-source Windows Universal Application
running on all Windows 10 devices, primarily focusing on Windows Phones.  The library exposes the Phones's sensors and capabilities to the an Arduino Wiring Sketch.
The following sensors and capabilities can be used from Arduino Wiring:

Sensors:
* Accelerometer
* Compass
* Geolocator (GPS)
* Gyrometer
* Light Sensor
* Orientation

Capabilities:
* Camera
* Device info (name, date/time/timezone, os)
* Email (initiation)
* Microphone
* Notifications (Tile/Toast)
* Screen (Text, Images, Audio/Video, Rectangles, Buttons, Touchscreen)
* Sms (initiation)
* Speech to Text and Speech Recognition
  * can receive table data from previous web search
* Vibration
* Web (Get and Post with result parsing)
  * XPath
  * JSON
  * Simple text
  * Regular expressions
  * Table iteration (keys/values saved)

## Within your Arduino Wiring Sketch, you can enable the following scenarios:

* Place buttons on your Windows Phone's screen which directly affect pins, motors on your Arduino.
  * Shields used:
     * Screen
* Send data gathered on the Arduino (Weather Station) to the cloud through the phone's data connection.
* or check a web page for a weather status and open or close windows in your house.
  * Shields used:
     * GPS
     * Web
* Turn the phone's accelerometer into a remote driving controller for an Arduino robot.
  * Shields used:
     * Accelerometer
* Ask questions and based on voice responses, control pins to turn on lights or motors.
  * Shields used:
     * Text to Speech and Speech Recognition.
* Security Cam: Sense movement with an Arduino ultrasonic sensor, take a picture, record audio, upload to Azure and alert you.
  * Shields used:
     * Web
     * Camera
     * Microphone

## Getting Started : Hardware

### What you need
 1. Arduino Uno or compatible device.
 2. Bluetooth module: SparkFun BlueSMiRF Silver (https://www.sparkfun.com/products/12577) and 4 wires to connect.
 3. Windows 10 phone ([Lumia 520](http://www.microsoft.com/en-us/mobile/phone/lumia520/), [Lumia 635](http://www.microsoft.com/en-us/mobile/phone/lumia635/))

### Set up your Arduino [using the Windows Virtual Shields for Arduino library](https://github.com/ms-iot/virtual-shields-arduino/)
 1. Prepare the Bluetooth module if necessary (the Bluetooth module may need to have headers soldered onto it).
 2. Except for one difference below, connect the Bluetooth module to the Arduino per your wiring diagram ([BlueSMiRF wiring diagram](https://learn.sparkfun.com/tutorials/using-the-bluesmirf/hardware-hookup)).

    DIFFERENCE: Use pins 0 and 1 instead of 2 and 3:
        The Bluetooth TX should connect to pin 0 (Arduino RX).
        The Bluetooth RX should connect to pin 1 (Arduino TX).

### Set up your Windows 10 phone
 1. Windows 8 users can get the "Windows Insider" application from the app store. This allows the user to opt into receiving Windows 10 Technical Previews as updates.
 2. Pair the Bluetooth device in the Bluetooth settings.
    BlueSMiRF default pin code is 1234.
    NOTE: The red blinking light on the BlueSMiRF continues to blink red after a successful pairing. This is expected. It only turns green after a connecting with the application.
    When pairing you should see a device name like "RNBT-76BC" the last four characters are the last four characters of the MAC address printed on the sticker of the module.

## Getting Started : Software

### What you need
 1. Arduino IDE 1.6 or better.
 2. ArduinoJson library.
 3. This repository.
 4. Visual Studio 2015 to sideload UWA (phone app) onto developer unlocked phone.

### Set up your Arduino IDE [using the Windows Virtual Shields for Arduino library](https://github.com/ms-iot/virtual-shields-arduino/)
 1. Download and install the [Arduino IDE](http://www.arduino.cc/en/Main/Software).

### Set up ArduinoJson library [using the Windows Virtual Shields for Arduino library](https://github.com/ms-iot/virtual-shields-arduino/)
 1. From the [ArduinoJson repository](https://github.com/bblanchon/ArduinoJson), branch the reporsitory or download the zip.
 2. Place the whole repository into your libraries folder (i.e. Documents\Arduino\libraries\ArduinoJson\).

### Set up this repository. [using the Windows Virtual Shields for Arduino library](https://github.com/ms-iot/virtual-shields-arduino/)
 1. Branch this repository or download the zip.
 2.	Copy the Arduino/libraries/VirtualShield folder from your repository to your Arduino library (i.e. Documents\Arduino\libraries\VirtualShield\).

### Set up your Visual Studio 2015
 1. Get the Windows 10 Technical Preview tools, including Visual Studio 2015 from [dev.windows.com](https://dev.windows.com/en-us/windows-10-developer-preview-tools).
 2. Load the Shield.sln from this repository (<repository>/Shield/Shield.sln).
 3. Ensure your phone is developer-unlocked [run the Windows Phone Developer Registration tool installed with the tools](https://msdn.microsoft.com/en-us/library/windows/apps/dn614128.aspx).
 4. Deploy to your device.
 5. Run the Virtual Shields for Arduino application.
 6. In the app settings, find your previously paired Bluetooth device and Connect.

### Test your setup
 1. From the Arduino IDE, go to the menu item File->Examples->Virtual Shields->Hello Blinky. This should load the Hello Blinky example.
 2. Before downloading, temporarily remove the Bluetooth TX and RX wires from the Arduino. (There is only one serial port shared between the USB and Bluetooth. The Bluetooth interferes with the download).
 3. Download the sketch.
 4. Replace the Bluetooth TX and RX wires into the Arduino pins. (Bluetooth TX to Arduino RX and Bluetooth RX to Arduino TX).
 5. Press the Reset button on the Arduino to restart the sketch.
 6. (You should see a message on your phone and be able to interact).

## Troubleshooting:
*	Did you build a custom sketch? Remember to include “ shield.begin() “ in your setup():

```c++
      shield.begin();      // for default 115200 baud rate
```

*	If nothing shows up, some devices require a baud of 57600, and even some at 9600. Try these in your sketch “ shield.begin(57600) “ in your setup().

```c++
      shield.begin(57600); // for 57600 baud rate
```

*	Double check that your Bluetooth’s TX pin is connected to your Arduino’s RX pin and that the Bluetooth’s RX pin is connected to your Arduino’s TX pin per this [diagram](https://learn.sparkfun.com/tutorials/using-the-bluesmirf/hardware-hookup).
*	Is there another strong broadcasting Bluetooth device around, like headphones or a Bluetooth mouse? This can interfere.

## Arduino Wiring Sketch : Hello World example

```c++

    #include <ArduinoJson.h>

    #include <VirtualShield.h>
    #include <Text.h>

    VirtualShield shield;        // identify the shield
    Text screen = Text(shield);  // connect the screen

    void setup()
    {
	    shield.begin();              // begin communication

	    screen.clear();              // clear the screen
	    screen.print("Hello Windows Virtual Shields for Arduino");
    }

    void loop()
    {
    }
```

===

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

repository: ms-iot/virtual-shields-universal

branch_name: refs/heads/develop

gha_language: C#

repo_name: ms-iot/virtual-shields-universal


text:
# MRSketch

Simple library for building multi-resolution sketches: Multi-level streaming statistics & Multi-level online machine learning

Supports arbitrary number of dimensions, levels of resolution, and node states

## Install
```
pip install mrsketch
```

## Quick Start

First, define the individual states that need to be stored at each resolution by specifying these functions to a state descriptor:

Assuming we have a dataset/stream that contains [Year, Month, Day, Value] for each record

we want to keep track of the max value at each level of resolutions (year, month, and day levels)

```python
from mrsketch import Graph, StateDescriptor

max_state = StateDescriptor(
    constructor=lambda: [0],                                   # mutable list to keep track of max
    updater=lambda x, state: state[0] = max(state[0], x[3]),   # update the max by comparing with new record's value
    merger=lambda state1, state2: [max(state1[0] + state2[0])],# the max of two max as a new state
    serializer=lambda state: repr(state[0]),                   # python's repr
    deserializer=lambda x: [eval(x)],                          # reconstruct the state from input string
    extractor=lambda x: x[0]                                   # when get(), extract the max from the list (state)
)
```

Parameters | default | description | use case
--- | --- | --- | ---
constructor | Required | function that takes no input a return a newly initialized state | Used by the Graph to initalize new nodes
updater | Required | function that takes an input record, the state of a given node, and mutate the state with the input record | Used by the graph to update and populate effected nodes upon inserting a record
merger | Required | function that two input state and combined into a __new__ state | Used by the Graph to perform graph merges and aggregated queries
serializer | Required | function that takes a state as input and return the serialization of the given state as string, serializer and deserializer must be inverse functions | Used by the Graph to perform graph serialization
deserializer | Required | function that takes a string as input and return a deserialized state from the input, serializer and deserializer must be inverse functions | Used by the Graph to perform graph deserialization
extractor | lambda state: state | optional function that defines the behavior of state extraction on graph.get() | Used as the final stage of get(), once the states of relevant nodes are merged, extractor is applied on the final merged state to support custom extraction behavior. Default function is Identity, which returns the entire state obj.

> Serializer and deserializer must be inverse functions: `deserializer(serializer(G)) == G`

Once the StateDescriptor is defined, pass it into the Graph constructor:

```python
g = Graph(
    state_descriptors={
        'max': max_state
    },
    path_extractor=lambda x: {
        'time': list(x[:3]),
    }
)
```

The path_extractor is a function that takes a record as input and returns a NDPath

In this example the path along the `time` dimension is extracted by slicing the first three items in each record

This tells the graph how the hierarchical data can be extracted from a given record

now lets push some records into the graph:
```python
g.push([2020, 10, 30, 2])
g.push([2020, 10, 31, 2])
g.push([2020, 10, 31, 5])
g.push([2020, 11, 2, 10])
```

The graph will update the state of all nodes that are impacted by the dates. To extract, specify an NDPath
```python
g.get({'time': [2020, 10, 30]}) # -> 2
g.get({'time': [2020, 10]}) # -> 5
g.get({'time': [2020]}) # -> 10
```

## Design & Documentation

__Path__: Path represents a sequence of values along a specific hierarchical tree of resolution: Jun 16th, 2017 can be encoded as [2017,6,16], where indices encodes the level of hierarchy (2017 - top/root level, 16 - lowest/leaf level), and every next index is the child of (or nested in) the previous index. Geohash 8ygzq can be encoded as [8, y, g, z, q]

__NDPath__: N-dimensional path. A mapping of dimension names to __Path__.
A __Path__ only describes the path along a single dimension, the graph supports arbitrary number of multi-resolution dimensions:
```python
g = Graph(
    state_descriptors={
        'max': max_state
    },
    path_extractor=lambda x: {
        'time': list(x[:3]),
        'geohash': list(x[3:10]) # <- add arbitrary dimensions as long as its
    }                             # hierarchy (path) can be extracted from the records
)
```

__Graph__: A Directed Acyclic Graph where node is identified by an NDPath describing its coordinates among N dimensions. The node manages arbitrary amount of states described by the graph state_descriptors. A node points to other child nodes with NDPath that overlapse with itself and extend by 1 level of resolution in any dimension. So `time=2018/1/1, geohash=abc` is a children of `time=2018/1, geohash=abc`, but not a children of `time=2019/1, geohash=abc`

__Portability__: The (de)serializer functions specified in state descriptors are intented to be used by the graph to produce a serialized byte sequence that snapshots the entire state.
The serialized bytes in the form of json or pickle can then be sent over the network and restored into memory.

__Thread safety__: Concurrent read/write are protected by read/write locks within each node. This improves concurrency by allowing writes to different region in the graph.


text:
# Play Java Hello World

This is a stripped down version of the `play-java` app https://github.com/playframework/playframework/tree/master/templates/play-java.

repository: ingojaeckel/play-java

repo_name: ingojaeckel/play-java


text:
# tlks.io : Event manager & queue system

This subproject is planed for the future 0.3.0.

You should not be working here, this is only a quick overview document
that will serve as an start-point to I+D and write a proper documentation and
specs for the project.

## Overview

This subproject will handle all pieces of work that can be decoupled from the
different applications that belongs to the front-end subproject. Will allow
to transform tlks.io into a true distributed and microservices based platform
instead of a big & complex monolithic one.

3 different components are going to be provided by its subproject:

### A global message bus

* uses the event manager and the queue system
* handles registration of all active microservices
    * only allow registered microservices to interact with the bus
    * common API for microservices
    * HTTP & REST based protocol
    * documented API specification using API BluePrint
    * unit tested spec ( not code! )
    * defensive programming approach of its development
* handles communication between all microservices
    * common API to publish messages
    * common API to subscribe messages
    * HTTP & REST based
    * publish subscribe pattern implementation ( pubsubhubbub )
    * documented API specification using API BluePrint
    * unit tested spec ( not code! )
    * defensive programming approach of its development
* JSON as a global data transport format for message payloads
* globally handle exceptions and errors on all registered microservices
    * common errors message specification/codification
    * microservices are expected to not break its execution never
* configurable logging system
    * per topic
    * per consumer
    * per producer
* message pre and post process using middleware pattern
    * compress payloads to save space/memory
    * enhance payload with producer authorization
    * message validation?

###### Ideas

* monitor / control its execution in real time (without restart)
* HTTP streaming support message handling
* authorization ( do not use passwords! Use tokens! )?
* support webhooks?
* support socket.io clients?
* support smtp clients?
* support sms clients?
* secure message communication using JSON web tokens
* distributed bus or, multiple buses on different hosts
    * replication
    * sharding

###### Questions

* Is this a server? a web application?
* data structure used to store registered microservices? FAST! SIMPLE!
* Unique id for a registered microservice?
* what is the metadata for a registered microservice?
* data structure to store the message payload request?
* shall we persist message responses?
* data structure to store the message payload response?
* common schema envelope for a message?
* common schema format for an error?
* How we log bus activity?

### A distributed event manager

* implement observer pattern on message bus data structures
* support for synchronous events
    * A triggered event must wait for a response
    * Event is completed when the response is received
    * Producer knows when the message is processed
* support for asynchronous events
    * A trigged event doesn't waits for a response
    * Producer doesn't know when the message is processed
    * A function callback is provided
* support for scheduled events
    * Event triggers on specific moments
    * Support cront-tab like definition format for date triggering
* support for topic based routing : multicast
    * Topics are collections of typed events
    * Topics are implemented using a queue system
    * Topics optionally, can be tunned to support different queue disciplines
    * Producers publish messages to topics
    * Consumers subscribe topics to receive messages
    * Producers can write to one or multiple topics
    * Consumers can subscribe to one or multiple topics

###### Ideas

* support for content based routing
    * middle-ware pattern to pre-process producer messages
    * partial/regexp/jsonpath query engine to match message payloads
    * Producers publish payloads directly without a topic name
    * Each different match query produces a new topic
    * Consumers can subscribe to this automatically topic

###### Questions

* Is this a library?
* What is an event? Do you have an example?
* How is codified an event? And its payload?
* What happens if a synchronous event fails? Message is discarded?
* Can we assure a message is processed only once? Shall we?
* Can we assure a message is processed at least once? Shall we?
* How we log event activity?
* What is event routing?
* How to check for scheduled events periodically?
* Can be producers also scheduled events?
* Can be consumers also scheduled events?
* What is a Topic?
* What is multicast?
* data structure for the collection of data types is our queue system?

### A multi-queue system

* support for first in first out discipline
* support for last in first out discipline
* support for priority discipline

###### Ideas

* Define a CRUD on steroids as a common API for the persistence API.
* common data persistence interface
    * in memory persistence driver
    * file system persistence driver
    * database persistence driver
        * Redis

###### Questions

* Which data structure is a queue?
* What is first in first out?
* What is last in first out?
* What is a priority discipline?
* Can i use more than an queue at once?
* Can different queues use different disciplines?
* How can we log queue activity?

repository: tlksio/docs

branch_name: HEAD

repo_name: tlksio/docs


text:
# Binja Sibyl

A Miasm2 + binaryninja based function divination.

## What it does

[Sybil](https://github.com/cea-sec/Sibyl) is a tool to recognize standard functions based on their side effects.
For a detailed introduction see [Sybil's README](https://github.com/cea-sec/Sibyl/blob/master/README.md).

## Screenshot

![Screenshot](https://user-images.githubusercontent.com/1985669/31853411-16df2d64-b688-11e7-91be-fc5ac8d08ab5.png)

## Options

- `Function prefix`: a prefix to prepend to the function name after it has been recognized (e.g.: `prefix_strlen`).
- `Function selector`: whether to apply the analysis to unknown functions (starting with `sub_`) or every funtion.
- `Add comment`: whether to add a comment at the top of the function. Useful to keep in mind that the function name might be wrong (Sibyl can give false positives).

## Speed

Currently, Binja Sibyl uses a single thread so, as of now, it's slower than running Sibyl manually.

## Props

Shout out to Camille MOUGEY, the author of Sibyl.
The underlying idea is pretty clever.


text:
# Changelog

## [1.3.2] - 07-19-2023
* revising camelCase of SidePanel naming for class and ID references (in HTML, in CSS, in JS),
along with all references
* replace older gulp-cssnano build process with newer postcss-based build process

## [1.3.1] - 07-15-2023
* fix a bug for when SidePanelCollapse() is called with just a string name by constructing a valid options{}
* minor simplifications

## [1.3.0] - 07-06-2023

* new dist builds for v1.3.0
* bootstrap to 4.6.2
* package updates
* minor javascript cleanup
* refine the demo site
* fix bug in sidebar layout of more advanced example page

## [1.2.0] - 01-07-2022

* package updates
* bootstrap to 4.6.1
* revision typing of multiple javascript variables
* convert some functions to arrow functions
* update year
* update readme content
* added/revised comments

## [1.1.1] - 06-04-2021
Primarily package updates

* bootstrap to 4.6.0
* package audit fix (w/o -force)

## [1.1.0] - 03-07-2020
Primarily package updates.

### Changed
* Updated browser targets
* Updated bootstrap usage to version 4.5.0.
* Updated jquery usage to version 3.5.1.
* Updated autoprefixer package
* Multiple other package updates

## [1.0.1] - 14-02-2020
### Added
* Change in SidePanelCollapse.js to reference the css variables. Prevents error when the sidepanel element is not in the page.

### Removed
* Removed popper.js from project inclusion - popup components are not used in the demo, so library isn't needed.

### Changed
* Revised message about independence of library from UX design of the SidePanel.
* Minor revisions to text content of demo pages.
* Updated the year (date) in footer.
* Updated jquery usage to version 3.4.1.
* Updated bootstrap usage to version 4.4.1.
* Updated multiple node packages.
* Rewrote the gulp webserver task to be slightly less brittle.

## [1.0.0] - 17-03-2019
### Added
* Initial release.

repository: mmilano/SidePanelCollapse

repo_name: mmilano/SidePanelCollapse


text:
heroku labs
===========

experimental features
# Commands

* [heroku labs [OPTIONS]](#labs)
* [heroku labs:disable [FEATURE] [OPTIONS]](#labsdisable)
* [heroku labs:enable FEATURE [OPTIONS]](#labsenable)
* [heroku labs:info FEATURE [OPTIONS]](#labsinfo)
## labs

list experimental features

```
USAGE
  $ heroku labs [OPTIONS]

OPTIONS
  -a, --app=app        app to run command against
  -r, --remote=remote  git remote of app to use
  --json               display as json
```

### labs:disable

disables an experimental feature

```
USAGE
  $ heroku labs:disable [FEATURE] [OPTIONS]

OPTIONS
  -a, --app     app to run command against
  -r, --remote  git remote of app to use
  --confirm
```

### labs:enable

enables an experimental feature

```
USAGE
  $ heroku labs:enable FEATURE [OPTIONS]

OPTIONS
  -a, --app=app        app to run command against
  -r, --remote=remote  git remote of app to use
```

### labs:info

show feature info

```
USAGE
  $ heroku labs:info FEATURE [OPTIONS]

OPTIONS
  -a, --app=app        app to run command against
  -r, --remote=remote  git remote of app to use
  --json               display as json
```

license: ISC

repository: jkutner/heroku-cli-clippy

repo_name: jkutner/heroku-cli-clippy


text:
---
layout: post
title: Dasper
date: 2016-05-22 00:00:00
homepage: https://github.com/ozgrozer/dasper
download: https://github.com/ozgrozer/dasper/archive/master.zip
demo: http://ozgrozer.com
author: ozgrozer
thumbnail: dasper.png
license: MIT License
license_link: https://github.com/ozgrozer/dasper/blob/master/LICENSE
---

Dasper is a [Jekyll](http://jekyllrb.com/) theme inspired by
[Ghost](https://ghost.org/)'s default theme
[Casper](https://demo.ghost.io/) and also
[Jasper](https://biomadeira.github.io/jasper/) &
[Kasper](http://rosario.io/)


text:
# A0135812L
###### \DeveloperGuide.md
``` md
## 1. Introduction
Welcome to the developer guide for SmartyDo. This guide is meant to enable budding developers like yourself to better understand the implementation of our program. Through this guide, we hope that you will be able to learn not only about how SmartyDo is implemented, but about different parts of the application that you are able to improve yourself.
```
###### \DeveloperGuide.md
``` md

## 2. Setting up

#### 2.1 Prerequisites
To ensure that you are able to run SmartyDo smoothly, do ensure that you have met the following prerequisites:

1. Installed **JDK `1.8.0_60`**  or later<br>

    > This app may not work as intended with earlier versions of Java 8. <br>
    This app will not work with earlier versions of Java.

2. Installed **Eclipse** IDE
3. Installed **e(fx)clipse** plugin for Eclipse (Follow the instructions given on
   [this page](http://www.eclipse.org/efxclipse/install.html#for-the-ambitious))
4. Installed **Buildship Gradle Integration** plugin from the Eclipse Marketplace

#### 2.2 Importing the project into Eclipse
To import the lastest version of this project into Eclipse, follow the instructions as given below:

0. Fork this repo, and clone the fork to your computer
1. Open Eclipse (Note: Ensure you have installed the **e(fx)clipse** and **buildship** plugins as given
   in the prerequisites above)
2. Click `File` > `Import`
3. Click `Gradle` > `Gradle Project` > `Next` > `Next`
4. Click `Browse`, then locate the project's directory
5. Click `Finish`

  > * If you are asked whether to 'keep' or 'overwrite' config files, choose to 'keep'.
  > * Depending on your connection speed and server load, it can even take up to 30 minutes for the set up to finish
      (This is because Gradle downloads library files from servers during the project set up process)
  > * If Eclipse auto-changed any settings files during the import process, you can discard those changes.

## 3. Design

### 3.1 Architecture
The **_Architecture Diagram_** given above will explain to you the high-level design of the App. Below, we will give you a quick overview of each component.

<img src="images/Architecture.png" width="600"><br>Figure 1. Overview of Main

`Main` has only one class called [`MainApp`](../src/main/java/seedu/address/MainApp.java). It is responsible for,
* At app launch: `Main` will initialize the components in the correct sequence, and connect them up with each other.
* At shut down: `Main` will shut down the components and invoke cleanup method where necessary.

[**`Commons`**](#36-common-classes) represents a collection of classes used by multiple other components.
Two of those classes play important roles at the architecture level.
* `EventsCentre`: This class (written using [Google's Event Bus library](https://github.com/google/guava/wiki/EventBusExplained))
  is used by components to communicate with other components using events (i.e. a form of _Event Driven_ design)
* `LogsCenter`: Used by many classes to write log messages to the App's log file.

The rest of the App consists four components.
* [**`UI`**](#ui-component): The UI of the App.
* [**`Logic`**](#logic-component): Executes commands given by the user.
* [**`Model`**](#model-component): Holds the data of the App in-memory.
* [**`Storage`**](#storage-component): Reads data from, and writes data to the hard disk.

Each of the four components will
* Define its _API_ in an `interface` with the same name as the Component.
* Expose its functionality using a `{Component Name}Manager` class.

For example, the `Logic` component (see the class diagram given below) defines it's API in the `Logic.java`
interface and exposes its functionality using the `LogicManager.java` class.<br>
<img src="images/LogicClassDiagram.png" width="800"><br>Figure 2. Overview of Logic<br>

The _Sequence Diagram_ below will show you how the components interact for the scenario where the user issues the
command `delete 3`.

<img src="images\SDforDeletePerson.png" width="800"><br>Figure 3. Sequence Diagram: Delete 1<br>

>Note how the `Model` simply raises a `ToDoChangedEvent` when the To-Do data are changed,
 instead of asking the `Storage` to save the updates to the hard disk.

The diagram below will show you how the `EventsCenter` reacts to that event, which eventually results in the updates
being saved to the hard disk and the status bar of the UI being updated to reflect the 'Last Updated' time. <br>
<img src="images\SDforDeletePersonEventHandling.png" width="800"><br>Figure 4. Sequence Diagram: ToDoEventChange<br>

> Note how the event is propagated through the `EventsCenter` to the `Storage` and `UI` without `Model` having
  to be coupled to either of them. This is an example of how this Event Driven approach helps us reduce direct
  coupling between components.

The follwing sections will give you more details about each component.

### 3.2 UI component

The UI consists of a `MainWindow` that is made up of parts e.g.`CommandBox`, `ResultDisplay`, `TaskListPanel`,
`StatusBarFooter`, `BrowserPanel` etc. All these, including the `MainWindow`, inherit from the abstract `UiPart` class
and they can be loaded using the `UiPartLoader`.

<img src="images/UiClassDiagram.png" width="800"><br>Figure 5. Overview of UI<br>

**API** : [`Ui.java`](../src/main/java/seedu/address/ui/Ui.java)

The `UI` component uses JavaFx UI framework. The layout of these UI parts are defined in matching `.fxml` files
 that are in the `src/main/resources/view` folder.<br>
 For example, the layout of the [`MainWindow`](../src/main/java/seedu/address/ui/MainWindow.java) is specified in
 [`MainWindow.fxml`](../src/main/resources/view/MainWindow.fxml)

The `UI` component will
* Execute user commands using the `Logic` component.
* Bind itself to some data in the `Model` so that the UI can auto-update when data in the `Model` change.
* Respond to events raised from various parts of the App and updates the UI accordingly.

### 3.3 Logic component
Logic is in charge of reading user input and executing the correct commands. It is also in charge of give the user feedback on their input.

<img src="images/LogicClassDiagram.png" width="800"><br>Figure 6. Overview of Logic <br>

**API** : [`Logic.java`](../src/main/java/seedu/address/logic/Logic.java)

1. `Logic` uses the `Parser` class to parse the user command.
2. This results in a `Command` object which is executed by the `LogicManager`.
3. The command execution can affect the `Model` (e.g. adding a task) and/or raise events.
4. The result of the command execution is encapsulated as a `CommandResult` object which is passed back to the `Ui`.
5. `Logic` loads the `undo/redo Manager` which is initially an empty stack. If the command that is recently executed successfully belongs to a undoable command, the undo/redo manager will record it.

Below, you will find the Sequence Diagram for interactions within the `Logic` component for the `execute("delete 1")`
 API call.<br>
<img src="images/DeletePersonSdForLogic.png" width="800"><br>Figure 7. Sequence Diagram: Delete in Logic<br>

### 3.4 Model component
Model is in charge of the structure of the to-do list, and serves as the manager of the abstraction layer between Logic and the actual list of tasks.

<img src="images/ModelClassDiagram.png" width="800"><br>Figure 8. Overview of Model<br>

**API** : [`Model.java`](../src/main/java/seedu/address/model/Model.java)

The `Model`,
* stores a `UserPref` object that represents the user's preferences.
* stores the To-Do data.
* exposes a `UnmodifiableObservableList<ReadOnlyTask>` that can be 'observed' e.g. the UI can be bound to this list
  so that the UI automatically updates when the data in the list change.
* does not depend on any of the other three components.

### 3.5 Storage component
Storage is in charge of saving and retrieving data from files stored on the user’s device.

<img src="images/StorageClassDiagram.png" width="800"><br>Figure 9. Overview of Storage<br>

**API** : [`Storage.java`](../src/main/java/seedu/address/storage/Storage.java)

The `Storage` component,
* can save `UserPref` objects in json format and read it back.
* can save the SmartyDo data in xml format and read it back.

### 3.6 Common classes

You may find classes used by multiple components are in the `seedu.addressbook.commons` package.

## 4. Implementation

### 4.1 Logging

We are using `java.util.logging` package for logging. You can use `LogsCenter` class to manage the logging levels
and logging destinations.

* You can control the logging level by using the `logLevel` setting in the configuration file
  (See [Configuration](#configuration))
* You can obtain the `Logger` for a class by using `LogsCenter.getLogger(Class)` which will log messages according to
  the specified logging level
* Currently log messages are output through: `Console` and to a `.log` file.

**Logging Levels**
|Level|Details|
|---|---|
| `SEVERE` | Critical problem detected which may possibly cause the termination of the application.
| `WARNING` | Can continue, but with caution.
| `INFO` | Information showing the noteworthy actions by the App.
| `FINE` | Details that are not usually noteworthy but may be useful in debugging e.g. printout of the actual list instead of just its size

### 4.2 Configuration

You can control certain properties of the application (e.g App name, logging level) through the configuration file
(default: `config.json`):

## 5. Testing

You can find tests in the `./src/test/java` folder.

**In Eclipse**:
> If you are not using a recent Eclipse version (i.e. _Neon_ or later), you will need to enable assertions in JUnit tests
  as described [here](http://stackoverflow.com/questions/2522897/eclipse-junit-ea-vm-option).

* You can run all tests by right-clicking on the `src/test/java` folder and choose
  `Run as` > `JUnit Test`
* You can also run a subset of tests by right-clicking on a test package, test class, or a test and choose
  to run as a JUnit test.

**Using Gradle**:
* You may refer to [UsingGradle.md](UsingGradle.md) to see how to run tests using Gradle.

We have two types of tests:

1. **GUI Tests** - These are _System Tests_ that test the entire App by simulating user actions on the GUI.
   These are in the `guitests` package.

2. **Non-GUI Tests** - These are tests not involving the GUI. They include,
   1. _Unit tests_ targeting the lowest level methods/classes. <br>
      e.g. `seedu.address.commons.UrlUtilTest`
   2. _Integration tests_ that are checking the integration of multiple code units
     (those code units are assumed to be working).<br>
      e.g. `seedu.address.storage.StorageManagerTest`
   3. _Hybrids of unit and integration tests._ These test are checking multiple code units as well as
      how they are connected together.<br>
      e.g. `seedu.address.logic.LogicManagerTest`

**Headless GUI Testing** :
Thanks to the [TestFX](https://github.com/TestFX/TestFX) library we use,
 our GUI tests can be run in the _headless_ mode.
 In the headless mode, GUI tests do not show up on the screen.
 That means the developer can do other things on the Computer while the tests are running.<br>
 See [UsingGradle.md](UsingGradle.md#running-tests) to learn how to run tests in headless mode.

## 6. Dev Ops

### 6.1 Build Automation

You may read [UsingGradle.md](UsingGradle.md) to learn how to use Gradle for build automation.

### 6.2 Continuous Integration

We use [Travis CI](https://travis-ci.org/) to perform _Continuous Integration_ on our projects.
You may read [UsingTravis.md](UsingTravis.md) for more details.

### 6.3 Making a Release

Here are the steps to create a new release.

 1. Generate a JAR file [using Gradle](UsingGradle.md#creating-the-jar-file).
 2. Tag the repo with the version number. e.g. `v0.1`
 2. [Create a new release using GitHub](https://help.github.com/articles/creating-releases/)
    and upload the JAR file your created.

### 6.4 Managing Dependencies

A project often depends on third-party libraries. For example, SmartyDo depends on the
[Jackson library](http://wiki.fasterxml.com/JacksonHome) for XML parsing. Managing these _dependencies_
can be automated using Gradle. For example, Gradle can download the dependencies automatically, which
is better than these alternatives.<br>
a. Include those libraries in the repo (this bloats the repo size)<br>
b. Require developers to download those libraries manually (this creates extra work for developers)<br>

## 7. Appendix
```
###### \DeveloperGuide.md
``` md
## 7.3 Appendix C : Non Functional Requirements

1. Should work on any [mainstream OS](#mainstream-os) as long as it has Java `1.8.0_60` or higher installed.
2. Should be able to hold up to 2 years of entries estimated to be 8000 entries.
3. Should come with automated unit tests and open source code.
4. Should favor DOS style commands over Unix-style commands.

```
###### \UserGuide.md
``` md
## 1. Introduction
SmartyDo is a **to-do-list** application. With SmartyDo, forgetting upcoming deadlines and sleepless nights over incomplete tasks are a thing of the past. SmartyDo **increases your efficiency** by showing the lists of tasks that can be completed simultaneously. Treat SmartyDo like your personal assistant and just focus on **completing your tasks**!

## 2. Quick Start
**Launch SmartyDo**: Simply double-click on the `SmartyDo.jar` file to start SmartyDo. You will be greeted with a simple interface that has three components: a **Visual Box**, a **Message Box** and a **Command Bar**.

<img src="images/mainScreen.png" width="250"><br>Figure 1. Welcome Screen<br>

**Command Bar** is where you enter short commands to tell SmartyDo what to do.<br>
**Visual Box** is where you can see a comprehensive list of your tasks.<br>
**Message Box** shows the result of your command.<br>
```
###### \UserGuide.md
``` md
### 3.4. **Adding Tasks Into SmartyDo**

You can add a task into SmartyDo by using the add command. There are number of parameters that you can use to add more details to the task. Below is a summary of the various parameters and their usage:<br>

Here is the summary of the parameters and their usage:

| Parameter     |     Flag     |   Format Requirements    | Optional |
| ------------- |:-------------:| -----:|:---:|
| `TASK_NAME`   |     | _**n;**_ required if `TASK_NAME` is not the first parameter | No |
| `DATE_TIME` |    **t;**  | [Date] [Start_Time] [End_Time] , delimited by spaces    | Yes |
| `TAG`         | _**t/**_ | alphanumeric | Yes |
| `LOCATION` | _**a;**_ |  alphanumeric  | Yes |
| `DESCRIPTION` | _**d;**_ | alphanumeric | Yes |
Table 3.2. Add Command Parameters

- `TASK_NAME` is the name of the task and this parameter is compulsary.
- `Date` is the date of the task supports date format of
dd/mmm/yyyy eg:20-Jan-2017 and dd/mm/yyyy with `/` interchangleable with `.` and `-` eg: 20-01-2017.
- `START_TIME` and `END_TIME` is the starting time and ending time of the task respectively. You may consider to use these parameters when starting time and/or deadline is known. You may omit the details of 'DATE_TIME' which will result in a task that has no time frame.
- `TAG` is the characteristic you can add to the task. Such tags can be "Urgent", "HighPriority" and etc.
- `LOCATION` is the place of task being done. You can use this parameter to remind you where to go to complete the task.
- 'DESCRIPTION' is where you can include some extra information about your task.

Format : `add TASK_NAME [t; DATE START_TIME] [a;LOCATION] [t/TAG] [d;`

> You don't have to enter the optional parameters when you don't need them. The order of the parameters are not fixed. You can enter the parameters in any order. For example, `add t/[TAG] t; DATE START_TIME ` is also correct format.

**Example:**<br>
Let's say you want to add task named "Presentation" which is scheduled for 18 July 2016, 9:00AM. All you need to do is enter the following as shown below.

<img src="images/addCommand.png" width="250" align="middle"><br>Figure 5. Example of add command<br>

After entering the command, MessageBox will show you task is successfully added into SmartyDo and you will see the updated list of task in the Visual Box.
```
###### \UserGuide.md
``` md
### 3.13. **Clearing Saved Data**
You may clear all data stored in SmartyDo by using the `clear` command. SmartyDo will prompt you to confirm this action. Enter `yes` to complete the command. Entering a different command will cancel the `clear` command.

Format: `clear`

**Example**<br>
If you wish to clear all data in SmartyDo, you many enter `clear` into the CommandBox.

<img src="images/clearConfirmCommand.png" width="500" align="middle"><br>Figure 14. Example of locate command<br>

After entering the command, a prompt will appear in the MessageBox asking you to confirm this action. Enter `yes` to proceed.

### 3.14. **Exiting SmartyDo**

After using SmartyDo, you can exit the program by using `exit` command.

Format: `exit`

By entering `exit` command in the command box, SmartyDo will quit and save the data.

## 4. Smart Features

### 4.1. **FlexiCommand**
It is okay if you cannot remember the syntax entirely! As long as you remember the keyword some reshuffling of the parameters entered is fine. Our program will ask you for confirmation if we are unsure what you want.

### 4.2. **Saving the Data**
SmartyDo will automatically save your data in the hard disk after any command that changes the data. There is no need to save manually.

```

gha_language: Java


text:
# JS

This folder will store all the javascript files that are specific to the project.
Here's some rules to follow in order to all work the same way across projects.

1. Only specific project files
   - If a part of the code can be used in multiple projects, think about making a sharable package
2. Stick to standards
   - **Avoid using coffeescript**, unless necessary
   - Use **Yarn/NPM** as package manager
   - Use `import` syntax to include packages
   - Process your files to **ES5** spec in `dist` folder
   - Use **webpack** when needed to package your codebase
3. Syntax
   - Use **meaningful variables names**
   - Prefer understandable statements over too complex ones just to prove your IQ
4. Document your code!
   - Use the docblock syntax to document your code
5.
   - Stick to standards is a good way to start...

repository: jd-buzz/coffeekraken

repo_name: jd-buzz/coffeekraken


text:
---
layout: docs
title: "The Opal Compiler"
---

{{ page.title }}
================

The compiler included in opal is a source-to-source compiler: it takes
ruby code and output javascript code. All code generated depends on the
bundled runtime - not just for the core library, but also some runtime
functions included in the core runtime files. This is not a VM, but just
assistant methods to define classes etc.

Opal also generates code which maintains line numbers for all statements
and expressions. This makes it really easy to debug through the
generated javascript. Also, advanced debuggers will use these line
numbers in stack traces etc to make things extra eash.

The generated code
------------------

The opal compiler generates a function which takes three args - the
opal runtime, the `self` value for the generated code (which will almost
always be "top self"), and the filename the generated code should use.
These three arguments are filled in by the runtime when the code is
about to be run (in the browser or using therubyracer on the command
line).

### Example of a compiled file

The given ruby code:

{% highlight ruby %}
puts 1, 2, 3
{% endhighlight %}

Will compile into (something like) the following javascript:

{% highlight javascript %}
// $rb = opal runtime
// self = self value
// __FILE__ = current filename
function($rb, self, __FILE__) {
  // actual file implementation
  function $$() {
    return self.m$puts(1, 2, 3);
  }

  var nil = $rb.Qnil, $class = $rb.dc, $defn = $rb.dm;
  return $$();
}
{% endhighlight %}

The outermost function is the one previously mentioned - opal simple,
when required, will pass the relevant args to this function to execute.
The inner function `$$` is the body of the file. This is where all the
code actually goes. It is wrapped so that is can be called after all the
variables below it can be initialized. The variables are not defined
first as it will add a lot of line noise which makes it hard to debug.

Below the function we define the variables needed for the file - these
are all taken from the runtime and include `nil`, `$class` for defining
classes and `$defn` for defining methods. There are a few more but they
are ommitted to keep the example simple.

The final line `return $$()` simply runs the body and returns the value.
This value is mostly ignored, but it is useful for REPLs (for instance).

Compiling object literals
-------------------------

### self

In the generated code, the `self` variable is always generated as just
that - self. This is defined by the given value in the outer-most
function above. When entering into a class definition, method body or
block body, the value of self is redefined. See the relevant section
below for more. Note: self always compiles to the "self" variable.

### nil

`nil` in opal is a true ruby object and does not simply fall back to
`null` or `undefined`. This allows it to respond to messages just like
in ruby. Nil always compiles to the nil variable which is also defined
within the top level function.

### true and false

In Opal the `Boolean` class is used instead of seperate `TrueClass` and
`FalseClass` allowing native javascript `true` and `false` values to be
used.

### Numbers

In Opal the only numerical class is `Numeric` which represents both
integers and floats. This is a result of only a single numeric type in
javascript, so keeping to a single class for numbers improves
efficiency. Numbers in opal compile directly into number literals in
javascript.

### Strings

Strings in opal compile directly into javascript string literals.
Because of this all strings in opal are immutable, so some mutating
string methods are ommitted from opal.

### Symbols

The symbol syntax in opal is maintained, but there is no symbol class.
Symbols compile directly into string literals as their speed benefit is
lost in javascript and they would actually make the runtime slower.

### Arrays

Opal arrays also compile directly into javascript array literals. This
feature is very useful when dealing with splat method calls and splat
arguments in blocks and method definitions.

### Hash

Hash literals compile into a function call that returns a new hash
instance. Hashes in opal are true ruby objects so the allocator method
adds each key/value pair into its internals. This compiles as follows:

{% highlight javascript %}
$hash("key1", "value1", "key2", "value2")
{% endhighlight %}

where `$hash` is defined in the outer function as a property retrieved
from the runtime.

Compiling Ruby methods
----------------------

Opal makes use of prototypes for inheriting and method storage. When a
method is defined on a receiver, it has a 'm$' prefix - this stops ruby
methods conflicting with native functions and properties on a receiver
(like arrays for instance which are just native js arrays). Opal
maintains method names, evern for methods which are invalid as
javascript identifiers, so some method names need to be wrapped inside a
property accessor.

### Method calls

The following three ruby calls:

{% highlight ruby %}
do_something 1, 2, 3
self.length
self.title = "adam"
self.loaded?
{% endhighlight %}

compile into the following javascript:

{% highlight javascript %}
self.m$do_something(1, 2, 3)
self.m$length()
self['m$title=']("adam")
self['m$loaded?']()
{% endhighlight %}

Splat method call are also fully supported, and compile the following
ruby:

{% highlight ruby %}
puts *[1, 2, 3]
{% endhighlight %}

into the somewhat ugly:

{% highlight javascript %}
self.m$puts.apply(self, [1, 2, 3])
{% endhighlight %}

#### Blocks

Blocks are not regular method arguments in ruby, so they are not treated
as so in opal. To send a method a block, there is a special '$B'
variable on the runtime that holds the current block function and proc.
The block function is the literal function (method) that the block is
sent to. Before calling a method, the function is noted. The proc is the
actual block implementation which is just a regular function.

For example, the ruby call:

{% highlight ruby %}
self.method do
  nil
end
{% endhighlight %}

is compiled into (something like) the following:

{% highlight javascript %}
($B.p = function() { return nil; }, // the proc
 $B.f = self.m$method               // the method/function receiver
).call()                            // call the method
{% endhighlight %}

The receiver method is responsible for looking up the block to see if
one was sent to it.

The process is similar for `&block` args in the method parameter list.

### Method definitions

Ruby methods are implemented as regular javascript functions. The
runtime offers two functions to define a method: `dm` for defining a
regular method and `ds` to define a singleton method which automatically
creates a singleton class as needed (if needed).

A very simple ruby method:

{% highlight ruby %}
def to_s
  "main"
end
{% endhighlight %}

is compiled into the following javascript:

{% highlight javascript %}
$defn(self, 'to_s', function() { var self = this;
  return "main";
});
{% endhighlight %}

`$defn` is a local variable, set in the outer function, that points to
`dm`. There is also `$defs` used for defining the singletons. The first
argument is the receiver, which is always self for normal methods, or
will be the receiver for singleton methods. The second arg is the method
name, and the third is the implementation.

It is also obvious that `self` here is set to `this`, which is the
object receiver. The singleton version of this function would be
identical except for the receiver.

#### Handling blocks

A method is said to handle a block if it either calls `yield` in its body,
uses `block\_given?` or defines a block as its last argument, with `&`.
If a method handles a block it will always check the previously
mentioned runtime property to see if the block function is the callee.
If it is, the method gets the block and sets both properties to nil. It
must set both properties to nil to avoid the next call to the method
from receiving the block as a false posotive. The block is then just a
native function, so is called as appropriate.

Compiling class and module definitions
--------------------------------------

repository: avioli/opal

repo_name: avioli/opal


text:
---
date: 2015-01-21T20:35:00Z
description: "Hugo 0.12 focused on polishing the theme engine and adding critical functionality to the templates."
title: "Hugo 0.12"
categories: ["Releases"]
---

A lot has happened since Hugo v0.11.0 was released. Most of the work has been
focused on polishing the theme engine and adding critical functionality to the
templates.

This release represents over 90 code commits from 28 different contributors.

- 10 [new themes](https://github.com/spf13/hugoThemes) created by the community
- fully themable [partials](/templates/partials/)
- [404 template](/templates/404/) support in themes
- [shortcode](/content-management/shortcodes/) support in themes
- [views](/templates/views/) support in themes
- inner [shortcode](/content-management/shortcodes) content now treated as markdown
- support for header ids in markdown (# header {#myid})
- [where](/functions/where/) template function to filter lists of content, taxonomies, etc.
- [groupby](/templates/lists#by-page-field) & [groupbydate](/templates/lists/#by-date-1) methods to group pages
- taxonomy [pages list](/templates/taxonomy-templates#taxonomy-methods) now sortable, filterable, limitable & groupable
- general cleanup to taxonomies & documentation to make it more clear and consistent
- [showcase](/showcase/) returned and has been expanded
- pretty links now always have trailing slashes
- [baseurl](/getting-started/configuration#baseurl) can now include a subdirectory
- better feedback about draft & future post rendering
- a variety of improvements to [the website](/)

repository: bep/hugo

gha_language: Go

repo_name: bep/hugo


text:
---
layout: default
---

# 1996-07-31 - Re: VISA Travel Money

## Header Data

From<EMAIL_ADDRESS>(Mike Duvos)

To<EMAIL_ADDRESS>Message Hash: f9e8caa9b3eae46e672f812e4f77df727e03de9a88f0672de94b9d8d2beb3130

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-07-31 01:28:25 UTC

Raw Date: Wed, 31 Jul 1996 09:28:25 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Mike Duvos)
Date: Wed, 31 Jul 1996 09:28:25 +0800
To<EMAIL_ADDRESS>Subject: Re: VISA Travel Money
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Jim Bell writes:

> Even if not, chances are good that "all" of the transactions can
> be linked together, even if they can't be directly linked to an
> identifiable person.  Doesn't sound too promising.

I think it will be a popular product.  Sort of the credit card
equivalent of the disposable phone card.

Since the transactions all involve the extraction of money, there
is really no record of your purchases.  The linking together of a
number of cash wishdrawals is not that big a deal, although they
could be used to track your movements if you did them in more than
one specific location.

There is also the problem of being photographed every time you use
an ATM, if you do not wish your identity known.

Still, for people who are not on the FBI's most wanted list, who
plan to completely exhaust the card in a single location, and who
dislike signing a huge bunch of Traveler's Checks at one time to
buy something, it sounds like something that might be handy to have.

--
     Mike Duvos         $    PGP 2.6 Public Key available     $
<EMAIL_ADDRESS>   $    via Finger.                      $

{% endraw %}
```

## Thread

+ Return to [July 1996](/archive/1996/07)

+ Return to "[jim bell <jimbell@pacifier.com>](/authors/jim_bell_jimbell_at_pacifier_com_)"
+ Return to<EMAIL_ADDRESS>(Mike Duvos)](/authors/mpd_at_netcom_com_mike_duvos_)"
+ Return to "[Sandy Sandfort <sandfort@crl.com>](/authors/sandy_sandfort_sandfort_at_crl_com_)"
+ Return to "[snow <snow@smoke.suba.com>](/authors/snow_snow_at_smoke_suba_com_)"

+ 1996-07-31 (Wed, 31 Jul 1996 08:57:10 +0800) - [Re: VISA Travel Money](/archive/1996/07/978872043a792eceb75b303cb9a65e9b1b76f369224addb29ef27699b9f37031) - _jim bell<EMAIL_ADDRESS>  + 1996-07-31 (Wed, 31 Jul 1996 09:28:25 +0800) - Re: VISA Travel Money -<EMAIL_ADDRESS>(Mike Duvos)_
  + 1996-07-31 (Wed, 31 Jul 1996 10:04:25 +0800) - [Re: VISA Travel Money](/archive/1996/07/0eb135d43e02c3cf004a67568d541fa1d57e4e22dd7f509d0ddef5296ccb67ae) - _Sandy Sandfort<EMAIL_ADDRESS>    + 1996-07-31 (Wed, 31 Jul 1996 14:02:54 +0800) - [Re: VISA Travel Money](/archive/1996/07/12437da52459f8e420a1f8f3ebc6f5b79834090354e48254b81c03a1d4d84377) - _snow<EMAIL_ADDRESS>      + 1996-07-31 (Wed, 31 Jul 1996 15:10:44 +0800) - [Re: VISA Travel Money](/archive/1996/07/c9826e295230708c4cc960f8e1897aa946434ec23a0b588d67d17a6dfab5e626) -<EMAIL_ADDRESS>(Mike Duvos)_


text:
---
layout: post
title: How much does your privacy cost?
categories:
- blog
---

# How much does your privacy cost?

For most crypto users (especially, the “not so careful” once), the cost of their privacy would usually cost the price of an airdrop they collect.

How so?

Well, let's put it this way: when an airdrop is announced, most users will collect all utxo's into one single tx and then share that key with the related airdrop address. By hence, basically revealing to both chains your tx history.

If by a chance, one of those addresses was also involved in a KYC procedure (say an exchange address), then it gets even easier for anyone to know who you are.

So, what is the cost of your privacy?
Is it your identity?
Can you do anything?

Well, for a starter, use different emails and IP addresses. Use mixers that cannot associate you and your ID. Don't do the obvious (described above). Do not collect airdrops that aren't worth it. Do not use addresses that have passed KYC \ AML procedures.

Saying that anyone who really wants to follow your tx logistics, will be pretty much able do, even you are careful, after an airdrop claim.

gha_language: CSS


text:
# [F18] Operating Systems

*Innopolis University, 2018*

*Operating Systems, 2nd Year, Fall Semester*

*Author: **Gleb Petrakov***

---

This repository is dedicated to the Operating Systems course labs assignments.

Repository is structured with respect to weeks, on which tasks were assigned.


text:
SublimeLinter-contrib-PSScriptAnalyzer
======================================

[![Build Status](https://travis-ci.org/SublimeLinter/SublimeLinter-contrib-PSScriptAnalyzer.svg?branch=master)](https://travis-ci.org/SublimeLinter/SublimeLinter-contrib-PSScriptAnalyzer)

This linter plugin for [SublimeLinter](https://github.com/SublimeLinter/SublimeLinter) provides an interface to [PowerShell](https://github.com/PowerShell/PowerShell)'s [__PSScriptAnalyzer__](https://github.com/PowerShell/PSScriptAnalyzer) module. It will be used with files that have the “__PowerShell__” syntax.

## Installation

SublimeLinter must be installed in order to use this plugin.

Please use [Package Control](https://packagecontrol.io) to install the linter plugin.

Before installing this plugin, you must ensure that:

 - `pwsh` is installed on your system ([PowerShell Core](https://github.com/PowerShell/PowerShell)).
 - Module [PSScriptAnalyzer](https://github.com/PowerShell/PSScriptAnalyzer) is installed. If not, install it from PowerShell:

```powershell
Install-Module -Name PSScriptAnalyzer
```

In order for `pwsh` to be executed by SublimeLinter, you must ensure that its path is available to SublimeLinter. The docs cover [troubleshooting PATH configuration](http://sublimelinter.readthedocs.io/en/latest/troubleshooting.html#finding-a-linter-executable).

## PSScriptAnalyzer settings

If a file named `PSScriptAnalyzerSettings.psd1` exists in the user's home directory it's used as PSScriptAnalyzer's settings file when calling `Invoke-ScriptAnalyzer` cmdlet. Please refer to [PSScriptAnalyzer](https://github.com/PowerShell/PSScriptAnalyzer#explicit) for details.

Example content of a settings file:

```powershell
@{
    # Select which diagnostic records to show.
    # Valid values are: ParseError, Error, Warning, Information
    Severity = @('ParseError', 'Error', 'Warning')

    ExcludeRules = @(
        'PSUseApprovedVerbs'
    )

    IncludeDefaultRules = $true
}
```

Path/name of the PSScriptAnalyzer's settings can be customized:

```
"linters": {
    ...
    "psscriptanalyzer": {
        // full path
        "settings": "D:\\Scripts\\CustomSettings.psd1"
        // environment variables will be expanded
        "settings": "%SCRIPTS_DIR%\\CustomSettings.psd1"
        // or built-in preset name (beware that linting fails if the name is not a valid preset name)
        "settings": "PSGallery"
        // default - remove or set to null
        "settings": null
    }
```

## General Settings

- SublimeLinter settings: http://sublimelinter.readthedocs.org/en/latest/settings.html
- Linter settings: http://sublimelinter.readthedocs.org/en/latest/linter_settings.html

## TODO

 - Handle the case when a given preset name is not a valid PSScriptAnalyzer preset. Now it just fails to lint.


text:
%{
  version: "1.2.1",
  title: "Testing",
  excerpt: """
  Testing is an important part of developing software.
  In this lesson we'll look at how to test our Elixir code with ExUnit and some best practices for doing so.
  """
}
---

## ExUnit

Elixir's built-in test framework is ExUnit and it includes everything we need to thoroughly test our code.
Before moving on it is important to note that tests are implemented as Elixir scripts so we need to use the `.exs` file extension.
Before we can run our tests we need to start ExUnit with `ExUnit.start()`, this is most commonly done in `test/test_helper.exs`.

When we generated our example project in the previous lesson, mix was helpful enough to create a simple test for us, we can find it at `test/example_test.exs`:

```elixir
defmodule ExampleTest do
  use ExUnit.Case
  doctest Example

  test "greets the world" do
    assert Example.hello() == :world
  end
end
```

We can run our project's tests with `mix test`.
If we do that now we should see an output similar to:

```shell
..

Finished in 0.03 seconds
2 tests, 0 failures
```

Why are there two dots in the test output? Besides the test in `test/example_test.exs`, Mix also generated a doctest in `lib/example.ex`.

```elixir
defmodule Example do
  @moduledoc """
  Documentation for Example.
  """

  @doc """
  Hello world.

  ## Examples

      iex> Example.hello
      :world

  """
  def hello do
    :world
  end
end
```

### assert

If you've written tests before then you're familiar with `assert`; in some frameworks `should` or `expect` fill the role of `assert`.

We use the `assert` macro to test that the expression is true.
In the event that it is not, an error will be raised and our tests will fail.
To test a failure let's change our sample and then run `mix test`:

```elixir
defmodule ExampleTest do
  use ExUnit.Case
  doctest Example

  test "greets the world" do
    assert Example.hello() == :word
  end
end
```

Now we should see a different kind of output:

```shell
  1) test greets the world (ExampleTest)
     test/example_test.exs:5
     Assertion with == failed
     code:  assert Example.hello() == :word
     left:  :world
     right: :word
     stacktrace:
       test/example_test.exs:6 (test)

.

Finished in 0.03 seconds
2 tests, 1 failures
```

ExUnit will tell us exactly where our failed assertions are, what the expected value was, and what the actual value was.

### refute

`refute` is to `assert` as `unless` is to `if`.
Use `refute` when you want to ensure a statement is always false.

### assert_raise

Sometimes it may be necessary to assert that an error has been raised.
We can do this with `assert_raise`.
We'll see an example of `assert_raise` in the lesson on Plug.

### assert_receive

In Elixir, applications consist of actors/processes that send messages to each other, therefore you will want to test the messages being sent.
Since ExUnit runs in its own process it can receive messages just like any other process and you can assert on it with the `assert_received` macro:

```elixir
defmodule SendingProcess do
  def run(pid) do
    send(pid, :ping)
  end
end

defmodule TestReceive do
  use ExUnit.Case

  test "receives ping" do
    SendingProcess.run(self())
    assert_received :ping
  end
end
```

`assert_received` does not wait for messages, with `assert_receive` you can specify a timeout.

### capture_io and capture_log

Capturing an application's output is possible with `ExUnit.CaptureIO` without changing the original application.
Simply pass the function generating the output in:

```elixir
defmodule OutputTest do
  use ExUnit.Case
  import ExUnit.CaptureIO

  test "outputs Hello World" do
    assert capture_io(fn -> IO.puts("Hello World") end) == "Hello World\n"
  end
end
```

`ExUnit.CaptureLog` is the equivalent for capturing output to `Logger`.

## Test Setup

In some instances it may be necessary to perform setup before our tests.
To accomplish this we can use the `setup` and `setup_all` macros.
`setup` will be run before each test and `setup_all` once before the suite.
It is expected that they will return a tuple of `{:ok, state}`, the state will be available to our tests.

For the sake of example, we'll change our code to use `setup_all`:

```elixir
defmodule ExampleTest do
  use ExUnit.Case
  doctest Example

  setup_all do
    {:ok, recipient: :world}
  end

  test "greets", state do
    assert Example.hello() == state[:recipient]
  end
end
```

## Test Mocks

We want to be careful of how we think about “mocking”. When we mock certain interactions by creating unique function stubs in a given test example, we establish a dangerous pattern. We couple the run of our tests to the behavior of a particular dependency, like an API client. We avoid defining shared behavior among our stubbed functions. We make it harder to iterate on our tests.

Instead, the Elixir community encourages us to change the way we think about test mocks; that we think about a mock as a noun, instead of a verb.

For a longer discussion on this topic, see this [excellent article](http://blog.plataformatec.com.br/2015/10/mocks-and-explicit-contracts/).

The gist is, that instead of mocking away dependencies for testing (mock as a *verb*), it has many advantages to explicitly define interfaces (behaviors) for code outside your application and use mock (as a *noun*) implementations in your code for testing.

To leverage this "mocks-as-a-noun" pattern you can:

* Define a behaviour that is implemented both by the entity for which you'd like to define a mock *and* the module that will act as the mock.
* Define the mock module
* Configure your application code to use the mock in the given test or test environment, for example by passing the mock module into a function call as an argument or by configuring your application to use the mock module in the test environment.

For a deeper dive into test mocks in Elixir, and a look at the Mox library that allows you to define concurrent mock, check out our lesson on Mox [here](/en/lessons/testing/mox)

repository: elixirschool/elixirschool

repo_name: elixirschool/elixirschool


text:
# react-native-use-input-scroll-handler

<img src="https://user-images.githubusercontent.com/3551795/118034222-bc615280-b337-11eb-944e-6dc0a3631176.gif" width="200">

A react-native hook that handle auto-scroll when input is focused and behind keyboard.

## Installation

```sh
yarn add react-native-use-input-scroll-handler
```

## Usage

```js
import useInputScrollHandler from "react-native-use-input-scroll-handler";

// ...

const { scrollHandler } = useInputScrollHandler();

<ScrollView {...scrollHandler}>
```

## API

Custom options can be passed to this hook.

| **Option**                  | **Type**                         | **Description**                                                                                |
| --------------------------- | -------------------------------- | ---------------------------------------------------------------------------------------------- |
| `ref`                       | `MutableRefObject`               | Use this if you need to use your own scroll view ref.                                          |
| `extraScrollHeight`         | `number`                         | Adds an extra offset to the keyboard. Useful if you want to stick elements above the keyboard. |
| `keyboardOpeningTime`       | `number`                         | Sets the delay time before scrolling to new position, default is 250                           |

## Contributing

See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.

## License

MIT

repository: magrinj/use-input-scroll-handler

repo_name: magrinj/use-input-scroll-handler


text:
---
title: Flower pot house
tags: terrain
date: 2022-04-01
layout: post
---

![image-20220402000949705](image-20220402000949705.png)

![image-20220402002047762](image-20220402002047762.png)

I pimped an old metal flower pot into a nice little house.

![image-20220402001026817](image-20220402001026817.png)

I started by gluing some cardboard around the flower pot, because it wasn't all straight from top to bottom.

![image-20220402001103233](image-20220402001103233.png)

As you can see, the top is larger than the base, so the cardboard helps in getting straight(er) walls.

![image-20220402001132721](image-20220402001132721.png)

I then covered the cardboard with hardened black tape, to add an additional layer of stiffness, but also to protect the cardboard. I'm going to use a lot of glue, paint and water and I didn't want my "walls" to disintegrate.

![image-20220402001235992](image-20220402001235992.png)

I then glued it on a piece of cardboard, and glued foam bricks all around it. The door is made of ice cream sticks, and the handle is a small jewelry bead.

![image-20220402001322352](image-20220402001322352.png)

For the window I used golden paper and plastic mesh.

![image-20220402001342761](image-20220402001342761.png)

I also added some small Lego windows.

![image-20220402001356327](image-20220402001356327.png)

I then added some filling paste in the space between the bricks.

![image-20220402001454855](image-20220402001454855.png)

I did it by adding the paste on roughly 20% of the wall, then spreading it as much as I could over the holes. Using a wet brush, I would spread it even further, to cover any gap. Finally, I would use paper towels to wipe the excess off, so the paste only stays in the gaps, and does not cover the brick faces.

![image-20220402001644012](image-20220402001644012.png)

Doing it all over the house is long, but it looks so much better once painted compared to just glued bricks. It also makes the piece slightly heavier, which is always good, as to not accidentally knock if off.

![image-20220402001826951](image-20220402001826951.png)

First layer of gray overbrush. I used Playmobil toys to spice up the front porch.

![image-20220402001858083](image-20220402001858083.png)

Second, lighter, layer and door.

![image-20220402001916110](image-20220402001916110.png)

More layers and the floor.

![image-20220402001927559](image-20220402001927559.png)

Painting individual stones with diluted paint of various earthy colors for variation.

![image-20220402001951075](image-20220402001951075.png)

Doing it all around.

![image-20220402002002753](image-20220402002002753.png)

Final black wash on top, and adding some flocking and flowers.

![image-20220402002026172](image-20220402002026172.png)

View from behind.