text:
---
layout: home
title: Feature - Tax Engine
sidebar: features
lang: en
subnav: features_tax_type
---

# Tax type

There are three default tax types in Thelia 2 :

* Fixed amount tax type
* Percent of the product price tax
* Fixed amount depending on a product's feature value ; you can set tax amount on each product in the given feature.

# Create your own tax type

You can create tax types in your plugins, or why not directly in [*Thelia 2*](https://github.com/thelia/thelia) and ask for a pull request.

For this, you must create a class which extends `\Thelia\TaxEngine\BaseTaxType`.

Here is the FixAmountTaxType class as an example :

```php
class PricePercentTaxType extends BaseTaxType
{
    public function pricePercentRetriever()
    {
        return ($this->getRequirement("percent") * 0.01);
    }

    public function getRequirementsList()
    {
        return array(
            new TaxTypeRequirementDefinition('percent', new FloatType())
        );
    }

    public function getTitle()
    {
        return Translator::getInstance()->trabs("Price % Tax");
    }
}
```

`getRequirementsList()` should return an array of TaxTypeRequirementDefinition objects. The TaxTypeRequirementDefinition class store the name of a requirement (a parameter) of your tax type, that will be entered in the back-office by the administrator.

`getTitle()` returns a short description of your tax type, used in the back-office in the tax management section.

You shoudl override either `pricePercentRetriever()` or `fixAmountRetriever()`, depending on your tax type. If it provides a percentage that should be applied to product price, implement `pricePercentRetriever()`.
If it provides a constant amount, implements `fixAmountRetriever()`. See BaseTaxType for more information.

If you're implementing this new class outside the Thelia core, e.g. outside the base Tax types directory `Thelia/TaxEngine/TaxType` - in a plugin for example - you should inform the Tax Engine.

Let's say you have created the MyTaxPlugin, and stored several tax type classes in the `MyTaxPlugin/TaxType` directory. The namespace of these classes will be `MyTaxPlugin\TaxType`.

First, in your plugin constructor (or any convenient place) get the TaxEngine from the container :

```php
$taxEngine = $container->get('thelia.taxEngine');
```

If you have implemented only a few tax type, just call the `addTaxType` method for each tax type, providing the fully qualified class name of your tax type. For example, if your tax type class is `MyTaxType` :

```php
$taxEngine->addTaxType('MyTaxPlugin\TaxType\MyTaxType');
```

If you have several tax types, store all implementations in the same directory, and call the `addTaxTypeDirectory` method, providing the namespace of your classes, and the path to the directory :

```php
$taxEngine->addTaxTypeDirectory('MyTaxPlugin\TaxType', __DIR__ .DS . 'TaxType');
```


text:
---
layout: core-developers
title: Formatting Dates and Numbers
---

# Formatting Dates and Numbers

## Defining Formats

Struts2 supports localization (l10n) aware formatting of dates, times and numbers very easily, utilizing Java's
built-in date formatting features.

As seen in the [Localization](localization) chapter, it is quite easy to define hierarchical resource bundles
with Struts2, giving the developer the opportunity to define locale dependent message formats. This is the entry point
to define the needed date, time and number formats. Your default properties could contain the following generic formats:

```
format.time = {0,time}
format.number = {0,number,#0.0##}
format.percent = {0,number,##0.00'%'}
format.money = {0,number,\u00A4##0.00}
```

An appropriate en_US format definition extension could look like this:

```
format.date = {0,date,MM/dd/yy}
```

In parallel, you could add the following to your de_DE bundle:

```
format.date = {0,date,dd.MM.yyyy}
```

Read more on how to define message formats in Sun's Java API docs for [MessageFormat](http://java.sun.com/j2se/1.5.0/docs/api/java/text/MessageFormat).

Now that we have our formats set up, it is quite easy to use them in our views.

## Formatting output using the s:text tag

Given you had a Float value myMoneyValue, accessible through the getter getMyMoneyValue in your action, the following
code would print out localized representation of the value as a currency amount, using the format.money message
format defined above with a `s:text` tag:

```jsp
<s:text name="format.money">
    <s:param name="value" value="myMoneyValue"/>
</s:text>
```

The (first) parameter defines the value which is to replace the '0' placeholder in the defined message format.

Another example, formatting a date value:

```jsp
<s:text name="format.date"><s:param value="dueDate"/></s:text>
```

> While the `s:text` tag is very useful to format numbers, date formatting has become a lot easier thanks
> to the `s:date` tag.

## Localizing form data with getText

Placing a textfield in a form like this

```jsp
<s:textfield key="orderItem.price" />
```

to input a number, one might have noticed that the number is always shown in the Java default number format. Not only
that this is not "nice", if you are in a non-en locale, it will also cause trouble when submitting the form since type
conversion is locale aware. The solution is to again use the message formats as defined above, by using the getText
method of ActionSupport:

```jsp
<s:textfield key="orderItem.price" value="%{getText('format.number',{orderItem.price})}" />
```

This maps to the method signature `getText( String key, Object[] params )` in ActionSupport.

## Using getFormatted() with conversion support

A new method getFormatted was added to ActionSupport (which can be implemented in your base action) to support
formatting and conversion errors with I10N.

You can place a code like below

```jsp
<s:textfield key="user.born" value="%{getFormatted('format.number','user.born')}" />
```

to get support for I10N and also to support conversion errors.

branch_name: refs/heads/master

extension: md

gha_language: HTML

license_type: permissive


text:
OVF or OVA are a standard to package virtual machines. vSphereOVF will allow you to deploy an OVF/OVA into a VMware vSPhere infrastructure.

# Prerequisites

Before deploying you'll need to:
- Install VMware PowerCli
- Connect to a vCenter server or an ESXi server with the command `Connect-VIServer`

# Simple Example

Here is an example deployment config:

```Powershell
Deploy 'MyOVF' {
    By vSphereOVF {
        FromSource 'C:\MyOVF.ovf'
        To 'esxi.example.com'
        Tagged 'Prod'
        WithOptions @{
            Name = 'VM01'
            Datastore = 'DATASTORE01'
            OvfConfiguration = @{
                'NetworkMapping.VM Network' = 'Production'
            }
            PowerOn = $true
        }
    }
}
```

Let's explain the different parameters:
- `FromSource` specifies the path to the .ovf or .ova file
- `To` specifies the esxi server used as a target
- `Name` specifies the name of the virtual machine
- `Datastore` specifies on wich datastore the VM will be stored. If not provided, the datastore with the largest free space will be selected
- `OvfConfiguration` specifies advanced configurations that will be used to deploy the virtual machine
- `PowerOn` specifies if the virtual machine should be powered on after the deployment

# Real Example

Here is an example to deploy a VMware vCenter Virtual Appliance (VCSA). More specific informations about the automated deployment of a VCSA can be found [here](http://www.virtuallyghetto.com/2015/02/ultimate-automation-guide-to-deploying-vcsa-6-0-part-1-embedded-node.html)

```Powershell
Deploy 'VCSA' {
    By vSphereOVF {
        FromSource 'D:\VMware\vSphere\vSphere 6.0\vCenter\VCSA\U2\vmware-vcsa.ova'
        To 'esxi.example.com'
        Tagged 'Prod'
        WithOptions @{
            Name = 'VCENTER' # VM Name
            Datastore = 'SALLE1-DATASTORE02' # Datastore Name
            OvfConfiguration = @{
                'NetworkMapping.Network 1'                = 'Supervision' # vSphere Portgroup Network Mapping
                'DeploymentOption.value'                  = 'tiny' # tiny,small,medium,large,management-tiny,management-small,management-medium,management-large,infrastructure
                'IpAssignment.IpProtocol'                 = 'IPv4' # IP Protocol
                'guestinfo.cis.appliance.net.addr.family' = 'ipv4' # IP Address Family
                'guestinfo.cis.appliance.net.mode'        = 'static' # IP Address Mode
                'guestinfo.cis.appliance.net.addr'        = '<IP_ADDRESS>' # IP Address
                'guestinfo.cis.appliance.net.pnid'        = '<IP_ADDRESS>' # IP PNID (same as IP Address if there's no DNS)
                'guestinfo.cis.appliance.net.prefix'      = '24' # IP Network Prefix (CIDR notation)
                'guestinfo.cis.appliance.net.gateway'     = '<IP_ADDRESS>' # IP Gateway
                'guestinfo.cis.appliance.net.dns.servers' = '<IP_ADDRESS>' # Comma separated list of IP addresses of DNS servers.
                'guestinfo.cis.appliance.ntp.servers'     = '0.pool.ntp.org' # Comma seperated list of hostnames or IP addresses of NTP Servers
                'guestinfo.cis.appliance.root.passwd'     = 'VMware1!' # Root Password
                'guestinfo.cis.appliance.ssh.enabled'     = 'True' # Enable SSH
                'guestinfo.cis.vmdir.domain-name'         = 'vsphere.local' # SSO Domain Name
                'guestinfo.cis.vmdir.site-name'           = 'site01' # SSO Site Name
                'guestinfo.cis.vmdir.password'            = 'VMware1!' # SSO Admin Password
            }
            PowerOn = $true
        }
    }
}
```

license: MIT

repository: ThePoShWolf/PSDeploy

gha_license_id: MIT

repo_name: ThePoShWolf/PSDeploy


text:
# README
These files are required to boot a VIRL instance in the cloud. Bootstrapping a VIRL instance won't work without a valid private key for the Salt minion which is not included here.

See the LICENSE.TXT for licensing information.

# Files
Here's a list of the important files and what they do.

* `boot-data/boot.sh` Sample script that shows how to boot the instance passing the user-data and the meta-data to the instance.
* `boot-data/user-data` Cloud-init file passed into nova that contains a few files that are placed into the newly created instance. The Salt ID and the Salt domain need to be adapted. The private key file name must match the Salt ID and Salt domain. The extra.conf data must match the key / key file.
* `etc/virl.ini` is the virl.ini file that will be placed into the instance. The content is pretty much static, it should use dummy interfaces.
* `etc/common.sh` contains config variables and common stuff for the install scripts.
* `install.sh` is the main install script. It executes all additional scripts in the stages directory. It will reboot the instance after a stage has been finished and the exit value of that state is 1 (0 will not reboot the instance and continue with the next stage).
* `stages` Directory that contains the various stages that install the required packages and images.
* `born.py` extracts the instance create time from Cloud-Init using meta data that has been created during the 'nova boot' call.
* `reset.sh` is for testing, it will reset all stages to initial state (e.g. they will have the 'done-' prefix removed).

license: ISC

repository: rschmied/sb-bootstrap

gha_language: Shell

repo_name: rschmied/sb-bootstrap


text:
# rapture

A cross platform install script library / package manager

## Install

```bash
# Install with cargo to build
cargo install rapture

# Bootstrap rapture
rapt install https://raw.githubusercontent.com/adam-mcdaniel/rapture/master/scripts/rapture.rapt

# Uninstall old cargo
cargo uninstall rapture

# Source your modified path
. ~/.bashrc
source ~/.bashrc
```

repository: adam-mcdaniel/rapture

gha_language: Rust

repo_name: adam-mcdaniel/rapture


text:
xgboost: eXtreme Gradient Boosting
=======
A General purpose gradient boosting (tree) library.

Authors:
* Tianqi Chen, project creater
* Kailong Chen, contributes regression module

Turorial and Documentation: https://github.com/tqchen/xgboost/wiki

Features
=======
* Sparse feature format:
  - Sparse feature format allows easy handling of missing values, and improve computation efficiency.
* Push the limit on single machine:
  - Efficient implementation that optimizes memory and computation.
* Layout of gradient boosting algorithm to support generic tasks, see project wiki.

Supported key components
=======
* Gradient boosting models:
    - regression tree (GBRT)
    - linear model/lasso
* Objectives to support tasks:
    - regression
    - classification
* OpenMP implementation

Planned components
=======
* More objective to support tasks:
    - ranking
    - matrix factorization
    - structured prediction

File extension convention
=======
* .h are interface, utils and data structures, with detailed comment;
* .cpp are implementations that will be compiled, with less comment;
* .hpp are implementations that will be included by .cpp, with less comment

repository: ChenglongChen/xgboost

repo_name: ChenglongChen/xgboost


text:
# Phomopsis controversa (Sacc.) Traverso, 1906 SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Fl. ital. crypt. (Florence), Pyrenomycetae 2(1): 273 (1906)

#### Original name
Phoma controversa (Desm.) Sacc.

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Sordariomycetes/Diaporthales/Diaporthaceae/Diaporthe/Diaporthe eres/ Syn. Phomopsis controversa/README.md

repo_name: mdoering/backbone


text:
---
path: /
title: Home
metaDesc: Secure, reliable management of gov.au domain names
type: standard
---

  # Secure, reliable management of gov.au domain names

      gov.au is the top-level domain for Australian Commonwealth, State, Territory and Local government digital services.

      Use this service to apply for new gov.au domains or to manage existing domains.

Apply for a new gov.au domain name

Manage an existing gov.au domain name

Guidance, help and advice for gov.au domains

      Government services should be easy to identify on the internet. The Domain Name Administration team, part of the Digital Transformation Agency, operates the gov.au top-level domain (TLD) and makes it available to Australian government organisations, from federal agencies to local municipalities. Using a gov.au domain shows you’re an official government organization.

repository: govau/domainname-gov-au-frontend

branch_name: refs/heads/develop

gha_language: TypeScript

repo_name: govau/domainname-gov-au-frontend


text:
# Code best practices

As our team is growing and external people can contribute to our code, it's always good to have some principles around our code, so we can keep some consistency and clean code.
As we are evolving, more guidelines will be added here.

## Constants

Inside a component file, guideline for constants is as follow:
* all fixed non-localized strings, numbers, etc.. , should be:
  * capitalized,
  * added at the top (before component code).
* other constants should be at the bottom (after component code)

## Styles

For components, guideline for styles is as follow:
* styles should be in a separate file ("ComponentName.styles.ts") if one of the following conditions applied:
  * there's more than 1 style
  * style is too long
* styles depending on "theme" should be defined as functions with theme as arg, and added to the styles file.

repository: JohnVUgonabo/communication-ui-library

branch_name: refs/heads/main

repo_name: JohnVUgonabo/communication-ui-library


text:
# Dart Hacker News PWA

The application is deployed at [hnpwa.dartlang.org](https://hnpwa.dartlang.org).

It was built as an example for [hnpwa.com](https://hnpwa.com/).

<img width="834" src="https://user-images.githubusercontent.com/168174/36634757-57637b9a-195e-11e8-82f9-07c882f0471c.png">

## Running locally

To run and debug locally using `dartdevc`:

```console
$ webdev serve
```

Then navigate to `http://localhost:8080`.

## Running locally with release configuration

To run locally using `dart2js`, add the `--release` flag.

```console
$ webdev serve --release
```

## Deploy to Firebase

1. Install and setup [Firebase CLI][firebase-cli].

2. Create a new [Firebase project][firebase-project].

3. Select your new Firebase project:

    ```console
    $ firebase use --add
    ```

    This will create a `.firebaserc` file to store your project configuration.

4. Update the offline URL cache [timestamp][offline-urls-timestamp] to the
   current date. Automation of this step has temporarily been disabled due to
   [#1369][issue-1369].

5. Deploy:

    The `firebase.json` file has the build command configured via the `predeploy`
    setting, so you just have to run `deploy`.

    ```console
    $ firebase deploy
    ```

[firebase-cli]: https://github.com/firebase/firebase-tools
[firebase-project]: https://console.firebase.google.com
[issue-1369]: https://github.com/dart-lang/angular/issues/1369
[offline-urls-timestamp]: https://github.com/dart-lang/angular/blob/master/examples/hacker_news_pwa/lib/pwa/offline_urls.g.dart#L11


text:
---
title: "Code of Conduct Reporting Guidelines"
date: 2010-03-02T13:43:30+01:00
draft: false
menu:
  nav:
    parent: 'Code of Conduct'
---

## Replicante Code of Conduct - Reporting Guide

If you believe someone is violating the code of conduct we ask that you report
it by emailing [conduct@replicante.io](mailto:conduct@replicante.io).
**All reports will be kept confidential**.
In some cases we may determine that a public statement will need to be made.
If that's the case, the identities of all victims and reporters will remain confidential
unless those individuals instruct us otherwise.

**If you believe anyone is in physical danger, please notify appropriate law enforcement first**.
If you are unsure what law enforcement agency is appropriate, please include this in your report
and we will attempt to notify them.

If you are unsure whether the incident is a violation, or whether the space
where it happened is covered by this Code of Conduct, we encourage you to still
report it. We would much rather have a few extra reports where we decide to take
no action, rather than miss a report of an actual violation. We do not look
negatively on you if we find the incident is not a violation. And knowing
about incidents that are not violations, or happen outside our spaces, can also
help us to improve the Code of Conduct or the processes surrounding it.

In your report please include:

  * Your contact info (so we can get in touch with you if we need to follow up)
  * Names (real, nicknames, or pseudonyms) of any individuals involved. If there were other witnesses besides you, please try to include them as well.
  * When and where the incident occurred. Please be as specific as possible.
  * Your account of what occurred. If there is a publicly available record (e.g. a mailing list archive or a public IRC logger) please include a link.
  * Any extra context you believe existed for the incident.
  * If you believe this incident is ongoing.
  * Any other information you believe we should have.

### What happens after you file a report?

You will receive an email from the Code of Conduct committee acknowledging receipt immediately.
We promise to acknowledge receipt within 24 hours (and will aim for much quicker than that).

The committee will immediately meet to review the incident and determine:

  * What happened.
  * Whether this event constitutes a code of conduct violation.
  * Who the bad actor was.
  * Whether this is an ongoing situation, or if there is a threat to anyone's physical safety.

If this is determined to be an ongoing incident or a threat to physical safety,
the committee' immediate priority will be to protect everyone involved.
This means we may delay an "official" response until we believe that the
situation has ended and that everyone is physically safe.

Once the working group has a complete account of the events they will make a
decision as to how to response. Responses may include:

  * Nothing (if we determine no violation occurred).
  * A private reprimand from the working group to the individual(s) involved.
  * A public reprimand.
  * An imposed vacation (i.e. asking someone to "take a week off" from a mailing list or IRC).
  * A permanent or temporary ban from some or all spaces (mailing lists, IRC, etc.)
  * A request for a public or private apology.

We'll respond within one week to the person who filed the report with either a
resolution or an explanation of why the situation is not yet resolved.

Once we've determined our final action, we'll contact the original reporter to
let them know what action (if any) we'll be taking. We'll take into account
feedback from the reporter on the appropriateness of our response, but we don't
guarantee we'll act on it.

### Attribution
Adapted from the [Django Reporting Guidelines](https://www.djangoproject.com/conduct/reporting/).


text:
# php-localytics-push

A PHP client for sending push notifications via the [Localytics Push Notification](https://www.localytics.com/features/push-messaging/) service

[![Author](http://img.shields.io/badge/author-@superbalist-blue.svg?style=flat-square)](https://twitter.com/superbalist)
[![Build Status](https://img.shields.io/travis/Superbalist/php-localytics-push/master.svg?style=flat-square)](https://travis-ci.org/Superbalist/php-localytics-push)
[![StyleCI](https://styleci.io/repos/71333548/shield?branch=master)](https://styleci.io/repos/71333548)
[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE)
[![Packagist Version](https://img.shields.io/packagist/v/superbalist/php-localytics-push.svg?style=flat-square)](https://packagist.org/packages/superbalist/php-localytics-push)
[![Total Downloads](https://img.shields.io/packagist/dt/superbalist/php-localytics-push.svg?style=flat-square)](https://packagist.org/packages/superbalist/php-localytics-push)

## Installation

```bash
composer require superbalist/php-localytics-push
```

## Integrations

Want to get started quickly? Check out some of these integrations:

* Laravel - https://github.com/Superbalist/laravel-localytics-push

## Usage

```php
$client = new GuzzleHttp\Client();
$appID = 'your-app-id';
$apiKey = 'your-api-key';
$apiSecret = 'your-api-secret';

$localytics = new \Superbalist\LocalyticsPush\LocalyticsPush($client, $appID, $apiKey, $apiSecret);
$message = [
    'target' => [
        'profile' => [
            'criteria' => [
                [
                    'key' => '$email',
                    'scope' => 'Organization',
                    'type' => 'string',
                    'op' => 'in',
                    'values' => [
<EMAIL_ADDRESS>                    ]
                ]
            ],
            'op' => 'and',
        ],
    ],
    'alert' => [
        'title' => 'Message Title',
        'body' => 'This is my message content!',
    ]
];
$response = $localytics->pushMessage('profile', $message);
```

repository: Superbalist/php-localytics-push

gha_language: PHP

repo_name: Superbalist/php-localytics-push


text:
---
layout: page
title: Get Started
description: Get started with FastMoE
---

Get Started
============

You can get started with FastMoE with docker or in a direct way.

## Docker

### Environment Setup

#### On host machine

First, you need to setup the environment on the host machine.

- [NVIDIA driver](https://github.com/NVIDIA/nvidia-docker/wiki/Frequently-Asked-Questions#how-do-i-install-the-nvidia-driver)

- [Docker](https://www.docker.com/) and [nvidia-docker](https://github.com/NVIDIA/nvidia-docker)

Then, we recommend the [official PyTorch docker image](https://hub.docker.com/r/pytorch/pytorch), as the environment is well-setup there. Note that you should use the image with `devel` in its tag, rather than `runtime`. Theoretically, Pytorch environment on your host machine is not needed.

For example, you can run `docker pull pytorch/pytorch:1.8.0-cuda11.1-cudnn8-devel` to get a Pytorch docker image.

#### Inside the docker

Run a docker container with commands like:

```shell
docker run --name pytorch -it pytorch/pytorch:1.7.1-cuda11.0-cudnn8-devel
```

And use bash to interact with it:

```shell
docker exec -ti pytorch /bin/bash
```

For distributed expert feature, NCCL is required. Inside the docker, you can first check if the NCCL is installed, such as:

```shell
$ apt list --installed | grep nccl
libnccl-dev/unknown,now 2.8.4-1+cuda11.2 amd64 [installed]
libnccl2/unknown,now 2.8.4-1+cuda11.2 amd64 [installed]
```

If not, you can follow the [official documentation](https://docs.nvidia.com/deeplearning/nccl/install-guide/index.html) to install the right version according to CUDA version (which can be inspected by `nvcc -V`) in your docker. After that, you need to setup NCCL in your conda environment, following [this](https://anaconda.org/anaconda/nccl).

Finally, you can check NCCL simply with `torch.cuda.nccl.version()` in Python. Additionally, there is an [official repo](https://github.com/NVIDIA/nccl-tests/) for testing NCCL, and it is up to you.

### Installation

Enter our repo directory inside the well-prepared docker container. By default, the distributed expert feature is disabled. So you need to set environment variable `USE_NCCL=1` to enable it. Use `python setup.py install` to easily install our FastMoE, and you can check the installation with:

```shell
$ conda list | grep fastmoe
fastmoe	0.1.1	pypi_0	pypi
```

Finally, enjoy using FastMoE for training!

## Direct way

### Preparations

To use FastMoe, CUDA and PyTorch are required.

1. CUDA Tookit is available at <https://developer.nvidia.com/cuda-downloads>. Select your operating system and follow instructions on the website to install CUDA.
   Notice: version of CUDA must match the version of nvidia driver. If you're not sure whether you have installed nvidia driver or you don't know its version, you may use `nvidia-smi` to get information about nvidia driver.

2. Add CUDA to the list of environmental variables. If you work with Linux, use command `vi ~/.bashrc`  and add the following content to the end of file (replace X.X with version of CUDA you've downloaded):

```
export PATH=$PATH:/usr/local/cuda-X.X/bin
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-X.X/lib64
export CUDA_HOME=$CUDA_HOME:/usr/local/cuda-X.X
```

Then don't forget to use `source ~/.bashrc` to update the configurations.
So far, CUDA has been installed successfully, you can use `nvcc --version` to check its version.

3. PyTorch can be installed with pip. Version `>=1.8.0` is required if you want to use Megatron. After installation, run the following Python code:

```
import torch
torch.cuda.is_available()
torch.cuda.decive_count()
```

If result of `torch.cuda.is_available()` is `True` and `torch.cuda.decive_count()` returns number of your device, then conguatulations! CUDA and PyTorch run successfully on your device.

### NCCL

1. If you want to enable distributed expert feature, please download NCCL at <https://developer.nvidia.com/nccl/nccl-legacy-downloads>. Version of  NCCL should be no less than `2.7.5` and match the version of PyTorch. You can use function `torch.cuda.nccl.version()` to see the version of NCCL required.

2. Install the 'deb' file. If you use Ubuntu or Debian, just use the following commands (nccl_repo_file is your file, XXX and X.X mean version of NCCL and CUDA):

```
sudo dpkg -i nccl_repo_file.deb
sudo apt update
sudo apt install libnccl2=XXX+cudaX.X libnccl-dev=XXX+cudaX.X
```

### FastMoe Installation

1. Clone the repo of FastMoe from <https://github.com/laekov/fastmoe>, and use the following command to install:

```
python3 setup.py install
```

2. If you need NCCL, set environmental variable `USE_NCCL=1` before installation. For example, you may use command as follows:

```
export USE_NCCL=1
```

3. Installation finishes. Enjoy FastMoe now! You can try excuting `benchmark_mlp.py` in directory `tests`.

repository: Sengxian/fastmoe-website

gha_language: SCSS

repo_name: Sengxian/fastmoe-website


text:
01. Course Overview
02. Introducing IaaS and Azure PowerShell - Introducing the Course
03. Introducing IaaS and Azure PowerShell - Learning Goals
04. Introducing IaaS and Azure PowerShell - Course Outline
05. Introducing IaaS and Azure PowerShell - What You'll Need
06. Introducing IaaS and Azure PowerShell - Installing Azure PowerShell
07. Introducing IaaS and Azure PowerShell - Azure Resource Manager
08. Introducing IaaS and Azure PowerShell - VM Pre-requisites
09. Introducing IaaS and Azure PowerShell - Creating VM Pre-requisites
10. Introducing IaaS and Azure PowerShell - Creating Windows Server VM
11. Introducing IaaS and Azure PowerShell - Windows VM Recap
12. Introducing IaaS and Azure PowerShell - Azure IaaS Costs
13. Introducing IaaS and Azure PowerShell - RDP into Windows VM
14. Introducing IaaS and Azure PowerShell - Creating Ubuntu Server VM
15. Introducing IaaS and Azure PowerShell - SSH into Ubuntu VM
16. Introducing IaaS and Azure PowerShell - Module Summary
17. Custom Images and Load Balancers - Module Introduction
18. Custom Images and Load Balancers - Setting up the Windows VM
19. Custom Images and Load Balancers - Extracting a Windows Image
20. Custom Images and Load Balancers - Sysprep and Windows Images
21. Custom Images and Load Balancers - Linux Proxy Configuration
22. Custom Images and Load Balancers - Setting up the Ubuntu VM
23. Custom Images and Load Balancers - Extracting an Ubuntu Image
24. Custom Images and Load Balancers - waagent and Linux Images
25. Custom Images and Load Balancers - Extending the Virtual Network
26. Custom Images and Load Balancers - Creating the Internal Load Balancer
27. Custom Images and Load Balancers - Creating the Internet-facing Load Balancer
28. Custom Images and Load Balancers - Load Balancers and Availability Sets
29. Custom Images and Load Balancers - VM Setup with Availability Sets and Load Balancers
30. Custom Images and Load Balancers - Module Summary
31. PowerShell DSC & ARM Templates - Module Introduction
32. PowerShell DSC & ARM Templates - Using PowerShell DSC on Azure
33. PowerShell DSC & ARM Templates - How DSC Works with Windows and Linux
34. PowerShell DSC & ARM Templates - Setting up the Linux Proxy with DSC
35. PowerShell DSC & ARM Templates - Runnning the Azure DSC Linux Extension
36. PowerShell DSC & ARM Templates - Working with PowerShell DSC and Linux
37. PowerShell DSC & ARM Templates - Setting up the Windows Web Server with DSC
38. PowerShell DSC & ARM Templates - Runnning the PowerShell DSC Windows Extension
39. PowerShell DSC & ARM Templates - Working with PowerShell DSC and Windows
40. PowerShell DSC & ARM Templates - Understanding ARM Templates
41. PowerShell DSC & ARM Templates - Writing and Generating ARM Templates
42. PowerShell DSC & ARM Templates - Configuring PowerShell DSC with ARM Templates
43. PowerShell DSC & ARM Templates - Deploying ARM Templates with PowerShell
44. PowerShell DSC & ARM Templates - Module Summary
45. Managing Azure VMs - Module Introduction
46. Managing Azure VMs - Security Options for Azure IaaS Deployments
47. Managing Azure VMs - Using Random Passwords with Azure VMs
48. Managing Azure VMs - Managing Operating System Updates
49. Managing Azure VMs - Securing Subnets with Network Security Groups
50. Managing Azure VMs - How to Adjust Performance of Azure VMs
51. Managing Azure VMs - Scaling Azure VMs up and Down
52. Managing Azure VMs - Resizing the OS Disk for an Azure VM
53. Managing Azure VMs - Adding Data Disks to Azure VMs
54. Managing Azure VMs - Performance Options for Azure VMs
55. Managing Azure VMs - How Azure IaaS Monitoring Works
56. Managing Azure VMs - Adding Diagnostics Extensions to Azure VMs
57. Managing Azure VMs - Monitoring Windows and Linux VMs
58. Managing Azure VMs - Course Summary

url: https://raw.githubusercontent.com/sarfarazit08/CodeRepo/a09a406ddb2c51da62db1590486682aba31fc962/Azure/Managing Azure IaaS with PowerShell/content.md

gha_language: Jupyter Notebook


text:
input format:
./bin_to_hex FILENAME
if this isn't specified it will by default take "source.txt"

Why do you output my input in a text file in the same folder? Don't I already know what it is?
If you get bad results, you can check the file to see if it matches, since it outputs the data that's being used.

Why is there a byte of zeroes at the end?
Null terminator. It's a C string. You can recompile this and go to n-1 if you care.


text:
# DocHeaderGenerator
Library to add some Header information to all the files. Typically can be used to add Copyright information to all the files.

## Motivation
Adding copyright information to all the source files of the project can be tedious if the project is large and can be cumbersome.
This library simplifies the task of writing the copyright information in just one file in the necessary format and running the library with the path to your project source code and it will append the information to all the specified files.
It will also show which are modified by the library and which are not so that you can keep a track of it.

## Usage
``` cmd
 java -jar docHeaderGenerator.jar <path_to_your_project_root> <path_to_header_file> <fileType> <fileType> ...
```
 Make sure JAVA_HOME is setup on your classpath to execute this.

#####Examples
``` cmd
 java -jar docHeaderGenerator.jar ./usr/vijet/projects/HelloWorld /usr/licenses/apache_license.txt *.*
```
This modifies each of the files that are present in the *./usr/vijet/projects/HelloWorld* folder having any file extension.
``` cmd
 java -jar docHeaderGenerator.jar ./usr/vijet/projects/HelloWorld /usr/licenses/apache_license.txt *.java
```
This modifies all the .java files that are present in the *./usr/vijet/projects/HelloWorld* folder having any file extension.

``` cmd
 java -jar docHeaderGenerator.jar ./usr/vijet/projects/HelloWorld /usr/licenses/apache_license.txt *.java *.xml
```
This modifies all the .java and .xml files that are present in the *./usr/vijet/projects/HelloWorld* folder having any file extension.

** NOTE:
* The first 3 arguments are mandatory(projectpath, header_file_path, file_format). Atleast one file format has to be specified.
* Its a good practice to keep a copy of your source code before using this library. If somethings goes wrong, its better to fallback to the earlier version.

repository: vijetb/DocHeaderGenerator

repo_name: vijetb/DocHeaderGenerator


text:
# ScreenSnapper
An OS X menu-bar application for taking screenshots.

Every time I needed to take a screenshot I ended up having to google the obscure keyboard shortcut or use Grab.

This is a small application that lives in your menu bar and provides shortcuts to taking screenshots and save them to either the clipboard or a file.

![ScreenSnapper in Action](http://i.imgur.com/MgLiYy8.gif)

Allows you to save the entire screen, a selection, or the contents of a single window.

When "Save to File" is enabled, screenshots to be saved to wherever your system screenshot location is (by default this is `~/Desktop/`)

Works by simply simulating the correct system keyboard shortcut using `CGEventCreateKeyboardEvent`.

##Installation:
* Download a zip containing the latest release [here](/stonesam92/ScreenSnapper/releases/download/v1.0.0/ScreenSnapper.zip)
* Extract the zip and copy the app to your Applications folder
* If gatekeeper is enabled, you must right-click the app and select "Open" the first time you run the app

repository: aapteedea/ScreenSnapper

repo_name: aapteedea/ScreenSnapper


text:
# Récolte-Links

## About Récolte-Links

Récolte-Links is a custom web app built using the Laravel framework. It was created by C. Liam Brown for internal use by Collectif Récolte as a way to share and manage external links in conjuction with Slack.

If you would like to install this app for your organization, please contact Liam: <a href="mailto:liam<EMAIL_ADDRESS>
## Requirements

- see [Laravel requirements](https://laravel.com/docs/8.x/installation)
- Composer
- npm (dev environment only)
- MySQL
- Slack pro (or nonprofit) account

## Installation

1. SSH into webhost and navigate to one level above `public_html`
1. `git clone https://github.com/cliambrown/recolte-links.git`
1. `cd recolte-links`
1. `composer install` (may need to install composer first)
1. `npm install` (optional — dev environment installs only)
1. `cp .env.example .env`
1. `php artisan key:generate`
1. Create a MySQL database + privileged user
1. Add db info from previous step to `.env` file
1. Update `.env` with required info
   * Create a Slack App
   * Add the App to the desired link-sharing channel
   * Add all required Slack info to `.env`
1. `php artisan migrate` (optional: ` -seed`)
1. On cPanel or equivalent, add a new subdomain pointing directly to `/recolte-links/public`
1. Make sure the domain redirects all requests to https (e.g. with `.htaccess`)

## License

Récolte-Links is open-sourced software licensed under the [MIT license](https://opensource.org/licenses/MIT).

repository: cliambrown/recolte-links

repo_name: cliambrown/recolte-links


text:
# README #

### What is this repository for? ###

* Program that extracts information such as chat participants and message count from a Whatsapp chat backup
* Includes generating graphs of most commonly used words and message length distribution, which can be saved as pngs
* Core chat parsing functionality offers a simple API to query messages and participants with extensibility for new message formats.
* V<IP_ADDRESS>

### How do I use it? ###

* [Download](https://bitbucket.org/SamLord/whatsappchatparser/downloads/) the latest installer
* First you'll want a chat archive - [iphone](https://faq.whatsapp.com/en/iphone/28041113), [android](https://faq.whatsapp.com/en/android/23756533/?category=5245251)
* Then just open the program and click File>Open and select your file
* Once your file is open all of the analysis gubbins is under the 'Tools' menu item - go play :)
* Then come back [here](https://bitbucket.org/SamLord/whatsappchatparser/issues/new) and suggest improvements by subitting an issue as an 'enhancement' or 'proposal'

### What's in the repo? ###

* Visual Studio 2011 solution in C#

### Something gone wrong? ###

Congratulations! You've found a bug! - Check to see if someone else has [already found it](https://bitbucket.org/SamLord/whatsappchatparser/issues?status=new&status=open), if so go and drop any info in their issue. Otherwise, [open a new issue](https://bitbucket.org/SamLord/whatsappchatparser/issues/new) - info in that link about the kinds of info to include.

Thanks for the help!


text:
## Financial News Web Scraping
This project has been built to automate the daily scrape of the latest financial news from a variety of sources and topics. The information retrieved is processed from another (proprietary) project in to produce a sentiment score on the daily news and make investment decisions.

## Project settings
- The file `sources.csv` contains the sources from which we scrape the data from and the type of object to be targeted for each website.

- The file `companies.csv` contains the word to filter for each topic. Project allows for synonyms to be separated from a comma: eg `word1, word2`

- The file `settings.R` contains different settings such as  the number of cores to be used for the parallel computation and the word you wish to remove from the news scraped.

## Packages Installation & Execution

The process is run mainly by the library `rvest`for web scraping and the package `tm` for text mining. In order to install these packages, and other useful for the analysis, run the `packages_install.R` by running:
- `cd <project_folder>`
- `Rscript ./master/packages_install.R`

Once the environment is set up, you can start the process by running:
- `cd <project_folder>`
- `Rscript main.R`

This script will load the necessary settings `settings.R`, functions `functions_source.R` and run the main code `financial_scrape.R`. The news retrieved will be store into the `.csv` files in the `./data` folder and available for further analysis.

## Project Details

Within the main code we:
- scrape the news from the sources specified in `./master/sources.csv`
- cleans the strings by making usage of `regex`
- apply word stemming and other technique to reduce the news title to a root form
- filter the news according to the topic specified in `./master/companies.csv`
- produce a data set for each topic filtering out the repeated mews within a certain period

At the end of the execution, each topic will have a dedicated data set `./data/<topic>.csv` containing the date and title of the news. The data set is now ready for further analysis.

As a bonus, we produce a `wordcloud` to inspect daily most used word and potentially identifiy new interesting topics to look at.

## R installation instruction

#### R
The whole project is coded in `R`. R is an open source language for statistical analysis.

On a Linux Debian based machine, R can be easily installed from the terminal by running
`sudo apt-get install r-base`

#### RStudio
*The RStudio IDE is a set of integrated tools designed to help you be more productive with R and Python. It includes a console, syntax-highlighting editor that supports direct code execution, and a variety of robust tools for plotting, viewing history, debugging and managing your workspace.*
You can download `RStudio` from <https://www.rstudio.com/products/rstudio/download/#download> and install it by running the executable.


text:
# Release History

# 2.8 / 2012-03-08

* Fix issue where indexedDB adapter's get method didn't execute callback when lookup is successful but result is empty.

# 2.7 / 2012-03-07

* Improved get and set methods by handling array of keys/items.
* Removed redundant serialization in indexedDB adapter's get and set
  methods.

## 2.6 / 2012-02-23

* Ensure compatibility with both FF and Chrome indexedDB implementations
* Added tests for each adapter (using Mocha framework)
* Refactored cookie adapter methods and fixed bug with StickyStore.remove() being called twice in certain cases
* Fixed bug with missing callback in StickyStore.adapters.localStorage.remove() causing multiple removals not to fire callback
* Fixed bug with number type conversion in StickyStore.serialize()

## 2.5 / 2012-02-19

* Fixed bug with callback not firing after all storage adapters are exhausted

## 2.4 / 2012-02-18

* Cleaned-up StickyStore.exec()

## 2.3 / 2012-02-18

* Fixed bug with indexedDB initialization not firing callback in certain
  cases.

## 2.2 / 2012-02-15

* Fixed localStorage adapter's get method not unserializing

## 2.1 / 2012-02-13

* Instead of waiting for all storage interfaces to connect before firing
  ready event, only wait for one interface to connect.

## 2.0 / 2012-02-13

* Added support for new IDBRequest.onupdateneeded event, while keeping
  backwards-compatible with old IDBDatabase.setVersion() method.
* Re-written for modularization of storage mechanisms.
* Proper support for multiple stores.

## 1.2 / 2011-12-29

* Fixed typo in webSQL removal callback

## 1.1 / 2011-12-23

* Added events; StickyStore.on() and StickyStore.trigger()
* Aliased the ready option by registering it with the 'ready' event
* Expanded error handling and replaced console messages with 'error' events
* Added events for StickyStore.get(), StickyStore.set(), and StickyStore.remove()

## 1.0 / 2011-12-22

* Improved error handling

## 0.9 / 2011-12-16

* Convert stored numbers to Number objects when repopulating

## 0.8 / 2011-11-17

* Fixed bug with storing Number objects
* Refactored some indexedDB logic when repopulating the store
* Refactored type checking in StickyStore.set()

## 0.7 / 2011-11-01

* Removed versioning of stores due to too many idiosyncracies
* Fixed bug with repopulating previous sessions data using indexedDB

## 0.6 / 2011-10-24

* Fixed bug with key reference for ObjectStore.put()

## 0.5 / 2011-10-21

* Fixed bug with webSQL versions
* Fixed bug with storing objects in indexedDB
* Updated documentation

## 0.4 / 2011-10-16

* Added callbacks
* Added default value for store.get()
* Added browser-specific detection of indexedDB

## 0.3 / 2011-10-11

* Fixed bug with indexedDB's continue and delete methods being reserved keywords causing Safari to throw errors

## 0.2 / 2011-10-10

* Added ```store.opts.name``` to handle multiple stores by prefixing keys
* Added ```store.removeAll()``` method
* Fixed bug where only objects and arrays were persisted to webSQL and indexedDB
* Updated documentation

## 0.1 / 2011-10-09

* Initial release
* Started release history


text:
[![Build Status](https://travis-ci.com/fetchrobotics/flow_ros.svg?branch=master)](https://travis-ci.com/fetchrobotics/flow_ros)

[**3.23.2021**]
_We are currently experiencing issues with Travis CI after they changed their plan for open source repositories. The build badge is currently not reliable. Apologies._

# Flow-ROS

C++14 library providing ROS-enabled wrappers for [Flow](https://github.com/fetchrobotics/flow).

## API Documentation

Documentation for latest version available [here](https://fetchrobotics.github.io/flow_ros/doxygen-out/html/index.html).

## What is this used for?

This library is meant for synchronizing multiple series of ROS messages, collected by `ros::Subscriber` objects. This is typically desirable in ROS nodes where multiple inputs are required to compute something, and the computed result is accurate only if the inputs have consistent relative sequencing. This library uses [Flow](https://github.com/fetchrobotics/flow) to fulfill these requirements in a customizable way.

Secondarily, this library provides in-process subscriber/publisher mechanisms which do not require a running ROS core and are swappable with their ROS-enabled counterparts. These are especially useful for testing message passing subsystems.

## Requirements

- [ROS](http://wiki.ros.org/melodic/Installation)
    + Tested with ROS Melodic
- [rosbag](http://wiki.ros.org/rosbag)
- [Boost](https://www.boost.org/users/history/version_1_65_1.html) (v1.65.1)
- [Bazel](https://docs.bazel.build/versions/3.4.0/getting-started.html)
    + repository currently provides Bazel build configurations for the library and tests
    + `cmake` configurations _coming soon_; contribution welcome
    + This library can be used as a header-only library if you will not be making use of the ROS-free local message passing facilities provided by `flow_ros::Router`.

## Components

### Subscribers

[`ros::Subscriber`](http://wiki.ros.org/ROS/Tutorials/WritingPublisherSubscriber%28c%2B%2B%29) objects are commonly used to listen for messages and run callbacks on message-receive events. These callbacks are run with de-serialized message contents as an input. Since this callback works on a single series of messages, a synchronization mechanism is needed to match these messages to messages received by other subscribers. This is where `flow_ros::Subscriber` objects come in.

`flow_ros::Subscriber` wrap `ros::Subscriber` objects and use their message-callback behavior to "inject" messages into a buffer. The contents of this buffer are serviced to synchronize messages across multiple series.

![Subscriber](doc/subscriber.png)

The way that messages are collected from a `flow_ros::Subscriber` buffer is defined by an associated synchronization policy, which may be configured with a Flow [driver](https://github.com/fetchrobotics/flow#drivers) or [follower](https://github.com/fetchrobotics/flow#followers) template as a template argument.

A `flow_ros::Subscriber` type may look as follows:

```c++
using PoseStampedSubscriberType = flow_ros::Subscriber<geometry_msgs::PoseStamped,  // message type
                                                       flow::follower::Before       // sync policy
                                                      >;

ros::NodeHandle nh;

PoseStampedSubscriberType sub{nh, "topic", 1 /*ROS queue size*/, ros::Duration{1} /*policy-specific args*/};
```

#### Synchronization

`flow_ros::Subscriber` objects can be serviced just like `flow::Captor` objects to synchronize messages, like so:

```c++
// We have three subscribers to synchronize; odometry and pose data are
// synchronized to laser scan messages

using LaserScanSubscriberType =
  flow_ros::Subscriber<sensor_msgs::LaserScan, flow::driver::Next>;

using PoseStampedSubscriberType =
  flow_ros::Subscriber<geometry_msgs::PoseStamped, flow::follower::Before>;

using OdometrySubscriberType =
  flow_ros::Subscriber<nav_msgs::Odometry, flow::follower::ClosestBefore>;

...

std::vector<sensor_msgs::LaserScan::ConstPtr> scans;
std::vector<geometry_msgs::PoseStamped::ConstPtr> poses;
std::vector<nav_msgs::Odometry::ConstPtr> odoms;

// Run data capture
const auto result = flow::Synchronizer::capture(
  std::forward_as_tuple(scan_driver, pose_follower, odom_follower),
  std::forward_as_tuple(std::back_inserter(scans),
                        std::back_inserter(poses),
                        std::back_inserter(odoms)));

if (result == flow::State::PRIMED)
{
  // scans, poses, odoms are ready
}
```

By default, `flow_ros::Subscriber` objects are configured such that `flow::Synchronizer::capture` needs to be called in a separate thread, as subscriber synchronization policies have built-in data waits which wake on data injection. For single threaded contexts, and extra template argument should be provided.

For a completely single-threaded application, you can do away with the overhead thread-safety mechanisms with `flow::NoLock` as follows:

```c++
using PoseStampedSubscriberType = flow_ros::Subscriber<geometry_msgs::PoseStamped,  // message type
                                                       flow::follower::Before,      // sync policy
                                                       flow::NoLock                 // no data waits
                                                      >;
```

For multi-threaded applications which employ synchronization polling rather than data waits, the `flow::PollingLock` template can be used make buffer accesses from multiple threads safe:

```c++
using LockType = std::lock_guard<std::mutex>;

using PoseStampedSubscriberType = flow_ros::Subscriber<geometry_msgs::PoseStamped,  // message type
                                                       flow::follower::Before,      // sync policy
                                                       flow::PollingLock<LockType>  // locking, but no waits
                                                      >;
```

#### Message sequencing

Default data sequencing within `flow_ros::Subscriber` buffers is performed using message header stamps. Namely, messages are ordered using `ros::Time`. Time offsets are specified with `ros::Duration`.

The Flow library describes how to implement [custom](https://github.com/fetchrobotics/flow#dispatch) access traits objects for dealing with data sequencing. Following this scheme, a default set of traits and accessors are provided in [`message_stamp_access.h`](flow_ros/include/message_stamp_access.h) which assume that messages have `MsgType::header::stamp` or `MsgType::stamp` (of type `ros::Time`). Messages which do not have a `header`, but do have a `ros::Time` member (named something other than `stamp`) are also usable after defining the appropriate companion accessors. For example, one can implement specialized access for a particular message like so:

###### Example Message Definition
`CustomMessageType.msg`
```
time custom_stamp_field_name

...

# other fields #
```

###### Access specialization
```c++
namespace flow
{

template <> struct DispatchAccess<boost::shared_ptr<const CustomMessageType>>
{
  using CustomMessageConstPtr = boost::shared_ptr<const CustomMessageType>;

  static const ros::Time& stamp(const CustomMessageConstPtr& msg) { return msg->custom_stamp_field_name; }

  static const CustomMessageConstPtr& value(const CustomMessageConstPtr& msg) { return msg; }
};

}  // namespace flow
```

##### Default Sequence Number Accessor

When using `flow_ros::Subscriber` objects directly, you may also opt to use sequence numbers for data ordering. Default handling for this is provided by [`message_seq_access.h`](flow_ros/include/message_seq_access.h).

#### Transport abstraction

Aside from providing a synchronization mechanisms on top of `ros::Subscriber` objects, `flow_ros::Subscriber` objects also provide a level of transport abstraction. Moreover, `flow_ros::Subscriber` objects may also be used without a running ROS core through the use of `flow_ros::Router`.

The `flow_ros::Router` provides simple in-process message passing facilities. It implements a subset of the methods provided by `ros::NodeHandle` which can be used to initialize both `flow_ros::Subscriber` and `flow_ros::Publisher` objects. This is convenient for areas of a program that don't need to expose external message connections (like unit tests). It also enables the passing of "non-message" objects to be synchronized with ROS messages, so long as they also use the same sequencing stamp type, i.e. `ros::Time`, sequence number, etc.

#### Messages from ROS bag files

`flow_ros::Router` supports message data injection from a `rosbag::MessageInstance`. This means that you can pump messages through a system of `flow_ros::Publisher` and `flow_ros::Subscriber` objects setup to pass messages locally. This is especially useful for testing a subsystems which run using data collected from a live run.

```c++
using LaserScanSubscriberType =
  flow_ros::Subscriber<sensor_msgs::LaserScan, flow::driver::Next>;

// Create local message router
flow_ros::Router router;

// Create lase scan subscriber
LaserScanSubscriberType laser_scan_sub{router, "/base_scan", 10U};

// Open a bag in read mode
rosbag::Bag bag;
bag.open("test.bag", rosbag::bagmode::Read);

std::vector<std::string> topics;
topics.emplace_back("/base_scan");

// Inject messages
rosbag::View view{bag, rosbag::TopicQuery{topics}};
for (const auto& mi : view)
{
  try
  {
    router.inject(mi);
  }
  catch (const flow_ros::UnknownSubscriptionError& ex)
  {
    // no routing for mi.getTopic()
  }
}

// Now there are messages loaded in laser_scan_sub
```

Note that calling `Router::inject` for an unknown topic (topics which haven't been advertised or subscriber to); or calling `Router::inject` with mismatched message types for a known topic will cause this method to throw an `flow_ros::UnknownSubscriptionError` exception.

### Publishers

`flow_ros::Publisher` objects are meant to be simple wrappers around `ros::Publisher` functionality, and are used in the same way as `ros::Publisher` objects. All that they add is the ability to make use of local message passing for interoperability with `flow_ros::Subscriber` objects. They also ensure a stable interface for use with the `flow_ros::EventHandler`.

A `flow_ros::MultiPublisher` template is provided for the purpose of outputting a sequence of messages returned from a `flow_ros::EventHandler` event callback.

### Event Handler

The `flow_ros::EventHandler` is a high-level mechanism for message driven callback execution. The `EventHandler` is used to:

1. service several subscription resources to gather synchronized data
2. run an event callback with captured data as an input, if synchronization was possible
3. publish values returned by the event callback (may also return/publish nothing)

Note that the `flow_ros::Subscriber` and `flow_ros::Publisher` objects used with the `EventHandler` may mix local message passing through a `flow_ros::Router` and ROS message communication freely.

![Event Handler](doc/event_handler.png)

A `flow_ros::EventHandler` can be used in a single threaded application like so:

```c++
// A tuple of publisher types
using Publishers = std::tuple<
  flow_ros::Publisher<const geometry_msgs::PoseStamped>,
  ...
  flow_ros::Publisher<const CustomResultType>
>;

// A tuple of subscriber types (note the use of flow::NoLock)
using Subscribers = std::tuple<
  flow_ros::Subscriber<sensor_msgs::LaserScan, flow::driver::, flow::NoLock>,
  flow_ros::Subscriber<geometry_msgs::PoseStamped, flow::follower::Before, flow::NoLock>,
  ...
  flow_ros::Subscriber<nav_msgs::Odometry, flow::follower::ClosestBefore, flow::NoLock>
>;

// Event handler type
using EventHandlerType = flow_ros::EventHandler<Publishers, Subscribers>;

ros::NodeHandle nh;

// Instance handler with publisher and subscriber resources
EventHandlerType event_handler{
  std::forward_as_tuple(
    std::make_shared<flow_ros::Publisher<geometry_msgs::PoseStamped>>(nh, "out_topic1", 1),
    ...
    std::make_shared<flow_ros::Publisher<CustomResultType>>(nh, "out_topicM", 1)
  ),
  std::forward_as_tuple(
    std::make_shared<flow_ros::Subscriber<sensor_msgs::LaserScan, flow::driver::Next>>(nh, "in_topic1", 1),
    std::make_shared<flow_ros::Subscriber<geometry_msgs::PoseStamped, flow::follower::Before>>(nh, "in_topic2", 1, ...),
    ...
    std::make_shared<flow_ros::Subscriber<nav_msgs::Odometry, flow::follower::ClosestBefore>>(nh, "in_topicN", 1, ...)
  )
};

// Start fresh; clear all subscriber buffers
event_handler.reset();

while (ros::ok())
{
  // Synchronize and execute next event
  const flow_ros::EventSummary summary = event_handler.update();

  if (summary.state == flow_ros::EventSummary::State::EXECUTED)
  {
    ROS_DEBUG("event callback executed");
  }

  // (Optionally) check if next event is possible without waiting or executing callback...
  const flow_ros::EventSummary dry_summary = event_handler.dry_update();

  ros::spinOnce();
}
```

Note that `EventHandler` supports type-erasure through a `flow_ros::EventHandlerBase`. `flow_ros::EventHandler` instances can be operated on through a base-class pointer like:

```c++
std::shared_ptr<flow_ros::EventHandlerBase> event_handler_ptr = std::make_shared<EventHandlerType>(...);

...

const flow_ros::EventSummary summary =  event_handler_ptr->update();
```

## Running Tests

```
bazel test ... --test_output=all
```

Bazel isn't everyone's cup of tea. _cmake build to come later_; earlier contribution welcome.


text:
---
layout: cv
title: Shane Steinert-Threlkeld's CV
css:
    - file: media/shanest-screen.css
      media: screen
    - file: media/shanest-print.css
      media: print
bibliography: sst-pubs.yaml
csl: chicago-syllabus.csl
header-includes: |

test: true
panflute-verbose: true
---

# Shane Steinert-Threlkeld
Computational Linguist and Cognitive Scientist

<a href="mailto:shanest<EMAIL_ADDRESS>| shane.st | clmbr.shane.st (lab)

Last modified: 05/24/23

## Employment

#### University of Washington

- Assistant Professor, Linguistics
`2019 - now`
- Director: Computation, Language, and Meaning Band of Researchers (CLMBR; [clmbr.shane.st](https://clmbr.shane.st))
- Data Science Affiliate, [eScience Institute](https://escience.washington.edu/)

#### Universiteit van Amsterdam

- Postdoctoral Researcher, Institute for Logic, Language and Computation
`2017 - 2019`
- ERC Funded "Cognitive Semantics and Quanities" (PI: Jakub Szymanik)

#### École Normale Supérieure

- Visiting Researcher, Institut Jean Nicod
`2017`
- ERC Funded "New Frontiers of Formal Semantics" (PI: Philippe Schlenker)

#### Google Research and Machine Intelligence

- Research software engineering intern
`2016`

## Education

`2011-2017`
__PhD., Stanford University__

- Philosophy and Symbolic Systems
- Dissertation: "Communication and Computation: New Questions About Compositionality" \
  (committee: Johan van Benthem (chair), Thomas Icard, Chris Potts, Brian Skyrms)

`2007-2011`
__B.A., The Johns Hopkins University__

- Philosophy and Mathematics
- Minor: Computer Science

## Awards

`2022-2024`
__UW Linguistics Fund__

- "Crowdsourcing semantic fieldwork in the modal domain" (2 years; $39,888)

`2021-2022`
__UW Royalty Research Fund__

- "Learning to Translate by Learning to Communicate" (1 year; $37,270)

`2016-2017`
__Mellon Foundation Dissertation Completion Fellowship__

`2011-2016`
__Patrick Suppes Fellowship in Philosophy of Science__

`2007-2011`
__Hodson Trust Scholar__

## Publications

Contribution: as required, for each non-single-authored publication, an esimate of my percentage contribution is included.  In addition, in parentheses, I have included the roles that I played in the publication, according to the [Contributor Role Taxonomy (CRediT)](https://doi.org/10.1002/leap.1210) system.

### Journals

`2023`
@steinert-threlkeldSemanticUniversalModality2023

- Contribution: 90% (conceptualization, formal analysis, data curation, writing --- original draft, writing --- review and editing, supervision)

`2023`
@polQuantifiersSatisfyingSemantic2023

- Contribution: 25% (conceptualization, methodology, writing --- review and editing, supervision)

`2023`
@ramotowskaUncoveringStructureSemantic2023

- Contribution: 30% (conceptualization, methodology, software, data curation, writing --- review and editing, supervision)

`2022`
@schlenkerAnthropocentrismComparativeCognition2022

- Contribution: 20% (conceptualization, writing --- review and editing)

`2022`
@denicIndefinitePronounsOptimize2022

- Contribution: 40% (conceptualization, methodology, software, writing --- original draft, writing --- review and editing)

`2022`
@steinert-threlkeldExplainingSemanticTypology2022

`2021`
@steinert-threlkeldQuantifiersNaturalLanguage2021

`2021`
@steinert-threlkeldReferentialGeneralCalls2021

- Contribution: 75% (conceptualization, methodology, software, formal analysis, writing --- original draft, writing --- review and editing)

`2021`
@carcassiMonotoneQuantifiersEmerge2021

- Contribution: 45% (conceptualization, methodology, software, writing --- original draft, writing --- review and editing)

`2021`
@steinert-threlkeldHowSocialNetworks2021

- Contribution: 60% (conceptualization, methodology, software, formal analysis, writing --- original draft, writing --- review and editing)

`2020`
@steinert-threlkeldEaseLearningExplains2020

- Contribution: 90% (conceptualization, methodology, software, formal analysis, writing --- original draft, writing --- review and editing)

`2020`
@steinert-threlkeldEmergenceNontrivialCompositionality2020

`2020`
@steinert-threlkeldExplanationVeridicalUniformity2020

`2020`
@hawkeSemanticExpressivismEpistemic2021

- Contribution: 50% (conceptualization, methodology, writing --- original draft, writing --- review and editing)

`2019`
@steinert-threlkeldLearnabilitySemanticUniversals2019

- Contribution: 90% (conceptualization, methodology, software, formal analysis, writing --- original draft, writing --- review and editing)

`2016/2018`
@hawkeInformationalDynamicsEpistemic2018

- Contribution: 50% (conceptualization, methodology, writing --- original draft, writing --- review and editing)

`2016`
@steinert-threlkeldCompositionalSignalingComplex2016

`2016`
@steinert-threlkeldCompositionalityCompetitionMonkey2016

`2016`
@steinert-threlkeldPropertiesIteratedLanguages2016

`2013/2016`
@mintsADCMethodProof2016

- Contribution: 30% (conceptualization, methodology, writing --- original draft, writing --- review and editing)

`2013`
@steinert-threlkeldIteratingSemanticAutomata2013

- Contribution: 60% (conceptualization, methodology, writing --- original draft, writing --- review and editing)

`2012`
@steinert-threlkeldOntologicalLabelsAutomated2012

- Contribution: 60% (software, formal analysis, methodology, writing --- original draft, writing --- review and editing)

### Proceedings

(NB: An * next to the year indicates abstract, as opposed to full paper, review.)

`2023`
@shapiroIconicArtificialLanguage2023

- Contribution: 40% (conceptualization, methodology, writing --- review and editing, supervision, funding acquisition)

`2022`
@yiProbingUnderstandingEnglish2022

- Contribution: 20% (conceptualization, methodology, writing --- review and editing, supervision, project administration)

`2022`
@banTestingPretrainedLanguage2022

- Contribution: 20% (conceptualization, methodology, writing --- review and editing, supervision, project administration)

`2022*`
@imelModalSemanticUniversals2022

- Contribution: 45% (conceptualization, methodology, software, formal analysis, visualization, writing --- review and editing, supervision, project administration)

`2022`
@guoDatabaseModalSemantic2022

- Contribution: 60% (conceptualization, methodology, software, data curation, writing --- original draft, writing --- review and editing, supervision, project administration)

`2022`
@downeyMaskedSegmentalLanguage2022

- Contribution: 25% (conceptualization, writing --- review and editing, supervision, project administration)

`2022`
@tienBilingualAlignmentTransfers2022a

- Contribution: 40% (conceptualization, methodology, writing --- review and editing, supervision, project administration)

`2022`
@steinert-threlkeldEmergentCommunicationFinetuning2022

- **Note:** Runner-up best paper award
- Contribution: 60% (conceptualization, methodology, writing --- original draft, writing --- review and editing, supervision, project administration, funding acquisition)

`2021`
@shapiroMultilabelApproachMorphosyntactic2021

- Contribution: 30% (conceptualization, methodology, writing --- review and editing, supervision)

`2021`
@jumeletLanguageModelsUse2021

- Contribution: 30% (conceptualization, methodology, writing --- review and editing, supervision)

`2021`
@vandepolQuantifiersSatisfyingSemantic2021

- Contribution: 25% (conceptualization, methodology, writing --- review and editing, supervision)

`2020`
@liLinguisticallyInformedTransformationsLIT2020

- Contribution: 20% (conceptualization, methodology, writing --- review and editing, supervision, project administration)

`2020`
@geffenlanSpontaneousEmergenceDiscrete2020

- Contribution: 35% (conceptualization, methodology, visualization, writing --- original draft, writing --- review and editing, supervision)

`2020*`
@denicComplexityInformativenessTradeoff2020

- Contribution: 40% (conceptualization, methodology, software, writing --- original draft, writing --- review and editing)

`2020*`
@ramotowskaMostNotMore2020

- Contribution: 30% (conceptualization, methodology, software, data curation, writing --- review and editing, supervision)

`2019*`
@steinert-threlkeldQuantifiersNaturalLanguage2019

`2019`
@carcassiEmergenceMonotoneQuantifiers2019

- Contribution: 45% (conceptualization, methodology, software, writing --- original draft, writing --- review and editing)

`2019`
@polComplexityLearnabilityExplanation2019

- Contribution: 35% (conceptualization, methodology, software, writing --- review and editing, supervision)

`2019`
@osullivanNeuralModelsPsychosemantics2019

- Contribution: 40% (conceptualization, methodology, software, writing --- review and editing, supervision)

`2018`
@steinert-threlkeldPayingAttentionFunction2018

`2018`
@pezzelleThemCanBe2018

- Contribution: 45% (conceptualization, methodology, software, investigation, writing --- original draft, writing --- review and editing)

`2017*`
@steinert-threlkeldUniformDefinabilityAssertability2017a

`2015`
@hawkeInformationalDynamicsMight2015

- Contribution: 50% (conceptualization, methodology, writing --- original draft, writing --- review and editing)

`2015*`
@steinert-threlkeldAlternativeRepresentationsFormal2015

- Contribution: 70% (conceptualization, methodology, formal analysis, investigation, writing --- original draft, writing --- review and editing)

`2014`
@steinert-threlkeldDecidabilityIteratedLanguages2014

`2013`
@szymanikAutomataComplexityMultipleQuantifier2013

- Contribution: 60% (conceptualization, methodology, formal analysis, investigation, writing --- original draft, writing --- review and editing)

`2011`
@steinert-threlkeldOntologicalLabelsAutomated2011

- Contribution: 60% (software, formal analysis, methodology, writing --- original draft, writing --- review and editing)

### Other

`2017`
@steinert-threlkeldCommunicationComputationNew2017

`2011`
@steinert-threlkeldLambdaCalculi2011

`2009`
@steinert-threlkeldOpenStandardsWebBased2009

- Contribution: 70% (conceptualization, software, visualization, writing --- original draft, writing --- review and editing)

### In Process

`revise and resubmit`
@guerinImpactSyntacticSemanticsubmitted

`submitted`
@jiangWeightedMobiusScoresubmitted

`submitted`
@downeyLearningTranslateLearningsubmitted

`submitted`
@ogiharaLimitationsModalAnalysissubmitted

`under contract`
@steinert-threlkeldComputationalExplanationsSemanticinprep

## Talks

### Invited

#### TBD

`Fall 2023`
UMass Amherst Linguistics Colloquium

`July 2023`
Internal and external pressures shaping language

#### Unnatural Language Semantics

`05/01/23`
UC Davis Linguistics Colloquium

`03/17/23`
Inaugural MIT Breakstone Speakers Series on Language, Mind, and Computation

`02/28/23`
UC Irvine Language Science Colloquium

#### Degrees of Monotonicity

`12/06/22`
McDonell Foundation Workshop on The Nature and Origins of the Human Capacity for Abstract Combinatorial Thought

#### Unnatural Language Semantics

`09/22/22`
South by Semantics Workshop (SXSW) @ University of Texas

`03/30/2022`
Center for Linguistic Theory and Studies in Probability (CLASP) @ Gothenburg

`03/04/2022`
Allyson Ettinger lab @ Chicago

#### Learning to Translate by Learning to Communicate

`09/21/22`
Computational Linguistics Seminar @ University of Texas

#### An Efficient Communication Analysis of Modal Typology

`05/19/2022`
Cognitive Semantics and Quantities closing workshop

#### Two Approaches to Explaining Semantic Universals

`09/08/2021`
Computational Psycholinguistics Lab @ MIT (PI: Levy)

`06/17/2021`
Konstanz Philosophy Colloquium

`02/17/2021`
Language Change: Theoretical and Empirical Perspectives (@ Hebrew University of Jerusalem)

`10/01/2020`
Computation and Langauge Lab @ Berkeley (PI: Piantadosi)

#### Cognitive Science to / from NLP

`02/22/2021`
Montana State University Computer Science Colloquium

#### Degrees of Monotonicity

`06/12/2019`
Workshop in Honor of Johan van Benthem's 70th Birthday

#### Explaining Semantic Universals

`05/24/2019`
Social Models of Meaning Acquisition (U Warsaw)

`04/17/2019`
Universität Osnabrück Institute of Cognitive Science Colloquium

`04/05/2019`
AwesomeIT Symposium (U Amsterdam)

`03/07/2019`
Logic and Interactive Rationality Seminar (ILLC, Amsterdam)

`02/20/2019`
University of Washington Linguistics Colloquium

`01/24/2019`
Cornell University Linguistics Colloquium

#### Ease of Learning Explains Semantic Universals

`12/15/2018`
Workshop on Universals in the Modal Domain (Utrecht)

`09/10/2018`
Cognition, Language and Communication Seminar (Amsterdam)

`11/14/2017`
Computational Linguistics Seminar (Amsterdam)

`11/10/2017`
Paris-Amsterdam-London Meeting

`09/28/2017`
Cognitive Semantics and Quantities kick-off workshop

#### How to be an Expressivist About Epistemic Modals

`06/26/2017`
Inquisitiveness Below and Beyond the Sentence Boundary (with Peter Hawke)

#### Pragmatic Expressivism and Non-disjunctive Properties

`03/22/2017`
Institut Jean Nicod

#### Compositional Signaling in a Complex World

`12/11/2015`
Center for Logic, Language, and Mind (Stockholm University)

#### Signaling Games

`12/10/2015`
Higher Seminar in Theoretical Philosophy (Stockholm University)

#### Epistemic Modality and the Dynamics of Discourse

`05/31/2015`
Fourth CSLI Workshop on Logic, Rationality and Intelligent Interaction

`04/14/2015`
Stanford Mathematical Logic Seminar

#### Learning to Use Function Words in Signaling Games

`12/11/2013`
Knowledge, Argumentation and Games in Amsterdam

#### Iterating Semantic Automata

`01/09/2014`
Cognition and Language Workshop

`05/14/2013`
Stanford Mathematical Logic Seminar

`06/02/2012`
First CSLI Workshop on Logic, Rationality and Intelligent Interaction

### Refereed

#### Iconic Artificial Language Learning
`07/xx/2023`
Annual Meeting of the Cognitive Science Society (CogSci 44); with Naomi Tachikawa Shapiro

#### Northwest Sahaptin modal expressions: a case study
`04/21/2023`
Workshop on Modality in Underdescribed Languages: Methods and Insights; with Sharon Hargus and Virginia Beavert

#### Testing Pre-Trained Language Models’ Understanding of Distributivity via Causal Mediation Analysis
`12/08/2022`
Analyzing and Interpreting Neural Networks for NLP (BlackboxNLP 5, at EMNLP); with Pangbo Ban, Yifan Jiang, Tianran Liu

#### Probing for Understanding of English Verb Classes and Alternations in Large Pre-Trained Language Models
`12/08/2022`
Analyzing and Interpreting Neural Networks for NLP (BlackboxNLP 5, at EMNLP); with David K Yi, James V Bruno, Jiayu Han, Peter Zukerman

#### An Efficient Communication Analysis of Modal Typology

`06/10/2022`
Semantics and Linguistic Theory (SALT 32); with Nathaniel Imel

`05/20/2022`
Experiments in Linguistic Meaning (ELM 32); with Nathaniel Imel

#### A Database for Modal Semantic Typology
`07/14/2022`
4th Workshop on Research in Computational Linguistic Typology and Multilingual NLP at NAACL; with Qingxia Guo, Nathaniel Imel

#### A Masked Segmental Language Model for Unsupervised Natural Language Segmentation
`07/14/2022`
19th SIGMORPHON Workshop on Computational Research in Phonetics, Phonology, and Morphology at NAACL; with C.M. Downey, Fei Xia, Gina-Anne Levow

#### Bilingual Alignment Transfers to Multilingual Alignment for Unsupervised Parallel Text Mining
`05/23/2022`
Association for Computational Linguistics (ACL); with Chih-chan Tien

#### Emergent Communication Fine-Tuning (EC-FT) for Pretrained Language Models
`04/29/2022`
Workshop on Emergent Communication: New Frontiers at ICLR; with C.M. Downey, Zeyu Liu, Xuhui Zhou

#### Linguistically-Informed Transformations (LIT): A Method for Automatically Generating Contrast Sets
`11/20/2020`
Analyzing and interpreting neural networks for NLP (BlackboxNLP); with Chuanrong Li, Lin Shengshuo, Zeyu Liu, Xinyi Wu, Xuhui Zhou

#### Complexity/informativeness trade-off in the domain of indefinite pronouns
`08/18/2020`
Semantics and Linguistic Theory (SALT 30); online, with Milica Denic

#### Quantifiers Satisfying Semantic Universals are Simpler
`07/30/2020`
Annual Meeting of the Cognitive Science Society (CogSci 43); with Iris van de Pol, Paul Lodder, Leendert van Maanen, Jakub Szymanik

#### On the Spontaneous Emergence of Discrete and Compositional Signals
`07/07/2020`
Association for Computational Linguistics (ACL 2020); online, with Nur Lan and Emmanuel Chemla

#### Quantifiers in natural language optimize the simplicity/informativeness tradeoff
`12/18/2019`
Amsterdam Colloquium (AC 2019)

#### Most, but not more than haf, is proportion-dependent and sensitive to individual differences
`09/06/2019`
Sinn und Bedeutung 24; with Sonia Ramotowska, Leendert van Maanen, Jakub Szymanik

#### The emergence of monotone quantifiers via iterated learning
`07/27/2019`
Annual Meeting of the Cognitive Science Society (CogSc 41); with Fausto Carcassi, Jakub Szymanik

#### Complexity and learnability in the explanation of semantic universals of quantifiers
`07/27/2019`
Annual Meeting of the Cognitive Science Society (CogSc 41); with Iris van de Pol, Leendert van Maanen, Jakub Szymanik

#### Semantic expressivism for epistemic modals, conditionals, and quantifiers
`06/22/2019`
Bilateral Approaches to Meaning; with Peter Hawke

#### Nueral Models of the Pyschosemantics of "most"
`06/07/2019`
Workshop on Cognitive Modeling and Computational Linguistics (CMCL); with Lewis O'Sullivan

#### Individual differences in semantic representations affect quantifier processing
`04/03/2019`
Reasoning, Argumentation and Logic in Natural Language: Experiments and Models; with Sonia Ramotowska, Leendert van Maanen, and Jakub Szymanik

#### Function Words and Context Variability

`12/08/2018`
Neural Information Processing Systems (NeurIPS2018), workshop on Emergent Communication

`11/04/2018`
Philosophy of Science Association, symposium on Evolutionary Explanations of Compositional Communication

#### Assertability Semantics for Conditionals, Quantification, and Modality
`03/29/2018`
Pacific Division of the American Philosophical Association; with Peter Hawke

#### Uniform Definability in Assertability Semantics
`12/22/2017`
Amsterdam Colloquium (AC 2017)

#### Alternative Representations in Proportional Quantifier Verification

`12/17/2015`
Amsterdam Colloquium (AC 2015); with Gert-Jan Munneke, Jakub Szymanik

`10/17/2015`
Linguistic and Cognitive Aspects of Quantification; with Gert-Jan Munneke, Jakub Szymanik

#### Epistemic Modality and the Dynamics of Discourse
`05/02/2015`
Berkeley-Stanford-Davis Graduate Conference in Philosophy; with Peter Hawke

#### On the Decidability of Iterated Languages
`04/25/2014`
Philosophy, Mathematics, Linguistics: Aspects of Interaction (PhML 2014)

#### Quantifier Scope and Tensed Clauses
`10/11/2013`
California Universities Semantics and Pragmatics Conference (CUSP 6); with Eric Acton and Daria Popova

#### Deflationism, Gaps, and Expressive Power
`04/26/2013`
Berkley-Stanford-Davis Graduate Conference in Philosophy

#### Ontological Labels for Automated Location of Left-Ventricular Remodeling
`09/21/2011`
Fifth IEEE International Conference on Semantic Computing

## Public Scholarship

### Text Media Appearances

`2023` "[Google’s Bard Writes Convincingly About Known Conspiracy Theories](https://www.bloomberg.com/news/articles/2023-04-04/google-s-bard-writes-convincingly-about-known-conspiracy-theories?accessToken=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzb3VyY2UiOiJTdWJzY3JpYmVyR2lmdGVkQXJ0aWNsZSIsImlhdCI6MTY4MDYyMzU3OCwiZXhwIjoxNjgxMjI4Mzc4LCJhcnRpY2xlSWQiOiJSU0xER1pEV1gyUFMwMSIsImJjb25uZWN0SWQiOiJFNzAxNENGQzIzNTI0MzU0QTVENUY2QkREMDAxOEU3NiJ9.Odn8lGbFzIufan19kvqfUUcpmUTTBpSmnQYe8E5a374)" by Davey Alba in _Bloomberg_

`2023` "[Tech’s hottest new job: AI whisperer. No coding required.](https://www.washingtonpost.com/technology/2023/02/25/prompt-engineers-techs-next-big-job/)" by Drew Harwell in _The Washington Post_

## Teaching

### Washington

LING 571 Deep Processing Methods for NLP: Aut '19, '20, '21, '22

LING 572 Advanced Statistical Methods for NLP: Win '20

LING 574 Deep Learning for NLP: Spr '21, '22

- NB: New course development

LING 575 Analyzing Neural Language Models: Win '20, Spr '21, '22

### Amsterdam

Causality, Decisions, and Games (with Robert van Rooij)

Neural Network Methods for Quantifiers

### Stanford

PHIL 152 Computability and Logic

PHIL 23A Cognitive Science of Mathematics

PHIL 150e Logic in Action (with Thomas Icard and Peter Hawke)

### Summer Schools and Mini-courses

The Artificial Language Toolkit: MIT Linguistics March 15-16 2023

Learnability of Quantifiers (with Jakub Szymanik): ESSLLI 2019; NASSLLI 2022

Quantification and Computation (with Jakub Szymanik): ESSLLI 2014

## Advising

### PhD

__Primary Advisor__

- Naomi Tachikawa Shapiro
- C.M. Downey (co-advisor: Gina-Anne Levow)
- Cassandra Maz

__Committee Member__

- Angelina McMillan-Major (chair: Emily M Bender)
- Yuanhe Tian (chair: Fei Xia)
- Nicolas Guerin (Institut Jean Nicod, chair: Emmanuel Chemla)

__Graduate Student Representative (external member)__

- Julian Michael (computer science)
- Jungo Kasai (computer science)
- Ofir Press (computer science)
- Suchin Gururangan (computer science)
- Saadia Gabriel (computer science)
- Jacob Geffen (computer science)
- Bo-Ru (Roy) Lu (electrical and computer engineering)
- Bhargavi Paranjape (computer science)
- Sewon Min (computer science)

### MS theses

`2022`
Nathaniel Imel (PhD Student, Logic and Philosophy of Science @ UC Irvine), "Modals in natural language optimize the simplicity/informativeness tradeoff"

`2022`
Katya Simpson (Software Engineer @ Twitter), " "Obama never said that": Evaluating fact-checks for topical consistency and quality"

`2021`
Megan Barnes (Software Engineer @ Google), "Latent Compositional Representations for English Function Word Comprehension"

`2021`
Jessica Sweeney (Data Scientist @ Coastal Community Bank), "Comparing Methods for Automatic Identification of Mislabeled Data"

`2021`
Shunjie Wang (Data Scientist AI/NLP @ Happify Health), "Evaluating Transformer's Ability to Learn Mildly Context-Sensitive Languages"

`2021`
Wes Rose (Language Engineer @ Amazon), "Toward the Emergence of Quantifiers"

`2021`
Devin Johnson (PhD student, Linguistics @ Northwestern), "Semantic Universals in Bayesian Learning of Quantifiers"

`2020`
Benny Longwill (Research Engineer @ ETS), "The Suitability of Generative Adversarial Training for BERT Natural Language Generation"

`2020`
Chih-chan Tien (PhD student, CS @ Chicago), "Bilingual alignment transfers to multilingual alignment for unsupervised parallel text mining"

`2020`
Daniel Campos (PhD student, CS @ UIUC), "Explorations In Curriculum Learning Methods For Training Language Models"

`2020`
Paige Finkelstein (Software Engineer, turn.io), "Human-Assisted Neural Machine Translation: Harnessing Human Feed- back for Machine Translation"

## Service

### Refereeing

#### Journals

Semantics & Pragmatics (5); Glossa Psycholinguistics; The Psychological Review; Mind; Noûs; Mind \& Language; Journal of Data Science; Erkenntnis (3); Synthese (2); The Review of Symbolic Logic (2); Journal of Logic, Language and Information (3); Journal of Semantics (4); Australasion Journal of Philosophy; Ergo; Philosophical Studies; Interaction Studies (formerly known as Evolution of Communication); Frontiers in Artificial Intelligence; Frontiers in Psychology (Language Sciences); Theoria (2); Logic Journal of the IGPL; PLoS Computational Biology

#### Conferences

Association for Computational Linguistics (ACL); Empirical Methods in Natural Language Processing (EMNLP); International Conference of Learning Representations (ICLR); Semantics and Linguistic Theory (SALT); North American ACL (NAACL); *SEM (Joint Conference on Lexical and Computational Semantics); Neural Information Processing Systems (NeurIPS); Experiments in Linguistic Meaning (ELM); BlackboxNLP; West Coast NLP (WeCNLP); International Conference on Machine Learning (ICML); COLING; Semantics and Philosophy in Europe (SPE); Amsterdam Colloquium; Annual Meeting of the Cognitive Science Society; AACL-IJCNLP (Asia-Pacific ACL - International Joint Conference in NLP); Joint Conference on Language Evolution (JCoLE); Experimental approaches to language universals in structure and meaning; Approaches to implicature: rational choice and/or exhaustification; WeSSLLI (Web Summer School in Logic, Language and Information) Student Session; ACL Student Research Workshop

### Conference Organization

#### General Chair

- Computational and Experimental Explanations in Semantics and Pragmatics, at ESSLLI 2021 (with Jakub Szymanik)
- Quantity in Language and Thought, at ESSLLI 2018 (with Jakub Szymanik)
- Discourse in Philosophy Colloquium Series (with Thom van Gessel, Peter Hawke)
- Cognitive Semantics and Quantities Kick-off Workshop (with Peter Hawke)
- NASSLLI 2014 Student Session
- First, Second, Third, Fourth CSLI Workshop on Logic, Rationality and Intelligent Interaction (with Peter Hawke, JT Chipman, Thomas Icard, Johan van Benthem)

#### Area Chair

- ESSLLI 2023: Language and Computation
- CoNLL 2023: Lexical, Compositional and Discourse Semantics

### Mentorship

Regular participant in Pop-Up Mentoring Program (PUMP) for LSA events (e.g. SALT, NASSLLI)

- Via the Diversity and Inclusion Committees at various *CL conferences, I have led:
  - early career mentoring session on work-life balance
  - early career mentoring session on finding research questions
  - birds-of-a-feather for interpretability and analysis
  - birds-of-a-feather for semantics and natural langauge understanding
- As the above have been replaced, I am now a standing mentor for the ACL Year-round Mentorship Program.

### Professional Societies

- Association for Computational Linguistics
- Special Interest Group in Typology
- Cognitive Science Society


text:
# Getting Started with Spark

Sample code to play with Spark using Java, Scala and Python

* [Getting Started with Spark using Python and Jupyter Notebook](https://github.com/tirthalpatel/Learning-BigData/tree/master/gs-spark/gs-spark-python)
* [Getting Started with Spark using Java](https://github.com/tirthalpatel/Learning-BigData/tree/master/gs-spark/gs-spark-java)
* [Getting Started with Spark using Scala](https://github.com/tirthalpatel/Learning-BigData/tree/master/gs-spark/gs-spark-scala)

# Further References

* [Apache Spark Key Terms, Explained](https://www.kdnuggets.com/2016/06/spark-key-terms-explained.html)
* [Spark courses on Pluralsight](https://www.pluralsight.com/search?q=spark&categories=course&sort=displayDate)
* [Spark Tutorials](https://techvidvan.com/tutorials/spark-tutorial/)
* [Spark Recipes](https://sparkour.urizone.net/recipes)
* Spark Examples [1](https://spark.apache.org/examples.html) | [2](https://github.com/apache/spark/tree/v2.3.1/examples)
* [Developing and Running a Spark WordCount Application](https://www.cloudera.com/documentation/enterprise/5-5-x/topics/spark_develop_run.html)
* [How to use SparkSession in Apache Spark 2.0](https://databricks.com/blog/2016/08/15/how-to-use-sparksession-in-apache-spark-2-0.html)
* [How to submit Spark Applications](https://spark.apache.org/docs/2.3.1/submitting-applications.html)
* [Getting Started with Spark: Running a Simple Spark Job in Java](https://www.datasciencebytes.com/bytes/2016/04/18/getting-started-with-spark-running-a-simple-spark-job-in-java/)
* [Setup Development Environment for Intellij, Scala and Spark](https://kaizen.itversity.com/setup-development-environment-intellij-and-scala-big-data-hadoop-and-spark/)
* [Example Maven configuration for a Spark, Scala project](https://github.com/martinprobson/Spark-Scala-Maven-Example)

repository: tirthalpatel/Learning-BigData

repo_name: tirthalpatel/Learning-BigData


text:
# hustle

A github and bitbucket activity graph mashup.

## Development Mode

```
lein dev
node target/server_dev/index.js
```

Figwheel will automatically push cljs changes to the browser and node server.

Wait a bit, then browse to [http://localhost:3779](http://localhost:3779).

### Run tests:

```
lein clean
lein doo phantom test once
```

The above command assumes that you have [phantomjs](https://www.npmjs.com/package/phantomjs) installed. However, please note that [doo](https://github.com/bensu/doo) can be configured to run cljs.test in many other JS environments (chrome, ie, safari, opera, slimer, node, rhino, or nashorn).

## Production Build

@TODO

repository: comamitc/hustle

repo_name: comamitc/hustle


text:
# Todo Manager

A React Application for managing your tasks.

## Run Locally

After you clone this repository you need to install all of the dependencies of the project using:

```sh
npm install
# or
yarn install
```

Then, you'll have the following scripts available:

```
# run the project in develop mode
yarn dev

# create a production build of the project
yarn build

# run the test of the project
yarn test
```

## License

[MIT](LICENSE)

repository: angelmtztrc/todo-manager

repo_name: angelmtztrc/todo-manager


text:
## SParts Command Line Interface

### Overview

The SParts Command Line interface (cli) is the command line tool to interface with the ledger. For example you can list out the suppliers, create new software parts and associate artifacts with existing parts. It was designed to have a similar look, feel  and behavior as the git command line interface. Enter the following to get a list of available commands

```
sparts --help
```

Examples of some of the more common commands include:

```
  sparts <command> --help			// obtain detailed help description for
 								  // <command>'s

  sparts config --list				// list the sparts local working direct

  sparts ping					   // checks if ledger is up

  sparts supplier --list		    // list the current suppliers

  sparts add <file1> <file2>		// Add artifacts to the staging areas

  sparts status 				   // Display ledger artifacts staging status

  sparts part --create 				// create a new part for the default supplier
```
### To Build

You will need to install the following third party components:

```
go get github.com/mattn/go-sqlite3 // might need to install gcc on Windows
go get github.com/nu7hatch/gouuid
go github.com/ghodss/yaml
go github.com/btcsuite/btcd/btcec
go github.com/btcsuite/btcd/chaincfg
go github.com/btcsuite/btcd/chaincfg/chainhash
go github.com/btcsuite/btcutil

```

Edit build.sh

```
# Set to directory within your $PATH (otherwise build in local directory)
BIN_DIR="."
```

Run build.sh

repository: hyperledger-labs/SParts

gha_language: Go

repo_name: hyperledger-labs/SParts


text:
# greedy-js-snake

## trying to make greedy snake :snake:
1. - [x] think the design path
2. - [x] launch local node.js first
3. - [x] simple html layout
4. - [ ] ~~testing css color block moving~~ 18-12-2020諗到
    > not the best way to design like that.
    > use javascript canvas would be better.
4. - [x] using javascript canvas
    > used javascript rect made first animation :+1: [Basic-Animation](https://github.com/Leesinbaka/greedy-js-snake/blob/main/Basic-Animation.md) 21/12/2020done!
5. - [x] using js function parameter to move
    > finally solved cant move problem :+1: [Basic-Move-Block](https://github.com/Leesinbaka/greedy-js-snake/blob/main/Basic-Anime-With-AddEventListener.md) 31/12/2020done!
6. - [x] move one direction at single time 31/12/2020
7. - [ ] ~~the fps calculate :( :slightly_smiling_face:~~ 6/1/2021 found out no good :(
8. - [ ] block :eggplant: next :eggplant: door
9. - [x] deside to not using this method to create game25/5/2021 and petty sad after breaking up with my gf
10. - [x] start to make are new one refence by this link [simple-greedy-snake](https://www.programmersought.com/article/75374205120/)
11. - [ ] And make him not that simple i think :3
20. - [ ] game logic thinking :O
```
        [0 0 0 0 0]
        [0 0 1 0 0]
snake = [0 0 1 1 0]
        [0 0 0 0 0]
        [0 0 0 0 0]
```

repository: Leesinbaka/greedy-js-snake

repo_name: Leesinbaka/greedy-js-snake


text:
#Course Content Survey Results
ACIT3620 - BCIT - Winter 2018

Thank you for taking part in the course content survey (the 20% who did).

My takeaways from the results are shown in alert boxes below each question.

- Quizzes and tests were much much harder than the practice material
- There is a lot of memorization required, especially file paths and the location of config files
- Lakc of time
- Explanation of some points and support during the labs
- Preparation bafore midterm for the bash script
- Midterm format
- Course content
- Partner set up with Pi related activities
- All conceptual sections were painful. Course should be entirely Practical
- need more class time for final assignment
- there wasnt much visual aid to help me see what things do
- we didnt get enough teaching in class
- relied too much on redhat

    Need more instruction & practice, especially for scripting

###Types of online activity, preceding a lab/seminar, are?

    Assigned readings, especially from the student guide, help.

###Techniques for assessing online activity part of "blended"?

    D2L survey or quiz, for some small marks, sound appropriate.

###Effectiveness of different ways to start a seminar with a "mini-lecture"?

    Recap of the important concepts and main points of the Student Guide chapter(s).

###Effectiveness of different lab styles/techniques?

    Current practices work, but no individual tool assessments.

###Opinions about the Raspberry Pi (for assignments)?

    Continue with entry level Pi, introduced earlier.
    Start with RaspbianOS and graduate to CentOS.

###Opinions about the hands-on midterm?

    Hands-on, with shell script, but introduce shell scripting in lab.

###Topics on the RHCSA from the followup course to ours ... should these be addressed in our course?

    All three topics sound appropriate to address, especially security & troubleshooting.

###Topics not addressed in the RHCSA curriculum ... should these be part of ACIT3620?

    Shell scripting and "hacking" belong, but not so much OS theory.

###Topics that you feel should be addressed or emphasized much more, in ACIT3620?

- Process management (kill process etc) is difficult, I would have liked to spend more time on that.
- More shell scripting to complete tasks. This is good practice for using multiple commands
- More project oriented assignment that make use of multiple tools
- The proccess of the hardening the Pi and teacher to show and explain this topic on the lesson
- Same with hacking - show and explain on the lesson the hacking part of the course
- Explaining the background process of the hacking and hack-tools
- Pi activity
- Security
- Learning that linux can be normal for computer usage
- Security
- Drive Management/Partitioning
- Process Management
- bash scripting
- basic linux commands
- bash scripting

    Gotta have bash scripting, and need to address security.

###What are three topics that should that not be addressed in the course, or which should be downplayed?tt

- All these topics are important to sys admin work, I would still try and cover everything.
- If it is not enough time (like in this term) probably hacking and securing should be downsized, but explainned more explicitly
- file system
- I can't think of any, but don't add a tonne of theory
- the pi not a fan of it
- hacking the pi

    Assigned readings, especially from the student guide, help.


text:
# Change Log
All notable changes to this project will be documented in this file. This change log follows the conventions of [keepachangelog.com](http://keepachangelog.com/).

## [0.9.0]
### Added
- deps.edn support - thanks @chrisbetz (#48)
- support custom data readers when coercing Clojure body - thanks @Andre0991 (#45)

### Fixed
- don't swallow exceptions in parsing transit+json - thanks @tggreene (#47)

### Changed
- replace CircleCI with github actions

## [0.8.2]
### Fixed
- Handle missing content-type header in response - thanks @oliyh (#33)

### Added
- Expose executor configuration - thanks @furiel (#31)

## [0.8.1]
### Fixed
- Automatic body decompressions should work with mixed casing content-encoding - thanks @vincentjames501 (#28)

## [0.8.0]
### Added
- Option to pass in custom middleware via request map so built in convenience wrappers can use it - thanks @csgero (#24)

### Fixed
- transit does not decode in JDK11 because `.available` is always 0 (#25)

## [0.7.2]
### Fixed
- Remove reflective calls (#22) - thanks @jimpil

## [0.7.1]
### Fixed
- Make `request` more permissive to handle request with async? but without callbacks throwing ClassCastException (#19)

## [0.7.0]
### Changed
- Make ssl-context more permissive (#17)

### Fixed
- Exceptions are not thrown correctly in async requests with default callbacks (#13)

## [0.6.0]
### Added
- More flexibility in multipart file types (#13 thanks @vincentjames501)
- Alpha support for converting response body based on content-type with `:as :auto`

### Changed
- Use cheshire `parse-stream-strict` to decode InputStream directly. (Requires cheshire 5.9.0 or later)
- Always parse JSON non-lazily to prevent stream being closed prematurely.
See [clj-http#489](https://github.com/dakrone/clj-http/issues/489) for similar discussion.
- Simplify code by always using InputStream BodyHandler in `client.clj`, so coercion handling is pure middleware.

### Fixed
- Content type params not being parsed

## [0.5.0]
### Added
- Websocket support (thanks @vincentjames501)

## [0.4.1] - 2011-11-19
### Fixed
- Remove reflection warnings

## [0.4.0] - 2019-08-06
### Added
- Multipart support (#1)

### Changed
- Readme notes it is now a stable API and ready for use.

## [0.3.1] - 2019-07-01
### Added
- This CHANGELOG file

### Fixed
- Double encoding of query string (#3).

## [0.3.0] - 2019-07-01
### Added
- Support custom middleware (#2). This makes it easier for
users to make their own request function from some stack of middleware.

## 0.2.0 - 2019-06-24
### Added
- Initial release

[Unreleased]: https://github.com/gnarroway/hato/compare/v0.9.0...HEAD
[0.9.0]: https://github.com/gnarroway/hato/compare/v0.8.2...0.9.0
[0.8.2]: https://github.com/gnarroway/hato/compare/v0.8.1...0.8.2
[0.8.1]: https://github.com/gnarroway/hato/compare/v0.8.0...0.8.1
[0.8.0]: https://github.com/gnarroway/hato/compare/v0.7.2...0.8.0
[0.7.2]: https://github.com/gnarroway/hato/compare/v0.7.1...0.7.2
[0.7.1]: https://github.com/gnarroway/hato/compare/v0.7.0...0.7.1
[0.7.0]: https://github.com/gnarroway/hato/compare/v0.6.0...0.7.0
[0.6.0]: https://github.com/gnarroway/hato/compare/v0.5.0...0.6.0
[0.5.0]: https://github.com/gnarroway/hato/compare/v0.4.1...0.5.0
[0.4.1]: https://github.com/gnarroway/hato/compare/v0.4.0...0.4.1
[0.4.0]: https://github.com/gnarroway/hato/compare/v0.3.1...0.4.0
[0.3.1]: https://github.com/gnarroway/hato/compare/v0.3.0...v0.3.1
[0.3.0]: https://github.com/gnarroway/hato/compare/v0.2.0...v0.3.0

repository: gnarroway/hato

gha_language: Clojure

repo_name: gnarroway/hato