text:
# Change Log

All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

## [3.2.2](https://github.com/vuejs/vuefire/compare/vuexfire<EMAIL_ADDRESS>(2020-03-17)

**Note:** Version bump only for package vuexfire

## [3.2.1](https://github.com/vuejs/vuefire/compare/vuexfire<EMAIL_ADDRESS>(2019-12-31)

**Note:** Version bump only for package vuexfire

# [3.2.0](https://github.com/vuejs/vuefire/compare/vuexfire<EMAIL_ADDRESS>(2019-10-10)

### Features

* **vuexfire:** add wait option ([beb1ecb](https://github.com/vuejs/vuefire/commit/beb1ecb))
* **vuexfire:** allow reset option for rtdb ([b57a13b](https://github.com/vuejs/vuefire/commit/b57a13b))
* **vuexfire:** propagate `this` to actions wrapped by `firestoreAction` and `firebaseAction` ([#352](https://github.com/vuejs/vuefire/issues/352)) ([a16cd45](https://github.com/vuejs/vuefire/commit/a16cd45))

## [3.1.2](https://github.com/vuejs/vuefire/compare/vuexfire<EMAIL_ADDRESS>(2019-08-06)

**Note:** Version bump only for package vuexfire

## [3.1.1](https://github.com/vuejs/vuefire/compare/vuexfire<EMAIL_ADDRESS>(2019-08-05)

**Note:** Version bump only for package vuexfire

repository: EmilienLeroy/vuefire

repo_name: EmilienLeroy/vuefire


text:
---
title: Madison, WI
permalink: "/madison"
name: Letter to Council Members
state: WI
city: Madison
layout: email
recipients:
-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>subject: Reallocation of Funds from MPD to Social Service Programs
body: |-
  Dear Madison Council Members and Alderpersons,
  My name is [YOUR NAME] and I am a resident of [NEIGHBORHOOD/CITY].
  I am extremely concerned with the City of Madison's inordinate investment in the Madison Police Department (MPD) at the expense of critical youth, education, and health services.
  I am asking that the Madison Common Council make a more overt and visible commitment to racial justice. I demand that the budget vote be delayed so that Council may find ways to redirect money away from Madison Police Department’s overinflated budget. I urge you to pressure the City Manager’s Office towards an ethical and equal reallocation of the city’s expenditures, away from MPD, and towards sectors that facilitate the dismantling of racial and class inequality.
  Research shows that a living wage, access to holistic health services and treatment, educational opportunity, and stable housing are far more successful at reducing crime than police or prisons. As such, I demand more aggressive financial support be directed to those areas.
  I also urge the Madison Common Council to enact legislation that holds police accountable and to overturn policies that allow police to engage in unlawful behavior with impunity. Justice will only be served when the police are reformed, and this will not be possible until we defund them.
  People are marching in the streets because they know that these actions will result in a healthier, more just society. I implore you to please listen to the needs of your constituents and take immediate action to address their concerns.
  Can I count on you to consider an alternative budget that puts a focus on social service programs?
  Thank you for your time,
  [YOUR NAME]
  [YOUR ADDRESS]
  [YOUR EMAIL]
  [YOUR PHONE NUMBER]
---

license: MIT

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive


text:
---
layout: meeting-summary
title: Discussion on proposal to re-enable a subset of opcodes
group: opcodes
time: 20170131 1100 (UTC)
version: 1.0
participants: [
    Amaury Sechét of Bitcoin ABC,
    Shammah Chancellor of Bitcoin ABC,
    Jason B Cox of Bitcoin ABC,
    shadders of nChain,
    Dan Connoly of BitcoinJ Cash,
    Dagur of Bitcoin XT,
    Andreas Suisani of Bitcoin Unlimited,
    Josh Yabut
]
---

REQUEST TO EDITORS:

This document is intended to be updated so as to act as a reference for the topic at hand.  However, due to the nature of this also reflecting the discussion of a meeting which occured at a particular point in time, any additional information or clarification should be clearly marked as an editor's note "e.n."

# Discussion Topic

In order to support non-trivial cash use cases for the Bitcoin Cash blockchain, a number of ecosystem participants would like to see some of the original Bitcoin OpCodes re-enabled for use in smart contracts.  However, the original issues associated with these opcodes remain valid.  Namely, undefined behavior, and potential for DDoS attacks against the network.

The purpose of this discussion is to review a (specification proposed)[https://github.com/shadders/uahf-spec/blob/5ca75404f31d35fe3f682dd94580a5f111acf144/reenable-op-codes.md] by Steve Shadders and Dan Connolly which proposes to re-enabled a subset of the original Bitcoin OpCodes while addressing undefined behavior and any potentials for DDoS using contracts.

## Brief Overview of the Bitwise Logic Operators

Three operators are proposed to be re-enabled: `OP_AND`, `OP_OR`, and `OP_XOR`. These operators all take two operands from the stack, perform the bitwise logic operation on them, and push the result back on the stack.

```
   x1 x2 OP_AND -> out
```

Options on specification details were included for discussion in the meeting.

# Concerns Raised

The size of the operands for the operators was raised as a concern. Two options were proposed in the draft specification. The first option was the *restrictive* option, which was to require the size of the operands to be the same. The second option was a more *liberal* choice, which was to automatically "left pad" the shorter operand to make it equal in length to the longer operand before performing the operation. The concern raised here centered on the data type of the operands: it is not possible to determine the data type of the operands and "left padding" numeric operands is not the same as "left padding" byte arrays due to the presence of the sign-bit for numeric operands.

There was also a concern that the operators could be used to produce elements which are expected to be numeric, but which are not in canonical form and would subsequently cause errors. An example is `0x2020 0x00FF OP_AND`. This example would produce `0x0020` which, as a number, is not in canonical form.

With regard to the lengths of the operands for the bitwise operators, the proposal includes a recommendation for the more restricted option be selected for implementation. This option requires the lengths of the operands to be the same. Any danger inherent in automatically "left padding" operands is obviated.

# Possible Solutions

## OP_PADLEFT_NUM

Introduce a specialized padding operator which treats the stack element to be padded specifically as a number, converting it to a canonical form as a byte array.  This operator would need to be applied binary operands to ensure that binary operators are working with numbers in a canonical format.

## OP_BIN2NUM and OP_NUM2BIN

Another operator may be added: `x OP_BIN2NUM -> n`. This operator will convert a binary array into a valid (canonical) numeric element. It accounts for the sign bit. The input operand can be any byte length (within the SCRIPT_MAX_ELEMENT_SIZE limit) but the result must fit within the maximum size of the numeric elements (currently 4 bytes with one sign bit, do not depend on the specific size, it is possible the maximum size will change in the future). Example: 0x0000000002 OP_BIN2NUM -> 0x02. If the result would be too large, the operator fails.

* We propose to add an operator `n m OP_NUM2BIN -> out`. This operator will convert a numeric value `n` into a byte array of length `m`. Both `n` and `m` must be valid numeric values. `m` can be any size up to SCRIPT_MAX_ELEMENT_SIZE. The sign bit is accounted for and moves to the left bit of the result. The result may not be a valid numeric value (e.g. `0x02 4 OP_NUM2BIN -> 0x00000002`).

# Resolution

Steve Shadders and Dan Connolly will add a section at the beginning of the specification document describing the data types supported by the scripting language. This section must make it very clear that all data is considered to be an "array of bytes" type, unless specifically stated. Only the operators in the *arithmetic* section are designed for the numeric type, which is a subset of the "array of bytes" type, and have certain limitations (size and canonical form). Rules from BIP62 that have been implemented should also be included in this section.

Steve Shadders and Dan Connolly favor the operators `OP_BIN2NUM` and `OP_NUM2BIN` and will update the specification to reflect adding these operators.  These operators, unlike `OP_PADLEFT_NUM`, emphasize that the operators change the *type* of the operands and to highlight that the bitwise operators use binary operands, not numeric operands. The bitwise operators do not account for the sign bit in numeric values.

path: /workgroups/wg-opcodes/summaries/20180131 - Meeting Summary.md

filename: 20180131 - Meeting Summary.md

gha_language: CSS


text:
# App.Application

See `App.DOMApplication` for a non-abstract implementation.

## Purpose

The Application object in Typescene plays a major role when dealing with Activities. It keeps track of activities in a stack-like model, automatically activating and suspending activities as they become the topmost item on the activity stack (an instance of `App.ActivityStack`).

* Use the `.startActivityAsync` method to start an activity explicitly, either using an `App.Activity` reference, an `App.Activation` object, or by route (URL path) -- if activities are mapped to routes using the `App.mapRoute` decorator.
* Use the `.dropActivityAsync` method to remove an activity from the stack.
* Use the `.getTopActivity` method to obtain a reference to the current topmost activity.
* Use `.activities` to invoke the `ActivityStack` [.getCursor](~/App.ActivityStack/getCursor) method, which can be used to traverse the activities currently on the stack.

The `.startActivityAsync` method is also aliased as `App.startActivityAsync`.

Additionally, the Application object maintains a reference to the currently active `App.CultureService` in `.culture`, and observes changes to be applied to the UI.

# App.Application/PageNotFound

## Example
```typescript
// Redirect to #/ and log a warning message
App.Application.current.PageNotFound.connect(path => {
    console.log("Page not found: " + path);
    App.startActivityAsync("#/");
})
```

repository: Happy-Ferret/typescene

repo_name: Happy-Ferret/typescene


text:
# JsonReader

_JsonReader_ is a portable lightweight event-driven JSON data reader with a simple API written in C++.
It is especially suitable for reading large amounts of JSON text, since data is not stored in memory.
Extracting values using a callback-based approach instead of traversing the DOM tree should make the code more efficient and compact.
It is based on the same idea as the [SAX](https://en.wikipedia.org/wiki/Simple_API_for_XML) XML parsers.

## The API

_JsonReader_ is implemented as a C++ class. The API provides a set of methods that associate a callback with an event related to a JSON element (for example, when a certain key is found):

     void **onObjectBegin(** _element_, _callback_ **);**    // The definition of the object _element_ starts.
     void **onObjectEnd(** _element_, _callback_ **);**    // The definition of the object _element_ finishes.
     void **onArrayBegin(** _element_, _callback_ **);**    // The definition of the array _element_ starts.
     void **onArrayEnd(** _element_, _callback_ **);**    // The definition of the array _element_ finishes.
     void **onArrayItem**( _element_, _callback_ **);**    // An item of the array _element_ is found.
     void **onPair(** _element_, _callback_ **);**    // A key/value pair (where _element_ is the key) is found.

+ **_element_** is the name or path of the element we want to receive the event from, passed as a UTF-8 or a wide character string. This argument can be null, meaning that we want to receive this event from all elements that apply (e.g. to get notified when any object is found).
+ **_callback_** represents the code we want to get called when that event on that element happens. It is of type [std::function](https://en.cppreference.com/w/cpp/utility/functional/function) so it can be any callable target such as a function or a lambda expression. The execution of the callback is synchronous, and therefore the next JSON element will not be processed until it is done.

See the [header file](JsonReader.h) for the actual C++ syntax.

Example:

```
jsonReader.onArrayBegin("users", []()
{
    // Do something when the array 'users' has just been found.
});
```

In case the name of the target element can exist in different contexts (e.g. keys with the same name in different objects) or the element has no name (e.g. an unnamed object), the element's path must be used instead. Paths uniquely locate elements in the JSON data. See [below](#using-the-elements-path) for an explanation about how paths are built.

The methods **onArrayItem()** and **onPair()** respectively supply the array item's value and the key's value to the callback as a string pointer, provided that the value is of type string, number or boolean. Otherwise this pointer is null.

Values can be received as:

+ UTF-8 strings.
+ Wide character strings.
+ Non-Unicode multibyte strings, encoded according to a locale such as ISO-8859-1 or GB18030.

Example:
```
jsonReader.onPair("id", [](const char* value)
{
    // Print the value of 'id'.
    if (value)
        std::cout << "id: " << value << std::endl;
});
```

Once the callbacks have been defined, the next step is to start processing the JSON data. This is done by calling the methods **readFile()** or **readBuffer()** for reading from a file or a null terminated buffer:

     bool **readFile(** const char* _fileFullPath_ **);**
     bool **readBuffer(** const char* _buffer_ **);**

In either case, JSON data must be encoded in UTF-8.
The buffer is accessed directly, so it must not be modified until the process is finished.

If a problem occurs while parsing the data, these methods return _false_ and a description of the error can be obtained by calling the method **getErrorDescription()**.

From inside the callback it is possible to get information about the current context through the following methods:

+ **getCurrentElementPath()** and **getCurrentElementName()**. If the callback was not associated to a specific element (by setting the first argument '_element_' to null, as explained before), these methods can be used to find out the JSON path or the name of the current element being notified. There are different versions available: returning narrow or wide strings, by reference or by value.
+ **isValueQuoted()**. Returns _true_ if the value was quoted in the JSON data. Since values are notified as strings, this method allows distinguishing between, for example, reading the number 123 and the string "123", or reading the boolean _true_ and the string "true". Anyway, this distinction should not be necessary, as the type of the data passed to the callback is supposed to be known in advance.
+ **isPathAscii()**. Returns _true_ if the current path contains only ASCII characters.
+ **isArrayItemValue()**. Returns _true_ if the array item being notified is of type string, number, boolean or null. Therefore, it returns _false_ if this item is an object or an array.

In the following example, we get notified every time an item from any array is found. Then, we find out the name of each array and check if the current item is an actual value (string, number, boolean or null) or not (object or array).
```
// Set first argument to null to receive this event from any array.
// Capture the JSON reader in the lambda expression so we can use it.
jsonReader.onArrayItem((const char*)nullptr, [&jsonReader](const char* value)
{
    std::string arrayName = jsonReader.getCurrentElementName();
    bool isValue = jsonReader.isArrayItemValue();
    std::cout << "Array name: " << arrayName << std::endl;
    if (isValue)
    {
        if (value)
        {
            // The array item is a string, a number or a boolean.
            // We could use the method 'isValueQuoted' to discriminate.
            std::cout << "Item is " << value << std::endl;
        }
        else // The array item is 'null'
        {
            std::cout << "Item is null" << std::endl;
        }
    }
    else
    {
        std::cout << "Item is an object or a nested array" << std::endl;
    }
});
```
### Progress notification and cancellation

The progress, expressed as the number of bytes read so far in percentage, can be obtained in two ways:
+ Calling the method **getProgress()** (e.g. from a timer).
+ Registering a callback using the method **onProgress()**, which expects two arguments:
    + **_step_** as the increment of the percentage to notify. It must range from 1 to 99. For example, a value of 10 will send a notification every 10%. This is a target value; the actual progress value is passed to the callback.
    + **_callback_** as the code to execute whenever the progress percentage increments beyond **_step_**. It receives the current percentage as an integer. It is executed synchronously, so it should not be time consuming (e.g. just update a member variable).

See the [header file](JsonReader.h) for the actual C++ syntax.

The progress can be cancelled by calling the method **cancel()**. The reader will exit after the current item is processed.
Since the reader's thread is busy parsing the JSON data, this method must be called from a separate thread.
The method **isCancelled()** returns _true_ if the process was cancelled.

### Support for non-Unicode multibyte strings

If one or more callbacks handle the input values as narrow strings, these are passed as UTF-8 by default. However, by calling the method **useLocale()**, values can be encoded according to a locale (ISO-8859-1, GB18030, etc.):

     void **useLocale(** bool _useLocale_, const char* _locale_ **);**

The boolean _useLocale_ enables or disables the conversion of the strings extracted from the JSON data. If _true_, the argument _locale_ specifies the identifier of the locale to use for the conversion. Please make sure that the proper identifier is used, and that the locale is installed in your computer.

In this example, a name containing the letter 'e' with acute accent is converted to a non-Unicode string based on the Latin alphabet:
```
const char* data = R"({ "name": "Ren\u00E9e" })"; // 'Renée'
JsonReader jsonReader;

#ifdef _MSC_VER  // Windows
jsonReader.useLocale(true, ".1252");
#else  // Linux (check that the locale is installed with 'locale -a')
jsonReader.useLocale(true, "en_US.ISO-8859-1");
#endif

jsonReader.onPair("name", [](const char* value)
{
    if (value)
    {
        // Output is 0x52 (R) 0x65 (e) 0x6E (n) 0xE9 (é) 0x65 (e)
        for (size_t i = 0; i < strlen(value); i++)
            printf("0x%02X ", (unsigned char)value[i]);
    }
});
// Read the JSON data.
jsonReader.readBuffer(data);
```

### Full example

The following example extracts user data (name and identifier) from a set of key/value pairs and it also enumerates the colors contained in a list.

The method **onPair()** is used to associate callbacks with the events of finding the keys '_name_' and '_id_'.
In the same way, the method **onArrayItem()** is used to set a callback that will be triggered for each item found in the '_colors_' array.
These callbacks receive a string with the corresponding value.

```
// Input data
const char* data = R"s(
{
"users": [
    {
        "name": "Alice",
        "id": 1
    },
    {
        "name": "Bob",
        "id": 2
    },
    {
        "name": "Charlie",
        "id": 3
    }
],
"colors": [
    "red",
    "green",
    "blue"
]})s";

// Create an instance of the JSON reader.
JsonReader jsonReader;

// Associate callbacks with the following events:

// Find user names.
jsonReader.onPair("name", [](const char* value)
{
    std::cout << "User name: " << value << std::endl;
});
// Find user identifiers.
jsonReader.onPair("id", [](const char* value)
{
    std::cout << "User id: " << value << std::endl;
});
// Find color names.
jsonReader.onArrayItem("colors", [](const char* value)
{
    std::cout << "Color: " << value << std::endl;
});

// Start processing the JSON data.
jsonReader.readBuffer(data);
```
The output is:
```
User name: Alice
User id: 1
User name: Bob
User id: 2
User name: Charlie
User id: 3
Color: red
Color: green
Color: blue
```

By capturing variables in the lambda expressions, you can do more interesting things such as storing the received values in member variables.
See another example [here](Sample.cpp).

### Using the element's path

As mentioned before, paths uniquely locate elements in the JSON data, and should be employed when the use of the element's name may lead to ambiguity.
In this implementation, paths are built by appending the names and the opening curly and square brackets found from the root up to the element (without quotes).
Additionally, object and array paths must end with an opening curly or square bracket, respectively.

In the previous example, the path of the key '_id_' is `{users[{id` because, beginning from the root object '_{_' (with path `{` ), we find the array '_users_' (path is now `{users[` ), and then an unnamed object '_{_' (path is now `{users[{` ) to finally reach the key '_id_' (final path is `{users[{id` ). Supposing that another key named '_id_' was also used in a different context, the ambiguity would be solved by using its path:

```
jsonReader.onPair("{users[{id", [](const char* value)
{
    std::cout << "User id: " << value << std::endl;
});
```

In order to help finding out the path of an element, the following methods are provided:

     bool **getPathsFromFile(** const char* _fileFullPath_, std::set`<std::wstring>`& _paths_ **);**
     bool **getPathsFromBuffer(** const char* _buffer_, std::set`<std::wstring>`& _paths_ **);**

These return the unique paths of all elements found in the JSON data contained in a file or UTF-8 buffer.
In the previous example, they would return the following paths:
```
{            // The root object.
{colors[     // The array 'colors'.
{users[      // The array 'users'.
{users[{     // An unnamed object contained in the 'users' array.
{users[{id   // The user's key 'id'.
{users[{name // The user's key 'name'.
```
Once the needed paths have been found out, the call to these methods can be removed.

## Also, a text encoding converter

The class _JsonReader_ uses a nested class named _TextConverter_ to convert text to different encodings:

+ Wide character string to UTF-8 string.
+ UTF-8 string to wide character string.
+ Multibyte string to UTF-8 string.
+ UTF-8 string to multibyte string.
+ Unicode 4-bytes code point to UTF-8 character.

The term 'Multibyte' here refers to a non-Unicode charset, where characters can be encoded with one or more bytes according to a locale such as ISO-8859-1 or GB18030.

This class is public so it can be used externally and even independently of the main class.

Example:
```
// Convert a wide string to UTF-8.
JsonReader::TextConverter converter;
std::wstring input = L"café";
std::string output = converter.WideToUtf8(input.c_str(), input.length());

for (const unsigned char& ch : output)
    printf("0x%02X ", ch); // UTF-8 output is 0x63 0x61 0x66 0xC3 0xA9 ('cafÃ©')
```
Please note that this class is not thread-safe.
See the [header file](JsonReader.h) for more details.

## Set-up

Add the files `JsonReader.cpp` and `JsonReader.h` to your project and include `JsonReader.h` in the source file.

## Constraints

+ JSON data must be encoded in UTF-8.
+ The compiler must support C++ 11.
+ To read multiple JSON inputs in parallel, a different instance for each input must be used.

## Portability

It has been tested on Windows 10 (Visual Studio 2017), Ubuntu 14.04 LTS (g++ 5.5.0) and Mint 19.2 (g++ 7.4.0).

Notes on Linux:

+ Use _g++_ version 5.5 or later, and compile with the flag _-std=c++11_.
+ The _codecvt_ header is used to perform the text encoding. This header has been deprecated from C++17, but there is no standard replacement at the time of writing. If this is an issue, you can replace it with your own code or with a third-party library such as [Boost](https://www.boost.org/).

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

repository: curiousTauseef/JsonReader

repo_name: curiousTauseef/JsonReader


text:
Thymeleaf Layout Dialect JS
===========================

[![Build Status](https://travis-ci.org/ultraq/thymeleaf-layout-dialect-js.svg?branch=master)](https://travis-ci.org/ultraq/thymeleaf-layout-dialect-js)

In-browser version of the [Thymeleaf Layout Dialect](https://github.com/ultraq/thymeleaf-layout-dialect),
used for static prototyping.

 - Current version: (still under development)
 - Released: (n/a)

Current goals
-------------

 - be as easy to use as dropping a script into a page
 - parse all the `layout` directives (I think the `data-layout` variations will be easiest)
 - start by working using http on localhost (ie: work on the `file:///` problem later)


text:
---
layout: default
---

# 1995-09-13 - Re: Whitehouse "dissident" web site monitoring?

## Header Data

From<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: bcbfb2489b5199a6f7a9b511197daa7e4a5481febfde50c64d8a95a37ea4d38c

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1995-09-13 04:03:34 UTC

Raw Date: Tue, 12 Sep 95 21:03:34 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>Date: Tue, 12 Sep 95 21:03:34 PDT
To<EMAIL_ADDRESS>Subject: Re: Whitehouse "dissident" web site monitoring?
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

>What abuse?  Is there an expectation of privacy in Web-world,
>such that all users can honestly expect that a site is compelled
>to keep its "visitor log" private?

Absolutely, just as there is an assumption that private email will not be
distributed over USEnet.

There is a clear expectation of privacy. Just as the user of a USEnet server has
an expectation of privacy. The question of what is legitimate to use log file
data for is a very keenly debated one at W3 conferences.

	Phill H-B

{% endraw %}
```

## Thread

+ Return to [September 1995](/archive/1995/09)

+ Return to "[Brian Davis <bdavis@thepoint.net>](/authors/brian_davis_bdavis_at_thepoint_net_)"
+ Return to "[hallam@w3.org](/authors/hallam_at_w3_org)"
+ Return to "[Rich Salz <rsalz@osf.org>](/authors/rich_salz_rsalz_at_osf_org_)"
+ Return to "[Tim Scanlon <tfs@vampire.science.gmu.edu>](/authors/tim_scanlon_tfs_at_vampire_science_gmu_edu_)"

+ 1995-09-13 (Tue, 12 Sep 95 19:56:29 PDT) - [Re: Whitehouse "dissident" web site monitoring?](/archive/1995/09/eb832fb00c7775133ab2859ae7723dba3956a1c892d4634c5e55845f5b409560) - _Rich Salz<EMAIL_ADDRESS>  + 1995-09-13 (Tue, 12 Sep 95 21:03:34 PDT) - Re: Whitehouse "dissident" web site monitoring? -<EMAIL_ADDRESS>  + 1995-09-13 (Tue, 12 Sep 95 21:38:18 PDT) - [Re: Whitehouse "dissident" web site monitoring?](/archive/1995/09/a78446961d5675b331eaf12c5e8768d5d886084b9c6ac552a07db13ee76796ef) - _Brian Davis<EMAIL_ADDRESS>  + 1995-09-14 (Wed, 13 Sep 95 22:17:21 PDT) - [Re: Whitehouse "dissident" web site monitoring?](/archive/1995/09/2bbf3c43acee0dae9090d3e43275c1476e616651cc26dd36ed06392966095ff2) - _Tim Scanlon<EMAIL_ADDRESS>


text:
---
layout: page
---
# Evidence of testing

#### Manual testing

* Test Case 16

<video width="700" controls>
  <source src="../img/evidence/rooms.mp4" type="video/mp4">
</video>

* Test Case 17

<video width="700" controls>
  <source src="../img/evidence/pause.mp4" type="video/mp4">
</video>

* Test Case 18

<video width="700" controls>
  <source src="../img/evidence/demo.mp4" type="video/mp4">
</video>

* Tests Case 19

#### Automated testing
Automated tests have been designed with the help of material available here.

* JUnit test results can be found here.

branch_name: refs/heads/main


text:
---
layout: postag
title: 'PRON'
shortdef: 'pronoun'
udver: '2'
---

### Definition

A pronoun is a word that functions as a substitute for a noun or noun phrase. Pronouns have reference to entities that are participants in an event or possessors of an attribute, without specifying them by name.

Spanish pronouns can be personal (e.g., _yo_, _tú_, _él_), reflexive (e.g., _me_, _te_, _se_), demonstrative
(e.g., _este_, _ese_, _aquel_), relative (e.g., _que_, _quien_, _cual_), interrogative/exclamatory (e.g., _quién_, _qué_, _cuál_),
indefinite (e.g., _alguien_, _algo_, _ninguno_), or possessive (e.g., _mío_, _tuyo_, _suyo_).

Pronouns in Spanish agree in gender, number, and sometimes case with the noun or noun phrase they replace or refer to.
Pronouns can also take on different forms based on their syntactic function, such as subject, object, or possessive.
Possessive pronouns always function as determiners and are denoted by the [DET]() tag. They agree in gender and number
with the noun they modify and receive the feature [Poss]()`=Yes` to indicate their possessive nature.

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

gha_language: HTML

repo_name: UniversalDependencies/docs


text:
# DNS-validation

A NodeJS component used for DNS validation.

## Table of contents

- [Getting started](#getting-started)
- [Features](#features)
- [Usage](#usage)
- [Want to Contribute?](#want-to-contribute)
- [Need Help / Support?](#need-help)
- [Collection of Other Components](#collection-of-components)
- [Changelog](#changelog)
- [Credits](#credits)
- [License](#license)
- [Keywords](#Keywords)

## Getting started

Install the npm package:

``` bash
npm install nodejs-weblineindia-dns-validation
#OR
yarn add nodejs-weblineindia-dns-validation
```
## Features

- This component checks if domain name is registered and has a valid MX or A record.

## Usage

Use `isValidDNS` function to validate dns server:

```js
const { isValidDNS } = require('nodejs-weblineindia-dns-validation');
OR
import { isValidDNS } from 'nodejs-weblineindia-dns-validation'

async function valid(serverAddress) {
    try {
        // call this function in async function
        const result = await isValidDNS(serverAddress);
        console.log("Result ",result);
    } catch (error) {
        console.log(error)
    }
}

// call the function to check dns server
valid('smtp-mail.outlook.com')
```

-----

## Want to Contribute?

- Created something awesome, made this code better, added some functionality, or whatever (this is the hardest part).
- [Fork it](http://help.github.com/forking/).
- Create new branch to contribute your changes.
- Commit all your changes to your branch.
- Submit a [pull request](http://help.github.com/pull-requests/).

-----

## Need Help?

We also provide a free, basic support for all users who want to use dns validation in their software project. In case you want to customize this dns validation component as your development needs, then feel free to contact our [NodeJS developers](https://www.weblineindia.com/hire-node-js-developer.html).

-----

## Collection of Components

We have built many other components and free resources for software development in various programming languages. Kindly click here to view our [Free Resources for Software Development](https://www.weblineindia.com/software-development-resources.html).

------

## Changelog

Detailed changes for each release are documented in [CHANGELOG.md](./CHANGELOG.md).

## Credits

nodejs-weblineindia-dns-validation is inspired by the [dns](https://nodejs.org/api/dns.html).

## License

[MIT](LICENSE)

[mit]: https://github.com/miguelmota/is-valid-domain/blob/e48e90f3ecd55431bbdba950eea013c2072d2fac/LICENSE

## Keywords

 nodejs-weblineindia-dns-validation, node-dns-validation, dns-validation, dns, dnsvalidator, nodejs, node-component, nodecomponent, node, dns-resolver

repository: weblineindia/NodeJS-DNS-Validation

repo_name: weblineindia/NodeJS-DNS-Validation


text:
# Distributed Architecture

A Distributed Architecture is one that takes into account multiple servers running a conglomerated application or set of applications.  It may and often does involve more than one physical location.

This type of system brings a new set of problems to your application development.

- `Coordination`: Who's on first?
- `Consensus`: Does everyone have the same view of the system?
- `Scheduling`.  How do you determine where to run applications, processes?
- `Storage`.  If services are in different locations, how do they access common storage?
- `Service Discovery`.  Where are the other things I need to communicate with?

# Coordination

- Group membership

	Which servers are responsible for managing task X?

- Locking

	When only one system should execute a process how do you decide?

- Publisher/Subscriber

	Who is responsible for publishing, or consuming messages?

- Ownership

	Who owns this process, task, file, etc?

- Synchronization

	Run X first, then Y, when X and Y are on different nodes.

Common Tools:

- Zookeeper
- Etcd
- Consul

# Consensus

Does everyone have the same view of the system?

[Wikipedia](https://en.wikipedia.org/wiki/Consensus_(computer_science))

	The consensus problem requires agreement among a number of processes (or agents) for a single data value.

Some of the processes (agents) may fail or be unreliable in other ways, so consensus protocols must be fault tolerant or resilient.

The processes must somehow put forth their candidate values, communicate with one another, and agree on a single consensus value.

Common Tools:

- Zookeeper
- Etcd
- Consul

# Scheduling

How do you determine where to run your applications, processes, tasks?

- Simple solutions
	- Bash script
	- SystemD/Init/Upstart

- More control
	- Ansible/Puppet/Chef

- Most control
	- Mesos/Marathon/Kubernetes/DKron

# Storage

If services are in different locations, how do they access common storage?

- Cloud Services (Google,Rackspace,AWS, etc) use block storage
- Everyone else has to find another solution
	- Gluster
	- Minio
	- NFS - :(
	- Pinning Services to physical machines
	- Ceph

# Service Discovery

Where are the other things I need to communicate with?

- Service A lives on host X with IP adddress and port J:K
- Machines 1,2,3 provide "WWW" service

Common Tools:

- Zookeeper
- Etcd
- Consul
- SkyDNS
- mDNS (multicast DNS)
- DNS SRV Records

# Choosing boundaries between your applications

Whether you're starting a distributed application from scratch or breaking a monolith into smaller pieces, it's difficult to decide where your boundaries are.

Fortunately there are a few well proven patterns that help you decide.

# Architectural patterns

– Monolithic architecture
– Three-tiered architecture
– Request/response services
– Nearline and offline services
– Synchronous and asynchronous services
– Database per service

## Monolithic

A monolithic architecture is one where all components live in a single application.  No boundaries to set.

## Three Tiered Architecture

- User Facing (web or UI)
- Business Logic
- Data Access

Three tier architectures lend themselves well to distributed applications.  Even if you have more than 3 services running, you can still consider your application 3 tiered if the boundaries of the services follow these guidelines.

## Request/Response Services

Request/Response services are more loosely formed than three-tiered services.  There still has to be an endpoint where external users communicate with the aggregated service.  But a R/R architecture is defined at the microservice level, with many different services.

## Nearline and Offline Services

`Nearline` - Services that run in near real-time with your application(s)

`Offline` - Services that run after the fact

Nearline and Offline services usually require a queue of some sort to manage the work that needs to be done.

## Synchronous and Asynchronous Services

`Synchronous` - Request and wait for a response

`Asynchronous` - Request and get a response later, with some sort of signal that the work is complete.

## Database Per Service

In the Database Per Service model, each service in a distributed application has a separate database.  This is in contrast with a monolith database where one or many services talk to a single database.

The benefit of Database Per Service is scalability.

The downside is data integrity, which must be maintained without foreign keys.

# Exercise 1

Start a consul cluster between your three machines.

[Use progrium/consul from docker](https://hub.docker.com/r/progrium/consul/)

Follow the directions at https://hub.docker.com/r/progrium/consul/ to create a consul cluster between your three nodes.

Explore the UI at port 8500 on one of the machines.  Set a key in the KV store and see it propagate to the other two machines.

# Exercise 2

Run a minio (s3 compatible) server.

	docker run -v /mnt/minio:/minio -d -p 9000:9000 minio/minio:latest server /minio
	docker logs to see access information

	edit $GOPATH/src/architecture/exercises/minio/main.go to use YOUR keys/ID

	go build

	./minio

	browse minio at http://server.IP:9000

repository: ahmed-masud/learngo

repo_name: ahmed-masud/learngo