text:
# Acceptable Use Policy

*Effective date: April 21, 2022*

Prospect One ("us", "we", or "our") operates the cdn.jsdelivr.net website (the "Service" or "jsDelivr").

By using jsDelivr, you agree to follow this Acceptable Use Policy (the "Policy").
If you are found to be in violation of the Policy at any time, as determined by
Prospect One in its sole discretion, we may warn you, prevent you from using our
Service, or take any other action we deem appropriate. Please note that we may
change our Acceptable Use Policy at any time, and it is your responsibility to
keep up-to-date with and adhere to the Policy posted here.

## 1. Permitted Use

jsDelivr works as a CDN for content already stored on npm, GitHub, and other
third-party services. These services are not operated by us, and each of them has
its own terms of use.
Any content accessed via jsDelivr must conform to the terms of the service from
which it was retrieved. For example, when you use jsDelivr as a CDN for GitHub,
the content must conform to all GitHub's policies.
Additionally, any content accessed via jsDelivr must conform to our own policies
as described in this document.

As long as you do not violate our rules:
 - using jsDelivr is free for both personal and commercial use,
 - there are no limits on bandwidth or number of requests,
 - we will provide a reasonable level of support via GitHub issues and email for
   urgent and private matters.

## 2. Hard Limits and Restrictions

To maintain the performance and security of our Service, we have
various limits and restrictions in place. These may include but are not limited to:
 - maximum size of a single file,
 - maximum number of files in a single package,
 - maximum size of a single package,
 - blocking of certain file extensions.

When requesting a resource that does not meet these limits, you will get an error
response indicating the reason. The limits are set considerably higher than needed
for most projects and may be further increased or removed for legitimate projects
on request.

## 3. Soft Limits and Recommendations

These limits are not automatically enforced by our Service, but you agree not to
exceed them:

 1. For projects using our GitHub proxy:
     - We recommend that the number of actively accessed files per repository
       does not exceed 10 000. If you have considerably more files, a custom
       proxy endpoint for your project may be a better fit.
     - The soft limit for the number of files per repository is 100 000.

These recommendations are not automatically enforced by our Service, but may
indicate whether a project falls within the Permitted or the Prohibited use
when it is not immediately clear. We recommend that each project:
 - has a meaningful name,
 - has public documentation and an appropriate license that allows use by other people,
 - in case of npm packages, links to a public source code repository,
 - does not contain intentionally obfuscated code.

## 4. Prohibited Use

The following behavior is prohibited:

 1. Hosting or accessing content that:
     - contains malware or harmful code in any form,
     - violates proprietary rights of others,
     - is sexually explicit,
     - is potentially illegal in the EU or the USA.

 2. Abusing the service and its resources, or using jsDelivr as a general-purpose
    file or media hosting service. This includes, for example:
     - running an image hosting website and using jsDelivr as a storage for all
       uploaded images,
     - hosting videos, file backups, or other files in large quantities.

    We recognize that there are legitimate projects that consist of a large number
    of files, and these are not considered abuse. For example: icons packs, apps,
    or games with a large number of assets.

 3. Trying to bypass our limits or restrictions in any way. We will be happy
    to remove limits or provide custom solutions for legitimate projects.

## 5. Additional Restrictions in China

jsDelivr holds an ICP license issued by the Chinese government,
which allows us to operate infrastructure directly in Mainland China.
To keep this license and allow our Chinese users to benefit from the performance
improvements it provides, any content served via our Chinese network must conform
to Chinese policies. Content potentially violating Chinese policies may be
blocked in China without warning.

## 6. Limitation of Liability

In no event will the Prospect One and/or jsDelivr entities be liable to you
or any third party for any direct, indirect, incidental, special, consequential,
or punitive damages arising out of or relating to your access to or use of,
or your inability to access or use, the websites and online services or any materials
or content on the websites and online services, whether based on warranty, contract,
tort (including negligence), statute, or any other legal theory, whether or not
the Prospect One and/or jsDelivr entities have been informed of the possibility of such damage.

## 7. Contact Us

If you have any questions about this Acceptable Use Policy, please contact us:

By email<EMAIL_ADDRESS>

url: https://raw.githubusercontent.com/jsdelivr/jsdelivr/3fcbd5fe84ad2fa5a9dd56d4fb38668c1913969f/Acceptable Use Policy - jsdelivr.net.md

repository: jsdelivr/jsdelivr

filename: Acceptable Use Policy - jsdelivr.net.md

gha_language: JavaScript

repo_name: jsdelivr/jsdelivr


text:
# How to scale out a DolphinDB cluster

## 1. Introduction

This tutorial introduces how to scale out a DolphinDB cluster in order to increase its storage capacity and computing power.

## 2. About a DolphinDB Cluster

A DolphinDB cluster consists of 3 types of nodes: controller, agent, and data node.
- The controller manages the metadata of a cluster and provides the web cluster management interface.
  The controller has 3 core configuration files:
    - controller.cfg : the configuration parameters for the controller node, such as IP address, port number, the maximum number of connections, etc.
    - cluster.nodes : a list of nodes of the cluster. The controller node uses this file to get information of the cluster nodes.
    - cluster.cfg : personalized configuration of each node in the cluster, such as the volume attribute of a particular node.
- An agent is deployed on each physical machine and is responsible for starting and stopping local data nodes. The configuration file on the Agent is as follows
    - agent.cfg: Defines the properties of the proxy node, such as the proxy node IP and port, the cluster's controller node, etc.
- Data dodes for computing, querying, and data storing.

To add a new physical machine to a cluster, we need to take the following steps:
- Deploy an agent on the new server and configure the agent.cfg
- Register new Data Node information and Agent information with the Controller
- Restart the controller and all data nodes

To expand the storage space of an existing data node, we can modify the node configuration file of the node to add a path to the `volume` attribute.

## 3. Expand Data Nodes

In the example below, we add a new physical server to a cluster, and we deploy a data node on this new physical server.

Add new physical machine IP
```
<IP_ADDRESS>
```

The IP address, port number, and the unique alias name in the cluster.
```
<IP_ADDRESS>:8804:datanode4
```
The configuration of the original cluster is as follows:

controller.cfg
```
localSite=<IP_ADDRESS>:8990:ctl8990
```
cluster.nodes
```
localSite,mode
<IP_ADDRESS>:8701:agent1,agent
<IP_ADDRESS>:8701:agent2,agent
<IP_ADDRESS>:8701:agent3,agent
<IP_ADDRESS>:8801:node1,datanode
<IP_ADDRESS>:8802:node2,datanode
<IP_ADDRESS>:8803:node3,datanode
```
Start Controller
```
nohup ./dolphindb -console 0 -mode controller -script dolphindb.dos -config config/controller.cfg -logFile log/controller.log -nodesFile config/cluster.nodes &
```
Start Agent
```
./dolphindb -mode agent -home data -script dolphindb.dos -config config/agent.cfg -logFile log/agent.log
```

In order to verify the effect after the expansion work is completed, we create a partitioned database in the cluster and write the initial data.
```
data = table(1..1000 as id,rand(`A`B`C,1000) as name)
// we increase the partition range to 2000 to leave space for the subsequent writing task.
db = database("dfs://scaleout_test_db",RANGE,cutPoints(1..2000,10))
tb = db.createPartitionedTable(data,"scaleoutTB",`id)
tb.append!(data)
```
After the execution, you can navigate the generated data through the dfs explorer of the cluster web interface.

![image](https://github.com/dolphindb/Tutorials_CN/blob/master/images/scaleout/scale_dfs_exp1.PNG?raw=true)

After the completion of the node and storage extensions, we append the data in the same way to verify that the new node and storage are enabled.

> * For the cluster initial configuration, please refer to [multi-physical deployment cluster tutorial] (https://github.com/dolphindb/Tutorials_CN/blob/master/multi_machine_cluster_deploy.md)*

### 3.1 Configure Agent

The agent on the original server is deployed in the /home/<DolphinDBRoot> directory, copy the files in the directory to the /home/<DolphinDBRoot> directory of the new machine, and modify /home/<DolphinDBRoot>/config/agent.cfg

```
#Specify the ip and port of the agent itself
localSite=<IP_ADDRESS>:8701:agent4
#Specify the controller position of this cluster
controllerSite=<IP_ADDRESS>:8990:ctl8990
Mode=agent
```

### 3.2 Configure Controller

Modify file cluster.nodes to configure the newly added Data Node and Agent

```
localSite,mode
<IP_ADDRESS>:8701:agent1,agent
<IP_ADDRESS>:8701:agent2,agent
<IP_ADDRESS>:8701:agent3,agent
<IP_ADDRESS>:8801:node1,datanode
<IP_ADDRESS>:8802:node2,datanode
<IP_ADDRESS>:8803:node3,datanode

#newly added agent and data node
<IP_ADDRESS>:8704:agent4,agent
<IP_ADDRESS>:8804:node4,datanode
```

#### 3.3 Restart the cluster

To make newly added data node and storage take effect, we need to restart the entire cluster, including the cluster controller and all Data Nodes.

- Access the cluster web management interface ```http://<IP_ADDRESS>:8990``` to close all data nodes.

 ![image](https://github.com/dolphindb/Tutorials_CN/blob/master/images/scaleout/controller_stopAll.PNG?raw=true)

- Execute ```pkill dolphindb``` on the <IP_ADDRESS> server to shut down the Controller.
- After waiting for half a minute (waiting for the port to be released, depending on the operating system), restart the Controller again.

- Back to the web management interface, you can see that an agent4 has been added and is started. All data nodes are started on the web interface.

 ![image](https://github.com/dolphindb/Tutorials_CN/blob/master/images/scaleout/Controller_StartAll.PNG?raw=true)

At this point we have completed the addition of new nodes.

### 3.4 Verification

Let's verify that node4 is already enabled in the cluster by writing some data to the cluster.
```
Tb = database("dfs://scaleout_test_db").loadTable("scaleoutTB")
Tb.append!(table(1001..1500 as id,rand(`A`B`C,500) as name))
```
Looking at the dfs explorer, you can see that the data has been distributed to the new node4 node.

![image](https://github.com/dolphindb/Tutorials_CN/blob/master/images/scaleout/scale_dfs_exp2.PNG?raw=true)

### 3.5. Data distribution mechanism after extending data nodes

In a cluster of popular MPP architectures, after adding nodes, some data must be resharding, because the hash value changes, and it usually takes a long time to perform resharding on big amount of data.
The data storage of DolphinDB is based on the underlying distributed file system, and the data copy is managed by metadata. Therefore, after the node is expanded, the original data does not need to be resharding,
and the newly added data is saved to the new node according to the distribution policy.

Of course, data distribution can be made more evenly distributed, and DolphinDB is developing such a tool.

## 4. Extended storage

Due to insufficient disk space on the server where node3 is located, a disk has been expanded with the path /dev/disk2, which is included in the storage of node3.

### 4.1 Steps

The node storage of DolphinDB can be configured through the volumes attribute in the configuration file. In the case above, if there is no configuration,
the default storage path will be <HomeDir>/<Data Node Alias>/Storage. In this case, it is under /home/server/data/node3/storage.

> If you add a disk from the default path, you must explicitly set the original default path when setting the volumes property.
Otherwise, the metadata will be lost in the default path.

The default volume attribute is as follows. If there is no such line, you need to add it manually.

cluster.cfg
```
node3.volumes=/home/server/data/node3/storage
```

To add the new disk path /dev/disk2/node3 to the node3 node, just separate the new path with a comma after the above configuration.

cluster.cfg
```
node3.volumes=/home/server/data/node3/storage,/dev/disk2/node3
```

After modifying the configuration file, execute loadClusterNodesConfigs() on the controller to reload the node configuration. If the above steps are completed on the cluster management web interface, the overload process will be completed automatically without manual execution.
After the configuration is complete, there is no need to restart the controller. Just restart the node3 node on the web interface to make the new configuration take effect.

>
If you want node3 not to restart, but the new storage will take effect immediately, you can add variables by executing function addVolumes("/dev/disk2/node3") on node3. However, the effect of this function will not be persisted unless you configure as above.

### 4.2 Verfication

After the configuration is complete, write the new data to the cluster through the following statement to see if the data is written to the new disk.
```
tb = database("dfs://scaleout_test_db").loadTable("scaleoutTB")
tb.append!(table(1501..2000 as id,rand(`A`B`C,500) as name))
```
Observed data has been written to the disk:

![image](https://github.com/dolphindb/Tutorials_CN/blob/master/images/scaleout/3.PNG?raw=true)

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# `quickref`

Stylesheets and other support structures for building reference
documentation from markdown using pandoc. Does some pre-processing of
reference files in order to simplify the required syntax for
cross-references, and allows separate specification of reference content
and concept groupings into actual pages.

## Dependencies

- `make` (or you can just look at the Makefile and run the appropriate
  commands yourself)
- `pandoc`
- `python3`

## Usage

- First, place one or more `.ref` files into the `concepts/` directory
  (see `example.ref` for an example of the format).
- Next, edit `pages.json` to specify the concept grouping(s) that you'd
  like to generate HTML pages for.
- Finally, run `make` to build the specified reference pages, which will
  be put into the `out/` directory.

repository: solsword/quickref

repo_name: solsword/quickref


text:
# Remove-StatusCakeHelperMaintenanceWindow

## SYNOPSIS
Remove a StatusCake Maintenance Window

## SYNTAX

### ID
```
Remove-StatusCakeHelperMaintenanceWindow [-APICredential <PSCredential>] [-ID <Int32>] [-Series] [-PassThru]
 [-WhatIf] [-Confirm] [<CommonParameters>]
```

### name
```
Remove-StatusCakeHelperMaintenanceWindow [-APICredential <PSCredential>] [-Name <String>] -State <String>
 [-Series] [-PassThru] [-WhatIf] [-Confirm] [<CommonParameters>]
```

## DESCRIPTION
Deletes a StatusCake Maintenance Window using the supplied ID or name.
If the series switch is not provided then the next window scheduled under the ID will be removed.
The entire series of windows can be removed if the series switch is provided.

## EXAMPLES

### EXAMPLE 1
```
Remove-StatusCakeHelperMaintenanceWindow -ID 123456
```

Remove the next pending maintenance window under id 123456

### EXAMPLE 2
```
Remove-StatusCakeHelperMaintenanceWindow -ID 123456 -Series
```

Remove the series of maintenance windows scheduled under id 123456

## PARAMETERS

### -APICredential
Credentials to access StatusCake API

```yaml
Type: PSCredential
Parameter Sets: (All)
Aliases:

Required: False
Position: Named
Default value: (Get-StatusCakeHelperAPIAuth)
Accept pipeline input: False
Accept wildcard characters: False
```

### -ID
The maintenance window ID

```yaml
Type: Int32
Parameter Sets: ID
Aliases:

Required: False
Position: Named
Default value: 0
Accept pipeline input: False
Accept wildcard characters: False
```

### -Name
A descriptive name for the maintenance window

```yaml
Type: String
Parameter Sets: name
Aliases:

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -State
The state of the maintenance window to remove.
Required only when removing a MW by name.

```yaml
Type: String
Parameter Sets: name
Aliases:

Required: True
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -Series
Set flag to cancel the entire series of maintenance windows instead of cancelling the one window

```yaml
Type: SwitchParameter
Parameter Sets: (All)
Aliases:

Required: False
Position: Named
Default value: False
Accept pipeline input: False
Accept wildcard characters: False
```

### -PassThru
Return the object to be deleted

```yaml
Type: SwitchParameter
Parameter Sets: (All)
Aliases:

Required: False
Position: Named
Default value: False
Accept pipeline input: False
Accept wildcard characters: False
```

### -WhatIf
Shows what would happen if the cmdlet runs.
The cmdlet is not run.

```yaml
Type: SwitchParameter
Parameter Sets: (All)
Aliases: wi

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -Confirm
Prompts you for confirmation before running the cmdlet.

```yaml
Type: SwitchParameter
Parameter Sets: (All)
Aliases: cf

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### CommonParameters
This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable.
For more information, see about_CommonParameters (http://go.microsoft.com/fwlink/?LinkID=113216).

## INPUTS

## OUTPUTS

## NOTES

## RELATED LINKS


text:
# piwik-sdk-wincpp

## Reference Documentation

These are the entry points provided by the Piwik tracking library:

1. Construction:

	``PiwikClient (LPCTSTR url, int id = 0)``

	Parameters:

	``url``: the Piwik endpoint where requests are to be sent (can be changed later with SetApiUrl)
	``id``: the numeric ID of the site being tracked (can be changed later with SetSiteId)

2. Configuration:

	``int  CurrentSiteId ()``

	Returns the ID of the site currently being tracked.

	``void SetSiteId (int id)``

	Allows to set the numeric ID of the site being tracked, as known to the target Piwik server.

	``TSTRING CurrentUserId ()``

	Returns the string identifying the user accessing the Piwik service in this tracker.

	``void SetUserId (LPCTSTR p)``

	Allows to set the string identifying the user on this tracker (usually username or email address).
	This value will be used to generate the field VisitorId.

	``TSTRING CurrentApiUrl ()``

	Returns the URL of the target Piwik server.

	``void SetApiUrl (LPCTSTR p)``

	Allows to set the URL of the Piwik server where requests are to be sent. If no scheme is provided, http:// will be assumed. If http:// is explicitly specified, a non secure connection on port 80 will be used. If https:// is explicitly specified, a secure connection on port 443 will be established. The new value will be used for all tracking calls issued after this point.

	``int  CurrentRequestMethod ()``

	Returns the HTTP request method currently used to send requests to the Piwik server.

	``void SetRequestMethod (PiwikMethod m)``

	Allows to set the HTTP request method to be used. It can be one of the following values:

		PIWIK_METHOD_GET
		PIWIK_METHOD_POST

	Using GET will send the query parameters URL-encoded within the URL line of the request. Using POST (the default) will send the query encoded as a JSON object in the body of the request. This results in a more efficient transfer since several queries (up to 20) can be sent together in one physical request.

	``bool UsesSecureConnection ()``

	Returns if secure mode (SSL) is being used to communicate with the Piwik server.

	``void SetSecureConnection (bool f)``

	Allows to select the use of secure connections. When true, SSL will be used to access the Piwik service on port 443. Otherwise requests wil be sent unencoded over port 80.

	``TSTRING CurrentUserAgent ()``

	Returns the name of the user agent transmitted to Piwik with each query.

	``void SetUserAgent (LPCTSTR p)``

	Allows to set the name of the user agent transmitted to Piwik with each query. If not specified, the default value ("Piwik Client Windows Desktop") will be used.

	``TSTRING CurrentLanguage ()``

	Returns the language code being transmitted to Piwik with each query.

	``void SetLanguage (LPCTSTR p)``

	Allows to set the 2-letter language code to be transmitted to Piwik with each query.

	``void SetUserVariable (LPCTSTR nam, LPCTSTR val, int ind = -1)``

	Allows to set the name and value of a user (or global) variable. Both name and value are limited to 200 characters. There are up to 5 such variables available on each site, and each one of them	should keep always the same position in the set in order to be correctly tracked. The parameter ind allows to specify explicitly this position. If not provided, the tracker will try to deduce its value by looking up a variable with the same name in the current set. If found, its same index will be used, otherwise a free slot will be taken. If no free slots are remaining, the last slot will	be overwritten. Setting a NULL value for the variable will free the corresponding slot.

	``TSTRING CurrentApplication ()``

	Returns the name of the application being used to write settings in the Registry.

	``void SetApplication (LPCTSTR p)``

	Allows to set the name of the application to be used when writing settings to the Registry.

	``TSTRING CurrentLocation ()``

	Returns the base location corresponding to the site being tracked.

	``void SetLocation (LPCTSTR p)``

	Allows to set the base location of the site being tracked. This value will be prepended to the specific URL supplied in each tracking call if this URL is not absolute (i.e. if it doesn't contain a scheme delimited by a colon). Using this mechanism allows to simplify the URL parameter sent with each tracking call.

	``bool SetSessionTimeout (int t)``

	Allows to set the timeout in seconds after which a new session will be started. It defaults to 30 minutes. At the start of each session general identification data about the site being tracked is sent again to the	Pikik service.

	``void SetConnectionTimeout (int t)``

	Allows to set the timeout in seconds when trying to open a connection to the Piwik server.

	``void SetDispatchInterval (int t)``

	Allows to set the delay in seconds between successive connections to the Piwik server when using asynchronous mode. Tracking queries will remain pending during this time and be sent together at the end of each interval. Setting this value to 0 will effectively set synchronous	behavior. Setting it to a negative value will disable automatic transmission and will require a call to Flush to send data to the server. A value of 120 seconds will be used by default.

	``void StartNewSession ()``

	Allows to force the start of a new session.

	``bool IsPersistent ()``

	Returns if user data is being persisted to the registry.

	``void SetPersistent (bool v)``

	Allows to select persistent mode for user statistics. When persistent mode is active, number of visits and visit times will be stored in the Windows Registry for each user under the key HKEY_CURRENT_USER\Software\<application>\<username>. This allows the Piwik server to produce better	analytics for registered users.

	``bool IsDisabled ()``

	Returns if the tracker is temporarily out of service.

	``void SetDisabled (bool v)``

	Allows to set the tracker temporarily out of service. Tracking calls will be ignored in this state.

	``bool IsDryRun ()``

	Returns if the dry run mode is active.

	``void SetDryRun (bool v)``

	Allows to set dry run mode, in which tracking requests are processed but not sent effectively to the network. If logging is active, they will be dumped instead to the log stream.

	``void SetLogger (wostream* s, PiwikLogLevel lvl)``

	Allows to provide an output stream to which diagnostics of the library will be written for use by the hosting application.

3. Tracking

	Following calls can be used to track standard situations. They all return on success a positive identifier that can be used later to query the outcome of the request.

	``int TrackEvent (LPCTSTR path, LPCTSTR ctg = 0, LPCTSTR act = 0, LPCTSTR nam = 0, float val = 0)``

	Parameters:

	``path``: the URL of the event (required)
	``ctg``: the category of the event
	``act``: the action being tracked
	``nam``: the name of the property being tracked
	``val``: the numeric value associated with this property

	```
	int TrackScreen (LPCTSTR path, LPCTSTR act = 0, LPCTSTR nam1 = 0, LPCTSTR val1 = 0,
                    LPCTSTR nam2 = 0, LPCTSTR val2 = 0, LPCTSTR nam3 = 0, LPCTSTR val3 = 0,
                    LPCTSTR nam4 = 0, LPCTSTR val4 = 0, LPCTSTR nam5 = 0, LPCTSTR val5 = 0)
	```
	Parameters:

	``path``: the URL of the event (required)
	``act``: the action being tracked
	``nam[1-5]``: the name of a local variable associated with this screen
	``val[1-5]``: the value of this variable

	Local variables should keep always the same position within this set in order to be correctly tracked. When sending these values to the server they will be assigned to the slot corresponding to the positional parameter being used. Any unneeded slots can be filled with NULL.

	``int TrackGoal (LPCTSTR path, int goal, float rev = 0)``

	Parameters:

	``path``: the URL of the event (required)
	``goal``: the numeric identifier of the goal being tracked
	``rev``: the amount indicating the revenue corresponding to this goal

	``int TrackOutLink (LPCTSTR path)``

	Parameters:

	``path``: the URL of the followed link (required)

	``int TrackImpression (LPCTSTR path, LPCTSTR content, LPCTSTR piece, LPCTSTR target)``

	Parameters:

	``path``: the URL of the event (required)
	``content``: the name of the content being shown
	``piece``: the specific piece within this content
	``target``: the target associated with this content

	``int TrackInteraction (LPCTSTR path, LPCTSTR content, LPCTSTR piece, LPCTSTR target, LPCTSTR action)``

	Parameters:

	``path``: the URL of the event (required)
	``content``: the name of the content being shown
	``piece``: the specific piece within this content
	``target``: the target associated with this content
	``action``: the specific action being tracked

	To track more complex situations a ``PiwikState`` can be explicitly constructed and provided as such:

	``bool Track (PiwikState& st)``

	Parameters:

	``st``: the state to be tracked, containing following fields:

		int SiteId;
		TSTRING UserId;
		TSTRING VisitorId;
		int ApiVersion;
		TSTRING UserAgent;
		TSTRING Language;
		TSTRING ScreenRes;
		PiwikVariableSet UserVariables;
		TSTRING TrackedPath;
		TSTRING TrackedAction;
		TSTRING EventCategory;
		TSTRING EventAction;
		TSTRING EventName;
		float EventValue;
		int Goal;
		float Revenue;
		TSTRING OutLink;
		TSTRING ContentName;
		TSTRING ContentPiece;
		TSTRING ContentTarget;
		TSTRING ContentInteraction;
		PiwikVariableSet ScreenVariables;

	``bool Flush ()``

	Allows to send all pending requests to the server. This is called implicitly when closing the Piwik instance.

	``int  RequestStatus (int rqst, int wait = 0);``

	Allows to query the outcome of a tracking request based on the identifier provided by the tracking call. A positive integer indicates success while a negative one indicates failure. Zero will be returned while the status is still unknown, and a timeout in seconds can be provided to instruct the function to wait for a defined state if necessary.

license: MIT

repository: MULTIPLAYER-LABORATORY/piwik-sdk-wincpp

repo_name: MULTIPLAYER-LABORATORY/piwik-sdk-wincpp


text:
@name Hydration Node Mismatch
@category runtime
@shortDescription During hydration, Angular expected a DOM node, but either the actual DOM was different or was not found.

@description
This error means that during the hydration process, Angular expected a DOM structure as rendered and annotated during server side rendering. However, on the client, the DOM tree was different than the server rendered DOM tree.

This error typically happens due to direct DOM manipulation using native browser APIs that alter the DOM structure outside of what Angular produced. It will also occur if you use `innerHTML` or `outerHTML` to set HTML content, which similarly alters the DOM structure outside of what Angular produced. You can resolve this by refactoring the component to use native Angular APIs instead of native APIs. If that's not possible, you can add the `ngSkipHydration` attribute to your component's host node, which will disable hydration for the component and its children. `ngSkipHydration` should only be used as a last resort and should be considered a bug that needs to be fixed.

More information about hydration can be found in [this guide](guide/hydration).

The following example will trigger the error.

```typescript
@Component({
  standalone: true,
  selector: 'example-cmp',
  template: '<div><span>world</span></div>',
})
export class ExampleCmp {
  hostElement = inject(ElementRef).nativeElement;

  ngOnInit() {
    // Create a new <p> element with the `Hello` text inside
    const newNode = document.createElement('p');
    newNode.innerHTML = 'Hello';

    // Insert the <p> before the first element. Since Angular has no information
	  // about the <p> element, it will be looking for the <div> element at the first
	  // element position instead. As a result, a hydration mismatch error would be
	  // thrown. Instead, update component's template to create the <p> element.
	  this.hostElement.insertBefore(newNode, this.hostElement.firstChild);
	}
}
```

@debugging
The error message in the developer console should contain information on a specific part of the application's DOM structure that is causing the problem. Review that part of the application for hydration-related errors, such as direct DOM manipulation using native APIs.

Check that your template has valid HTML structure. See more information in the [hydration guide](guide/hydration#valid-html-structure).

You can add the `ngSkipHydration` attribute to your component host node as a possible workaround.

If your application works in development environment, but you see hydration errors in production builds, make sure that the generated HTML that is delivered to a browser contains comment nodes produced by Angular during the rendering on the server. Those comment nodes are used by Angular runtime as anchors for view containers (with and without hydration) and hydration process expects them to be present at their original locations. If you have a custom logic to remove comment nodes from the HTML generated by the server-side rendering or you've configured your CDN to remove them before serving the content - disable the comment nodes removal and check if hydration errors are gone.

repository: angular/angular

branch_name: refs/heads/main

gha_language: TypeScript

gha_license_id: MIT

repo_name: angular/angular


text:
# BinaryDataParser [![Travis master](https://img.shields.io/travis/ak80/BinaryDataParser/master.svg?maxAge=3600)](https://travis-ci.org/ak80/BinaryDataParser) [![Coverage Status](https://coveralls.io/repos/github/ak80/BinaryDataParser/badge.svg?maxAge=3600)](https://coveralls.io/github/ak80/BinaryDataParser?branch=master) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/34e46b5a77694ea2a11227b915235218)](https://www.codacy.com/app/josef-koch/BinaryDataParser?utm_source=github.com&utm_medium=referral&utm_content=ak80/BinaryDataParser&utm_campaign=Badge_Grade) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.ak80.bdp/BinaryDataParser/badge.svg?style=flat-square)](https://maven-badges.herokuapp.com/maven-central/org.ak80.bdp/BinaryDataParser/) [![GitHub license](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg?style=flat)](http://www.apache.org/licenses/LICENSE-2.0)

BinaryDataParser is used to parse binary data into POJOs and to serialize it. It generates a custom
mapper (combined parser/serializer) for each class. The mapping for a property is
defined with an annotation.

The code is written in Kotlin but the unit tests are in Java. The software is
licensed under the Apache License 2.0

## Quickstart

You need to add a runtime and a compile time dependency. Then you add the annotations to
the class you want to map. When you compile this clas, a custom mapper will be generated and can then be
used from your code.

### Add dependency

Add this dependency to you project

~~~~
        <dependency>
            <groupId>org.ak80.bdp</groupId>
            <artifactId>bdp-runtime</artifactId>
            <version>1.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.ak80.bdp</groupId>
            <artifactId>bdp-processor</artifactId>
            <version>1.0.1</version>
            <optional>true</optional>
        </dependency>
~~~~

### Add annotations to the class you want to map

```java

public class ClassToMap {

  @MappedByte(index = 0)
  private int byte0;

  @MappedByte(index = 1)
  private int byte1;

  @MappedWord(index = 2, endianess = Endian.BIG_ENDIAN)
  private int wordBig;

  @MappedWord(index = 4, endianess = Endian.LITTLE_ENDIAN)
  private int wordLittle;

  // getters / setters omitted for brevity

}

```

### Use generated mapper

```java

public class ClassToMapTest {

  @Test
  public void testParse() {
    // Given
    ClassToMap classToMap = new ClassToMap();
    ClassToMapParser parser = new ClassToMapParser();

    int[] data = new int[]{0x01, 0x02, 0x03, 0x04, 0x05, 0x06};

    // When
    parser.parse(classToMap, data);

    // Then
    assertThat(classToMap.getByte0(), is(0x01));
    assertThat(classToMap.getByte1(), is(0x02));
    assertThat(classToMap.getWordBig(), is(0x0304));
    assertThat(classToMap.getWordLittle(), is(0x0605));
  }

  @Test
  public void testSerialize() {
    // Given
    ClassToMap classToMap = new ClassToMap();
    ClassToMapParser parser = new ClassToMapParser();

    classToMap.setByte0(0x01);
    classToMap.setByte1(0x02);
    classToMap.setWordBig(0x0304);
    classToMap.setWordLittle(0x0506);

    int[] data = new int[6];

    // When
    parser.serialize(classToMap, data);

    // Then
    assertThat(data, is(new int[]{0x01, 0x02, 0x03, 0x04, 0x06, 0x05}));
  }

}
```

## Purpose

Generate parser and serializer for byte data based an annotations on properties of the class.

For each class with annotations a Parser-Serializer class will be generated. When parsing it consumes an int array and sets the
properties according to the definitions made with the annotations. When serializing it produces an int array based on the properties of the given object.

## Use of the AnnotationsProcessor
The AnnotationsProcessor is in the bdp-runtime JAR file and registers a Service. Just drop it into your classpath!

## Supported mappings

### Mapping a single byte value

A single byte value is mapped to / from a numeric with the *@MappedByte* annotation:

```java

  @MappedByte(index = 0)
  private int byte0;

```
The parameter *index* defined the position of the byte in the array.

### Mapping a two byte value

A two byte value is mapped to / from a numeric with the *@MappedWord* annotation:

```java

  @MappedWord(index = 0)
  private int wordBig;

  @MappedWord(index = 2, endianess = Endian.LITTLE_ENDIAN)
  private int wordLittle;

```

The parameter *index* defined the position of the word in the array. The parameter *endianess* defined
the byte order, either *Endian.BIG_ENDIAN*, which is the default, or *Endian.LITTLE_ENDIAN*.

### Mapping a single bit to a boolean

** only supported in snapshot, please see in the tests or wait for the next release **

### Mapping a group of bits to an enum

** only supported in snapshot, please see in the tests or wait for the next release **

## Planned Features

* Mapping one or more bits to a numeric
* Mapping one or more bits to an enum, with a builder class
* Handling bit flags for a group of booleans
* Create a new array when serializing
* Generate new instance instead of need to pass an existing instance
* Generate documentation
* Sanity checking for overlapping definitions
* Sanity checking for unmapped parts
* Default settings e.g. for endianess
* Suppport has/get with flags instead of only is


text:
# mesoscope

[![Latest Version](https://img.shields.io/pypi/v/meoscope.svg?style=flat-square)](https://pypi.python.org/pypi/mesoscope)
[![Build Status](https://img.shields.io/travis/sofroniewn/mesoscope/master.svg?style=flat-square)](https://travis-ci.org/sofroniewn/mesoscope)
[![Binder](https://img.shields.io/badge/launch-binder-red.svg?style=flat-square)](http://mybinder.org:/repo/sofroniewn/mesoscope)

> preprocessing and conversion for mesoscope data

This package contains a module and command line tool to process raw data from the [two-photon random access mesoscope](https://elifesciences.org/content/5/e14472) (2P-RAM). The raw output of the mesocope, via the ScanImage control software, is a matrix of resonant scan lines across multiple rois stored as TIF files. For the majority of applications, users will want to merge and reshape their contents into images that are appropriately merged and reshaped. This module helps you do that.

# install

You can install using pip

```
pip install mesoscope
```

# example

Here we'll convert the example test data included with the repository

```python
import mesoscope as ms

data, meta = ms.load('test/resources/input')
newdata, newmeta = ms.convert(data, meta)

data.shape
>> (23, 5152, 64)

converted.shape
>> (23, 464, 576)
```

# use as command line tool

Given a directory with input TIF files and a metadata file as JSON, just call

```
mesoscope convert input/ output/
```

This will create a folder `output` with the converted images. Type `mesoscope convert -h` to see other options. Note that during image writing `int16` values will be written as `uint16` so any negative values will be clipped at 0.

# use as a module

The `mesocope` package includes just two methods

#### `data, meta = load(path, engine=None)`

Loads both data and metadata from the specified `path`. The optional `engine` can be used to load the data using a parallel backend. Currently supports either `None` (for local compute) or a `SparkContext` (for parallelization using a Spark cluster).

#### `newdata, newmeta = convert(data, meta)`

Converts the given data using the provided metadata. The `data` should be a `numpy` array or a `thunder` `images` object.

repository: freeman-lab/mesoscope

repo_name: freeman-lab/mesoscope


text:
# videoScroll

[![Bower version](https://img.shields.io/badge/bower-v0.5.1-green.svg)](https://github.com/rbingham/videoScroll)

Video Scroll is an angular directive to allow for playing an html5 video while you scroll.

## Installation
	bower install angular-videoScroll --save

## Code Examples

Include videoScroll as a dependency of your angular module.
```js
angular.module('yourModule', ['videoScroll']);
```

Add the play-video attribute to the video you want to play.
```html
<video id="v0" tabindex="0" autobuffer="autobuffer" preload="preload" play-video>
</video>
```

To change the scroll speed of the video add the time attribute.
Note: The default time is .15 seconds.
```html
<video id="v0" tabindex="0" autobuffer="autobuffer" preload="preload" play-video time=".15">
</video>
```

To change when the video starts playing relative to the top of the screen (in pixels), use the offset attribute.
```html
<video id="v0" tabindex="0" autobuffer="autobuffer" preload="preload" play-video offset="100">
</video>
```

To change whether normal scrolling is disabled while the video is playing, add the preventScroll option. Default is set to true.
```html
<video id="v0" tabindex="0" autobuffer="autobuffer" preload="preload" play-video preventScroll="true">
</video>
```

## License

Video Scroll is an open-sourced software licensed under the [MIT licence](http://opensource.org/licenses/MIT)

repository: rbingham/videoScroll

repo_name: rbingham/videoScroll


text:
Assignment # 2

**RESEARCH PAPERS**

**1.**`` **Newell, A. and H.A Simon, Human Problem Solving, Englewood Cliffs, NJ., Prentice       Hall, 1972 (summary paper)**

2. Hayes-Roth,F., Rule based systems, Communications of the ACM, vol . 28, no 9, pp., 921-932, september 1985

3. Michie, D., Expert systems, The computer journal, vol 23, no 4, pp 369-376, 1980

HUMAN PROBLEM SOLVING

Allen Newell & Herbert A. Simon

REFERENCES

This project is an attempt to build the catalogue for Artificial Intelligence books. I would proudly say I used Internet as a least preferable source for getting information, although I know I could have found many more on internet.

What I tried to do was to collect all books that exist in the CUNY (City University of NY) library database. So that it would make students and readers to know range of books that exist in CUNY and also provide them exact location to find those books.

Other than that what I tried to do, was to get the reference books usually found at the end of each books as references. This was a much better source as it gave me the exact books related to the research topic.

In this assignment I tried to avoid the duplication of records, if in case there exist one, I am sorry for that.

Enjoy!

Prof. Danny Kopec

CIS 718

Submitted by

Aalia Rafique

October 18, 2005

HUMAN PROBLEM SOLVING

This research conducted by Allen Newell and Herbert A. Simon focuses mainly on the human thinking and information processing. Human system is considered, as a system constitute of many parts like sensory subsystems, memory, effectors, arousal subsystems, and so on. It shows many of the dimensions along which the total human system can vary.

Mainly three issues are put under consideration in this research. These are:

Task dimension

Human behaves in different classes of situations. For example walks, talks, reads etc.

 Performance learning development dimensions

By keeping the task environment control, one can distinguish in performing a task, earning a task, and developing a task.

Individual difference dimensions

Each person is a member of population. Every person differs systematically, unique genetic endowment and historical fate.

This research has been studied in detail in this book by developing a discussion on Chess, symbolic logic and algebra like puzzles. These tasks are short, moderately difficult problems of symbolic nature. Research mostly dealt with the performance, and some learning but doesn’t deal with the development or differences related to age. It de-emphasizes the details of processing on the time scale of elementary reactions. Similarly long term integrated activities extending over periods or days or years receive no attention. It studies the performance of intelligent adults in culture.

The main concern in this study is given to the integrated activities that constitute problem solving and ignores the perception, motor skills or personality variables. Or we can say that the human performance in problem solving is analyzed more rather than the learning capability.

IPS (information processing system)

Human dealing with different task, depending on the task environment and the problem space is called as the processor of information. This theory describes how does the man processes task oriented symbolic information.

Information processing theory mainly describes the processes of human problem solving, characteristics of information system that carries out the processes and the nature of task environment in which the processes operate. The information processing system theory constitutes that:

- Human when engaged in      problem solving are represented as information processing systems
- Substantial subject      differences exist among programs, that involves the differences of problem      structure, method and content
- Substantial task      differences exist among programs, that involves differences of structure      and content
- Task environment and      intelligence of problem solver determines behavior of problem solver,      independently of the detailed internal structure of information processing      system

Specific variations in the behavior by individuals and by tasks, and also the general predictability of intelligent behavior from the requirements of the task are the pervasive features of human behavior. This confronts all attempts to develop human psychology.

According to this theory the four basic propositions for the information system are:

- A few and only a few      characteristic of human IPS are invariant over tasks and problem      solvers  In human problem solving      memory , processing , programs, retrieval time, etc are the main      constitutes of information processing system. The invariants in human      processing are:
- - Size, access       characteristics and read and write times for the various memories in       human IPS
  - Serial character of IP       and the rate at which the elementary information processes can be       performed
  - Production and goal       character

These invariants determine and affect the information processing in problem solving situation.

In human information system Long-term memory (LTM) has infinite capacity of storing information. The smallest unit of memory in IPS is called as SYMBOL. LTM is referred as associative as it holds the symbols in a relative fashion. The retrieval time in LTM is more. Other kind of memory is the SHORT TERM MEMORY (STM). This has a limited capacity and less access time than LTM. During the IPS processes STM holds the symbols needed for the given instant of time. Information in STM is not permanent and decays with time. All processes take their inputs from STM and leave out puts in STM. The rate of processing depends on three main factors:

- - - Number of processes        occurring simultaneously
    - Time required for each        processor
    - Amount of work done by        each processor

Other than that the most important feature for the IPS is the presence of EXTERNAL MEMORY (EM). The processing of IPS with and without the EM possesses great difference. For an IPS to be successful and efficient it should posses an EM.

- The characteristics of IPS      are sufficient to determine that a task environment is represented (in      IPS) as a problem space, and that problem solving takes place as a problem      spaces.           For the problem solver to      be efficient in decision problem space must have the enough knowledge      about the task environment. Whenever a problem is approached, problem      space must be created for it or retrieved from the memory. Problem spaces      can be changed or modified during problem solving. Problem space is the      place where the problem solving takes place. It contains not only the      problem actual solution but also the possible solutions. In problem      solving, processor not only searches for the exact solution but also to      formulate the solution using the available information. The search      involves the backup – that is , return from time to time to old knowledge      states and hence the abandonment of knowledge state information.
- The structure of task      environment determines the possible structures of problem space            for every task a different kind      of problem space is created. It means that the task environment can limit      the problem space. The effectiveness and completion of any task depends on      the structure of problem space. Problem space also reflects the aspects      relevant to task environment.
- The structures of problem      space determines the possible programs that can be used for problem      solving

In the problem space, usually problem solver has available repertory of such methods, which control his behavior under different conditions. During the task analysis and investigation of behavior of particular subject various methods are discovered. This allows the possibilities for behavior organization and permits us to drive consequences from one or the other method. Methods depend on the total situation other than the structure of problem space. Methods translate the information into the pattern of decisions.

This section argues that the method is not a completely independent variable to be added some how to the specification of the task environment, the goals of the problem solver, and the selection of the problem space. Clearly it is partly independent; a range of methods and mixtures is available, and a problem solver need not use all these methods, of the best ones. Which methods he does use is partly a measure of his intelligence and education. But his choices are highly circumscribed.

It is very difficult to compare the human behavior with the theory, as the human thinking is the dynamic, history dependent system.

Throughout this study human intelligence is referred as the adaptive system that can shape them into environment. A system that is not flexible to meet the demands of environment is not adaptive. The feature of the adaptive information processing system that shows through deal with the kind of memories available to the IPS as characterized by memory size, rates of reading and writing and accessing modes.

In general, computers, memory size, rates and ways of accessing determine the performance of system. The performance of computers is related to the flexibility of programs as it mediates between the detailed structure of computers and the structure of problem that is the situation to which it is to be adaptive.

The characteristics of the human intelligence “ memory an processing rates” determine that the problem space is a major invariant of problem solving. Or we can say that all problem solving occurs in some problem space. It is not necessary therefore, that the information processing system ‘s with different characteristics from the human will solve problems in the same way and will employ the problem spaces to organize their efforts.

Although the information processing system dictates that the problem solving shall take place in the same problem space, the task environment determines the structure of that space. Problem solving could be effective only if the significant information about the objective environment is encoded in the problem space where it can be used by the problem solver. But it is not necessary that all the relevant information in the task environment is reflected in the problem space. Therefore this theory defines that the intelligence of problem solver and the knowledge in relevant domain is sufficient to predict what problem space will be used. Thus the task environment remains the overwhelming determinant of problem space.

Only that decision is available for making decisions, which has been embedded in the problem space after its extraction from the task environment. Thus the possible programs can be sharply categorized by the kinds of information available.

Some fundamental characteristics of theory are discussed here:

Relation to Artificial intelligence

Most of the work in artificial intelligence has started from the psychological concerns. A theory of psychology of problem solving requires not only the good task analysis but also an inventory of possible problem solving mechanisms from which one can surmise what actual mechanisms are being used by humans.

Emphasis on performance

What sort of IPS a human becomes depends on the way he develops. Human learn continuously and much they do involves using in obvious ways information gathered for a specific purpose rather than solving difficult problems.

Learning transforms a system capable of certain performance into a system capable of additional ones. The study of learning theoretically must start with model of performing organisms. The study of learning takes its cue from the nature of performance system. In this research motivational and personality variables are excluded. As most of the work with the cognitive system. (Most AI recognition machines are built around the single act of recognition rather than the sequential and integrated behavior that is the heart of thinking)

The shape of theory

The theory proclaims man to be an information processing system, especially solving problems. The theory presents the set of processes or mechanisms that produce the behavior of human thinking. Thus the theory is reductionistic, it does not simply provide a set of relations or laws about behavior from which one can often conclude what behavior must be.

The theory purports to explain behavior and not just to describe it. The processes posited by theory exist in central nervous system as described by the human physiology and accepted by all sciences. This theory posits internal mechanisms of great extent and complexity and endeavors to make conduct between them and the visible evidences of problem solving.

The theory of individual

The technical apparatus for conceptualizing IPS leads to construct particular programs that accomplish particular tasks. Psychologically this aspect leads to constructing IPS that model the behavior of a single individual in a single task situation.

This model describes individuals, so it is required to get the precision what is common to all human IP. This theory views human as a complex mechanism whose parts and connections can ultimately be deciphered that is highly accepted by most of science.

Content oriented theory

This theory is content oriented. Theory explains a task by describing the manipulation of information down to the level where a simple interpreter (digital computer) can turn the description into an effective process for performing task.

Dynamically oriented theory

Information processing theory is dynamic, in describing the change in a system through time. Such theory describes the time course of behavior, characterizing each new act as a function of immediately preceding state of organisms and of its environment.

In information processing system the state is a collection of symbolic structures in memory, rather than the set of the values of position and momentum of physical system in some coordinate system. A program generally specifies a discrete change in a single component of state at a moment of time. Whereas a differential equation system specifies infinitesimal change in all coordinates simultaneously

The approach of this dynamic theory is to explore the steady state solutions of system (the place where the laws of motion say that nothing changes) and exploring the asymptotic behavior (what happens in long run).

An environment, not experimental theory

Due to the fact that much goes on within a single problem solving encounters experiments are only rarely useful. Rather it is essential to get enough data about each individual subject to identify what information he has and how he is processing it.

A nonstatistical theory

It is difficult to test theories of dynamic, history dependent systems. Theory and data are compared and some attempts are made to measure and tabulate such comparisons.

Sufficiency analysis

This theory puts efforts in discovering and describing systems of mechanisms that are sufficient to perform the cognitive tasks under study. Producing a system capable of performing provides a first approximation taking into account the limitations on humans’ ability to process information, processing rate, immediate memory and so on.

If an IPS meeting these constraints can be devised that does the task, then a revised system can be developed that has higher fidelity to specific data on human processing.

----

## ChangeLog

- 2018-07-16 李亮创建


text:
# 2016-06-03 Meeting minutes: Sprint 23 review

## Present:
- Brylie Oxley
- Taija Björklund
- Illya Nizyev
- Ville Jyrkkä
- Damir Mustafin
- Nazia Hasan

### Ilya

- Issue #929 - documentation upload functionality
  - Working demo:
    - Add link to documentation
    - Upload documentation file
    - Remove documentation file
    - Fields help text
  - Missing:
    - Confirmation window for file remove
  - Todo
    - Validation (file type, format, etc.)
- Issue #622

### Damir

- Issue #960 - cleanup config file & feedback for submit fix
- Issue #1080 - dynatable i18n text duplication

### Brylie

- TODO: Issue #648
- Issue #847 - Swagger UI alternatives research
  - ReDoc
- Issue #933 - Node-Red
- #937 Manual test session
- #950 Research generating code snippers from API documentation
- Monitoring service's status tools

### Ville

- File Upload feature
- Docker
- Deployment

### Nazia

- Issue #977 - Catalog research
  - Link to API catalog page placement: link does not show up when user is authenticated
  - Disable bookmarking options if not authenticated
  - Catalog search
  - Filtering by format/protocol
- Issue #978 - Heuristic Evaluation
  - Report: https://github.com/apinf/platform/blob/develop/docs/UX/APINF-Catalogue-Heuristic-Evaluation-Report

repository: apinf/docs

repo_name: apinf/docs


text:
# RedFoot-WebApp
> ### Web application for reporting wild animals that are percieved as a threat. The idea came from a need for communal knowledge around local wildlife.

> ### [Live Demo](https://redfoot.netlify.app)
[![Netlify Status](https://api.netlify.com/api/v1/badges/c4a32418-0f77-4622-b7d9-ecc0837a54ab/deploy-status)](https://app.netlify.com/sites/redfoot/deploys)

## Run Locally
---
## Authentication
In order for the map to allow users to make annotations they must be authenticated. This is done through *[Firebase](https://firebase.google.com)* and will require an API key to be placed in your `.env.development` file. You will also need a *[MapBox](https://account.mapbox.com/access-tokens/)* access token.

Example as follows:
```js
GATSBY_APP_ID="API_ID"
GATSBY_AUTH_DOMAIN="<Firebase auth domain>"
GATSBY_DB_URL="<Firebase Realtime database URL>"
GATSBY_FB_API="<Firebase API Key>"
GATSBY_MSG_ID="<Firebase Message ID>"
GATSBY_PROJ_ID="<Firebase Project ID>"
GATSBY_STRG_BUCKET="<Firebase Storage Bucket>"
GATSBY_MAP_API="<MAPBOX ACCESS TOKEN>"
```

Once you have setup your configuration for Authentication, Database and MapBox you can run `npm start` from the project's root directory.

## Next Steps
---
-[ ] Containerize the app to a docker image that will leverage and support local database solutions as well as off premise solutions.

-[ ] Adopt Material-UI component structure for map side bar.

repository: NetPenguins/RedFootWebApp

repo_name: NetPenguins/RedFootWebApp


text:
---
templateKey: blog-post
title: ASP.NET Sandbox Projects
path: blog-post
date: 2006-06-28T04:04:33.793Z
description: "[Ambrose] posted about the ASP.NET Sandbox yesterday (which I saw
  in my daily [DotNetSlackers] new email), which prompted me to have another
  look at it. Read [Ambrose’s post] first – he gives a nice overview of what’s
  there."
featuredpost: false
featuredimage: /img/default-post-image.jpg
tags:
  - asp.net
  - Cool Tools
category:
  - Uncategorized
comments: true
share: true
---
<!--StartFragment-->

[Ambrose](http://dotnettemplar.net/thecatsoutoftheboxtheaspnetsandbox.aspx) posted about the [ASP.NET Sandbox](http://www.asp.net/downloads/teamprojects/default.aspx?tabid=1) yesterday (which I saw in my daily [DotNetSlackers](http://dotnetslackers.com/) new email), which prompted me to have another look at it. Read [Ambrose’s post](http://dotnettemplar.net/thecatsoutoftheboxtheaspnetsandbox.aspx) first – he gives a nice overview of what’s there.

The list includes some projects that have had big press, like Web Application Projects and Web Deployment Projects, but there are also some less-well-known projects in the works including [BLINQ](http://www.asp.net/sandbox/app_blinq.aspx?tabid=62), which [ScottGu](http://weblogs.asp.net/scottgu) demo’d at TechEd, and a nice [Table Profile Provider](http://www.asp.net/sandbox/samp_profiles.aspx?tabid=62) that stores user profile data in a more accessible manner than the default SqlProfileProvider. I haven’t had a chance to get either of these working myself but I’ve downloaded them both and hope to do so soon.

Another tool that looks promising to me is the [IIS Log Parser](http://www.asp.net/sandbox/app_logparser.aspx?tabid=62). I’ve downloaded this and used it in the past and it’s pretty nice – comes with full source, too. I’m not using it in my day-to-day activities yet or anything, but it’s certainly worth checking out, both as a useful app and as a nice example of how to write such an application.

<!--EndFragment-->

repository: ShadyNagy/ardalis-com-gatsby

repo_name: ShadyNagy/ardalis-com-gatsby


text:
# side.js
## Synchronous javascript thanks to caching & pure functions.

This is a tool to make it easier to write asynchronous AWS Lambda functions.
It helps avoid "callback hell" and/or promises for those who prefer a more
traditionnal synchronous style of programming. It works outside of AWS
Lambda too.

```javascript
Side( function( side ){
  try{
    var a = side.slot( cb => async_read( "a", cb ) );
    var b = side.slot( () => promise_read( "b" ) );
    signal_success( a + b );
  }catch( err ){ side.catch( err );
    signal_error( err );
  }
} );
```

Don't:

```javascript
async_read( "a", function( err, a ){
 if( err )return signal_error( err );
 async_read( "b", function( err, b ){
   if( err )return signal_error( err );
   signal_success( a + b )
 } );
} );
```

Nor:

```javascript
promise_read( "a" ).then(
  ( a ) => promise_read( "b" ).then(
    ( b ) => signal_success( a + b ),
    ( err ) => signal_error( err )
  ),
  ( err ) => signal_error( err )
);
```

The idea is fairly simple. A synchronous function is a function that does
not need to "block". But blocking is often necessary. Can it be considered
a recoverable 'exception' however?

Yes but only when nothing irreversible was done before the block, ie when
there was no "side effects". In that case, the same code can run again,
possibly multiple times, until no more reasons to block remain.

With a good cache policy, running the same code multiple times is ok
performance wise when the associated cost is low compared to a cache
miss, a miss that typically involves an IO operation.

To use async functions, sync functions must cache async results. `Side.slot()`
helps about that. It works with promises too.

Please note that each side action has its own new cache. To manage caches
with longer lived results, "memoize" type of solutions may help; there are
multiple npm packages that implement it and other caching schemes.

Side action objects created using `Side()` are thenables, `Promise.all()`
and `Promise.race()` work on them.

Unfortunately this does not work for "write" type of code. Such code cannot
run multiple times or else multiple writes accumulate and this is not
usually the desired effect. Hence, write code cannot run synchronously
unless some special code detects and/or avoid double writes.

A solution is to postpone writes until all reads are done, when possible.
Another one is to provide routines to erase side effects, routines to run
when a block occurs. In that case, code is included in a transaction and
no other side action can run until the transaction is done. A third solution is
to avoid double writes by remembering that a write was done already, ie
caching writes.

### Lambda usage:

```javascript
exports.my_function = Side.lambda( function( event ){
  // ... build result ... using Side methods & Side.context
  return result;
} );
```

### Other usages:

```javascript
function do( it, context, param ){
  try{

    // ... cache for async functions ...
    var a = it.slot( cb => async_read( "some key", cb ) );

    // ... delayed write actions, ran once, on success
    it.write( () => console.log( "Success, 'a' was", a ) );

    // ... cache for promises ...
    var b = it.slot( () => promise_read( a ) );

    // ... logging, with filtering over multiple retries ...
    it.log( "'b' was", b );

    // ... reversible side effects ...
    it.restore( ( r )=> some_global.value = r, some_global.value );
    some_global.value = "changed";

    var result = "some_result: " + param + a + b;

    // Code ran once only
    if( side.once( "Done" ) ){
      write_result( result )
    }

    // ... sub side actions ...
    var sub = it.side( some_code ).outcome();
    var sub2 = it.run( some_code, context );

    return result;

  // ... handle exceptions ...
  }catch( error ){
    it.catch( error );
    console.error( "an error occurred", error );
    return "sorry";
  }
}

Side( do, config, "x" ).then( r => console.log( r ) );
```

### Concepts

#### blocking functions

In most computer languages, a "blocking" function is a function that
can be interrupted and later restarted at that point of interruption.

In javascript only special "generator" functions behave this way.
Normal functions never block. As a result, javascript is mostly a
single threaded synchronous language.

Instead, javascript is "event based". When a function needs to wait
for something, it has to describe what will happen next when that
something happens. This is typically done using "callbacks".

Interrupting a function is easy, one just needs to throw an exception.
If that exception is not handled by the current function then it is
propagated to the caller function, up to the top of the call chain if
no functions at all handle the exception.

What is impossible is to restart the interrupted function. However, any
function in the call chain can handle the exception and can therefore
decide to retry the interrupted function later, by restarting it, typically
after some event occured that the interrupted function was expecting.

#### pure functions

Restarting a function from its beginning is very different from restarting
it from some well known point of interruption. However, in some cases the
effects are the same. Specially with "pure" functions.

Such special functions are called "pure" because they have no "side effects",
they just produce a result depending only on their parameters, without modifying
anything around. The same pure function called a million times with the same
parameters will always return the same result.

Using lots of pure functions is typical of a style of programming known as
"functional programming". The absence of side effects has many benefits,
it makes it much easier to test and debug functions. It has a major drawback:
nothing changes, much as if the pure function had never been called.

Consequentely, pure functions need to be called by some much less pure
ones, in order to produce some observable change.

The Side module uses pure functions to simulate blocking functions.
From the point of view of the function code, it's like if the function
could be interrupted and restarted, much like blocking functions.

#### cache

Obviously, something needs to change to successfully restart an interrupted
function. Maybe it is the result of some IO operation that became available.
Maybe it is some promise that is fulfilled. Something. A something that
the interrupted function had to take care of, had to make happen. By
initiating some action.

Such functions are not pure anymore. If ran twice, they will initiate two
actions. That's problematic. Unless, somehow, a mechanism prevent the
duplicate actions.

A typical scenario is a function that needs to access some data. But that
data is not available immediately, it needs to be provided by some
external resource that must be queried. The javascript function cannot
block until the data is provided, it cannot wait, it must return.

However, once the data becomes available, it can be stored locally. As a result,
if the same data is needed again, this time it can be provided immediately,
with no block, with no interruption. If the same function is run again, this
time it won't need to be blocked or interrupted, it will access the data
in a synchronous way.

This is how Side works. Using pure functions and caches, javascript functions
can be written as if they could block.

But this works only with "read" type of functions. "write" type of functions,
functions that need to change things, that need to produce side effects, are
a different story. Fortunately, "read" functions are usually much more frequent
than "write" functions.

#### side effects

To help with "write" type functions, Side provides tools to encapsulate side
effects in order to produce them in a well controlled manner. Three manners
actually, delayed writes, transactions and "once only" code.

Delayed writes is about postponing write operations until all blocking read
operations are done. Transactions are about reversing side effect unless all
blocking operations succeed and locking the global state while doing so. Once
only code is code that is run only the first time a retry reaches it.

See `side.write()` about postponed write operations, `side.restore()` about
transactions and `side.once()` about once only code.

## API

```javascript
var Side = require( "side" );
var new_side_action = Side( function(){ return "ok"; } );
...
new_side_action.then( r => console.log( r ) );
```

The Side module exports a function that creates new side actions like
`side.start()` does. That function is also accessible via any side action
object using either `side.Side` or `side.side`.

Additionaly, for convenience, `Side()` (without parameters), creates a new
"slot" like `side.slot()` does.

### Side.it - access to current side action

When a side action runs, global `Side.it` references it. When a new side
action is created while no side action is running, its parent, `side.parent`,
is the special root side action (`Side.root`).

As a convenience, `.it` and `.root` are also available on side action objects
in addition to their availability on the global `Side()` factory.

### side.start( f, ctx, p1, p2, ... ) - start a new side action

This is similar to `Side( ... )`, it starts a new side action. The new side
action is a child action of the parent side action. That parent needs to be
the current side action or else an error is raised.

`f` is the only mandatory parameter, it is expected to be a function object.
If it is a thenable promise instead, the outcome of the new side action depends
on the outcome of that promise.

Function `f` is called immediately. It either returns a result, raises an
exception or "blocks", using `side.wait()` somehow. If it blocks (a special
exception) then function `f` will typically run again later when the reason for
the block is removed.

The signature of `f` is `f( side_action, ctx, p1, p2, ... )`. `side_action` is the
newly created side action. `ctx` is the value provided when the side action was
started or an empty `{}` object. The other parameters are the ones provided to
`side.start()`.

`side.start()` returns a new Side action object. With the exception of the
`Side()` function itself, all other API methods are member functions of such
Side action objects. When not otherwise specified, member functions are chainable
and return the side object they were invoked upon.

Unless the new side action is created while no side action is running, it is
a sub side action of the current side action. The parent action won't terminate
until all its child side actions are done. It can also wait for the outcome of
the newly created side action by calling `new_action.outcome()`.

### side.outcome() - get side action outcome or block

When the outcome of a side action is available, `side.get()` will provide it,
either as a normal value or by raising an exception. If the outcome is not
available then `side.outcome()` "blocks" by raising a special exception.

### side.run( f, ctx, p1, p2, ... ) - run a new side action

This is a shorthand for `side.start( ... ).outcome()`.

### side.then( ok, ko ) - register callbacks to process side action outcome

Side actions are thenable promises. The outcome of the side action is delivered
to either the `ok` or `ko` callback depending on success/failure. Failure is
detected when some unhandled exception is raised by the side action. In that
case, the error is delivered to the `ko` callback.

### side.retry() & side.wait() - block and later retry a side action

When a function needs to block, it simply raises a special exception using
`side.wait()`. When the blocked function can be deblocked, something need to
call a function previously acquired using `side.retry()`.

Usage:
```javascript
if( data_is_available() ){
  return data_value();
}else{
  var retry = side.retry();
  async_get_data( function( err, value ){
    data_fill( err, value );
    retry();
  } );
  side.wait();
}
```

If `side.wait()` is called without `side.retry()` beeing called first, then it
does nothing, assuming no retry is needed.

As a convenience `side.wait( a_promise )` will automatically call `side.retry()`
and will use its result when the promise is delivered. Until that, it blocks
the action by raising the special exception for that purpose.

### side.once( key ) - run code once only

Because the same code will run multiple time when blocks occur, in some cases
it may be necessary to run some parts once only, typically when such parts
have side effects.

`side.once( key )` returns true once only per key. After that `side.context[ key ]`
is set to true and `side.once( key )` returns false.

Usage:
```javascript
if( side.once( "log it" ) ){
  console.log( "Reached" );
}
```

### side.end( result ) - set result of side action with no retries

After a call to `side.end()`, the next retry will actually terminate the
side action. This is useful to avoid an extra attempt when the last step of
a side action blocks, specially when that last step performs a side effect
and needs not to be done twice. See also `side.write()`.

### side.catch( err ) - propagate blocks

When an exception is raised it can either be a regular exception or the
special exception used to signal that the current side action needs to block
before a retry.

Using `side.catch( err )`, such special exceptions will be detected and
rethrown.

Usage:
```javascript
try{
  ...
}catch( error ){
  side.catch( error );
  // ... process 'normal' exceptions
}
```

### side.detach() - detach sub side action from parent side action

When a side action is created, it is initially a child side action of another
action. That parent action cannot succeed until all child side actions are
done.

`side.detach()` remove a side action from the list of sub actions of its
parent action ; a parent action that therefore does not need anymore to wait
for the sub action to succeed.

Usage:
```javascript
 side.start( f ).detach();
```

### side.abort( error ) - premature termination of a pending side action

If a side action is blocked waiting for something then it can be aborted. The
optional `error` will set the outcome, it defaults to a "Side abort" Error object.

When applied to the currently running action, that action is immediately blocked,
an exception about that is immediately raised.

### side.blocked(), side.pending(), side.done(), side.success(), side.failure()

The state of a side action evolves when its code runs. As long as attempts are
required to make it succeed, `side.pending()` will return true.

When the side action is fully terminated, `side.done()` will return true.
`side.success()` and `side.failure()` then tell weither the outcome is a success
or an error. See also `side.outcome()` to access the outcome.

When a side action is neither pending nor done, it is terminating. This is a
special phase when delayed sub actions are run to process side effects
typically, see `side.write()` and `side.restore()`.

Only pending side actions can be aborted.

### side.write( fn ) - register code to run when side action succeeds

One safe way to handle side effects is to postpone them until the end of a
side action. That way, when a side action is run multiple times because of
blocks, side effects are still done once only.

The provided `fn` function is run in a side sub action. It will run once only
because it is expected to block at most once and a call to `side.end()` is
for that purpose done before the side sub action starts.

Functions are run in sequence, in the registration order, fifo style.

When a side action fails or blocks, the registered functions are not run at all.

### side.finally( fn ) - registers code to run when side action terminates

Like `side.write()` but after. For traces typically, `side.log()` uses it.

### side.log(), side.warn(), etc - like console.log() but without duplicates

When `console.log()` is called by a side action, the same message will be
issued multiple times when the side action blocks. Using `side.log()` such
duplicates are avoided. Messages are issued once only, when the side action is
done.

### side.restore( fn, val, no_mutex ) - manage reversible side effects

Because a side action runs multiple times when blocks occur, side effects, if
any, often need to be reversible. As a result, either all side effects are done,
when the side action succeeds, or all side effect are erased, when the side action
fails or blocks.

Additionnaly, after `side.restore()` is called, no other side action can run
until the side action is done. The side action hence become a "transaction" that
either commits or rolls back.

Beware that no other side action will run even if the side action blocks, much
as if the side action had acquired a mutex on the global state. This behavior
can be avoided by using the optional third parameter.

The second parameter when present is provided to the `fn` function when/if it is
called after a block or a failure.

By using `side.restore()` a function can behave as a pure function until the
last minute, it therefore can run multiple times safely, with side effects
left in place only when the side action succeeds, not when it blocks or fails.

### side.slot( fn ) - allocate and fill a slot

The trick to make side actions look like synchronous functions is to restart
them when they need to block. However, the next time the function runs,
something must have changed or else the action would get restarted forever.

One way to manage such changes is to initiate them and collect their results
into some cache where they will be available in a synchronous manner. With Side
such caches are called "slots" and are used like local variables.

If `fn` is a function then its signature is expected to be `f( cb )` where
`cb` is a nodejs style callback, `cb( error, result)`. The function is expected
to initiate an action that will eventually result in a call to the callback.

That function is called once only. The next time the side action is restarted,
it is not called and it is the result stored by the callback that is returned.

Usage:

```javascript
var a = side.slot( cb => async_read( "something", cb ) );
```

If the `fn` function returns a thenable promise, that is detected and the
callback is automatically attached using `then( ok, ko )`.

As a convenience, `Side()` is equivalent to `Side.it.slot()`, it allocates
a new empty slot in the current side action.

If neither a function nor a thenable promise is provided then whatever value
is available is immediately returned.

Usage:
```javascript
var a = side.slot( cb => async_read( "something", cb ) );
var b = side.slot( () => promise_read( "something" ) );
```

## side.random() - deterministic random numbers

If random numbers are required by a blocking side action, the same numbers
must be provided whenever the side action is restarted. `side.random()` store
delivered numbers in order to deliver them again when the side action is
restarted.

## side.now() - frozen time during side action

When the behavior of a side action depends on the current time, that time should
not change or else the side action may have to be retried forever.

`side.now()` returns a timestamp like `Date.now()` does. This timestamp will stay
the same during the life time of the side action.

## side.sleep( delay_ms ) - block for a fixed time

After the specified delay the current side action is restarted.

## Side.ize( fn ) - efficiency

Because every block requires a new attempt, faking synchronous code with pure
functions can be inefficient.

For exemple, if function A processes a list of 10 items by calling function B
10 times and if function B needs to block 3 times then function A may have to
be restarted a total of 30 times, that's a lot.

One way to reduce that is to turn the B function into a "sideized" function, a
function that will create sub side actions. That way, function A will be
restarted 10 times instead of 30.

Usage:
```javascript
function concat_labels( items ){
  var fast_get_label = Side.ize( get_label );
  var msg = "";
  items.forEach( item, function(){
    msg += fast_get_label( item );
  } );
}
```

If a blocking function is always called in the context of a running side action,
it can as well be defined as a sideized function straigth away.

Usage:
```javascript
User.prototype.get_profile = Side.ize( function(){
  var result = {
    name: this.name,
    log_history: this.get_log_history()
  };
  result.time_last_log = result.log_history[ result.log_history.length - 1 ].timestamp;
  return result;
} );
```

repository: virteal/side

repo_name: virteal/side


text:
---
layout: creature
name: "Ushabti"
tags: [large, construct, cr9, tome-of-beasts]
cha: 9 (-1)
wis: 19 (+4)
int: 11 (+0)
con: 20 (+5)
dex: 17 (+3)
str: 21 (+5)
size: Large construct
alignment: unaligned
challenge: "9 (5000 XP)"
languages: "Ancient language of DM's choice"
skills: "Arcana +4, History +4, Perception +8"
senses: "darkvision 60 ft., passive Perception 18"
saving_throws: "Dex +7, Cha +3"
damage_immunities: "poison; bludgeoning, piercing, and slashing from nonmagical weapons"
condition_immunities: "charmed, exhaustion, frightened, paralyzed, petrified, poisoned"
speed: "30 ft."
hit_points: "105 (10d10 + 50)"
armor_class: "18 (natural armor)"
---

***Dynastic Aura.*** A creature that starts its turn within 15 feet of the ushabti must make a DC 17 Constitution saving throw, unless the ushabti is incapacitated. On a failed save, the creature has its breath stolen; it takes 9 (2d8) necrotic damage, and until the end of the ushabti's next turn, can't cast spells that require a verbal component or speak louder than a whisper. If a creature's saving throw is successful, the creature is immune to this ushabti's Dynastic Aura for the next 24 hours.

***Healing Leech.*** If a creature within 30 feet of the ushabti regains hit points from a spell or a magical effect, the creature gains only half the normal number of hit points and the ushabti gains the other half.

***Immutable Form.*** The ushabti is immune to any spell or effect that would alter its form.

***Magic Resistance.*** The ushabti has advantage on saving throws against spells and other magical effects.

***Magic Weapons.*** The ushabti's weapon attacks are magical.

### Actions

***Multiattack.*** The ushabti makes one attack with Medjai's scepter and one with its khopesh.

***Medjai's Scepter.*** Melee Weapon Attack: +9 to hit, reach 5 ft., one target. Hit: 12 (2d6 + 5) bludgeoning damage plus 10 (3d6) poison damage.

***Khopesh.*** Melee Weapon Attack: +9 to hit, reach 5 ft., one target. Hit: 12 (2d6 + 5) slashing damage.

gha_language: CSS

gha_license_id: NOASSERTION


text:
# Steam Controller Singer
## Orignally by Pila
## Modified by xTdub, Krackle, and Some1fromthedark

[Original Repo Link](https://gitlab.com/Pilatomic/SteamControllerSinger)

## What was added?
- Support for multiple controllers
- A "Duty Cycle Modifier" for reducing the volume of resonating notes

repository: xTdub/SteamControllerSinger

repo_name: xTdub/SteamControllerSinger


text:
# Articles

## We fired our top talent. Best decision we ever made.
Our resident genius, our Dr. Jekyll, explosively completed his transformation into Mr. Hyde.
Reading time
8 min read
https://medium.freecodecamp.org/we-fired-our-top-talent-best-decision-we-ever-made-4c0a99728fde

## Moving to three-person engineering teams
https://medium.com/do-not-erase/moving-to-three-person-engineering-teams-bcf599670c2a

## Product Manager and UX Designer - What's the difference?
https://www.uxpin.com/studio/blog/product-manager-and-ux-designer-whats-the-difference/

## On Being A Senior Engineer
Some good commentary around what a Senior Engineer is and some good competencies to look for when considering someone as a "Senior Engineer"
https://www.kitchensoap.com/2012/10/25/on-being-a-senior-engineer/

## Managing Bias
Not an article, but some good tests to help uncover unconcious biases you might have
https://managingbias.fb.com/

## Getting to 10x (Results): What Any Developer Can Learn from the Best
https://medium.com/javascript-scene/getting-to-10x-results-what-any-developer-can-learn-from-the-best-54b6c296a5ef

## 101 Questions to ask in one on ones
A handy list of questions to ask in 1:1's
https://jasonevanish.com/2014/05/29/101-questions-to-ask-in-1-on-1s/

## Average Manager vs. Great Manager
A cute comic that explains the difference very simply
https://medium.com/the-year-of-the-looking-glass/average-manager-vs-great-manager-cf8a2e30907d

## How to communicate effectively as an engineer without resorting to management speak
Not sure the title does this one justice, it gives good tips on how to run a productive meeting with everyone's engagementalong with how to engage with people less familiar with technical jargon more effectively.
https://www.tombartel.me/blog/communicate-effectively-without-management-speak/

## On being a bad manager
Thoughts on why it's so easy to be a "bad manager" TLDR; management takes practice.
https://m.signalvnoise.com/on-being-a-bad-manager-e56e1fb3d9dc

## The 5 ways to improve your self-awareness as a leader
Some good tips on how to improve as a leader
https://blog.knowyourcompany.com/the-5-ways-to-improve-your-self-awareness-as-a-leader-2f1464e5b00

## The best career advice I've recieved
Some good career advice if you find you've stopped progressing as an engineer
https://humanwhocodes.com/blog/2013/10/15/the-best-career-advice-ive-received/

## Conflict Resolution
Some good tips and strategies for resolving conflict
https://www.mindtools.com/pages/article/newLDR_81.htm

## From a group of individuals to a performing team: navigating the Tuckman's model
Has a brief overview of the forming-storming-performing model, and some high level hints at how to move through each stage and what to look out for. Warning: Uses exclusive pronouns the whole way through.
https://leadersyndrome.wordpress.com/2013/12/22/from-a-group-of-individuals-to-a-performing-team-navigating-the-tuckmans-model/

## The Six Styles of Leadership
A high level look at six "hats" (skillsets) you need to learn as a leader
https://intenseminimalism.com/2015/the-six-styles-of-leadership/

## How to fail as a new engineering manager
Some good tips on how to avoid common pitfalls new engineering managers often fall into
https://blog.usejournal.com/how-to-fail-as-a-new-engineering-manager-30b5fb617a

## Self-Selecting Teams - Why You Should Try Self-Selection
Self-selection is a process of letting people group into small Agile and Scrum cross-functional teams
https://www.methodsandtools.com/archive/selfselectingteams.php

## Spotify’s Failed \#SquadGoals
“The Spotify model” got a bunch of companies talking like Taylor Swift about startup culture, but four former Spotify employees reveal the truth: its eponymous way of working failed before it scaled.
https://www.jeremiahlee.com/posts/failed-squad-goals/

## To Read:

On Leadership and Culture
https://hackernoon.com/on-leadership-and-culture-ca4d6f2a9bb0

The Coffee Shop Effect: Why changing your location boosts your productivity
https://blog.trello.com/coffee-shop-effect-boosts-productivity

Manager Energy Drain
https://larahogan.me/blog/manager-energy-drain/

What is the expectation out of each software engineering level at Facebook?
https://www.forbes.com/sites/quora/2013/12/09/what-is-the-expectation-out-of-each-software-engineering-level-at-facebook/#631260053bce

It's not really a technology problem
https://medium.com/startup-patterns/its-not-really-a-technology-problem-5b534a642bb0

How to corntol your emotions during a difficult conversation
https://hbr.org/2017/12/how-to-control-your-emotions-during-a-difficult-conversation

What Google learned from it's quest to build the perfect team
https://www.nytimes.com/2016/02/28/magazine/what-google-learned-from-its-quest-to-build-the-perfect-team.html

Why open office design makes you less productive
https://medium.com/swlh/why-open-office-design-makes-you-less-productive-95d45ffba9eb

How to coach teammates: A key responsibility of effective leaders
https://wavelength.asana.com/coaching-workplace-why-examples/

How product managers and engineers at Asana develop great relationships
https://blog.asana.com/2017/10/product-managers-engineers-develop-great-relationship/

How we build products at Asana — The Product Process: From Inception to Launch
https://medium.com/@jackiebo/how-we-build-products-at-asana-the-product-process-from-inception-to-launch-c5cce9adf776

repository: thechard/engineering-management

repo_name: thechard/engineering-management


text:
---
title: Setting Up Mailgun With CloudFlare
date: 2016-11-15T05:01:48+00:00
author: gerryw1389
layout: single
classes: wide
permalink: /2016/11/setting-up-mailgun-with-cloudflare/
categories:
  - Networking
tags:
  - Cloud
  - Setup
---
<!--more-->

### Description:

After signing up for CloudFlare to host my website, I found that it will automatically disable Google's free email address that comes with the domain. I used the following steps to resolve this:

### To Resolve:

1. Signup for a free account on mailgun.com

2. Log into your account in Mailgun and add a domain from the top menu bar. Once your domain is added, you will see that Mailgun gives you a few MX records and TXT records to be added for your domain, for both successful email forwarding and verification of the domain.

3. Now go to CloudFlare's DNS panel and add those MX records and TXT records provided by Mailgun.

   - Choose your site and select DNS Settings

   - Add the CNAME record. Name = email, Value = mailgun.org, TTL = Automatic, Make sure the cloudflare cloud is gray and not orange/active => You have to click on the cloud icon.

   - Add the two MX records
     - Name = domain.com (no www), value = mxa.mailgun.org, Priority = 10
     - Name = domain.com (no www), value = mxb.mailgun.org Priority = 10

   - Add the two TXT records
     - Name= domain.com (no www), value = v=spf1...
     - Name = smtp._domainkey, value = k=rsa...

4. Log into your Mailgun account and go to Routes section from the top menu. Now add as many routes as you want.

   - For example, if your domain is example.com and you want all the mails sent to<EMAIL_ADDRESS>to be forwarded to<EMAIL_ADDRESS>then create that route. So for me that means:

     - Expression Type = Match Recipient
     - Recipient =<EMAIL_ADDRESS>
     - Actions = Forward to<EMAIL_ADDRESS>
     - Priority = 10
     - Description = Forwards from my domain to my Gmail.

5. If you want people to email TO you at that email, you are done, congrats. I wanted to go one step further and send email FROM that email address. To do this, I went into my Gmail and:
   - Log in to Gmail and go to settings => Accounts and Import:
     - name = Anything you want
     - email address<EMAIL_ADDRESS>(this should be the email you set up in the steps before)
     - Leave treat as an alias checked
     - Click Next Step

6. For the following info you'll need to login to mailgun and use the info under Domain Information

   - SMTP Server Use SMTP Hostname from Mailgun
   - Username Use Default SMTP Login from Mailgun
   - Password Use Default Password from Mailgun
   - I couldn't get this to work, so I created a new SMTP user and password. I plugged this into Google. So it was:
   - SMTP Server: smtp.mailgun.org PORT=587
   - Username: MyUserEmail
   - Password: MyUserPassword
   - Secured connection using TLS (recommended) radio button selected
   - Now comes the hard part, Gmail will send an email to that address and you will have to open to go to the link for verification:
   - Thankfully, Mailgun is aware of people needing temp access to their mailboxes, so they created an [event API](http://blog.mailgun.com/how-to-view-your-messages/) that works like this:
   - You login to Mailgun and go to Logs for your domain and select the most recent inbox message.
   - You can see the API URL to the message along with its unique key under the "storage" section when expanding the log entry.
   - To view the message in the browser just copy the URL and enter `api` as username and your `API key` in the password box. This will let you to view the parsed message. You get your API key under Account Settings in the web GUI.
   - Copy and paste the Google verification link in another tab to "authorize" your email as a trusted sender.

6. Now you can send and receive from a mailbox that seems to be connected to your domain!


text:
# XmlAddChildWithXPathResult

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**successful** | **Boolean** | True if the operation was successful, false otherwise |  [optional]
**resultingXmlDocument** | **String** | Resulting, modified XML document |  [optional]
**nodesEditedCount** | **Integer** | Count of the matching results |  [optional]

gha_language: Java