text:
# Overview

The following documentation outlines how to incorporate an Apache Camel Connector Source into part of your project.
This allows a user to
construct Apache Camel applications that interact with Vantiq.

The Apache Camel Connector constructs the environment necessary to run an Apache Camel Application.
It uses the [Vantiq Camel Component](../camelComponent/README.md) (if necessary). The building of an Apache Camel
application usually involves building the application, including the dependencies, using the Maven system
(constructing POM.xml files, etc.).

The Vantiq Apache Camel Connector is configured with the Camel application desired, and, using that definition,
discovers, downloads, provisions the connector, running the application using the appropriate Apache Camel
Components as specified in the routes included in the configuration.  Within the Vantiq system, the connection point will be a Vantiq Source.

In order to incorporate this Extension Source, you will need to create the
Source in the VANTIQ Modelo IDE. The documentation
has been split into two parts, [Setting Up Your Machine](#machine) and [Setting Up Your VANTIQ Modelo IDE](#vantiq).

## Details

When using the Camel connector, the connector makes a discovery pass to find the components required.  Then, it
downloads them and constructs a class loader including the components needed. Thus, when using the connector,
you need only supply the routes (and any specific connection properties you may need),
and the connector finds & resolves the Apache Components & Dataformats required,
and then runs your application.  We generally expect this will involve Vantiq, but it need not.

Discovery, at a high level, operates more or less as follows. An Apache Camel system operates
with what is called a CamelContext. This provides the directory of directories to what's going on.
Within the context, one can replace the component resolver and data format resolver -- there are a
number of special purpose resolvers within the Camel system.
Generally, the default ones know how to load the components required via the metadata in the jar files.

In the camel connector, discovery operates by providing its own so-called `Enumerating`
component & data format resolvers. These operate by saving the information about what is required,
and providing a `PlaceHolder` parts to allow Apache Camel to think it is operating. Once Camel
thinks it has successfully started, the connector stops it, using the information from
the `Enumerating`*`Resolver`s to get the list of components and data formats required.

From that list, we construct the set of libraries required and download those libraries and their
dependencies. This is done using Apache Ivy. Once downloaded, we construct a `URLClassLoader`
that we set up as Camel's application class loader,
construct a new CamelContext (with that class loader but no special resolvers),
and let Camel operate the Camel application in its normal manner.

# Prerequisites

**IMPORTANT:** Read the [Testing](#testing) section before building this project.

An understanding of the VANTIQ Extension Source SDK is assumed. Please read the [Extension Source README.md](../README.md) for more
information.

The user must [define the Apache Camel Connector Source implementation](../README.md#-defining-a-typeimplementation)
in the Vantiq system. For an example of the definition,
please see the [*camelConnectorImpl.json*](src/test/resources/camelConnectorImpl.json) file
located in the *src/test/resources* directory.

# Setting Up Your Machine

## Repository Contents

The _connector_ directory (`src/main/java/io/vantiq/extsrc/camelconn/connector`) contains the following files:

*   **CamelMain** -- The main function for the program. Connects to sources as specified in a
    configuration file.
*   **CamelCore** -- Coordinates the connections to the database, and sends the resulting data back to VANTIQ Modelo if
    necessary.
*   **CamelHandleConfiguration** -- Sets up the Apache Camel routes based on the source's configuration document, and
    initializes the queryHandler and publishHandler.

The _discovery_ directory (`src/main/java/io/vantiq/extsrc/camelconn/discover`) contains a variety of classes
implementing the discovery, resolution, and provisioning of the components necessary to run the Apache Camel
application configured as part of the source.

## How to Run the Program

1.  Clone this repository (vantiq-extension-sources) and navigate into `<repo location>/vantiq-extension-sources`.
2.  Run `./gradlew camelConnector:assemble`.
3.  Navigate to `<repo location>/vantiq-extension-sources/camelConnector/build/distributions`. The zip and tar files both contain
    the same files, so choose whichever you prefer.
4.  Uncompress the file in the location that you would like to install the program.
5.  Run `<install location>/camelConnector/bin/camelConnector` with a local server.config file or specifying the [server config file](#serverConfig) as the first argument. Note that the `server.config` file can be placed in the `<install location>/camelConnector/serverConfig/server.config` or `<install location>/camelConnector/server.config` locations.

### Changing Camel Versions

The camelConnector has been tested with the version of Apache Camel defined in the `build.gradle` file.
If you wish to change this, you will need to perform the following actions:

1. Change the `camelVersion` property in the `build.gradle` file.
2. Update the `artifactMap.json` found in `src/main/resources`. This file is the list of components and data formats provided by the Camel version in question.  To update this map, you will perform the following actions.
   1. Clone the [Apache Camel source repository](https://github.com/apache/camel)
   2. Set the `camelRoot` gradle property to the  root directory of the cloned repo above.
   3. Run the `./gradlew camelConnector:generateComponentList` command.  This will take a little while as it examines the source code in question to determine the set of components and data formats provided. This list is used when determining the set of libraries required to provision the connector for your Apache Camel application.

## Logging
To change the logging settings, edit the logging config file
`<install location>/camelConnector/src/main/resources/log4j2.xml`,
which is an [Apache Log4j configuration file](https://logging.apache.org/log4j/2.x/manual/configuration.html). The logger
name for each class is the class's fully qualified class name, *e.g.* "io.vantiq.extjsdk.ExtensionWebSocketClient".

## Server Config File
(Please read the [SDK's server config documentation](../extjsdk/README.md#serverConfig) first.)

### Vantiq Options
*   **authToken**: Required. The authentication token to connect with. These can be obtained from the namespace admin.
*   **sources**: Required. A comma separated list of the sources to which you wish to connect. Any whitespace will be
    removed when read.
*   **targetServer**: Required. The Vantiq server hosting the sources.

# Setting Up Your VANTIQ Modelo IDE

## Source Configuration

To set up the Source in the VANTIQ Modelo IDE, you will need to add a Source to your project. Please check the [Prerequisites](#pre)
to make sure you have properly added a Source Definition to VANTIQ Modelo. Once this is complete,
you can select CAMEL_CONNECTOR
(or whatever you named your Source Definition) as the Source Type. You will then need to provide the
Source Configuration Document.

The Configuration document may look similar to the following example:

```json
    {
       "camelRuntime": {
         "appName": "myCamelAppName",
         "routesDocument": "someVantiqDocName.xml"
       },
      "general": {
      }
    }
```

### Options Available for camelRuntime

* **appName**: Optional -- name of the app.  If not provided, default to _camelConnectorApp_.
* **routesDocument** or **routesList** and **routesFormat**: Required. This is the list of Camel routes to run.
    * **routesDocument** -- the name of a Vantiq Document containing the XML or YAML definition of the routes to run. The format of the document (XML or YAML) will be determined from the file name (_e.g._, `routes.xml`)
    * **routesList** and **routesFormat** -- the XML or YAML specification of the Camel routes to run.  The **routesList** property should contain the appropriate text, and the **routesFormat** should contain either `xml` or `yml` indicating the style used to specify the routes.
      * *Note*: You must specify either the **routesDocument** or **routesList** _AND_ **routesFormat** properties, but not both.
* **componentProperties** -- a list of JSON objects which contain the component name & associated properties. These are used by some components for their configuration and/or operation. Values here may include security information (clientId or tokens).
    * The format of this values is a list of JSON objects, where each JSON object contains a **componentName** property containing the name of the component for which these properties are to be applied, and **componentProperties** containing a Json object consisting of property names and values.
    * For example, if we needed to define the `clientId` and `securityToken` properties for the `example` component, we would add the following to the `camelRuntime` section of the source configuration.

        ```json
        {
            "camelRuntime": {
            ...
            "componentProperties": [
                {
                    "componentName": "example",
                    "componentProperties": {
                        "clientId"<EMAIL_ADDRESS>                        "securityToken": "someExampleToken..."
                    }
                }
           ],
           ...
           }
        }
        ```

* **propertyValues** -- a JSON object where each property specifies the name and value to be provided for the Apache Camel property placeholder. [Property placeholders](https://camel.apache.org/manual/using-propertyplaceholder.html) can be used in Camel routes to supply values at the route configuration time.
    * For example, to provide values for the properties `name` and `company`, you would add the following the the `camelRuntime` section.

    ```json
    {
        "camelRuntime": {
            ...
            "propertyValues": {
                "name": "fred",
                "company": "vantiq"
            }
            ...
        }
   }
   ```

### Options available for general

*   **componentCacheDirectory** -- (Optional) the name of a directory into which to place the downloaded components for use later.  If absent, defaults to `componentCache`.
*   **componentLibraryDirectory** -- (Optional) The name of the directory into which to place component libraries (and associated dependencies) for running.  It is from here that the required component classes will be loaded.  If not present, defaults to `componentLib`.
*   **repoList** - (Optional) A list of URLs for Maven repositories from which to load components.  If absent, defaults to _maven central_.
*   **additionalLibraries** -- (Optional) A list of libraries to include _in addition to_ those found via discovery. These should be specified as "<group>:<name>:<revision>" triples.

### Defining Camel Routes that include Vantiq

The [Vantiq Camel Component](../camelComponent/README.md) has details on how to define a Vantiq Camel Endpoint.
The Vantiq Camel Component, itself, is not a full-connector -- it uses the connector protocol to
manifest the component.

That said, the Vantiq Camel Connector is a full connector, requiring the `server.config` file
as outlined [here](#runtheconnector).
In most cases, the Camel Application will contain Vantiq endpoints,
and these endpoints will refer to the Vantiq server specified in the `server.config` file.

Rather than re-specifying this information, the Vantiq Camel Connector provides a mechanism
whereby routes including Vantiq endpoints can refer to the Vantiq specified in the `server.config` file.
This is done by specifying a Vantiq endpoint
that uses `server.config` as the host name.  That is, specify a route like the following route
that accepts message from the Vantiq server specified in the connector's `server.config` file and logs the result.

```xml
    <routes xmlns="http://camel.apache.org/schema/spring" >
        <route id="xml-route">/
            <from uri="vantiq://server.config"/>
            <to uri="log:INFO"/>
        </route>
    </routes>
```

#### Connector Operation

Upon startup (or when the Vantiq Source configuration changes), the Camel Connector will examine the configuration
to determine the route(s) to run. To configure itself, the connector will perform the following actions:

* Read the configuration and determine the route(s) to be used.
* Start the Camel routes in an internal _discovery_ mode where the components required to run the routes are
discovered.
* Based on the discovered components, download the required libraries and their dependencies.
    * If the **additionalLibraries** property is provided as part of the configuration, the libraries listed
therein are downloaded as well.
    * The downloads happen based on the Maven Central repository, unless the **repoList** property is specified
in the configuration.  If that is present, that list is used _instead_ of the Maven Central repository. Thus, if
one wishes to add a repo in addition to Maven Central, one must include the Maven Central repository in the list.
This allows the configurer to override things for testing, etc.
* Once the downloads are completed, the runtime is augmented with the required components,
and the Camel application is started (in _normal_ mode) to run the route(s) requested.
* This discovery process happens on each restart or reconfiguration.
However, libraries already downloaded will not be downloaded again (unless a version update is required).
    * To force a new download, clear the directory specified (or defaulted) by the **componentCacheDirectory**
configuration property.

## Messages to the Source

Messages are sent to the source as _notifications_, and are delivered as _events_ to the associated source.
Messages sent to Vantiq from the component/connector will
arrive as VAIL objects, where the property names correspond to the Map keys.
The Vantiq Component expects messages in an exchange to arrive in the form of a Java Map.  However, messages arriving
in JSON format will be accepted as well.
When constructing your Camel Application, you must keep this in mind.

## Messages from the Source

Messages that are sent to the component will arrive in a Camel Exchange as a Java Map, where the keys in the map
correspond to the property names in the object sent from Vantiq.

## Select Statements

In order to interact with the Apache application, one option is to use VAIL to select from the source. To do this, you will need
to specify query message using the WITH clause on the VAIL SELECT statement. The data will be returned to
VANTIQ as a set of _rows_, where each _row_ contains a set of properties.

The following example uses a VAIL Select Statement to **query** an application:
```js
PROCEDURE queryCamel()

try {
    // Normal SELECT Statement in VAIL, but using WITH Clause is important.
    SELECT ONE * from SOURCE camelConnectorSource as result WITH
        value1: "some value",
        value2: 35

    // We expect a result with a property named "answer"...

    var ourAnswer = result.answer

} catch (error) {
    // Catching any errors and throwing the exception.
    exception(error.code, error.message)
}
```

In this example, we expect only one row to be returned.

## Publish Statements

Another method to interact with the Camel application is to use VAIL to publish to the source.
To do this, you will need to send the desired VAIL object to your application using the Publish parameters.
The following VAIL procedure will send data to the Camel application by sending an event to the associated source.

```js
PROCEDURE publishToCamel(valueToSend Integer)
    PUBLISH {value: valueToSend} to SOURCE camelConnectorSource
```

## Error Messages

Query errors originating from the source will include the code and error message.
They may also include the cause (the underlying exception).

## Testing

In order to properly run the tests, you must add properties to your _gradle.properties_ file in the _~/.gradle_
directory. These properties include the Target VANTIQ Server URL, as well as an Access Token for that server.
The Target VANTIQ Server and Auth Token will be used to create a temporary VANTIQ Source, VANTIQ Type,
VANTIQ Topic, VANTIQ Procedure and VANTIQ Rule.
Some tests may require other gradle properties as well.

* **NOTE:** We strongly encourage users to create a unique VANTIQ Namespace in order to ensure that tests do not
accidentally override any existing Sources or Types.

## Licensing

The source code uses the [MIT License](https://opensource.org/licenses/MIT).

okhttp3, log4j, gson, and jackson-databind are licensed under
[Apache Version 2.0 License](http://www.apache.org/licenses/LICENSE-2.0).

slf4j and lombok are licensed under the [MIT License](https://opensource.org/licenses/MIT).

Apache, Camel, Apache Camel, Ivy, and Apache Ivy are trademarks of the Apache Software Foundation and are licensed under
[Apache Version 2.0 License](http://www.apache.org/licenses/LICENSE-2.0).

repository: Vantiq/vantiq-extension-sources

gha_language: Java

gha_license_id: NOASSERTION

repo_name: Vantiq/vantiq-extension-sources


text:
After you've connected your wallet to your BTCPay, you can explore various built in tools in the software.

## Creating the Point of Sale App

BTCPay has a PoS app which you can use to receive payments from your customers directly or to receive donations. To create the POS app, you need to have a store created in BTCPay.

![BTCPayPOS](img/BTCPay-Pos.gif)

1. Go to > Apps
2. Create a new App
3. Add a name of your app
4. Customize your PoS by adding your own items with prices, photos, and a description.
5. Click "Submit query".
6. Click "View" to preview your PoS (Your customers can access the PoS through that link).

You can change the appearance of your Point of Sale app by following [theme customization guide](Theme.md).

## Creating the Pay Button

Pay buttons are great when you have a fixed amount for a product or a donation. You can easily embed the button into HTML. When the customer or a visitor clicks on the button, BTCPay displays a checkout page and an invoice for them.

![BTCPayPOS](img/BTCPay-PayButton.gif)

1. Go to > Store > Settings > Pay Button
2. Allow anyone to create invoices
3. Customize your button
4. Copy the generated form and embed it on your website.

You can also take a look at [this video](https://www.youtube.com/watch?v=MIWGvl6_WzI) which explains how to create a payment button and embed it to your website.

## Connecting your BTCPay store to your e-commerce platform

Depending on the CMS you're using, you can easily connect BTCPay to your online store. Currently, BTCPay offers following integrations :

* [Drupal](Drupal.md)
* [WooCommerce](WooCommerce.md)
* [Magneto](https://github.com/btcpayserver/magento-plugin)
* [PrestaShop](https://github.com/btcpayserver/prestashop-plugin)
* [Custom integration](CustomIntegration.md)

license: MIT

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive


text:
# RxJava Debug Plugin

A execution plugin implementation for debugging [RxJava](https://github.com/ReactiveX/RxJava).  The DebugHook defined in this project uses those to give you hooks for the start/end/error of `Subscribe`, `OnNext`, `OnError`, `OnComplete` and `Unsubscribe`. For many of the `rx.plugins.DebugNotification` events you also get the operator where the notification is coming from and going to. It's like having a detailed materialized copy of every `rx.Observable` in the system.

## Master Build Status

## Communication

- Google Group: [RxJava](http://groups.google.com/d/forum/rxjava)
- Twitter: [@RxJava](http://twitter.com/RxJava)
- [GitHub Issues](https://github.com/ReactiveX/RxJavaDebug/issues)

## Binaries

Binaries and dependency information for Maven, Ivy, Gradle and others can be found at [http://search.maven.org](http://search.maven.org/#search%7Cga%7C1%7Cio.reactivex.rxjava-debug).

Example for Maven:

```xml
<dependency>
    <groupId>io.reactivex</groupId>
    <artifactId>rxjava-debug</artifactId>
    <version>x.y.z</version>
</dependency>
```
and for Ivy:

```xml
<dependency org="io.reactivex" name="rxjava-debug" rev="x.y.z" />
```

## Build

To build:

```
$ git clone git@github.com:ReactiveX/RxJavaDebug.git
$ cd RxJavaDebug/
$ ./gradlew build
```

## Bugs and Feedback

For bugs, questions and discussions please use the [Github Issues](https://github.com/ReactiveX/RxJavaDebug/issues).

## LICENSE

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

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

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

repository: ReactiveX/RxJavaDebug

repo_name: ReactiveX/RxJavaDebug


text:
# avoid-plagiarism-tooltip
Learning exercise to avoid plagiarism, using text and tooltip

## demo
* https://action-lab.github.io/avoid-plagiarism-tooltip/

## credits
* open-source code by Ilya Ilyankou and Jack Dougherty, Trinity College
* adapted from https://github.com/action-lab/jquery-tooltip-template
* Tippy.js (MIT): https://github.com/atomiks/tippyjs

repository: Action-Lab/avoid-plagiarism-tooltip

repo_name: Action-Lab/avoid-plagiarism-tooltip


text:
# Dropbox Code Of Conduct

*Dropbox believes that an inclusive development environment fosters greater technical achievement. To encourage a diverse group of contributors we've adopted this code of conduct.*

Please read the Official Dropbox [Code of Conduct](https://opensource.dropbox.com/coc/) before contributing.

repository: dropbox/dropbox-sdk-python

branch_name: refs/heads/main

gha_language: Python

repo_name: dropbox/dropbox-sdk-python


text:
# Matrix.NET

Matrix Microservices Chassis Framework and Boilerplate Modules

Matrix.NET (formerly, code-named CoreMatrix or CMX), is a microservices chassis framework with built-in boilerplate modules written in Microsoft .NET Core v2.0 framework and C#.

[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/parameshg/matrix.net)

**What is a microservices application?**

A microservice architecture is an architectural style and a product development approach for developing a single application as a suite of independently deployable smaller services which are built around individual business capabilities, each running in its own process and communicating using lightweight neutral mechanisms.

**Why this is a microservices application?**

Matrix.NET is an abstraction and functional grouping of common functionalities for a generic application which is designed and developed in microservices architectural style. This contains a suite of independently deployable services such as registry, directory, configurator, journal and postman which are build around distinct business capabilities of an application such as manifest, users, user groups, user roles, configuration settings, debug logs and external communication such as email and phone text messages.

### Technologies, Tools and Frameworks

- Microsoft .NET Core v2.0 Framework
- Microsoft ASP.NET Core MVC, Razor and WebApi
- Microsoft Entity Framework Core
- Microsoft Visual C#
- Microsoft Typescript
- Angular v4
- HTML5, Bootstrap, JavaScript and JQuery
- Microsoft SQL Server
- Sqlite Embedded Database Engine v3
- Docker, Docker-Compose and Docker Swarm
- Kubernetes
- Concourse CI
- Git, GitLab and GitHub repository

### Application Services

#### Registry

#### Directory

#### Configurator

#### Journal

#### Postman

#### Admin Web UI

#### Admin API

### Platform Services

- SQL Server
- MongoDB
- Cassandra
- Redis
- EventStore
- Kong
- Kong Admin
- RabbitMQ

### Design

### Build

### Deployment

### Installation

### Administration

#### CLI Tools

#### PowerShell Modules

### Usage

#### SDK


text:
---
title: Paperspace how-to (cheap cloud GPU)
layout: post
date: 2018-02-01 16:11:40
tags: drafts
---

The use of GPUs have become quite important for applications of Deep Learning. The landscape of this hardware has lately become quite interesting. The [cryptocurrency fad](https://arstechnica.com/tech-policy/2018/01/cryptocurrency-boom-creates-insane-global-graphics-card-shortage/) has led to GPUs becoming expensive and/or unavailable. One solution to this problem is to rent a computer with a GPU from Google, Amazon, Microsoft, and others. Google even [recently lowered](https://cloudplatform.googleblog.com/2017/11/new-lower-prices-for-GPUs-and-preemptible-Local-SSDs.html) their GPU prices quite substantially. I'll save doing a full comparison of each platform for later, but what I'll go over today is getting started with a relatively new service, [PaperSpace](https://techcrunch.com/2017/05/03/paperspace-launches-gpu-powered-virtual-machines-loaded-with-tools-for-data-scientists/) based in my home of Brooklyn <3.

The virtue of paperspace is that their entry-level GPU offering costs $0.40/hr (compared to Google's new $0.45/hr and Amazon's $0.90/hr) but [benchmarks ahead](https://medium.com/initialized-capital/benchmarking-tensorflow-performance-and-cost-across-different-gpu-options-69bd85fe5d58) of Amazon and other offers based on the Tesla K80.

Below, I'll show you how to get up and running quickly and how to set up cost-saving measures, like auto-shutdown.

# Steps to get running

First, as with any new machine, update the current packages with

```
sudo apt update
sudo apt upgrade
```

(Note: I had to add the `--fix-missing` flag to `sudo apt update`)

Add a new user according to [these instructions](https://www.digitalocean.com/community/tutorials/how-to-create-a-sudo-user-on-ubuntu-quickstart).

## open ports with ufw

By default, Paperspace has a very strict firewall (this is a good thing). We're going to want to get to our jupyter notebooks, though, so we need to open up some ports. You can do that with [these instructions](https://www.digitalocean.com/community/tutorials/how-to-setup-a-firewall-with-ufw-on-an-ubuntu-and-debian-cloud-server).

My version is pretty unsafe (it allows access from any IP) so feel free to check that link for info on restricting the IP that can access your jupyter port.

```
sudo ufw allow 8888
sudo ufw allow 60000:61000/udp
```

# set up jupyter

# fix autoshutdown with ssh

https://paperspace.zendesk.com/hc/en-us/articles/115002807447-How-do-I-use-Auto-Shutdown-on-my-Linux-machine-when-connecting-through-SSH-

# set up ssh keys

https://www.digitalocean.com/community/tutorials/how-to-set-up-ssh-keys--2

https://apple.stackexchange.com/questions/48502/how-can-i-permanently-add-my-ssh-private-key-to-keychain-so-it-is-automatically

# Install cuda 9.1

You can use the [official guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/) but I prefer [these instructions](https://askubuntu.com/questions/967332/how-can-i-install-cuda-9-on-ubuntu-17-10).

# Install cudnn

http://docs.nvidia.com/deeplearning/sdk/cudnn-install/index.html


text:
# flutter_dollar

Keep state in your `build()` function.

## Getting Started

Add corresponding mixin to your `StatefulWidget` or `StatelessWidget`:

```dart

import 'package:flutter_dollar/flutter_dollar.dart';

class Stateful extends StatefulWidget with $StatefulWidget {
    // logic
}

class Stateless extends StatelessWidget with $StatelessWidget {
    // logic
}

```

You can now keep state inside your `build()` method:

```dart

Widget build(BuildContext context) {
  final a = $var(()=> 1);

  return Button(onClick: ()=> a.value ++); // widget will be automatically updated after click
}

```

There's many other dollar functions.


text:
---
layout: default
---

# 1992-11-27 - Cypher Bank

## Header Data

From<EMAIL_ADDRESS>(Don Bellenger)

To<EMAIL_ADDRESS>Message Hash: 1431c93e4d0ad028ab0735cc273df9829c7f20eb31da80ce0c5763ce1b50103e

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1992-11-27 16:30:05 UTC

Raw Date: Fri, 27 Nov 92 08:30:05 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Don Bellenger)
Date: Fri, 27 Nov 92 08:30:05 PST
To<EMAIL_ADDRESS>Subject: Cypher Bank
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Does anyone know of a law, rule, regulation, or other restriction
that would prohibit the establishment of a simple cypher based bank?

I can think of 3 basic areas that would have to be satisfied:

     1.  Federal law and agencies, Federal Reserve, etc..

     2.  State and local (California for me).

     3.  Internet "Appropriate Use" policy.

If the bank is operated on a not-for-profit basis  --as an
experiment.  Then that should satisfy the appropriate use
requirement.

I could use some comments if anyone can cite specific federal or
California regulations.  Please respond either to me directly,
<EMAIL_ADDRESS>or to this mail list.

--------

The cypher bank would work like this: I would publish my physical
address; and offer to accept deposits by cash, check, or what have
you.  With the deposit, write on it your PGP handle.  Email me your
public key corresponding to the handle on the deposit.

I will maintain a public list showing handles vs. Amount received,
in collection, and in escrow.(Set Subject = "BANK" to get the list)

Funds will be paid out based on instructions encyphered with your
private key.

Comments would be appreciated.

Don Bellenger
<EMAIL_ADDRESS>

{% endraw %}
```

## Thread

+ Return to [November 1992](/archive/1992/11)

+ Return to<EMAIL_ADDRESS>(Don Bellenger)](/authors/donb_at_netcom_com_don_bellenger_)"
+ Return to "[Eric Hollander <hh@soda.berkeley.edu>](/authors/eric_hollander_hh_at_soda_berkeley_edu_)"
+ Return to<EMAIL_ADDRESS>(Perry E. Metzger)](/authors/pmetzger_at_shearson_com_perry_e_metzger_)"
+ Return to<EMAIL_ADDRESS>(Yanek Martinson)](/authors/yanek_at_novavax_nova_edu_yanek_martinson_)"

+ 1992-11-27 (Fri, 27 Nov 92 08:30:05 PST) - Cypher Bank -<EMAIL_ADDRESS>(Don Bellenger)_
  + 1992-11-27 (Fri, 27 Nov 92 10:25:55 PST) - [comments on Don's "Cypher Bank"](/archive/1992/11/882f2b4eb4a4e2aa814df6df770f4d7635c93c7737987be7c717eebea1c464e0) -<EMAIL_ADDRESS>(Yanek Martinson)_
    + 1992-11-29 (Sat, 28 Nov 92 18:25:32 PST) - [Re: comments on Don's "Cypher Bank"](/archive/1992/11/45531e0cf2e9c5b49a78be5f6857e7e623b7fc47a604a965ec438ba28031ff04) - _Eric Hollander<EMAIL_ADDRESS>      + 1992-11-29 (Sun, 29 Nov 92 10:38:53 PST) - [comments on Don's "Cypher Bank"](/archive/1992/11/8bfd85dd71dfdb589c313f387119a598f1210d489d0dec5b7731018093729714) -<EMAIL_ADDRESS>(Perry E. Metzger)_


text:
---
layout: post
title: "Recommender Systems: From Small to Scale"
categories: data_science
description: "How do you choose your recommender system? Most solutions you will get is for giants like Amazon, Netflix or Spotify. We want to break it down, from small to scale."
comments: true
tags: ["data science", "machine learning", "production"]
image:
  feature:
  credit:
  creditlink:
date: 2016-02-08T00:00:00+00:00
author: chuyuhsu
---

# Recommender Systems: From Small to Scale

> “The Age of Search has come to an end. Long live the recommendation!”
>
> -- Jeffrey M. O’Brien, CNN Money

Since our clients constantly need a recommender system for E-commerce, music, news, food etc. We want to make a brief introduction to recommender systems from small to large scale.

For a recommender system, its job is to filter those information users do not need to know. Yes, it sounds a little bit like what search engines do, in the opposite way. Exactly. It is known as an information filtering system, whiles search engines are usually known as information retrieval systems. [^1]

So how do you choose your recommender system? Just google it with something like "free recommendation engine", then use whatever first popped? Yeah, that will work. However, most solutions you will get is for giants like Amazon, Netflix or Spotify. I want to break it down, from small to scale.

## What is Your Scale?

 Different scale of users and items can make a totally different choice of your recommendation system. How much is your daily active logged-in user? How does the number of recommended items increase? The most crucial part is how much money you can burn.

Yes, recommender system can be very expensive. Many recommendation system rely on data mining; that is, attempting to discover useful patterns in large data sets. For instance, the collaborative filtering algorithms are computation intensive, because they have to exhaustively compare users and items.

While this kind of recommender system is the most effective when you have large amount of data, the maintenance of such a data pipeline is painful and costly. Yeah, to serve the result as soon as possible, for effectively user perference capturing, usually you will need other tricks to make up for the time consuming model training process.

## For Small

Small business usually doesn't have many users, and the number of items increases gently. If you are in this case, content-based recommender will be suitable for you. Old fashion still works. Other than the user activities you logged, you will need new data to put it work. It is exactly how we did back a decade ago, the **context** and **relevance**.

Content-based recommender can easily give related results user might be interested at by your existing search engine like Solr or ElasticSearch. Then some other tricks can be added, like novelty, blacklists or event lists. You still can get reasonable recommendations without all those burdens. In fact, the academic literature is still working on small scale recommendation solutions as well.[^2]

## To Scale

From the medium to the large scale business, collaborative filtering (CF) recommender systems can really make a profit from your user data. Every type of logs will be valuable. Every move user made on your website may be the key to understand what he/she wants. These data are huge. CF algorithms are born for this.

Although you can find a lot of open sourced machine learning libraries coming with a bunch of CF algorithms, it does not mean you can stop there. Don't forget, users want personalized recommendations, that is to say, users need to know what they want. But user preferences are dynamic. For example, the same user might want beers, but an hour later his last login, diapers might be what he wants. Capturing the vibes of users plays a big role. However, CF algorithms need time to be trained. It is hard to reflect the users interests immediately, because of the training latency. Those libraries have only completed half of the game.

You need more weapons to capture all those vibes. Analysing user activities, event boosting, and item relevance will be your bullets. Content-based recommender still plays in this game. Getting familiar with your users and the understanding of items and interactions between them are the keys to boost your business to the next level.

## Conclusion

Different recommender systems will be needed because the scale of the business is different. A website with text-rich items but less user activities is suitable for content-based recommenders, and it really works. For a larger website, data mining based recommenders from open sourced libraries might have played only a part of the game. Capturing the user interests immediately is the key to boost your business to the next level.

----

#### References:

[^1]: Recommender system, https://en.wikipedia.org/wiki/Recommender_system
[^2]: Recommendation Systems in-the-Small, lhttp://www.linozemtseva.com/research/2014/rsse_book/rits_chapter.pdf

branch_name: refs/heads/dev

gha_language: JavaScript


text:
---
layout: layout.pug
title: Mesosphere Universal Installer
excerpt: Use the Mesosphere Universal Installer to install DC/OS on AWS, Azure and GCP.
navigationTitle: Mesosphere Univeral Installer
menuWeight: 5
---

This installation method is officially supported by Mesosphere. Upgrades are supported using this installation method.

Any of the following methods can be used to install DC/OS:
- [Amazon Web Services (AWS)](/1.11/installing/evaluation/mesosphere-supported-methods/aws/): Install DC/OS on AWS by using the Mesosphere Universal Installer.
- [Azure](/1.11/installing/evaluation/mesosphere-supported-methods/azure/): Install DC/OS on Microsoft Azure by using the Mesosphere Universal Installer.
- [Google Cloud Platform (GCP)](/1.11/installing/evaluation/mesosphere-supported-methods/gcp/): Install DC/OS on Google Cloud Platform (GCP) by using the Mesosphere Universal Installer.

You can use the [Production Installation](/1.11/installing/production/) methods to install a fully functional cluster.

NOTE: Contact the mailing list or Slack channel for community support.

repository: JHBaik/dcos-docs-site

repo_name: JHBaik/dcos-docs-site


text:
---
title:             "Interlok 3.8.4"
description:       "Interlok 3.8.4 has been released and is now available for download."
published:         true
categories:        [interlok, releases]
tags:              [interlok, releases]
author:            higgyfella
billboard: /billboards/general-bg4.png
excerpt_separator: <!-- more -->
---

[Interlok 3.8.4](https://development.adaptris.net/installers/Interlok/3.8.4/) has reached GA. It is now available for [download](https://development.adaptris.net/installers/Interlok/3.8.4/).

<!-- more -->

The key highlights are :

* [Config projects](https://interlok.adaptris.net/interlok-docs/#/pages/ui/ui-config-project) continued improvements: better UX for loading projects; improved variable usage when moving/coping components with existing variables; and various improvements around the importing existing config with multiple variable sets; and configurability of the x-includes root location.
* The [Component Search](https://interlok.adaptris.net/interlok-docs/#/pages/ui/ui-interlok-component-search) has been improved so search results now link to the optional component page and vice versa.
* The [DynamicServiceExecutor](https://development.adaptris.net/javadocs/latest-stable/Interlok-API/com/adaptris/core/services/dynamic/DynamicServiceExecutor.html) has been enhanced and can be used as a simplified [DynamicServiceLocator](https://development.adaptris.net/javadocs/latest-stable/Interlok-API/com/adaptris/core/services/dynamic/DynamicServiceLocator.html) (which has been deprecated).
* OAuth components have been improved to support the generation of the OAuth Signature for OAUTH1.0 / RFC 5849 (Optional component: interlok-oauth-generic)
* A new service-list implementation that auto maps against StaX implementations (Optional component: Interlok-stax)
* New [XML Exception Report service](https://development.adaptris.net/javadocs/latest-stable/Interlok-API/com/adaptris/core/services/exception/XmlExceptionReport.html) that includes workflow ID and Message

The formal [change log](https://interlok.adaptris.net/interlok-docs/#/pages/overview/changelog) can be found [here](https://interlok.adaptris.net/interlok-docs/#/pages/overview/changelog).
Or you can check the usual [sway presentation](https://sway.office.com/53JmWZDwxTJlsU46)

# Screenshots

Config projects - load local project from filesystem:
![xpath validation for variables]({{ site.baseurl }}/images/posts/release-384/history1.png)

![xpath validation for variables]({{ site.baseurl }}/images/posts/release-384/history2.png)

![xpath validation for variables]({{ site.baseurl }}/images/posts/release-384/history3.png)

Config projects - x-incs base folder config:
![xpath validation for variables]({{ site.baseurl }}/images/posts/release-384/xincs.png)

Component Search - examples:
![xpath validation for variables]({{ site.baseurl }}/images/posts/release-384/search-link1.png)

![xpath validation for variables]({{ site.baseurl }}/images/posts/release-384/search-link2.png)

extension: markdown

gha_language: CSS


text:
---
title: Non-durable persistence
summary: Non-durable persistence (previously known as In-Memory persistence) stores data in a non-durable manner
component: NonDurablePersistence
reviewed: 2022-07-11
redirects:
- nservicebus/persistence/in-memory
---

partial: noteinmemory

Some scenarios require a non-durable persistence such as the development environment or a lightweight client not interested in durability across restarts:

## Persistence at a glance

For a description of each feature, see the [persistence at a glance legend](/persistence/#persistence-at-a-glance).

|Feature                    |   |
|:---                       |---
|Storage Types              |Sagas, Outbox, Subscriptions
|Transactions               |None
|Concurrency control        |Optimistic concurrency
|Scripted deployment        |Does not apply
|Installers                 |Does not apply

## Configuration

snippet: ConfiguringNonDurable

DANGER: All information stored is discarded when the process ends.

NOTE: The [delayed retries](/nservicebus/recoverability/#delayed-retries) mechanism uses the [timeout manager](/nservicebus/messaging/timeout-manager.md) when a transport does not natively support delayed delivery.
As delayed retries are enabled by default, using this persistence with a transport that uses the timeout manager has the risk of losing messages that have failed processing and are waiting for another retry attempt. Use this persistence only in scenarios where it is acceptable to lose messages.

partial: gatewaydedupe

## Saga concurrency

When simultaneously handling messages, conflicts may occur. See below for examples of the exceptions which are thrown. _[Saga concurrency](/nservicebus/sagas/concurrency.md)_ explains how these conflicts are handled, and contains guidance for high-load scenarios.

### Starting a saga

Example exception:

```
System.InvalidOperationException: The saga with the correlation id 'Name: OrderId Value: f05c6e0c-aea6-48d6-846c-d1663998ebf2' already exists
```

### Updating or deleting saga data

Non-durable persistence uses [optimistic concurrency control](https://en.wikipedia.org/wiki/Optimistic_concurrency_control) when updating or deleting saga data.

Example exception:

gha_language: C#


text:
# MyPCS

MyPCS is a set of Applications for creating a Port Community System using the MEAN stack.

### Tech
Rest API:
* [typescript] - We love typescript
* [nodejs] - ...
* [mongodb] - ...
* [express] - ...
* [mongoose] - ...

Client Application
* [angular2] - Great framework for SPA
* [primeng] - Visual components for angular2
* [nodejs] - evented I/O for the backend

Applications under development:
  - Administration Console
  - Application for forwarders

And of course mypcs-ts itself is open source with a [public repository][dill]
 on GitHub.

### Installation

mypcs-ts requires [nodejs](https://nodejs.org/) v6+ to run.

Download and extract the [latest pre-built release](https://github.com/tetio/mypcs-ts).

Install the dependencies and devDependencies and start the server.

```
$ mongoimport --db mypcs --collection aplications --file ./app/models/applications.json
```

### Development

Want to contribute? Great!

#### Preparing ddata base
```sh
$ cd mypcs-ts
$ mongoimport --db mypcs --collection aplications --file ./app/models/applications.json
```

#### For building develop version

```sh
$ cd mypcs-ts
$ npm install
$ npm run build
```

#### For running backend

```sh
$ cd mypcs-ts
$ npm start

```

### Todos

 - Write Tests
 - Rethink Github Save
 - Add Code Comments
 - Add Night Mode

License
----

MIT

**Free Software, Hell Yeah!**

[//]: # (These are reference links used in the body of this note and get stripped out when the markdown processor does its job. There is no need to format nicely because it shouldn't be seen. Thanks SO - http://stackoverflow.com/questions/4823468/store-comments-in-markdown-syntax)

   [typescript]: <http://.typescriptlang.org>
   [nodejs]: <http://nodejs.com>
   [mongodb]: <http://mongodb.com>
   [mongoose]: <http:/http://mongoosejs.com/>
   [express]: <http://expressjs.com>
   [angular2]: <http://angular.io>
   [primeng]: <http:/http://primefaces.org/primeng/>

repository: tetio/mypcs-ts

repo_name: tetio/mypcs-ts


text:
# Alloy

**Latest stable version:** 1.0.0

Alloy is an MVC application framework by [Appcelerator](http://www.appcelerator.com) for [Titanium](http://www.appcelerator.com/platform).

Alloy will allow Titanium developers, old and new, to develop cross-platform mobile applications easier and more effectively than ever. The separation of concerns will increase the scalability of your apps. Titanium best practices are generated for you under the hood, making your apps of the highest quality across platforms. The markup, styles, themes, and mountain of other Alloy features will take your producitivity to a whole new level.

**_It's kind of a big deal._**

## Getting Started

* [Quick Start Guide](http://docs.appcelerator.com/titanium/latest/#!/guide/Alloy_Quick_Start) that covers _everything_ from installation to building your first app with Alloy.
* Complete collection of [Alloy Guides](http://docs.appcelerator.com/titanium/latest/#!/guide/Alloy_Framework)
* [Collection of test apps](https://github.com/appcelerator/alloy/tree/master/test/apps) showing various aspects of Alloy in practice.
* Join the [Alloy Google group](https://groups.google.com/forum/?fromgroups#!forum/appc-ti-alloy).

## Installation

### from npm:

```bash
[sudo] npm install -g alloy
```

### from source:

```bash
git clone https://github.com/appcelerator/alloy.git
cd alloy
[sudo] npm install -g .
```

### from Titanium Studio

...oh yeah, Studio will do it for you automatically. :)

## Running Sample Test Apps

This is primarily done by Alloy devs just for testing purposes, but you may find it useful.

1. install jake: `[sudo] npm install -g jake`
2. Get into the root directory of the cloned alloy repository.
3. Find a test app in **test/apps** folder you want to run. For example, [basics/simple](https://github.com/appcelerator/alloy/tree/master/test/apps/basics/simple) or [models/todo](https://github.com/appcelerator/alloy/tree/master/test/apps/models/todo).
4. Run jake: `jake app:run dir=basics/simple`
5. Lather, rinse, repeat

### Importing the "Harness" to Titanium Studio

You can use these apps through Titanium Studio too. The easiest way to do that would be to import the **test/project/Harness** into Titanium Studio. After that, everytime you run `jake`, your project in Studio will be updated. Once in Studio, you can run for any platform, Titanium SDK version, or change any settings you want. This will give you a lot more options and power than running solely from the command line.

### Additional Notes

* Options for the `jake` command
	* **tiversion** - Set the Titanium SDK version to be used. Defaults to the latest installed SDK.
	* **platform** - The target mobile platform. Defaults to `iphone`. Must be `android` or `iphone`, `mobileweb` and `ipad` are not supported.
	* Examples
		* `jake app:run dir=basics/simple platform=iphone`
		* `jake app:run dir=basics/simple platform=android tiversion=3.0.0.GA`
		* `jake app:run dir=basics/simple tiversion=2.1.4`
* If you get permissions errors on OSX or Linux, try using `sudo` with the `jake` command

## Feedback

More so than any other Appcelerator project to this point, we are working collaboratively with the community to develop a framework that works for you. Here's the best ways to discuss Alloy or ask questions.

* Got an Alloy development question? Go to the Appcelerator [Q&A](http://developer.appcelerator.com/questions/newest), and make sure to use the **alloy** tag.
* Want to discuss the past, present, and future of Alloy? Join the [Alloy Google group](https://groups.google.com/forum/?fromgroups#!forum/appc-ti-alloy).
* Got a confirmed bug? Log it at the [Titanium Community Issue Tracker](https://jira.appcelerator.org/browse/TC). Make sure to give it the **alloy** label.

Other than that, all the usual rules for submitting feedback apply. The more code, details, and test cases you provide, the easier it will be to act on that feedback.

## Credits

Many credits should be noted in the development of Alloy.

- The Titanium community.  It's been a number of years and probably well over 50+ application frameworks that have been built around Titanium and we finally felt that it made sense for Appcelerator to work to build and support an official framework.  Thanks to everyone for their innovations, input and feedback.
- Jeff Haynie and Nolan Wright.  For their initial inspiration for Titanium and continued pushing to make it better. Codestrong.
- Kevin Whinnery.  For his passionate and persistent pushing to come up with a "standard way" and his many initial ideas.
- Russ McMahon. For his initial R&D work with Nolan to come up with the early versions and ideation.
- Tony Lukasavage.  For helping provide the JS ninja coding skills and for being the Alloy lead.
- Gabriel Tavridis. For helping provide the "herding of the engineering LOLcats" as the product manager for Alloy.

## Legal

Alloy is developed by Appcelerator and the community and is Copyright (c) 2012 by Appcelerator, Inc. All Rights Reserved.
Alloy is made available under the Apache Public License, version 2.  See the [LICENSE](https://github.com/appcelerator/alloy/blob/master/LICENSE) file for more information.

Alloy Widget
============

Alloy Widget 위젯 설치 방법과 위젯 샘플 모음

## Widget이란?

* [위키백과] (http://ko.wikipedia.org/wiki/%EC%9C%84%EC%A0%AF)
	* **위젯엔진** - 위젯 엔진(widget engine)은 PC에서 웹 브라우저를 대신하는 개인화된 프로그램을 띄워주는 소프트웨어 시스템이다. 대표적으로 OS X의 대시보드, 야후 위젯, 미니플, 네이버 데스크톱, 구글 데스크톱이 있다.
	* **GUI 위젯** - 컴퓨터 프로그래밍에서 위젯(widget) 또는 컨트롤(control)은 컴퓨터 사용자가 상호 작용하는 인터페이스 요소이다.
* [용어사전] (http://terms.co.kr/widget.htm)
	컴퓨터에서의 widget은 정보를 나타내거나, 운영체계 및 응용프로그램 등과 상호 작용하려는 사용자를 위해 특유한 방법을 제공하는 GUI 구성요소이다. [용어사전] (http://terms.co.kr/widget.htm)
* 기타
	* **[위젯이란?](http://lumirent.net/wp/?p=20)**

## Alloy Widgets
[Alloy Widgets 도큐먼트 링크](http://docs.appcelerator.com/titanium/latest/#!/guide/Alloy_Widgets-section-35621514_AlloyWidgets-UsingWidgets)

### Introduction

Widgets are self-contained components that can be easily dropped into Alloy-powered Titanium projects.
They were conceived as a way to reuse code in multiple applications or to be used multiple times in the same application.
Widgets have their own views, controllers, styles and assets and are laid out the same as the app directory in the Alloy project.

```
위젯은 Alloy로 개발되는 Titanium 프로젝트에 쉽게 장착할수 있는 독립적인 컴포넌트이다.
Alloy 위젯은 단일 어플리케이션 내에서의 반복된 코드, 또는 멀티 어플리케이션에서 코드의 재활용의 개념으로 시작되었다.
위젯은 Alloy 프로젝트의 app 디렉토리와 동일하게 views, controllers, styles, assets 디렉토리를 가진다.
또한 필요시 lib, theme 등의 디렉토리도 가질수 있다.
```

### Using Widgets

1. 사용하고자 하는 곳에 Require 태그로 `type:widget`, `src:위젯명`, `id:코딩 사용 id`로 지정한다.
```
<Alloy>
    <Window id="win">
        <Require type="widget" src="com.appcelerator.searchForBooks" id="sfb"/>
        <TableView id="table"/>
    </Window>
</Alloy>
```
`<Require type="widget" src="com.appcelerator.searchForBooks" id="sfb"/>`

2. config.json 파일을 열어 ddependencies 부분을 추가한다.
```
"dependencies": {
        "com.appcelerator.searchForBooks":"1.0"
    }
````

### Widget Element 사용

Require 대신 Widget으로 사용한다. require와 기능적으로 동일하다. 적용 방법도 동일하다.
```
<Alloy>
    <Window id="win">
        <Widget src="com.appcelerator.searchForBooks" id="sfb"/>
        <TableView id="table"/>
    </Window>
</Alloy>
```

### Widget 만들기
1. App 또는 Project Explorer에서 마우스 클릭 -> Alloy Widget 선택
2. Widget 이름 입력 -> 만들기
3. `/app/widgets/WidgetName`으로 폴더 자동생성 됨
4. view, tss, controller, .... 작성

### Widget 구조
	view : widget.xml
	styles : widget.tss
	controller : widget.js

### Controller에서 Widget 호출
View에서 정의되지 않은 Widget을 호출할때 Alloy.createWidget 메소드를 이용한다.
```
var loadIcon = Alloy.createWidget("com.appcelerator.loading");
win.add(loadIcon);

var button = Alloy.createWidget('foo', 'button').getView();
$.widget.add(button);

```

createWidget 메소드
```
createWidget( String id, String name, [*... args] ) : Alloy.Controller
Factory method for instantiating a widget controller. Creates and returns an instance of the named widget.

Parameters
id : String
	Id of widget to instantiate.

name : String
	Name of the view within the widget to instantiate ('widget' by default)
args : *... (optional)
	Arguments to pass to the widget.

Returns
Alloy.Controller
	Alloy widget controller object.
```

View에 Widget을 정의했을때 실제로는 createWidget 메소드를 사용하여 resourse에 생성된다.

그러므로 Tag 정의에 해당 프로퍼티의 값을 정해서 넘겨주면 Widget의 propertiy 값을 생성하거나 이용할 수 있다.

```
<controller>
	exports.init = function (args) {
	    // Button object with id=button
	    $.button.title = args.title || 'Si';
	    $.button.color = args.color || 'black';
	    // global variable
	    message = args.message || 'Hola mundo';
	}

<프로젝트 내 view에서 위젯 호출>
	$.foo.init({title:'Yes', color:'gray', message:'I pity the foo.'});
```

### Alloy Widget 사용시 고려사항

[* Alloy widgets vs JS controllers assets/lib]( http://developer.appcelerator.com/question/142670/alloy-widgets-vs-js-controllers-assetslib )

```
위젯은 기본적으로 UI를 갖는 경우에 사용, UI가 없는 기능성의 경우 lib/로 지정하고 사용 권장.
Tony Lukasavage answered a similar question for me on the Google Group for Alloy:
"If the code has no associated markup or tss styling, then yes, a commonjs module in app/lib would be the right choice"

```

여기서 이렇게 이미지가 보인다. ![iOS Drawer Closed](https://github.com/rifi/alloy/raw/master/test/apps/widgets/widget_drawer/docs/img/ios_closed.png)

repository: rifi/alloy

repo_name: rifi/alloy


text:
# Health Fit Cloud Bot #

This is the repository for a Slack bot powering and organizing the :tednology: *Stretch-a-Day™ Program for Optimal :pc: Health, Well-being and Performance*

It is written in [Kotlin](https://kotlin-lang.org) on top of [Spring 5](https://docs.spring.io/spring/docs/5.0.6.RELEASE/spring-framework-reference/) / [Spring Boot 2](https://docs.spring.io/spring-boot/docs/2.0.2.RELEASE/reference/htmlsingle/) / [Reactor](https://projectreactor.io/) / [Netty](http://netty.io/). Build and dependency management is provided by [Gradle](https://gradle.org/).

Slack API interaction is handled by the [JBot](https://github.com/ramswaroop/jbot) library.

### How do I get set up? ###
You'll need a JDK installed (Oracle or OpenJDK, take your pick). For best results, use [IntelliJ IDEA](https://www.jetbrains.com/idea/download/); simply open the project directory and it should auto-detect everything and set up correctly (just open `NotificationApplication.kt` and right-click + Run/Debug).

* Locally you will need to set 3 secrets from your Slack in your `application.yml` file:
 1. `webhook-url` - Your Incoming Webhook URL
 2. `bot-token1` - Your Bot token
 3. `slash-command-token` - Your Slash Command token
* Additionally, to tunnel traffic into your locally running instance, you can use `ngrok http localhost:8080`
* To run the project: `./gradlew bootRun` (runs on port 8080)
* To build the project: `./gradlew build`
* To deploy: `git push heroku master`

### Contribution guidelines ###

* Writing tests (we wrote those, right!?!?)

### Who do I talk to? ###

* Ted Smith -<EMAIL_ADDRESS>

license: Unlicense

repository: pagecloud/fitcloud-bot

repo_name: pagecloud/fitcloud-bot


text:
# Book-Line-and-Sinker
[![License: Unlicense](https://img.shields.io/badge/license-Unlicense-blue.svg)](http://unlicense.org/)

## Overview

Book, Line & Sinker provides a resource for readers where they can discover new books, keep a library of books they have read or would like to read, and view and contribute book reviews. This application uses MySQL, Express, NodeJS, Handlebars.js, and W3 Schools CSS Framework.

The front end was built using a combination of HTML, CSS, and Handlebars.js. MySQL handles the users' database information and stores book data. Node JS and Express handle the routes from the back end to the front. Passport npm package is used for user login.

### Questions? Email me<EMAIL_ADDRESS>
## Table of Contents

* [Installation](#installation)

* [Usage](#usage)

* [License](#license)

* [Screenshot](#screenshot)

* [Links](#links)

## Installing

To run the app locally, you will first need to git clone the repository to your local machine.

* Cd into repository
* Install dependencies by running 'npm install'
* Start app by running 'node server.js'

## Usage

Once you've cloned the repo and installed dependencies, simply run `npm run start` to start the executeion of the `server.js` file. This will host the app locally at http://localhost:3000 by default. Sign in and start adding books to your library.

## License

This project does not have a license. You are free to clone and distribute as you see fit. We assume no liability.

## Screenshot of Sample User Library

![Screenshot](./public/img/screenshots/screenshot.png)

## Links

* [Github Repo](https://github.com/smithse4/Book-Line-And-Sinker)

* [Deployed Site](https://bookls.herokuapp.com/)

## Contributors


text:
# Making JavaScript Games: From the Browser to the App Store

HTML5 gave life to new JavaScript APIs that make it possible to create amazing game experiences on a web page. Learn how to draw on a canvas, make sounds, respond to input, then how to package the game and ship it on the Apple App Store and Chrome Web Store.

Outline:

 - Why should you make games with JavaScript? (5 min)
 - What will the browser let you do? (5 min)
 - Walkthrough of a basic game (20 min)
   - canvas
   - window.requestAnimationFrame
   - mouse input
   - sound
 - How can you get your game into the app stores? (15 min)
   - Apple App Store
   - Chrome Web Store


text:
# peekaboo-server

:ghost: `peekaboo-server` is a reverse proxy for test doubles, for easily stub backend http/s calls, agnostically to its architecture.

Inspired by [polly.js](https://netflix.github.io/pollyjs), [anyproxy](https://anyproxy.io/), [mitmproxy](https://mitmproxy.org/), [mockserver](https://www.mock-server.com/), [wiremock](http://wiremock.org/), [lightproxy](https://github.com/alibaba/lightproxy), Google Chrome DevTools Network panel and maybe more.
Batteries included.

# WORK IN PROGRESS

![main](./doc/img/main.png)

![edit](./doc/img/edit.png)

## Quick start

```bash
npm i -g peekaboo-server
peekaboo-server
```

```bash
curl @todo request first time
curl @todo request with cache
```

## UI

When server is running, it provide its ui interface at `/`

@todo screenshot

## How it works

@todo

Running with https can also allow to use `peekaboo-server` with mobile applications.

## Settings

### default settings

@todo

### custom settings for my-app.js

```bash
peekaboo-server --settings stub-my-app.js
```

custom settings from my-app.js and override at runtime with env vars

```bash
APP_PORT=9123 LOG_LEVEL=debug peekaboo-server --settings my-app.js
```

available env vars

- **APP_PORT**, default `8080`
- **LOG_LEVEL**, default `warn`
- **LOG_PRETTY**, default `false`
- **RELAY_TIMEOUT**, default `20000`

## https

@todo

## Development

server

```bash
npm start
```

ui

```bash
cd src/ui
npm run serve
```

build

```bash
npm run build
```

## Contribution

Any contribution is welcome! You can propose a PR or open an issue and explain what you are going to do.

---

## License

The MIT License (MIT)

Copyright (c) 2020 [Simone Sanfratello](https://braceslab.com)

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: simone-sanfratello/peekaboo-server

repo_name: simone-sanfratello/peekaboo-server


text:
# A Roberta-ext-wwm Distillation Model

This is a chinese Roberta wwm distillation model which was distilled from roberta-ext-wwm-large. The large model is from this [github](https://github.com/ymcui/Chinese-BERT-wwm), thanks for his contribution.

## Based On

This model was trained based on this [paper](https://arxiv.org/abs/1910.01108), which was punished by huggingface.

## Corpus

For train this model, I used baike_qa2019, news2016_zh,  webtext_2019, wiki_zh. this data can be found in this [github](https://github.com/brightmart/nlp_chinese_corpus)

## Model Download

I just support BaiduYun to down this model, this link is below.

| Model                                          | BaiduYun                                                           |
|:----------------------------------------------:|:------------------------------------------------------------------:|
| Roberta-wwm-ext-base-distill, Chinese          | [Tensorflow](https://pan.baidu.com/s/1e7_Zqa1_TlFfzx1n51BTUw)      |
| Roberta-wwm-ext-large-3layers-distill, Chinese | [Tensorflow](https://pan.baidu.com/s/1XKaqVHrp8y0tHCNK64kpYw) 26hu |
| Roberta-wwm-ext-large-6layers-distill, Chinese | [Tensorflow](https://pan.baidu.com/s/1MlALh3WC71KO0lw-jTCyxw) seou |

## Train Detail

To train this model, I used 2 steps.

- I used roberta_ext_wwm_large model to get all examples tokens' output.

- I used the output to train the model, which inited roberta_ext_wwm_base pretrain model weights.

### Dataset

- I just used 5 different ways to mask one sentence, not dynamic mask.

- Every example just use maximum 20 token masks

### Teacher Model

- I used Roberta large model to get every masked token's output, which was mapped to vocab, I just kept max 128 dimensions, you could ask why didn't you keep more dimensions, first, the storge is too much, second, I think keep too much is unneccessary.

### Student Model

- **Loss**: In this training, I use 2 loss functions, first is cross entropy, second is cosin loss, add them together, I think it has a big improvement if I use another loss function, but I didn't have too much resource to train this model, because my free Google TPU expired.

- **Other Parameters**

| Parameter                                      | batch size | learning rate | training step | warming step |
|:----------------------------------------------:|:----------:|:-------------:|:-------------:|:------------:|
| Roberta-wwm-ext-base-distill, Chinese          | 384        | 5e-5          | 1M            | 2W           |
| Roberta-wwm-ext-large-3layers-distill, Chinese | 128        | 3e-5          | 3M            | 2.5K         |
| Roberta-wwm-ext-large-6layers-distill, Chinese | 512        | 8e-5          | 1M            | 5K           |

## Comparison

In this part, every task I just ran one time, the result is below.

### Classification

| Model                                          | AFQMC      | CMNLI     | TNEWS     |
|:----------------------------------------------:|:----------:|:---------:|:---------:|
| Roberta-wwm-ext-base, Chinese                  | 74.04%     | 80.51%    | 56.94%    |
| Roberta-wwm-ext-base-distill, Chinese          | **74.44%** | **81.1%** | **57.6%** |
| Roberta-wwm-ext-large-3layers-distill, Chinese | 68.8%      | 75.5%     | 55.7%     |
| Roberta-wwm-ext-large-6layers-distill, Chinese | 72%        | 79.3%     | 56.7%     |

| Model                                          | LCQMC dev | LCQMC test |
|:----------------------------------------------:|:---------:|:----------:|
| Roberta-wwm-ext-base, Chinese                  | 89%       | 86.5%      |
| Roberta-wwm-ext-base-distill, Chinese          | 89%       | **87.2%**  |
| Roberta-wwm-ext-large-3layers-distill, Chinese | 85.1%     | 86%        |
| Roberta-wwm-ext-large-6layers-distill, Chinese | 87.7%     | 86.7%      |

### SQUAD

| Model                                          | CMRC2018 dev (F1/EM) |
|:----------------------------------------------:|:--------------------:|
| Roberta-wwm-ext-base, Chinese                  | 84.72%/**65.24%**    |
| Roberta-wwm-ext-base-distill, Chinese          | **85.2%**/65.20%     |
| Roberta-wwm-ext-large-3layers-distill, Chinese | 78.5%/57.4%          |
| Roberta-wwm-ext-large-6layers-distill, Chinese | 82.6%/61.7%          |

In this part you could ask, your comparison is different with this [github](https://github.com/ymcui/Chinese-BERT-wwm), I don't know why, I just used the original base model to run this task, got the score is up, and I used same parameters and distilled model to run this task, got the score is up. Maybe I used the different parameters.

But as you can see,  in the same situation, the distilled model has improvement than the original model.

1. The purpose of punish this model is to identify feasibility of distilled of method.

2. As you can see, this distilled method can improve the accuracy.
- **Why did you punish the 3 layers model?**
1. Some githuber told me, we need small size one, the bert base version is so large, I can't afford the cost of the server, so I punished the small size one!

## Thanks

Thanks TFRC supports the TPU!

repository: humdingers/roberta-wwm-base-distill

repo_name: humdingers/roberta-wwm-base-distill


text:
# Contributing to mikroSDK Click repository

---

Welcome, and thank you for showing interest in contributing to MikroElektronika's click boards!

There are many ways in which you can contribute, beyond writing code. The goal of this document is to provide a high-level overview of how you can get involved.

## Asking Questions

Have a question? Rather than opening an issue, please consider one of the following steps:

1. Check our [Forum](https://forum.mikroe.com/) for more information.
2. Contact our technical support at [MikroElektronika](https://helpdesk.mikroe.com/conversation/new/3) and adding the tag `Click Board` in the message.

Our capable engineers will be eager to assist you.

## Providing Feedback

Your comments and feedback are welcome, and the development team can be reached by contacting our technical support.

Technical support can be contacted using already mentioned chat or by submitting a [conversation ticket](https://helpdesk.mikroe.com/conversation/new/3).

## Reporting Issues

Have you identified a reproducible problem in our click board packages? Perhaps you have a feature request? We want to hear about it! Here's how you can make reporting your issue as effective as possible.

### Look For an Existing Issue

Before you create a new issue, please do a search in [open issues](https://github.com/MikroElektronika/mikrosdk_click_v2/issues) to see if the issue or feature request has already been filed.

If you find your issue already exists, make relevant comments.

* :thumbsup: - upvote
* :thumbsdown: - downvote

If you cannot find an existing issue that describes your bug or feature, create a new issue using the guidelines below.

### Writing Good Bug Reports and Feature Requests

File a single issue per problem and feature request. Do not enumerate multiple bugs or feature requests in the same issue.

Do not add your issue as a comment to an existing issue unless it's for the identical input. Many issues look similar, but have different causes.

The more information you provide, the more likely someone will be successful at reproducing the issue and finding a fix.

Please include the following with each issue:

* Version of NECTO Studio

* Version of SDK

* Version of click package
  * You can also provided the downloaded package as a file

* Your operating system

* Zipped project files

* Reproducible steps (1... 2... 3...) that cause the issue

* What you expected to see, versus what you actually saw

* Images, animations, or a link to a video showing the issue occurring

* A code snippet that demonstrates the issue or a link to a code repository the developers can easily pull down to recreate the issue locally

  * **Note:** Because the developers need to copy and paste the code snippet, including a code snippet as a media file (i.e. .gif) is not sufficient.

* Errors from the `mikroDap.log` file
  * File located in:
    * Windows: `%localappdata%/Mikroe/NectoStudio/log/`
    * Linux: `~/.Mikroe/NectoStudio/log/`
    * MacOS: `~/Library/Application Support/Mikroe/NectoStudio/log/`

### Final Checklist

Please remember to do the following:

* [x] Search the issue repository to ensure your report is a new issue

* [x] Recreate the issue after reinstalling NECTO Studio

* [x] Simplify your code around the issue to better isolate the problem

Don't feel bad if the developers can't reproduce the issue right away. They will simply ask for more information!

### Follow Your Issue

Once submitted, developers will leave comments in the issue tagging the reporter. Be sure to understand what will happen next, so you know what to expect, and how to continue to assist throughout the process.

## Contributing fixes

If you are interested in writing code to fix issues,
follow these steps:

1. Fork and clone the repository
2. Create a new branch: `git checkout -b my-branch-name`
    * Branch name ( `my-branch-name` ) should be `username/issue_name`
3. Make your change, test locally and make sure the tests still pass before continuing
4. Push to your fork and submit a pull request
5. Pat your self on the back and wait for your pull request to be reviewed and merged

Here are a few things you can do that will increase the likelihood of your pull request being accepted:

1. Keep your changes as focused as possible. If there are multiple changes you would like to make that are not dependent upon each other, consider submitting them as separate pull requests
2. Write a good commit message
3. Work in Progress pull requests are also welcome to get feedback early on, or if there is something blocking you

## Thank You

Your contributions to open source, large or small, make great projects like this possible. Thank you for taking the time to contribute.

---

## Resources

* [How to Contribute to Open Source](https://opensource.guide/how-to-contribute/)
* [Using Pull Requests](https://help.github.com/articles/about-pull-requests/)
* [GitHub Help](https://help.github.com)

gha_language: C


text:
---
layout: post
title:  "Why you should use var with your variables"
categories: jekyll update
---

## Question:

Whether a variable is declared with the `var` keyword or not determines the scope of that variable. Describe how this mechanism works and give at least one example of how this works.

You should always declare a variable with the `var` word to not imply a global variable. You might be wondering why would this happen when I didn't tell JavaScript I wanted it to be global. Let's see :

```javascript
var y = 20;

function multiply() {
 var x = 10;
 y ;

 console.log(x * y);

}
multiply(); // output: 200
```

Above we have `y` thats declared in the `multiply` function but since we didn't declare with var y goes up to global in gets the global y value. If we change `y` to have a value then it will override the global variable which could lead to problems if we wanted y to stay 20 globally. If we didn't have a global variable set up then y would still become a global variable.

```javascript
var y = 20;

function multiply() {
 var x = 10;
 y = 10 ;

 console.log(x * y);

}
multiply(); // output: 100 oh no the global variable was overwritten

```

Now you know why you should declare your variables with `var` so you don't end up changing your global object.


text:
# plastic-element-collection
A Collection of Polymer Elements to Provide Greater Flexibility/Plasticity to Your Designs.

All elements have versions supporting Polymer 3.0 and Polymer 2.0.

See [the demonstrations site](https://mlisook.github.io/plastic-element-collection) to view each element in action, with code samples.

| Element | Description | WC Link | Polymer Versions |
| ------- | ----------- |:-----------------:|:-----------:|
| plastic-image | Extends `iron-image` with srcset, lazy loading, webp support | [link](https://www.webcomponents.org/element/mlisook/plastic-image) | 3.0, 2.0 |
| plastic-aspect-ratio | Container element where the _height_ depends on the _width_ | [link](https://www.webcomponents.org/element/mlisook/plastic-aspect-ratio) | 3.0, 2.0  |
| plastic-map-info | A more flexible, composable infowindow for Google Maps | [link](https://www.webcomponents.org/element/mlisook/plastic-map-info) | 3.0, 2.0, prior 1.x version [paper-map-info](https://github.com/mlisook/paper-map-info) |
| plastic-map-marker-svg | Custom SVG marker icons for google-map | [link](https://www.webcomponents.org/element/mlisook/plastic-map-marker-svg) | 3.0, 2.0 |
| paper-input-place | Google Places autocomplete styled as paper-input | [link](https://www.webcomponents.org/element/mlisook/paper-input-place) | 3.0, 2.0/1.x (Hybrid) |
| plastic-resize-aware | Element onResize and element queries | [link](https://www.webcomponents.org/element/plastic-resize-aware) | 3.0, prior version for 2.0/1.x [resize-aware](https://www.webcomponents.org/element/mlisook/resize-aware) |

Related, non element projects that may be of interest:

[plastic-diff-redirect](https://www.npmjs.com/package/plastic-diff-redirect) Client side build selection for Polymer, like `prpl-server-node`, but on client. Allows you to serve different Polymer builds based on the capability of the browser, even on a static server.

[plastic-geo-distance](https://www.npmjs.com/package/plastic-geo-distance) A collection of geographic distance related utility functions -
bounding rectangle given a point and distance, distance between two points, midpoint of an array of lat/lng, center of minimum distance for an array of lat/lng.

repository: mlisook/plastic-element-collection

repo_name: mlisook/plastic-element-collection


text:
# Module FAN

<el-tag effect="plain">SKU:M013</el-tag>

## Description

**FAN** is one of the M5Stack stacking module series. The fan cooling module can effectively cool the device itself, so that other hardware components can work in a stable and efficient way. The fan on the module is connected to the power pin by default, and can be stacked as well on other M5 Core devices.

## Product Features

- Rated voltage: DC 5V
- Rated current: 0.14 A
- Power consumption: 0.7W
- Speed: 7500 ± 10% RPM
- Noise: 30DBA
- Bearing: Hydraulic bearing
- Wiring: red line positive, black line negative

## Include

-  1x M5Stack FAN Module

## Specification

      Resources
      Parameter

      Net weight
      15.5g

      Gross weight
      25g

      Product Size
      54*54*13mm

      Package Size
      60*57*17mm

## MBUS PinMap

<el-divider content-position="right">Last updated: 2020-12-28</el-divider>


text:
---
title: Microsoft Exchange Integration
tags: [integrations list]
permalink: msexchange.html
summary: Learn about the Wavefront Microsoft Exchange Integration.
---
## Microsoft Exchange Integration

The Microsoft Exchange integration installs and configures Telegraf to send Microsoft Exchange performance metrics to Wavefront. Telegraf is a light-weight server process that can collect, process, aggregate and send metrics to a [Wavefront proxy](https://docs.wavefront.com/proxies.html).

In addition to setting up the metrics flow, this integration also installs a dashboard. Here's the overview section of a dashboard displaying Microsoft Exchange metrics.

{% include image.md src="images/ms_exchange_dashboard.png" width="80" %}

## Microsoft Exchange Setup

### Step 1: Set up the Wavefront Proxy

If you do not have a [Wavefront proxy](https://docs.wavefront.com/proxies.html) installed on your network, install a proxy.

### Step 2: Install the Telegraf Agent

{% include windows_telegraf.md %}

### Step 3. Configure Telegraf

Edit the `telegraf.conf` file located in `Program Files\Telegraf` and enter the following snippet:
{% raw %}
```
[[inputs.win_services]]
  service_names = [
      "MSExchangeTransport",
      "MSExchangeTransportLogSearch",
      "MSExchangeUM",
      "MSExchangeUMCR",
      "MSExchangeThrottling",
      "MSExchangeServiceHost",
      "MSExchangeFastSearch",
      "MSExchangeRepl",
      "MSExchangeRPC",
      "MSExchangePop3",
      "MSExchangeMonitoring",
      "MSExchangeSubmission",
      "MSExchangeDelivery",
      "MSExchangeMailboxReplication",
      "MSExchangeMailboxAssistants",
      "MSExchangeIS",
      "MSExchangeImap4",
      "MSExchangeHM",
      "MSExchangeFrontendTransport",
      "MSExchangeEdgeSync",
      "MSExchangeDiagnostics",
      "MSExchangeAntispamUpdate",
      "MSExchangeADTopology"
  ]

[[inputs.win_perf_counters]]
  [[inputs.win_perf_counters.object]]
    ObjectName = "Process"
    Counters = ["% Processor Time","Handle Count","Private Bytes","Thread Count","Virtual Bytes","Working Set"]
	Instances = [
	  "MSExchangeTransport",
	  "MSExchangeTransportLogSearch",
	  "umservice",
	  "Microsoft.Exchange.UM.CallRouter",
	  "MSExchangeThrottling",
	  "Microsoft.Exchange.ServiceHost",
	  "Microsoft.Exchange.Search.Service",
	  "msexchangerepl",
	  "Microsoft.Exchange.RpcClientAccess.Service",
	  "Microsoft.Exchange.Pop3Service",
	  "Microsoft.Exchange.Monitoring",
	  "MSExchangeSubmission",
	  "MSExchangeDelivery",
	  "MSExchangeMailboxReplication",
	  "MSExchangeMailboxAssistants",
	  "Microsoft.Exchange.Store.Service",
	  "Microsoft.Exchange.Imap4Service",
	  "MSExchangeHMHost",
	  "MSExchangeFrontendTransport",
	  "Microsoft.Exchange.EdgeSyncSvc",
	  "Microsoft.Exchange.Diagnostics.Service",
	  "Microsoft.Exchange.AntispamUpdateSvc",
	  "Microsoft.Exchange.Directory.TopologyService"
	]
    Measurement = "msexchange.process"

   [[inputs.win_perf_counters.object]]
     ObjectName = "Database"
     Counters = ["I/O Log Writes Average Latency","Log Threads Waiting","Log Record Stalls/sec",
	         "Database Cache % Hit","Database Page Fault Stalls/sec",
                 "I/O Database Writes Average Latency","I/O Database Reads Average Latency"]
     Instances = ["*"]
     Measurement = "msexchange"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchange ADAccess Domain Controllers"
     Counters = ["LDAP Read Time","LDAP Search Time","LDAP Searches Timed Out per Minute","Long Running LDAP Operations/min"]
     Instances = ["*"]
     Measurement = "msexchange"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchangeUMAvailability"
     Counters = ["Directory Access Failures","Total Inbound Calls Rejected by the UM Service",
	         "Total Inbound Calls Rejected by the UM Worker Process"]
     Instances = ["*"]
     Measurement = "msexchange"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchange Availability Service"
     Counters = ["Average Time to Process a Free Busy Request"]
     Instances = ["*"]
     Measurement = "msexchange"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchange OWA"
     Counters = ["Current Unique Users", "Requests/sec", "Average Search Time"]
     Instances = ["*"]
     Measurement = "msexchange.owa"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchangeFrontEndTransport SmtpSend"
     Counters = ["Bytes Sent Total", "Messages Sent Total"]
     Instances = ["*"]
     Measurement = "msexchange"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchangeIS Store"
     Counters = ["RPC Average Latency", "RPC Requests","RPC Operations/sec", ]
     Instances = ["*"]
     Measurement = "msexchange"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchangeIS Client Type"
     Counters = ["RPC Average Latency", "RPC Operations/sec" ]
     Instances = ["*"]
     Measurement = "msexchange.is.client"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchange ADAccess Processes"
     Counters = ["LDAP Read Time", "LDAP Search Time"]
     Instances = ["*"]
     Measurement = "msexchange"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchange ActiveSync"
     Counters = ["Mailbox Search Total", "Requests/sec", "Ping Commands Pending", "Current Requests",
                 "Average Request Time", "Sync Commands/sec"]
     Instances = ["*"]
     Measurement = "msexchange.active.sync"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchange Active Manager Server"
     Counters = ["Server-Side Calls/sec", "Active Manager Database State writes to Persistent storage/sec",
                 "GetServerForDatabase Server-Side Calls", "Total Number of Databases", "Active Manager Role"]
     Instances = ["*"]
     Measurement = "msexchange"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchangeAutodiscover"
     Counters = ["Requests/sec"]
     Instances = ["*"]
     Measurement = "msexchange.auto.disc"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchangeWS"
     Counters = ["Requests/sec"]
     Instances = ["*"]
     Measurement = "msexchange.ws"

   [[inputs.win_perf_counters.object]]
     ObjectName = "Web Service"
     Counters = ["Current Connections","Connection Attempts/sec","Other Request Methods/sec"]
     Instances = ["_Total"]
     Measurement = "msexchange.ws"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchange WorkloadManagement Workloads"
     Counters = ["ActiveTasks","CompletedTasks","QueuedTasks"]
     Instances = ["*"]
     Measurement = "msexchange.workload"

   [[inputs.win_perf_counters.object]]
     ObjectName = "ASP.NET"
     Counters = ["Application Restarts","Worker Process Restarts","Request Wait Time"]
     Instances = ["*"]
     Measurement = "msexchange.asp.net"

   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchange RpcClientAccess"
     Counters = ["RPC Averaged Latency", "RPC Requests", "Active User Count", "Connection Count",
                 "RPC Operations/sec", "User Count"]
     Instances = ["*"]
     Measurement = "msexchange.rpc.client"

```
{% endraw %}

Add one of the following snippets to enable the `Transport Queues` performance counters:
- For MSExchange Server 2010{% raw %}
```
   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchangeTransport Queues(_total)"
     Counters = ["Aggregate Delivery Queue Length", "Active Remote Delivery Queue Length",
                 "Active Mailbox Delivery Queue Length", "Submission Queue Length",
                 "Active Non-Smtp Delivery Queue Length", "Retry Mailbox Delivery Queue Length",
                 "Retry Non-Smtp Delivery Queue Length", "Retry Remote Delivery Queue Length",
                 "Unreachable Queue Length", "Largest Delivery Queue Length", "Poison Queue Length"]
     Instances = ["*"]
     Measurement = "msexchange.transport"
```
{% endraw %}
- For MSExchange Servers 2013, 2016 and 2019:{% raw %}
```
   [[inputs.win_perf_counters.object]]
     ObjectName = "MSExchangeTransport Queues"
     Counters = ["Active Mailbox Delivery Queue Length", "Active Non-Smtp Delivery Queue Length",
                 "Aggregate Shadow Queue Length", "Categorizer Job Availability",
                 "Delay Queue Length", "External Active Remote Delivery Queue Length",
                 "External Aggregate Delivery Queue Length (All External Total)",
                 "External Largest Delivery Queue Length", "External Largest Unlocked Delivery Queue Length",
                 "External Retry Remote Delivery Queue Length", "Internal Active Remote Delivery Queue Length",
                 "Internal Aggregate Delivery Queue Length (All External Total)",
                 "Internal Largest Delivery Queue Length", "Internal Largest Unlocked Delivery Queue Length",
                 "Internal Retry Remote Delivery Queue Length", "Items Completed Delivery Per Second",
                 "Items Completed Delivery Total", "Items Deleted By Admin Total",
                 "Items Queued For Delivery Expired Total", "Items Queued for Delivery Per Second",
                 "Items Queued For Delivery Total", "Items Resubmitted Total", "Locks Expired In Delivery Total",
                 "Messages Completed Delivery Per Second", "Messages Completed Delivery Total",
                 "Messages Completed Categorization", "Messages Deferred during Categorization",
                 "Messages Delayed Per Second", "Messages Delayed Total", "Messages Queued for Delivery",
                 "Messages Queued for Delivery Per Second",  "Messages Queued For Delivery Total",
                 "Messages Resubmitted during Categorization", "Messages Submitted Per Second",
                 "Messages Submitted Recently", "Messages Submitted Total", "Poison Queue Length",
                 "Retry Mailbox Delivery Queue Length", "Retry Non-Smtp Delivery Queue Length",
                 "Shadow Queue Auto Discards Total", "Submission Queue Items Expired Total",
                 "Submission Queue Length", "Submission Queue Locks Expired Total",
                 "Throttled Fork Agent Queued Messages", "Throttled Fork Agent Queued Recipients",
                 "Total Extra Connections for Idle Queues", "Unreachable Queue Length"]
     Instances = ["_total"]
     Measurement = "msexchange.transport"
```
{% endraw %}

**Note:** Make sure all `[[inputs.win_perf_counters.object]]` configuration snippets are inside the `[[inputs.win_perf_counters]]` configuration section. If there are any `[[inputs.win_perf_counters.object]]` configuration snippets added prior to enabling Microsoft Exchange, move those snippets into the `[[inputs.win_perf_counters]]`.

### Step 4. Restart Telegraf

After any changes restart your Telegraf agent service.

repository: srujann/docs

repo_name: srujann/docs


text:
# postgres-alpine
Postgres alpine that creates db

from https://hub.docker.com/r/_/postgres/

if `CREATE_DB` is set as an env var then a database will be created oin startup.

repository: s-block/postgres-alpine

repo_name: s-block/postgres-alpine


text:
# Unknown question event
This event will be triggered when he don't know what to answer. He will try to share you potential events, which probably you've meant in the message.

![Example](../../documentation/images/unknown-question.png)

## Installation guide
To install it please add it to `defined-events.go` and run next command:
```
make install
```

## Usage
Write in PM or tag the bot user with this message
```
some example
```
As good result you should receive an answer with the list of events
```text
Maybe you mean:
who are you? to trigger event example? Then ask who are you? --help for more details;
write a message to trigger event examplescenario? Then ask write a message --help for more details;
OR you also can write events list and I will show you all available events.
```

repository: sharovik/devbot

gha_language: Go

repo_name: sharovik/devbot


text:
# Virtuous' React Unit Test Suite

[![GitHub release](https://img.shields.io/github/release/bevirtuous/react-unit-test-suite.svg)]()
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

**THIS REPOSITORY IS NOT MAINTAINED ANYMORE. Its contents have been moved to [https://github.com/bevirtuous/tools](https://github.com/bevirtuous/tools).**

This test suite is a configuration for [ReactJS](https://facebook.github.io/react/) projects.

This configuration uses [Jest](https://facebook.github.io/jest/) for running the tests.
It is only an extension of the default Jest configuration and
prepares your tests for any React.js application.

## Installation

```sh
npm i --save-dev @virtuous/react-unit-test-suite react react-dom
```

## Usage

All test files should follow the naming convention of `*(spec|test).(js|jsx)`.

You have two options of how to create a configuration for Jest:
- You can create your own configuration following the [Jest Documentation](https://facebook.github.io/jest/docs/en/getting-started.html)
- You can use Virtuous' pre-defined configuration and extend it as you wish.

__NOTE: Using and extending the Virtuous configuration is the preferred way!__

### 1. Using Virtuous' configuration

Create a file called `jest.config.js` in the root of your project.
Add the following line to it:

```js
module.exports = require('@virtuous/react-unit-test-suite/jest.config');
```

### 2. Extending Virtuous' configuration

Create a file called `jest.config.js` in the root of your project.
Add the following line in the beginning of the file:

```js
const defaultConfig = require('@virtuous/react-unit-test-suite/jest.config');
```

This will load the default configuration. Now you can extend it by spreading the `defaultConfig`
into a newly created configuration object:

#### ES2015 / ES6 / ES2017 / ES.Next (recommended)

```js
module.exports = {
  ...defaultConfig,
  [Your config goes here],
};
```

#### CommonJS

```js
module.exports = Object.assign({}, defaultConfig, {
  [Your config goes here]
});
```

## Example Configuration
Here is an example showing how to extend the default configuration:

#### ES2015 / ES6 / ES2017 / ES.Next

```js
const defaultConfig = require('@virtuous/react-unit-test-suite/jest.config');

module.exports = {
  ...defaultConfig,
  moduleNameMapper: {
    '^Components(.*)$': '<rootDir>/components',
    '^Styles(.*)$': '<rootDir>/styles',
  },
};
```

#### CommonJS

```js
const defaultConfig = require('@virtuous/react-unit-test-suite/jest.config');

module.exports = Object.assign({}, defaultConfig, {
  moduleNameMapper: {
    '^Components(.*)$': '<rootDir>/components',
    '^Styles(.*)$': '<rootDir>/styles'
  }
});
```

repository: bevirtuous/react-unit-test-suite

repo_name: bevirtuous/react-unit-test-suite


text:
---
hrs_structure:
  division: '4'
  volume: '13'
  title: '35'
  chapter: '641'
  section: 641-12
type: hrs_section
tags:
  - Court
  - Judicial Proceeding
menu:
  hrs:
    identifier: HRS_0641-0012
    parent: HRS0641
    name: 641-12 From district courts
weight: 47025
title: From district courts
full_title: 641-12 From district courts
---
**§641-12 From district courts.** [(a)] Appeals upon the record shall be allowed from all final decisions and final judgments of district courts in all criminal matters. Such appeals may be made to the intermediate appellate court, subject to chapter 602, whenever the party appealing shall file notice of the party's appeal within thirty days, or such other time as may be provided by the rules of the court.

[(b)] Within a reasonable time after an appeal has been perfected from a decision of a district court to the appellate court in a criminal matter, it shall be incumbent upon the district court to make a return thereof, together with all papers and exhibits filed in such case.

[(c)] It shall be the duty of the clerk of the supreme court to transmit within a reasonable time, to the district court from whose decision the appeal was made, a statement showing the disposition of the case. [L 1972, c 89, pt of §5; [HRS §641-11.5](/title-35/chapter-641/section-641-11_5/); ren [HRS §641-12](/title-35/chapter-641/section-641-12/); am L 1979, c 111, §6(3); gen ch 1985; am L 2004, c 202, §69; am L 2006, c 94, §1; am L 2010, c 109, §1]

Rules of Court

Appeals, when taken, see HRAP rule 4.

Case Notes

The supreme court does not have jurisdiction to entertain appeals from interlocutory orders of the district courts in criminal cases. 57 H. 133, 552 P.2d 75 (1976); 62 H. 297, 613 P.2d 362 (1980).

Where defendant's interlocutory appeal from district court's denial of defendant's motion to dismiss on double jeopardy grounds did not satisfy prerequisites of collateral order exception, supreme court did not have to decide whether exception may apply to appeals from collateral orders of district court. 82 H. 446, 923 P.2d 388 (1996).

Where sentence imposed was not the final sentence because the district court expressly left open the possibility that its sentence of defendant might include an order requiring defendant to pay restitution, and the court did not finally decide whether it would order defendant to pay restitution and, if so, in what amount, the judgment was not final and, because it was not final, it was not appealable. 109 H. 435 (App.), 127 P.3d 95 (2005).

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# A recurrent state-space framework for modeling neural dynamics during decision-making

This package implements a wide class of decision-making models of neural activity in a unifying modeling framework. It includes the drift-diffusion model, one- and multi-dimensional accumulation to boundary models, the ramping model, and hybrid models with both ramping and discrete jumping components. The models are implemented by constraining the parameters of recurrent switching state-space models. The code extends the state-space modeling package [SSM](https://github.com/slinderman/ssm).

Details of the modeling methods are in this paper:

Zoltowski, David M., Jonathan W. Pillow, and Scott W. Linderman. "[Unifying and generalizing models of neural dynamics during decision-making](https://arxiv.org/abs/2001.04571)." arXiv preprint arXiv:2001.04571 (2020).

# Installation

```
git clone https://github.com/davidzoltowski/ssmdm.git
cd ssmdm
pip install -e .
```

repository: davidzoltowski/ssmdm

repo_name: davidzoltowski/ssmdm


text:
---
date: "2007-05-12T06:00:00"
title: "Exploring Pascal's pyramid"
description: "Problem 154"
---

A triangular pyramid is constructed using spherical balls so that each ball rests on exactly three balls of the next lower level.

Then, we calculate the number of paths leading from the apex to each position:

A path starts at the apex and progresses downwards to any of the three spheres directly below the current position.

Consequently, the number of paths to reach a certain position is the sum of the numbers immediately above it (depending on the position, there are up to three numbers above it).

The result is Pascal's pyramid and the numbers at each level <var>n</var> are the coefficients of the trinomial expansion
(<var>x + y + z</var>)<var>n</var>.

How many coefficients in the expansion of (<var>x + y + z</var>)200000 are multiples of 1012?


text:
Made of 2 separate files: one JPEG and one MOV

- [ios - Apple Live Photo file format - Stack Overflow](https://stackoverflow.com/questions/32508375/apple-live-photo-file-format)
- [Live Photos Called 'Best New Feature,' Composed of Separate JPG and MOV Files - Mac Rumors](http://www.macrumors.com/2015/09/22/iphone6s-live-photos-file-details/)

url: https://raw.githubusercontent.com/mems/calepin/ff95a8a301a40c5ebb1e1fb4e640d5e17710ac80/Formats, encoding and protocols/Apple Live Photo.md

repository: mems/calepin

filename: Apple Live Photo.md

repo_name: mems/calepin


text:
# Prediction of electricity consumption (KWH)

![](https://gosolargroup.com/wp-content/uploads/2017/04/What_Is_the_Average_Energy_Usage-01-e1498511460955.jpg)

## Table of Content
  * [Overview](#overview)
  * [Bug / Feature Request](#bug---feature-request)
  * [Technologies Used](#technologies-used)

## Overview
In this project, we will analyze and visualize the data by identifying the features' importance with the strongest statistical associations to residential electricity usage (KWH), then we will apply the data processing and feature selection. At the end, we will predict customers' electricity consumption using supervised machine learning techniques.

### The project is divided into three notebooks:

* In the first Notebook, [I worked on the Exploratory Data Analysis (EDA).](https://github.com/kh-bilal/Data-Science-Portfolio/blob/main/Prediction_Electric_Consumption/1%20-%20EDA%20-%20Exploratory%20data%20analysis.ipynb)
* In the 2nd Notebook, [I worked on the Data preprocessing and Feature Selection.](https://github.com/kh-bilal/Data-Science-Portfolio/blob/main/Prediction_Electric_Consumption/2%20-%20Data%20processing%20and%20Feature%20selection.ipynb)
* In the 3rd Notebook, [I worked on the development of ML models.](https://github.com/kh-bilal/Data-Science-Portfolio/blob/main/Prediction_Electric_Consumption/3%20-%20Development%2C%20and%20Evaluation%20%20of%20ML%20models.ipynb)

The RESIDENTIAL ENERGY CONSUMPTION SURVEY (RECS) Dataset is loctaed here: https://www.eia.gov/consumption/residential/data/2009/index.php?view=microdata

## Bug / Feature Request

If you'd like to request a new function, feel free to do so by opening an issue [here](https://github.com/kh-bilal/Data-Science-Portfolio/issues/new). Please include sample queries and their corresponding results.

## Technologies Used
![](https://forthebadge.com/images/badges/made-with-python.svg)

[](https://www.analyticsvidhya.com/wp-content/uploads/2015/01/scikit-learn-logo.png) [](https://static.javatpoint.com/tutorial/pandas/images/python-pandas.png) [](https://miro.medium.com/max/765/1*cyXCE-JcBelTyrK-58w6_Q.png)

repository: kh-bilal/Data-Science-Portfolio

repo_name: kh-bilal/Data-Science-Portfolio


text:
## [Unreleased]
Updated the reference to the traffic light protocol indicator field to use the new **cliname**.

## [20.3.4] - 2020-03-30
Improved test module functionality.

## [20.3.1] - 2020-03-04
-

## [20.2.4] - 2020-02-25
#### New Integration
This integration provides TAXII Services for system indicators (Outbound feed).