text:
---
title: Making a Contribution in Accounting Research – Part I
author: Gregory Saxton
type: post
date: -001-11-30T00:00:00+00:00
draft: true
url: /?p=2510
categories:
  - academia
  - research

---
This is first in a series of posts covering how to make an intellectual contribution in academic research in accounting as well as most other business and social science disciplines.

In the academic worlds I interact with — accounting, business, social sciences — one of the words you’ll hear time and again is “contribution.” This is particularly relevant when you receive a review of one of your own papers and read that it fails to make a large enough “contribution.” 🙂

So, what exactly constitutes an _intellectual contribution_ in accounting research? The short answer is that it tells us something useful that we do not already know. That short answer is not too helpful, however. So, in this post I will convey my more concrete thoughts on what makes a relevant contribution in an academic article.

First, let me lay out some generic categories of contributions and which ones are seen as best in top-tier academic accounting journals. The same general lessons apply to quantitative research in any of the other social sciences or business disciplines (I’ll leave aside the notion of a contribution in qualitative research). The following is a distillation of ideas I’ve learned over the years. For a more detailed discussion of some of these points, see, among others Voss (2003), Slater and Gleason (2012), and Colquitt and George (2011). The main ideas are my take on things, however, so the usual caveat applies.

    Contents

      1 Replication

      2 New Sample or Context

      3 New Measure (Often with Revised Conceptualization) or New Statistical Technique

      4 New Relationship

      5 Conclusion

      6 References

## Replication

A first type of contribution is to replicate, or “re-do,” an existing study.

To help make these ideas concrete, I will use the specific example of what leads to _earnings management_ in nonprofit organizations. Using an example of a strong, well-published accounting paper, let’s look at Eldenburg, Gunny, Hee, and Soderstrom (2011), who examined the relationship between _pay-for-performance incentives_ (the independent variable, or IV) and earnings management (the dependendent variable, or DV) in US-based nonprofit hospitals. If you were to try to replicate this study, you would draw a new sample of US-based nonprofit hospitals, recreate the authors’ measures, and then re-run the statistics using the same statistical procedures as in Eldenburg et al. (2011). You will have thus replicated their study.

While replication studies are needed in academia, unfortunately, they are not highly valued by the pinnacle accounting journals (nor those in other business or social science disciplines). In fact, replication is the “lowest” type of contribution, while in practice means you would likely find your study published in a low-level (or if you’re lucky a mid-level) accounting journal.

## New Sample or Context

Second, a contribution can be made by taking an existing relationship found in the literature and _applying it in a new geographic or organizational context._

Returning to our Eldenburg et al. (2011) example, and pointing out that they based their empirical tests on US nonprofit hospitals, someone could come along and test the same IV → DV relationship in a different context. If a different geographic context, the relationship could be tested in a sample of Canadian, or Chinese, or Cambodian hospitals. If a different organizational context, someone else might test the IV → DV relationship in a set of US-based educational nonprofits or environmental nonprofits. In either case, the authors are asking, “We know that X → Y holds in US-based hospitals, but does it also hold in other countries or in other types of nonprofits?”

This is certainly a valid way to build our knowledge and helps us understand such things as idiosyncracies of distinct contexts as well as boundary conditions, etc. However, it is what I would call an _incremental_ contribution. This type of contribution, as a general rule, will therefore be relegated to the mid-tier and lower-tier accounting journals.

## New Measure (Often with Revised Conceptualization) or New Statistical Technique

A third type of contribution is to make a new measure of one of the key concepts in an established relationship. Continuing our example above, a researcher might come along and develop a new measure of earnings management and then re-test the relationship between pay-for-performance incentives and earnings management in US-based nonprofit hospitals. Often, but not always, this new measurement approach will be spurred by the author’s view that the definition of the concept needs updating.

I would also place in this category new statistical tests of the relationship between the independent and dependent variable. For example, if someone comes along and argues that the original test should be done with robust clustered standard errors, then that is an example of this type of argument.

Again, this is a valid way to enhance our knowledge. Nevertheless, if this is the chief contribution, it is another example of an _incremental_ contribution that, as a general rule, will also for this reason be relegated to the mid-tier and lower-tier accounting journals.

## New Relationship

Lastly, adding a new variable to an existing model— whether a mediator, moderator, or existing explanatory factor—is one of the fundamental ways of doing “innovative” social scientific research (Slater and Gleason 2012; Voss 2003). Note that in all of these cases, it is the additional of a new _relationship_ (either new IV, new DV, or new IV/DV combination).

Here is the relationship:

[<img loading="lazy" src="http://social-metrics.org/wp-content/uploads/2020/08/Screen-Shot-2020-08-19-at-8.33.24-PM-1024x187.png" alt="" width="512" height="94" class="alignnone size-large wp-image-2532" srcset="http://social-metrics.org/wp-content/uploads/2020/08/Screen-Shot-2020-08-19-at-8.33.24-PM-1024x187.png 1024w, http://social-metrics.org/wp-content/uploads/2020/08/Screen-Shot-2020-08-19-at-8.33.24-PM-300x55.png 300w, http://social-metrics.org/wp-content/uploads/2020/08/Screen-Shot-2020-08-19-at-8.33.24-PM-768x140.png 768w, http://social-metrics.org/wp-content/uploads/2020/08/Screen-Shot-2020-08-19-at-8.33.24-PM.png 1138w" sizes="(max-width: 512px) 100vw, 512px" />][1]

Why is the relationship so important? The short answer: _theory_. Theory fundamentally involves examining the relationship between two or more concepts. We are making a theoretical argument when we try to explain why one concept (earnings management) is determined by another concept (pay-for-performance incentives).

Note that Eldenburg et al. did not come up with the idea that earnings management existed. Where they innovated was in positing and then testing the idea that earnings management was driven by pay-for-performance incentives (they also examined the effects of accounting performance, or the extent to which performance was above or below a benchmark).

## Conclusion

In short, when people (reviewers, discussants, co-authors) are talking about a “contribution” or an “intellectual contribution,” they are almost always referring to a _theoretical_ contribution. This means that at a minimum you should strive to add another conceptual relationship to the literature. This could be a new mediator, a new moderator, a new independent variable, or a new dependent variable. Of course, new definitions, new measures, and new contexts are also helpful but they should not be the sole novelty of any manuscript you’re thinking of sending to a top-tier journal.

## References

     Slater, M. D., & Gleason, L. S. (2012). Contributing to theory and knowledge in quantitative communication science. Communication Methods and Measures, 6(4), 215–236. [BibTeX] [Abstract] [PDF]

        We propose a framework for understanding how quantitative researchers typically seek to contribute to theory and generalizable knowledge in communication, noting some of the strengths and weaknesses of the various approaches typically used. The major approaches are described, and a content analysis of articles from four issues each of Journal of Communication, Human Communication Research, and Communication Research spanning parts of 2008 and 2009 provides information about their relative frequency of use in the field. We discuss how these categories can be employed by researchers when conceptualizing and articulating the theoretical contributions planned in their research and by reviewers, editors, and researchers in critically assessing such contributions in the work of others.

@article{Slater2012,
abstract = {We propose a framework for understanding how quantitative researchers typically seek to contribute to theory and generalizable knowledge in communication, noting some of the strengths and weaknesses of the various approaches typically used. The major approaches are described, and a content analysis of articles from four issues each of Journal of Communication, Human Communication Research, and Communication Research spanning parts of 2008 and 2009 provides information about their relative frequency of use in the field. We discuss how these categories can be employed by researchers when conceptualizing and articulating the theoretical contributions planned in their research and by reviewers, editors, and researchers in critically assessing such contributions in the work of others.},
annote = {doi: 10.1080/19312458.2012.732626},
author = {Slater, Michael D and Gleason, Laurel S},
doi = {10.1080/19312458.2012.732626},
issn = {1931-2458},
journal = {C}ommunication {M}ethods and {M}easures,
month = {oct},
number = {4},
pages = {215--236},
publisher = {Routledge},
title = {{Contributing to theory and knowledge in quantitative communication science}},
url = {https://doi.org/10.1080/19312458.2012.732626},
volume = {6},
year = {2012}
}

     Colquitt, J. A., & George, G. (2011). Publishing in AMJ—Part 1: Topic choice. Academy of Management Journal, 54(3), 432–435. [BibTeX] [PDF]

@article{Colquitt2011,
annote = {doi: 10.5465/amj.2011.61965960},
author = {Colquitt, Jason A and George, Gerard},
doi = {10.5465/amj.2011.61965960},
issn = {0001-4273},
journal = {A}cademy of {M}anagement {J}ournal,
month = {jun},
number = {3},
pages = {432--435},
publisher = {Academy of Management},
title = {{Publishing in AMJ—Part 1: Topic choice}},
url = {https://doi.org/10.5465/amj.2011.61965960},
volume = {54},
year = {2011}
}

     Eldenburg, L. G., Gunny, K. A., Hee, K. W., & Soderstrom, N. (2011). Earnings management using real activities: Evidence from nonprofit hospitals. The Accounting Review, 86(5), 1605–1630. [BibTeX] [PDF]

@article{Eldenburg2011,
annote = {doi: 10.2308/accr-10095},
author = {Eldenburg, Leslie G and Gunny, Katherine A and Hee, Kevin W and Soderstrom, Naomi},
doi = {10.2308/accr-10095},
issn = {0001-4826},
journal = {{The Accounting Review}},
month = {may},
number = {5},
pages = {1605--1630},
publisher = {American Accounting Association},
title = {{Earnings management using real activities: Evidence from nonprofit hospitals}},
url = {https://doi.org/10.2308/accr-10095},
volume = {86},
year = {2011}
}

    Voss, G. B. (2003). Formulating interesting research questions. Journal of the Academy of Marketing Science, 31(3), 356–359. [BibTeX]

@article{Voss2003,
author = {Voss, Glenn B},
issn = {0092-0703},
journal = {J}ournal of the {A}cademy of {M}arketing {S}cience,
number = {3},
pages = {356--359},
publisher = {SAGE Publications},
title = {{Formulating interesting research questions}},
volume = {31},
year = {2003}
}

 [1]: http://social-metrics.org/wp-content/uploads/2020/08/Screen-Shot-2020-08-19-at-8.33.24-PM.png

repository: gdsaxton/academic-kickstart

repo_name: gdsaxton/academic-kickstart


text:
---
title: Lesson 10
lesson: Fetch
template: article.jade
lessonId: 10
order: 3
---

You may have heard a term **AJAX**.  AJAX is the idea that javascript can load content from a different source and display that content in the page.

Now days AJAX data comes in as JSON.  JSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML.

```javascript
"foo" : {
  "bar" : "Hello"
}
```

This used to be very complex since you would never know if a file has fully loaded.  There are a number of library that can help with it.

Javascript has a build in way of getting json data called `fetch()`.

The `fetch()` method takes one mandatory argument, the path to the resource you want to fetch. It returns a *Promise* that resolves to the *Response* to that request, whether it is successful or not.

```javascript
fetch(URL)
```

Since we dont know when the fetch will return a value we can use a JS *Promise* that will let you chain on a `.then()` that will wait for the response to come back.  Since we are using *json* we need to call `.json()` on the data that then returns an other promise so out call will look something like this

```javascript
fetch(URL).then(raw => raw.json()).then(data => {/* do something with the data */})
```

but that could be hard to read so we can reformat it like this

```javascript
fetch(URL)
  .then(raw => raw.json())
  .then(data => {
    /* do something with the data */
  })
  .catch(error => console.error(error));
```

We added a `.catch()` that will be run if there is an error that is returned.

license: MIT

repository: danhahn/css-site

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: danhahn/css-site


text:
---
layout: default
---

# 1996-01-24 - Reporting ITAR Violations

## Header Data

From<EMAIL_ADDRESS>(Futplex)

To<EMAIL_ADDRESS>(Cypherpunks Mailing List)

Message Hash: 35cfaa9a923e13e6bb728f9c291e83404808a6238f9983e4458e4dd72edb1709

Message ID<EMAIL_ADDRESS>Reply To: \<9601231353.AA06639@alpha\>

UTC Datetime: 1996-01-24 07:16:59 UTC

Raw Date: Wed, 24 Jan 1996 15:16:59 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Futplex)
Date: Wed, 24 Jan 1996 15:16:59 +0800
To<EMAIL_ADDRESS>(Cypherpunks Mailing List)
Subject: Reporting ITAR Violations
In-Reply-To: <9601231353.AA06639@alpha>
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

-----BEGIN PGP SIGNED MESSAGE-----

ECafe Anonymous Remailer writes:
# Here is the RC4 cipher for the HP-48 calculator...

Mike McNally writes:
> You know, it'd be interesting to start loudly reporting such obvious
> ITAR violations.  Not, of course, because I feel myself threatened as
> a result of this attack on national security, but because it might
> make life more difficult for Them.
[...]

I would feel a bit more comfortable if violations by non-anonymous entities
were well publicized. Otherwise, we may force the TLAs to cash in the
"weapons export" card against the anonymizers, and hasten a crackdown on
them. (In this particular instance, the remailer resides outside the ITAR
zone, but that detail could be conveniently ignored in calling for a ban on
U.S. remailers.)

I'm still hoping for a test of the PA anonymity prohibition....

Futplex<EMAIL_ADDRESS>still catching up on last week's mail

-----BEGIN PGP SIGNATURE-----
Version: 2.6.2

iQEVAwUBMQXagSnaAKQPVHDZAQHZTwf/WrHgbZjgiJIXxW886mKO/E/eoSLh0eSE
IBnfnDABTmAUcbvUEo/UMn7n7Gsq03mJgyo9z1+6SUGxhqt45MV41d7rZQVhkBWs
+woh7YqGIiqGF9elvaVUlp7xsqyKLdXVQYqkahe0M4Ouw7S033HYIC+6lW6kTBeC
C0vOnwyoB82WJ1x2SRH8iz7/lCWJkQkDSiRJ3yaAB4UtXvsikug3ddvOGz2tbL19
sxlxoJslD5MlqcH8ubKqDvHR++N432cOKMOHR82GjAm8b2f4/0lmaDWAxDaaWNFb
jk0EH5Ax8gECoBWl6dw3Sw3asWNbM0M9UIthEmOTjiJoOb9cRxjoNw==
=O3fc
-----END PGP SIGNATURE-----

{% endraw %}
```

## Thread

+ Return to [January 1996](/archive/1996/01)

+ Return to<EMAIL_ADDRESS>(ECafe Anonymous Remailer)](/authors/cpunk_at_remail_ecafe_org_ecafe_anonymous_remailer_)"
+ Return to<EMAIL_ADDRESS>(Futplex)](/authors/futplex_at_pseudonym_com_futplex_)"
+ Return to<EMAIL_ADDRESS>(Mike McNally)](/authors/m5_at_dev_tivoli_com_mike_mcnally_)"

+ 1996-01-23 (Mon, 22 Jan 96 18:22:03 PST) - [RC4 for HP48](/archive/1996/01/e92193bd003113bb174d996ebb078f29352e8c66f69c73cc7b27a405686220a3) -<EMAIL_ADDRESS>(ECafe Anonymous Remailer)_
  + 1996-01-23 (Tue, 23 Jan 1996 22:06:30 +0800) - [RC4 for HP48](/archive/1996/01/d575c2bb4d87646e7497113860a2606a2da184f15664c3f8258506c99bb286e0) -<EMAIL_ADDRESS>(Mike McNally)_
    + 1996-01-24 (Wed, 24 Jan 1996 15:16:59 +0800) - Reporting ITAR Violations -<EMAIL_ADDRESS>(Futplex)_

gha_license_id: MIT


text:
# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](http://keepachangelog.com/)
and this project adheres to [Semantic Versioning](http://semver.org/).

Unreleased section should follow [Release Toolkit](https://github.com/newrelic/release-toolkit#render-markdown-and-update-markdown)

## Unreleased

## v1.10.1 - 2023-08-07

### ⛓ Dependencies
- Updated golang to v1.20.7

## v1.10.0 - 2023-07-24

### 🚀 Enhancements
- bumped golang version pinning 1.20.6

### ⛓ Dependencies
- Updated github.com/sirupsen/logrus to v1.9.3 - [Changelog 🔗](https://github.com/sirupsen/logrus/releases/tag/v1.9.3)

## 1.9.0 (2023-06-06)
### Changed
- Update Go version to 1.20

## 1.8.1  (2022-06-27)
### Changed
- Bump dependencies
### Added
Added support for more distributions:
- RHEL(EL) 9
- Ubuntu 22.04

## 1.8.0  (2022-03-08)
### Added
- `mysql-log.yml.example` is now in Linux packages to help setting up log parsing.

## 1.7.1  (2021-10-20)
### Added
Added support for more distributions:
- Debian 11
- Ubuntu 20.10
- Ubuntu 21.04
- SUSE 12.15
- SUSE 15.1
- SUSE 15.2
- SUSE 15.3
- Oracle Linux 7
- Oracle Linux 8

## 1.7.0  (2021-06-27)
### Added
- New parameter for MySQL local socket connection. Local socket connection is secure so MySQL will not complain about non-secure connection when `require_secure_transport = ON`.

- Moved default config.sample to [V4](https://docs.newrelic.com/docs/create-integrations/infrastructure-integrations-sdk/specifications/host-integrations-newer-configuration-format/), added a dependency for infra-agent version 1.20.0

Please notice that old [V3](https://docs.newrelic.com/docs/create-integrations/infrastructure-integrations-sdk/specifications/host-integrations-standard-configuration-format/) configuration format is deprecated, but still supported.

### Fix
- Detection of slave running for all mysql versions
- IPv6 address URI formation

## 1.6.1 (2021-06-08)
### Changed
- Support for ARM

## 1.6.0 (2021-05-05)
## Changed
- Update Go to v1.16.
- Migrate to Go Modules
- Update Infrastracture SDK to v3.6.7.
- Update other dependecies.
- Improve logs

## 1.5.1 (2021-03-25)
### Fixed

- Fixed a bug that caused rows to not be fully consumed (and therefore a panic) in some rare circumstances (https://github.com/newrelic/nri-mysql/pull/77).

## 1.5.0 (2020-01-14)
### Added
- Metrics for commits and rollbacks.

## 1.4.0 (2019-11-18)
### Changed
- Renamed the integration executable from nr-mysql to nri-mysql in order to be consistent with the package naming. **Important Note:** if you have any security module rules (eg. SELinux), alerts or automation that depends on the name of this binary, these will have to be updated.
## 1.3.0 (2019-04-29)
### Added
- Upgraded to SDK v3.1.5. This version implements [the aget/integrations
  protocol v3](https://github.com/newrelic/infra-integrations-sdk/blob/cb45adacda1cd5ff01544a9d2dad3b0fedf13bf1/docs/protocol-v3.md),
  which enables [name local address replacement](https://github.com/newrelic/infra-integrations-sdk/blob/cb45adacda1cd5ff01544a9d2dad3b0fedf13bf1/docs/protocol-v3.md#name-local-address-replacement).
  and could change your entity names and alarms. For more information, refer
  to:

  - https://docs.newrelic.com/docs/integrations/integrations-sdk/file-specifications/integration-executable-file-specifications#h2-loopback-address-replacement-on-entity-names
  - https://docs.newrelic.com/docs/remote-monitoring-host-integration://docs.newrelic.com/docs/remote-monitoring-host-integrations

## 1.2.0 (2019-04-08)
### Added
- Upgraded to SDKv3
- Remote monitoring option. It enables monitoring multiple instances,
  more information can be found at the [official documentation page](https://docs.newrelic.com/docs/remote-monitoring-host-integrations).
- Restored `NRIA_CACHE_PATH` legacy environment variable, for backwards-compatibility.
- Upgrade sql driver to support caching_sha2_password (MySQL 8 default) and sha256_password authentication support

## 1.1.5 (2018-12-05)

### Fixed
- Issue where the plugin returned metrics when only inventory was requested.

## 1.1.4 (2018-10-19)

### Bugs fixed

#### Allow rate and deltas

- Metrics of type rate and delta cannot be added unless there is a namespacing attribute on the metric-set.

## 1.1.3 (2018-10-12)

### Changed:

####  Update to SDKv3

- Updated the integration code from the previous version of the SDK to [SDK v3](https://github.com/newrelic/infra-integrations-sdk/#upgrading-from-sdk-v2-to-v3).

### Added:

#### Old password support

- Previously when trying to run Mysql integration on a mysql-server with old password support https://dev.mysql.com/doc/refman/5.6/en/server-system-variables.html#sysvar_old_passwords integration won't run. If customer has set old_passwords=1 at the MySQL server integration can now connect to it.

#### Ignore bin folder

`bin` folder added to `.gitignore`.

### Bugs fixed

#### Hostname issue
- Integration CLI-arguments are no longer overridden by environment-variables
As CLI-args are used by the NRI agent `HOSTNAME` that is a common bash env-var is not used to set MySql-host unless no hostname is provided via config.

## 1.1.2 (2018-10-16)
### Added
- Included metric `Master_Host`

### Changed
- Fixed code dependencies

## 1.1.1 (2018-09-07)
### Changed
- Updated Makefile

## 1.1.0 (2018-08-02)
### Added
- Added contributing information
- Added packaging script

### Changed
- Updated Makefile

## 1.0.0 (2018-07-24)
### Added
- Initial release, which contains inventory and metrics data

repository: newrelic/nri-mysql

gha_language: Go

repo_name: newrelic/nri-mysql


text:
# Azure Active Directory

Azure Active directory has two OAuth endpoints - [v1 and v2](https://docs.microsoft.com/en-us/azure/active-directory/develop/azure-ad-endpoint-comparison). Ideally, you'd want to use v2, but it has [some limitations](https://docs.microsoft.com/en-us/azure/active-directory/develop/azure-ad-endpoint-comparison#limitations), e.g. if your application relies on SAML, you'll have to use v1.

## V1

The main difference between v1 and v2 is that v1 uses _resources_ and v2 uses _scopes_ for access management.

V1 [does not specify a revocation endpoint](https://docs.microsoft.com/en-us/azure/active-directory/active-directory-configurable-token-lifetimes#access-tokens) because the access token are not revokable. Therefore `revoke` functionality doesn't work.

See the [Azure docs on requesting an access token](https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-protocols-oauth-code#request-an-authorization-code) for more info on additional parameters.

Please Note:

* `Scopes` is ignored.
* `additionalParameters.resource` may be required based on the tenant settings.

```js
const config = {
  issuer: 'https://login.microsoftonline.com/your-tenant-id',
  clientId: 'your-client-id',
  redirectUrl: 'com.myapp://oauth/redirect/',
  additionalParameters: {
    resource: 'your-resource'
  }
};

// Log in to get an authentication token
const authState = await authorize(config);

// Refresh token
const refreshedState = await refresh(config, {
  refreshToken: authState.refreshToken,
});
```

## V2

The V2 endpoint follows the standard OAuth protocol with scopes. Detailed documentation [here](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-overview).

```js
const config = {
  issuer: 'https://login.microsoftonline.com/your-tenant-id/v2.0',
  clientId: 'your-client-id',
  redirectUrl: 'com.myapp://oauth/redirect/',
  scopes: ['openid', 'profile', 'email', 'offline_access']
};

// Log in to get an authentication token
const authState = await authorize(config);

// Refresh token
const refreshedState = await refresh(config, {
  refreshToken: authState.refreshToken,
});
```

**Important** When you add your app in the azure portal and are given a `redirectUrl` to use, make sure you add a trailing slash when you add it to your config - e.g. `msauth.BUNDLEID://auth/` - failure to add that causes it to fail in IOS.

repository: FormidableLabs/react-native-app-auth

branch_name: refs/heads/main

gha_language: Java

repo_name: FormidableLabs/react-native-app-auth


text:
`vec2 resolution`

viewport resolution (pixels)

`float globalTime`

playback time (seconds)

`float baseFrequency`

score base frequency (hertz)

`float octave`

score octave range

`vec4 mouse`

normalized mouse coordinates (pixels)

`vec4 date`

year, month, day, time (seconds)

`sampler2D iInputN`

imported data access, typical usage : `texture2D(iInput0, uv);`

`float fvidN`

video current position (0 - 1 range)

`sampler2D pFrame`

the previous frame available as a texture (feedback)

`sampler2D pFrameSynth`

previous synth frame available as a texture (WebGL 2)

`int frame`

the current frame

`float htoy(f)`

a function with a frequency as argument, return a vertical position on the canvas (pixels)

`float fline(f)`

a function with a frequency as argument, return 1 or 0 (a shortcut to draw a horizontal line)

`float yfreq(y, samplerate)`

a function with a vertical position as argument and a sample rate argument, return the oscillator frequency at the corresponding position for the corresponding sample rate

`vec4[N] keyboard`

MIDI note-on/note-off events : frequency, velocity, elapsed time since the key was pressed, MIDI channel

`vec4[N+1] keyboard`

enhanced MIDI (MPE) : pitch bend, timbre (CC74), pressure (aftertouch), release velocity

`vec3[N] pKey`

store the previous note-off for each channels, frequency, velocity, elapsed time since the key was pressed

gha_language: JavaScript


text:
# Upgrade from 1.x to 2.0
The `sentry/sentry-symfony` package is updated to ^4.0 which requires changes in the configuration if you use the recommended configuration:

- Remove `sentry.monolog` configuration option

Before:
```yaml
sentry:
    dsn: '%env(SENTRY_DSN)%'
    register_error_listener: false
    monolog:
        error_handler:
            enabled: true
            level: error
    options:
        environment: '%kernel.environment%'
        release: '%env(VERSION)%' # your app version, optional
        send_attempts: 1
```

After:
```yaml
sentry:
    dsn: '%env(SENTRY_DSN)%'
    register_error_listener: false
    options:
        environment: '%kernel.environment%'
        release: '%env(VERSION)%' # your app version, optional
        send_attempts: 1
```

- Update the sentry monolog handler to `paysera_logging_extra.sentry_handler`

Before:
```yaml
monolog:
    handlers:
        ...
        sentry:
            type: service
            id: Sentry\Monolog\Handler
        ...
```

After:
```yaml
monolog:
    handlers:
        ...
        sentry:
            type: service
            id: paysera_logging_extra.sentry_handler
        ...
```

- Due to a bug in all versions below 6.0 of the SensioFrameworkExtraBundle bundle, you will likely receive an error during the building of symfony container related to the missing `Nyholm\Psr7\Factory\Psr17Factory` class. To workaround the issue, if you are not using the PSR-7 bridge, please change the configuration of that bundle as follows:

```yaml
sensio_framework_extra:
   psr_message:
      enabled: false
```

For more details about the issue see https://github.com/sensiolabs/SensioFrameworkExtraBundle/pull/710.

- The version of `sentry/sentry` was upgraded to ^3.0. If you're using self-hosted Sentry version < v20.6.0 then you should disable the tracing as it uses the envelope endpoint which requires Sentry version >= v20.6.0 to work.

```yaml
sentry:
  tracing:
    enabled: false
```

Check the [UPGRADE-3.0.md](https://github.com/getsentry/sentry-php/blob/master/UPGRADE-3.0.md) file of `sentry/sentry` for other notable updates.
Check the [UPGRADE-4.0.md](https://github.com/getsentry/sentry-symfony/blob/4.6.0/UPGRADE-4.0.md) file of `sentry/sentry-symfony` for other notable updates.

repository: paysera/lib-logging-extra-bundle

gha_language: PHP

repo_name: paysera/lib-logging-extra-bundle


text:
## Unity Solomons Key like Block placing Mechanic

This is a unity project presenting a basic character controller with a "magic stick" attached as a child object and a "block dispenser". The block dispensers is in charge of instantiating the blocks in the correct position. All the sprites are set to 128 px per unit so I can easily place the tiles at absolute positions. If the block dispenser is at x=1.34 y=1.46 the dispenser rounds up to 1,1 and places the object in that position.

### What it looks like

![alt text](http://i.imgur.com/o4jKNx0.gif "The game..")

### Controllers:
- Left Arrow to go left
- Right arrow to go right
- Up arrow to jump
- Space to place blocks

### Assets

All graphical assets come rom Kenney assets
http://kenney.nl/assets

repository: webocs/Unity-SolomonsKeyBlockMechanic

repo_name: webocs/Unity-SolomonsKeyBlockMechanic


text:
# Jupyter Notebook with Spark

Based on image [jupyter/all-spark-notebook](https://hub.docker.com/r/jupyter/all-spark-notebook/)  published by Jupiter Development

# What has been added

Added a script file that starts Jupyter notebook in ~/notebooks, this allows user to store notebooks in a local directory outside docker volumes.

# Steps

- Run build.sh to bulid the docker image
- Modify run.sh - set NOTEBOOK_DIR to your local directory for storing jupyter notebook files
- Run run.sh to run the container in attached mode

repository: bonapetite/docker

repo_name: bonapetite/docker


text:
[![Build Status](https://dev.azure.com/chefcorp-partnerengineering/Chef%20Base%20Plans/_apis/build/status/chef-base-plans.glibc?branchName=master)](https://dev.azure.com/chefcorp-partnerengineering/Chef%20Base%20Plans/_build/latest?definitionId=79&branchName=master)

# glibc

  The GNU C Library project provides the core libraries for the GNU system and GNU/Linux systems,
  as well as many other systems that use Linux as the kernel. These libraries provide critical
  APIs including ISO C11, POSIX.1-2008, BSD, OS-specific APIs and more. These APIs include such
  foundational facilities as open, read, write, malloc, printf, getaddrinfo, dlopen,
  pthread_create, crypt, login, exit and more.

## Maintainers

* The Core Planners<EMAIL_ADDRESS>
## Type of Package

Binary package

### Use as Dependency

Binary packages can be set as runtime or build time dependencies. See [Defining your dependencies](https://www.habitat.sh/docs/developing-packages/developing-packages/#sts=Define%20Your%20Dependencies) for more information.

To add core/glibc as a depdendency, you can add one of the following to your plan file.

##### Buildtime Dependency

> pkg_build_deps=(core/glibc)

##### Runtime Depdendency

> pkg_deps=(core/glibc)

### Use as Tool

#### Installation

To install this plan, you should run the following commands to first install, and then link the binaries this plan creates.

`hab pkg install core/glibc`

> » Installing core/glibc

> ☁ Determining latest version of core/glibc in the 'stable' channel

> ☛ Verifying core/glibc/2.29/20200305172459

> ✓ Installed core/glibc/2.29/20200305172459

> ★ Install of core/glibc/2.29/20200305172459 complete with 2 new packages installed.

`hab pkg binlink core/glibc`

> » Binlinking gencat from core/glibc into /bin

> ★ Binlinked gencat from core/glibc/2.29/20200305172459 to /bin/gencat

> ...

#### Using an example binary
You can now use the binary as normal:

`/bin/ldd --help` or `ldd --help`

```
Usage: ldd [OPTION]... FILE...
      --help              print this help and exit
      --version           print version information and exit
  -d, --data-relocs       process data relocations
  -r, --function-relocs   process data and function relocations
  -u, --unused            print unused direct dependencies
  -v, --verbose           print all information

For bug reporting instructions, please see:
<http://www.gnu.org/software/libc/bugs.html>.
```

repository: habitat-sh/core-plans

gha_language: Shell

repo_name: habitat-sh/core-plans


text:
# CHANGELOG

## Master (unreleased)

* Added support for BooleanFields (#325)

## 2.6.0

* Added support for Django 3.1.x
* Updated requirements_dev.txt
* Dropped support for Python 3.5
* Dropped support for Django below 2.2.x LTS release
* Added support for BigIntegerFields (#169)
* Added documentation for migration existing data (#246)

## 2.5.2

* Added support for Django 3.x
* Updated requirements_dev.txt

## 2.5.1

* Fixed regression in the definition of EmailPGPPublicKeyField (#77)
* Removed dead code (remove_validators and RemoveMaxLengthValidatorMixin)
* Updated requirements_dev.txt

## 2.5.0

* Added new DecimalFields for both public and symmetric key (#64)
* Added new FloatFields for both public and symmetric key (#64)
* Added new TimeFields for both public and symmetric key (#64)
* Added support for different keys based on database (#67)

## 2.4.0

* Added auto-decryption of all encrypted fields including FK tables
* Removed django-pgcrypto-fields `aggregates`, `PGPManager` and `PGPAdmin` as they are no longer needed
* Added support for `get_or_create()` and `update_or_create()` (#27)
* Added support for `get_by_natural_key()` (#23)
* Added support for `only()` and `defer()` as they were not supported with `PGPManager`
* Added support for `distinct()` (Django 2.1+ with workaround available for 2.0 and lower)
* Separated out dev requirements from setup.py requirements
* Updated packaging / setup.py to include long description
* Added AUTHORS and updated CONTRIBUTING
* Updated TravisCI to use Xenial to gain Python 3.7 in the matrix

## 2.3.1

* Added `__range` lookup for Date / DateTime fields (#59)
* Remove compatibility for `Django 1.8, 1.9, and 1.10` (#62)
* Improved `setup.py`:
    * check for Python 3.5+
    * updated classifiers
* Improved `make` file for release to use `twine`
* Added additional shields to `README`
* Updated Travis config to include Python 3.5 and 3.6
* Refactored lookups and mixins

## 2.3.0

* Invalid release, bump to 2.3.1

## 2.2.0

* Merge `.coveragerc` into `setup.cfg`
* Added `.gitignore` file
* Updated out-dated requirements (latest versions of `Flake8` and `pycodestyle`
are incompatible with each other)
* Updated `README` with better explanations of the fields
* Implemented DatePGPPublicKeyField and DateTimePGPPublicKeyField

## 2.1.1

* Added support for Django 2.x+
* Updated requirements for testing
* Updated travis config with Python 3.6 and additional environments

## 2.1.0

Thanks to @peterfarrell:
* Add support for `DatePGPSymmetricKeyField` and `DateTimePGPSymmetricKeyField`
including support for serializing / deserializing django form fields.
* Add support for auto decryption of symmetric key and public key fields via
the PGPManager (and support for disabling it in the Django Admin via the PGPAdmin)

## 2.0.0

* Remove compatibility for `Django 1.7`.
* Add compatibility for `Django 1.10`.
* Add `Django 1.9` to the travis matrix.

## v1.0.1

* Exclude tests app from distributed package.

## v1.0.0

* Rename package from `pgcrypto_fields` to `pgcrypto`.

## v0.7.0

* Make `get_placeholder` accepts a new argument `compiler`
* Fix buggy import to `Aggregate`

**Note: these changes have been done for django > 1.8.0.**

## v0.6.4

* Remove `MaxLengthValidator` from email fields.

## v0.6.3

* Avoid setting `max_length` on PGP fields.

## v0.6.2

* Allow/check `NULL` values for:
  `TextDigestField`;
  `TextHMACField`;
  `EmailPGPPublicKeyField`;
  `IntegerPGPPublicKeyField`;
  `TextPGPPublicKeyField`;
  `EmailPGPSymmetricKeyField`.
  `IntegerPGPSymmetricKeyField`.
  `TextPGPSymmetricKeyField`.

## v0.6.1

* Fix `cast`ing bug when sending negative values to integer fields.

## v0.6.0

* Add `EmailPGPPublicKeyField` and `EmailPGPSymmetricKeyField`.

## v0.5.0

* Rename the following fields:
  `PGPPublicKeyField` to `TextPGPPublicKeyField`;
  `PGPSymmetricKeyField` to `TextPGPSymmetricKeyField`;
  `DigestField` to `TextDigestField`;
  `HMACField` to `TextHMACField`.
* Add new integer fields:
  `IntegerPGPPublicKeyField`;
  `IntegerPGPSymmetricKeyField`.

## v0.4.0

* Make accessing decrypted value transparent. Fix bug when field had a string
representation of `memoryview` for PGP and keyed hash fields.

## v0.3.1

* Fix `EncryptedProxyField` to select the correct item.

## v0.3.0

* Access `PGPPublicKeyField`  and `PGPSymmetricKeySQL` decrypted values with
field's proxy `_decrypted`.
* Remove descriptor for field's name and raw value.

## v0.2.0

* Add hash based lookup for `DigestField` and `HMACField`.
* Add `DigestField`, `HMACField`, `PGPPublicKeyAggregate`, `PGPSymmetricKeyAggregate`.

## v0.1.0

* Add decryption through an aggregate class.
* Add encryption when inserting data to the database.

repository: incuna/django-pgcrypto-fields

gha_language: Python

repo_name: incuna/django-pgcrypto-fields


text:
## 4.1.  Authorization Code Grant

   The authorization code grant type is used to obtain both access
   tokens and refresh tokens and is optimized for confidential clients.
   Since this is a redirection-based flow, the client must be capable of
   interacting with the resource owner's user-agent (typically a web
   browser) and capable of receiving incoming requests (via redirection)
   from the authorization server.

     +----------+
     | Resource |
     |   Owner  |
     |          |
     +----------+
          ^
          |
         (B)
     +----|-----+          Client Identifier      +---------------+
     |         -+----(A)-- & Redirection URI ---->|               |
     |  User-   |                                 | Authorization |
     |  Agent  -+----(B)-- User authenticates --->|     Server    |
     |          |                                 |  (google.com) |
     |-browser--+----(C)-- Authorization Code ---<|               |
     +-|----|---+                                 +---------------+
       |    |                                         ^      v
      (A)  (C)                                        |      |
       |    |                                         |      |
       ^    v                                         |      |
     +---------+                                      |      |
     |         |>---(D)-- Authorization Code ---------'      |
     | Client  |          & Redirection URI                  |
     |(xxx.com)|                                             |
     |         |<---(E)----- Access Token -------------------'
     +---------+       (w/ Optional Refresh Token)

repository: bchenSyd/swagger-cors-support

repo_name: bchenSyd/swagger-cors-support


text:
This allows skins to fully extend others just by changing a small set of variable values.

	Components

	A skin is created by combining one or more components together. Different skins may use different components, so irrelevant styling can be easily stripped out.

	Structure vs Skin

	All styling is separated into structure and skin. Structure represents everything that affects the sizing and position of the elements. Meanwhile, skin represents all the purely cosmetic changes.

## Skins Overview

	At this moment, you can use any of the following skins out of the box:

	Ocean (default)

	Atlas

```text/html
  <link href="alloy-editor/assets/alloy-editor-atlas-min.css" rel="stylesheet">
```

	Moono

```text/html
  <link href="alloy-editor/assets/alloy-editor-moono-min.css" rel="stylesheet">
```

gha_language: HTML


text:
# jQuery-animations-spotlight
A plugin of [jQuery-animations](http://emn178.github.io/jquery-animations/) that provides tile animations.

## Download
[Compress](https://raw.github.com/emn178/jquery-animations-spotlight/master/build/jquery.animations-spotlight.min.js)
[Uncompress](https://raw.github.com/emn178/jquery-animations-spotlight/master/src/jquery.animations-spotlight.js)

## Demo
[Spotlight](http://emn178.github.io/jquery-animations-spotlight/samples/spotlight/)

## Browser Support
jQuery-animations-spotlight currently supports IE10+, Chrome, Firefox, Safari and Opera.

## Options
###### *radius: `Number` (default: `100`)*
Sets length of radius.

###### *count: `Number` (default: `5`)*
Sets count of move.

## Example
Basic usage
```JavaScript
$('#want-to-animate').animate('spotlight');
```

## License
The project is released under the [MIT license](http://www.opensource.org/licenses/MIT).

## Contact
The project's website is located at https://github.com/emn178/jquery-animations-spotlight
Author<EMAIL_ADDRESS>


text:
# Infrastructure

Many things to question for building applications.  When starting, these are some guidelines for things to consider.

* Identity Infrastructure
  * Internal
  * External
  * AD Controller
    * Identity
    * Object
    * Permission

* Network Infrastructure
  * Connectivity
    * Continual
    * Occasional
    * Never
  * Latency
  * Boundaries
    * Internal firewalls
    * Subnets

* Storage
  * Database
  * File Systems
    * Network connectivity

repository: jerhon/developer-notes

gha_language: C#

repo_name: jerhon/developer-notes


text:
# Feathers

> Let your web app fly.

[![Build Status](https://travis-ci.org/feathersjs/feathers.png)](https://travis-ci.org/feathersjs/feathers)

Feathers is a light weight web application framework that rides on top of [Express](http://expressjs.com). It makes it easy to create RESTful web services and real-time applications using [socket.io](http://socket.io).

The core focus of Feathers is **your data**. We believe that ultimately your app's purpose is to manage data in some fashion and so that's all you should really need to deal with. Managing your data.

## Install

As with any NodeJS module, just install it as a dependency in your application:

> npm install feathers --save

## Getting Started Is Easy

Building an app with Feathers is easy. There are only 4 things to worry about. A wrapped express server, providers, services & middleware. Services are just simple modules that expose certain methods to the providers in order to CRUD your data. We can easily initialize a service that say... provides a single Todo:

```js
var feathers = require('feathers');

var todoService = {
  get: function(name, params, callback) {
    callback(null, {
      id: name,
      description: "You have to do " + name + "!"
    });
  }
};

feathers()
	.configure(feathers.socketio())
	.use('/todo', todoService)
	.listen(8000);
```

That's all there really is to building an app with Feathers.

### REST

You can access the REST service by going to `http://localhost:8000/todo/dishes` in your browser
and will see:

```js
{
  "id": "dishes",
  "description": "You have to do dishes!"
}
```

> Note: Query parameters like `http://localhost:8000/todo/dishes?type=dirty` will be passed as `params.query`

### SocketIO

Since we configured our app with `feathers.socketio()`, you can also connect to your service via SocketIO.
Create an HTML page and insert the following code to see the response data logged on the console:

```html
<script src="http://localhost:8000/socket.io/socket.io.js"></script>
<script>
  var socket = io.connect('http://localhost:8000/');
  socket.emit('todo::get', 'laundry', {}, function(error, data) {
    console.log(data); // -> { id: 'laundry', description: 'You have to do laundry!' }
  });
</script>
```

## What's next?

Head over to the Feathers website at [feathersjs.com](http://feathersjs.com/) for more examples and the detailed documenation.


text:
# Simple process signal mapper Node.js module

[![Build Status](https://travis-ci.org/ewngs/proc-sigmap.svg?branch=master)](https://travis-ci.org/ewngs/proc-sigmap)

So you want to handle signals like SIGINT but also IPC messages too. SigMapper gives you a standard interface that allows renaming/redirecting messages and handles received IPC data.

## Installation

```
npm install proc-sigmap --save
```

## Usage

```
var processEvents = require('proc-sigmap')({
    SIGINT: 'shutdown',
    SIGHUP: 'reload'
});
```

These are the default mappings if you call the sigmap without argument.
Then you can subscribe to an event on your proc-sigmap instance:

```
processEvents.on('shutdown', function() {
  // you should close your connections and things and exit now
});

```

repository: ewngs/proc-sigmap

repo_name: ewngs/proc-sigmap


text:
# Introduction

A *shape* consists of a group of zero or more data *field*s taken together as a whole. For example:

```hack
shape('x' => int, 'y' => int)
```

The definition of a shape contains an ordered set of fields each of which has a name and a type. In this case, the shape consists of two `int` fields, with the names `'x'` and `'y'`, respectively.

Although we can use a shape type directly, oftentimes it is convenient to create an alias, such as the name `Point` below, and use that instead.

```hack
type Point = shape('x' => int, 'y' => int);
function f(Point $p1): void { /* ... */ }

class C1 {
  private Point $origin;
  private function __construct(int $x = 0, int $y = 0) {
    $this->origin = shape('x' => $x, 'y' => $y);
  }
}
```
A field in a shape is accessed using its name as the key in a subscript-expression that operates on a shape of the corresponding shape type. For example:

```hack
function distance_between_2_Points(Point $p1, Point $p2): float {
  $dx = $p1['x'] - $p2['x'];
  $dy = $p1['y'] - $p2['y'];
  return sqrt($dx*$dx + $dy*$dy);
}
```

The name of a field can be written in one of two possible forms:

  * A single-quoted string (as shown above)
  * A class constant of type `string` or `int`

Note that an integer literal **cannot** be used directly as a field name.

The names of all fields in a given shape definition must be distinct and have the same form.

The following example shows how class constants can be used:

````hack
class C2 {
  const string KEYA = 'x';
  const string KEYB = 'y';
  const int KEYX = 10;
  const int KEYY = 23;
}

type Point2 = shape(C2::KEYA => int, C2::KEYB => int);

type Point3 = shape(C2::KEYX => int, C2::KEYY => int);
```
In the case of the integer class constants, by arbitrary choice, the x-coordinate is stored in the element with key 10, while the y-coordinate is stored in the element with key 23.

repository: RexJaeschke/user-documentation

repo_name: RexJaeschke/user-documentation


text:
TM_export-ClustTrack
====================

This is the Matlab code that has been used in the pubblication (Mossuto M. et al., 2014) for importing TrackMate xlm files and calcuating mean square displacements and particle sizes from the movies.

The routines require the Image processing toolbox and the Optimization toolbox from matlab and require Matlab 2011a or higher. The folder containing the Matlab files of this repository need to be added to the Matlab path. Also the Matlab scripts from Fiji need to be included in the Matlab path.

To run the code open the file MSD_scriptForTrackMate.m in matlab and run by typing

run MSD_scriptForTrackMate

in the command window
The script will open a dialog to load the trackmate export xlm file, and a second dialog to import the .tif file containing the corresponding timeseries. After running the script 3 outputs will be placed in the workspace:

AA_tlist: vector with the timepoints for which the MSD has been calculated

AA_OUT_COEF: coefficients of the analysis:

AA_OUT_COEF (1,:) = Diffusion constants for each track;

AA_OUT_COEF (2,:) = Anomalous coefficient for each track;

AA_OUT_COEF(3,:) = sigma of gaussian fit to the particle in pixels in the first channel of the movie;

AA_OUT_COEF(4,:) = total intensity of the particle in the first channel of the movie;

AA_OUT_COEF(5,:) = sigma of gaussian fit to the particle in pixels in the second channel of the movie;

AA_OUT_COEF(6,:) = total intensity of the particle in the second channel of the movie;

AA_OUT_MSD: Mean squared displacements curves for each of the analyzed tracks.

=======================================================================
2014. Davide Mazza. San Raffaele Scientific Institute. Milan (Italy).


text:
### Port of MCUBoot library for evaluation with Cypress PSoC 6 chips

### Disclaimer

Given solution is included in `MCUboot` repository with purpose to demonstrate basic consepts and features of MCUboot library on Cypress PSoC 6 device. Applications are created per MCUboot library maintainers requirements. Implemetation differs from conventional and recomended by Cypress Semiconductors development flow for PSoC 6 devices. These applications are not recomended as a starting point for development and should not be considered as supported examples for PSoC 6 devices.

Examples provided to use with **ModusToolbox® Software Environment** are a recommended reference point to start development of MCUboot based bootloaders for PSoC 6 devices.

Refer to **Cypress Semiconductors** [github](https://github.com/cypresssemiconductorco) page to find examples.

1. MCUboot-Based Basic Bootloader [mtb-example-psoc6-mcuboot-basic](https://github.com/cypresssemiconductorco/mtb-example-psoc6-mcuboot-basic)
2. MCUboot-Based Bootloader with Rollback to Factory App in External Flash [mtb-example-anycloud-mcuboot-rollback](https://github.com/cypresssemiconductorco/mtb-example-anycloud-mcuboot-rollback)

### Solution description

There are two applications implemented:
* MCUBootApp - PSoC6 MCUboot-based bootloading application;
* BlinkyApp - simple PSoC6 blinking LED application which is a target of BOOT/UPGRADE;

The default flash map for MCUBootApp implemented is next:

* [0x10000000, 0x10018000] - MCUBootApp (bootloader) area;
* [0x10018000, 0x10028000] - primary slot for BlinkyApp;
* [0x10028000, 0x10038000] - secondary slot for BlinkyApp;
* [0x10038000, 0x10039000] - scratch area;

The flash map is defined through sysflash.h and cy_flash_map.c.

It is also possible to place secondary (upgrade) slots in external memory module. In this case primary slot can be doubled in size.
For more details about External Memory usage, please refer to separate guiding document `MCUBootApp/ExternalMemory.md`.

MCUBootApp checks image integrity with SHA256, image authenticity with EC256 digital signature verification and uses either completely software implementation of cryptographic functions or accelerated by hardware - both based on Mbed TLS Library.

### Downloading solution's assets

There is a set assets required:

* MCUBooot Library (root repository)
* PSoC6 Peripheral Drivers Library (PDL)
* Mbed TLS Cryptographic Library

Those are represented as submodules.

To retrieve source code with subsequent submodules pull:

    git clone --recursive https://github.com/mcu-tools/mcuboot.git

Submodules can also be updated and initialized separately:

    cd mcuboot
    git submodule update --init --recursive

### Building solution

Root directory for build is **boot/cypress.**

This folder contains make files infrastructure for building both MCUboot Bootloader and sample BlinkyApp application used for Bootloader demo functionality.

Instructions on how to build and upload MCUBootApp bootloader application and sample user applocation are located in `Readme.md` files in corresponding folders.

Supported platforms for `MCUboot`, `BlinkyApp`:

* PSOC_062_2M
* PSOC_062_1M
* PSOC_062_512K

### Build environment troubleshooting

Following CLI / IDE are supported for project build:

* Cygwin on Windows systems
* unix style shells on *nix systems
* Eclipse / ModusToolbox ("makefile project from existing source")

*Make* - make sure it is added to system's `PATH` variable and correct path is first in the list;

*Python/Python3* - make sure you have correct path referenced in `PATH`;

*Msys2* - to use systems PATH navigate to msys2 folder, open `msys2_shell.cmd`, uncomment set `MSYS2_PATH_TYPE=inherit`, restart MSYS2 shell.

This will inherit system's PATH so should find `python3.7` installed in regular way as well as imgtool and its dependencies.

repository: mcu-tools/mcuboot

gha_language: C

repo_name: mcu-tools/mcuboot


text:
---
title: Easily search for contributed nodes on the Node-RED Flows site
description: >
    Excellent work has been done to make sure that new nodes are discoverable.
    Here is a quick way to easily search from your browser.
comments: true
date: 2018-03-19 22:00:00
updated: 2018-03-19 22:00:00
---

The [Flows](https://flows.nodered.org/?num_pages=1) website is the best place to go in order to
find contributed nodes for Node-RED. It also contains example flows showing how to do various tasks.

You can search on that site by node name, author name and tags and the results are paged.

You can also use the URL to search and this means that you can add Flows as a custom
search engine in your browser. Or even from Node-RED itself!

## Chrome

Select "Settings" from the menu. Scroll down to the "Search engine" section and click on "Manage serach engines".

Click on the Add button and fill in as follows:

![Chrome Search Engine Edit](/images/nr-search.PNG)


text:
# LSA Final Project README Template

## Prerequisites

There are a few prerequisites which must be installed on your machine before you will be able to commit.

The following command will install all required and optional dependencies on Ubuntu Linux 18.04 or later:

```sh
$ sudo apt install git aspell colordiff
```


text:
# 0. Kata Dependencies

## Status

Drafting

## Context

Knowledge to solve a certain kata depends on the knowledge one should have gathered from other katas.
Within one kata-bundle (e.g. "es6/language") this is well defined and can be done already.
How can this be done across all katas in this repo?
E.g. a ES10 kata might require knowledge of something learned in an ES6 kata. To be able to inform the
user about such a learning path the katas should be able to reflect their dependencies throughout the
entire repo.

## Decision

See ES1 kata, where this was done. All katas export the available katas like so:
```js
export const es1 = {
  'ARRAY_SORT_BASICS': ['es1/language', 1],
  'ARRAY_SORT_WITH_FUNCTION': ['es1/language', 2],
  'GLOBAL_PARSEINT': ['es1/language', 3],
  //...
};
```
Inside the ES6 katas any kata can be refered to by importing and refering to this exact kata.
```js
// inside es6/language/__raw-metadata__.js
import {es1} from '../../es1/language/__raw-metadata__.js';

const requiresKnowledgeFrom = [es1.GLOBAL_PARSEINT];
```

## Consequences

repository: Ceheiss/katas

repo_name: Ceheiss/katas


text:
# grunt-elm
> Compile Elm files to JavaScript. [![build status][1]][2] [![NPM version][3]][4]

## Getting Started

This plugin requires Grunt `~0.4.0`

If you haven't used [Grunt](http://gruntjs.com/) before, be sure to check out the [Getting Started](http://gruntjs.com/getting-started) guide, as it explains how to create a [Gruntfile](http://gruntjs.com/sample-gruntfile) as well as install and use Grunt plugins. Once you're familiar with that process, you may install this plugin with this command:

```shell
npm install grunt-elm --save-dev
```

Once the plugin has been installed, it may be enabled inside your Gruntfile with this line of JavaScript:

```js
grunt.loadNpmTasks('grunt-elm');
```

*This plugin was designed to work with Grunt 0.4.x. If you're still using grunt v0.3.x it's strongly recommended that [you upgrade](http://gruntjs.com/upgrading-from-0.3-to-0.4), but in case you can't please use [v0.3.2](https://github.com/gruntjs/grunt-contrib-coffee/tree/grunt-0.3-stable).*

### Options

#### yes
Type: `Boolean`
Default: true

Automatically answer `yes` to any prompts that come up during the build.

### Usage Examples

```js
elm: {
  compile: {
    files: {
      'output-dir/': 'path/to/Source.elm',
      'other-output-dir/': ['path/to/sources/*.elm', 'path/to/more/*.elm']
    }
  },
```

### Changelog

#### 1.0.0

* Switches to using [node-elm-compiler](https://github.com/rtfeldman/node-elm-compiler) under the hood.
* The `yesToAllPrompts` option is now called `yes` and defaults to `true`.

#### 0.4.0

Initial release.

[1]: https://secure.travis-ci.org/rtfeldman/grunt-elm.svg
[2]: https://travis-ci.org/rtfeldman/grunt-elm
[3]: https://badge.fury.io/js/grunt-elm.svg
[4]: https://badge.fury.io/js/grunt-elm


text:
## Java Basics

### Language Basics

Variables
  - Instance Variables
    - Non-Static Fields
    - Values are unique to each instance of a class
  - Class Variables
    - Static Fields
    - Tells computer that there is exactly one instance of the variable in existence
  - Local Variables
    - ex: `int count = 0`
  - Parameters
    - ex: `public static void main(String[]args)`

Operators
  - special symbols that performs specific operations on one, two, or three operands, and then return a result.

  ![Operator Precendence](operators.png)
<!-- https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html -->

Expressions
  - constructs made up of variables, operators, and method invocations that are constructed according to the syntax of the language and evaluate a single value.

Statements
  - Roughly equivalent to sentences in natural languages
  - a complete unit of execution

Blocks
  - a group of zero or more statements between balanced braces
  - can be used anywhere a single statement is allowed

Learn more [**HERE**](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/index.html) and [**HERE!**](https://www.dummies.com/programming/java/making-sense-of-javas-api-documentation/)

Learn about compiling [**HERE**](https://www.reddit.com/r/explainlikeimfive/comments/233dq5/eli5_what_does_it_mean_to_compile_code/) and [**HERE!**](https://xkcd.com/303/)

[**Return to Home**](README.md)

repository: KrystianFH/reading-notes

repo_name: KrystianFH/reading-notes


text:
# react-progress-button

[![build status](https://img.shields.io/travis/mathieudutour/react-progress-button/master.svg?style=flat-square)](https://travis-ci.org/mathieudutour/react-progress-button)
[![npm version](https://img.shields.io/npm/v/react-progress-button.svg?style=flat-square)](https://www.npmjs.com/package/react-progress-button)
[![Dependency Status](https://david-dm.org/mathieudutour/react-progress-button.svg)](https://david-dm.org/mathieudutour/react-progress-button)
[![devDependency Status](https://david-dm.org/mathieudutour/react-progress-button/dev-status.svg)](https://david-dm.org/mathieudutour/react-progress-button#info=devDependencies)

> Simple [React](http://facebook.github.io/react/index.html) component for a circular Progress Button.

### [Demo](https://mathieudutour.github.io/react-progress-button)

[![Demo](https://cdn.rawgit.com/mathieudutour/react-progress-button/master/example/demo.gif "Demo")](https://github.com/mathieudutour/react-progress-button/blob/master/example/index.html)

## Install

```bash
npm install react-progress-button --save
```

## Example

### Controlled usage:

```javascript
import ProgressButton from 'react-progress-button'

const App = React.createClass({
  getInitialState () {
    return {
      buttonState: ''
    }
  },

  render () {
    return (
      <div>
        <ProgressButton onClick={this.handleClick} state={this.state.buttonState}>
          Go!
        </ProgressButton>
      </div>
    )
  },

  handleClick () {
    this.setState({buttonState: 'loading'})
    // make asynchronous call
    setTimeout(() => {
      this.setState({buttonState: 'success'})
    }, 3000)
  }
})
```

[Source](https://github.com/mathieudutour/react-progress-button/blob/master/example/index.html)

### Using Promises:

If the function passed in via the `onClick` prop return a Promise or if a promise
is passed as an argument of the `loading` method,
the component will automatically transition to its success or error
states based on the outcome of the Promise without the need for
external manipulation of state using a ref.

```javascript
import ProgressButton from 'react-progress-button'

const App = React.createClass({
  render () {
    return (
      <div>
        <ProgressButton onClick={this.handleClick}>
          Go!
        </ProgressButton>
      </div>
    )
  },

  handleClick() {
    return new Promise(function(resolve, reject) {
      setTimeout(resolve, 3000)
    })
  }
});
```

[Source](https://github.com/mathieudutour/react-progress-button/blob/master/example/index-promises.html)

## API

### Props

All props are optional. All props other than that will be passed to the top element.

##### controlled

`true` if you control the button state (by providing `props.state` and `props.onClick`).`false` to let the button manage its state with Promises.

##### classNamespace

Namespace for CSS classes, default is `pb-` i.e CSS classes are `pb-button`.

##### durationError

Duration (ms) before going back to normal state when an error occurs,
default is 1200

##### durationSuccess

Duration (ms) before going back to normal state when an success occurs,
default is 500

##### onClick

Function to call when the button is clicked; if it returns a Promise
then the component will transition to the success/error state based on
the outcome of the Promise

##### onError

Function to call when going back to the normal state after an error

##### onSuccess

Function to call when going back to the normal state after a success

##### state

State of the button if you do not want to use the functions. Can be `''`, `loading`, `success`, `error` or `disabled`.

##### type

Type of the button (can be 'submit' for example).

##### form

Id of the form to submit (useful if the button is not directly inside the form).

##### shouldAllowClickOnLoading

Whether click event should bubble when in loading state

### Methods

##### loading()

Put the button in the loading state.

##### disable()

Put the button in the disabled state.

##### notLoading(), enable()

Put the button in the normal state.

##### success([callback, dontGoBackToNormal])

Put the button in the success state. Call the callback or the onSuccess prop when going back to the normal state.

##### error([callback])

Put the button in the error state. Call the callback or the onError prop when going back to the normal state.

## Styles

Look at [react-progress-button.css](https://github.com/mathieudutour/react-progress-button/blob/master/react-progress-button.css) for an idea on how to style this component.

If you are using webpack, you'll need to have ```css-loader``` installed and include
```
 {
   test: /\.css$/,
   loader: "style!css"
 }
 ```

 in your webpack config. In your jsx file you can then import the CSS with ```import "../node_modules/react-progress-button/react-progress-button.css";``` although the path depends on how deeply nested your jsx is. If you wish to theme it yourself, copy the CSS to a convenient location and point the import path at the copy, which is part of your repo, unlike the original in ```node_modules```.

## License

  MIT

repository: mathieudutour/react-progress-button

repo_name: mathieudutour/react-progress-button


text:
# DOCUMENTATION

## OVERVIEW

## INSTALLATION

## QUICK START

## POLAR

### What is it?
### Mainnet Forking
### Mining Modes
### Reference

## Guides

### Setting up a project
### Compiling your contracts
### Testing with ethers.js & Waffle
### Testing with Web3.js & Truffle
### Migrating from Truffle
### Deploying your contracts
### Writing scripts
### Using the Hardhat console
### Creating a task
### Running tests with Ganache

## Troubleshooting

### Verbose logging
### Common problems
### Error codes

## API


text:
---
tags: politics
layout: post
title: "Pulling trickle-down out of the hat"
---

The return of voodoo economics - How did trickle-down (supply-side, what have you) become an assumption rather than an assertion? She is angry and it shows, but she doesn't resort to the level of Coulter or Michael Moore.

As a sidenote: I'd remembered Huffington as being conservative, aligned with some of Gingrich's ideas in the middle nineties. (Usually her name would be in close proximity to Alvin Toffler's.) And I've read these columns of hers on Salon for some time that are anything but doctrinaire. So what happened?

One of the first links on her site    is What prompted the transformation in Arianna's political thinking? It's not often you hear someone in our political culture say, "I was wrong" and move on.

gha_language: CSS


text:
# Optimization of turning process

Scripts were made as part of bachelor's thesis:
[Optimization of turning process](thesis/Zavrsni_rad_Tomislav_Bazina_full.pdf)

## Summary

The first section of thesis describes the model for optimization of multi-pass turning process. Machining process defined in the model is divided into rough machining, carried out in one or multiple number of passes, and finish machining, carried out in one finishing pass. Straight turning process is also clarified in this section, and two objective functions, considering maximum productivity and minimum cutting cost criteria, are defined. Model bounds and constraints during roughing and finishing are elaborated.

The optimization software with graphical user interface is compiled, using Python programming language, in the second thesis section. Method applied for optimization is a combination of Basin- Hopping algorithm, used for finding the global minimum, and sequential quadratic programming, used for local optimization. Software is verified with data used in the reference and by practical experiment.

### Prerequisites

Scripts were made using:
* [Kivy](https://github.com/kivy/kivy) v1.9.1
* [Python](https://www.python.org/) v2.7.12
* [NumPy](https://github.com/numpy/numpy) v1.10.4
* [SciPy](https://github.com/scipy/scipy) v0.17.0
* [Matplotlib](https://github.com/matplotlib/matplotlib) v1.5.1

To start the application, run:
```
main.py
```

### Screenshots

<!-- Stock and contour Definition -->
![Stock and contour Definition](screenshots/0_Stock_and_Contour.png)

<!-- Optimization type -->
![Optimization type](screenshots/1_Optimization_Type.png)

<!-- Maximum productivity -->
![Maximum productivity](screenshots/2_Maximum_Productivity.png)

<!-- Time input -->
![Time input](screenshots/3_Time_Input.png)

<!-- Tool life -->
![Tool life](screenshots/4_Tool_Life.png)

<!-- Bounds -->
![Bounds](screenshots/5_Bounds.png)

<!-- Relations and surface -->
![Relations and surface](screenshots/6_Relations_and_Surface.png)

<!-- Force and power -->
![Force and power](screenshots/7_Force_and_Power.png)

<!-- Optimization parameters -->
![Optimization parameters](screenshots/8_Optimization_Parameters.png)

<!-- Run Optimization -->
![Run Optimization](screenshots/9_Run_Optimization.png)

## License

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

repository: tbazina/optimize-straight-turning

repo_name: tbazina/optimize-straight-turning


text:
---
# Display name
title: Andrea Di Biagio

# Is this the primary user of the site?
superuser: true

# Role/position
role: PhD Student in Theoretical Physics

# Organizations/Affiliations
organizations:
- name: La Sapienza University of Rome
  url: "https://www.phys.uniroma1.it/fisica/"

# Short bio (displayed in user profile at end of posts)
bio: My research is focused on the interface of quantum gravity and quantum information. What can low energy quantum systems teach us about space and time?

interests:
- Quantum Information
- Quantum Foundations
- Quantum Gravity

education:
  courses:
  - course: MSc in Applied Mathematics
    institution: Imperial College London
    year: 2016
  - course: MSci in Physics with Theoretical Physics
    institution: Imperial College London
    year: 2013

# Social/Academic Networking
# For available icons, see: https://sourcethemes.com/academic/docs/page-builder/#icons
#   For an email link, use "fas" icon pack, "envelope" icon, and a link in the
#   form<EMAIL_ADDRESS>or "#contact" for contact widget.
social:
- icon: envelope
  icon_pack: fas
  link<EMAIL_ADDRESS>- icon: instagram
  icon_pack: fab
  link: https://www.instagram.com/minute_rapture/
- icon: telegram
  icon_pack: fab
  link: https://t.me/dibiagio
- icon: orcid
  icon_pack: ai
  link: https://orcid.org/0000-0001-9646-8457
- icon: arxiv
  icon_pack: ai
  link: https://arxiv.org/a/dibiagio_a_1.html
# Link to a PDF of your resume/CV from the About widget.
# To enable, copy your resume/CV to `static/files/cv.pdf` and uncomment the lines below.
- icon: scroll
  icon_pack: fas
  link: files/cv.pdf

# Enter email to display Gravatar (if Gravatar enabled in Config)
email: ""

# Highlight the author in author lists? (true/false)
highlight_name: false

# Organizational groups that you belong to (for People widget)
#   Set this to `[]` or comment out if you are not using People widget.
user_groups:
- Researchers
- Visitors
---

The twentieth century saw two revolutions of our understanding of the natural world in the formulation and development of quantum theory and the theory of general relativity. Their predictions have been verified to a spectacular degree experimentally and are central to a number of technologies (have you ever used a computer or a GPS?).
Our best stories the natural world, the standard model of particle physics and the standard model of cosmology, are told in the languages of quantum theory and general relativity.


text:
# ohol-data

This code can be used to analyze [Life Log files](http://onehouronelife.com/publicLifeLogData/) from the online game [One Hour One Life](https://onehouronelife.com/). See [this forum thread](https://onehouronelife.com/forums/viewtopic.php?id=2529) for a description of those files.

Here's some basic guidance. More may be added later, but for now I assume that you have some experience in using Python and a working environment on your computer.

Usage:
- Install requirements with `pip install -r requirements.txt`
- Download data using the script `download_lifelogs.py`. Parameters for servers and time range can be set through constants at the top of that file.
- Run a script under `./plotting`. Take care to set the parameters in that script so that they match the data you downloaded. This should produce a html file containing a graph that will open up in the browser.

Disclaimer:
This is work in progress and generally just meant to be used by myself. I put it here in case anybody wants to play with the OHOL lifelogs.

repository: thundersen/ohol-data

repo_name: thundersen/ohol-data


text:
# helgoboss-midi

Reusable C++ code for dealing with MIDI messages

[![Build Status](https://dev.azure.com/benjaminklum/helgoboss-midi/_apis/build/status/helgoboss.helgoboss-midi?branchName=master)](https://dev.azure.com/benjaminklum/helgoboss-midi/_build/latest?definitionId=1&branchName=master)

## Use

This is a library supposed to be used within a larger C++ application project. Assuming your project uses CMake and this
library is already available to CMake, all you need to do is to adjust your `CMakeLists.txt`:

```cmake
target_link_libraries(your-target PRIVATE helgoboss-midi::helgoboss-midi)
```

Here are some solutions to make the library available to CMake.

### Solution 1: vcpkg

This assumes you have your application-wide [vcpkg](https://github.com/microsoft/vcpkg) instance at `lib/vcpkg`.

1. Add https://github.com/helgoboss/helgoboss-vcpkg-overlays as Git submodule at `lib/helgoboss-vcpkg-overlays`
2. Integrate this into your application-wide vcpkg response file (e.g. `vcpkg.txt`) and use vcpkg to install the added
   package:
    ```
    helgoboss-midi
    --overlay-ports=../helgoboss-vcpkg-overlays/ports
    ```
3. Add the following to your `CMakeLists.txt` *before* `target_link_libraries`
    ```cmake
    find_package(helgoboss-midi 0.1.0 CONFIG REQUIRED)
    ```

### Solution 2: Submodule

1. Install the dependencies of this library mentioned in [vcpkg.txt](vcpkg.txt) using whatever packagement management approach you prefer
2. Copy this library to `lib/helgoboss-midi` (e.g. as Git submodule)
3. Add the following to your `CMakeLists.txt` *before* `target_link_libraries`
    ```cmake
    add_subdirectory(lib/helgoboss-midi)
    ```

## Develop

The following commands are tailored to Linux but need only minimal adjustments to be executed on OS X or Windows.

### Prepare
```sh
cd lib/vcpkg
./bootstrap-vcpkg.sh
./vcpkg install @../../vcpkg.txt
```

### Build
CMake >= 3.13
```sh
cmake -B build/linux
cmake --build build/linux --config Release
```

CMake < 3.13
```sh
mkdir -p build/linux
cd build/linux
cmake ../..
cmake --build . --config Release
```

### Test
```sh
cd build/linux
ctest
```

### Install
CMake >= 3.15
```sh
cmake --install build/linux --prefix build/linux/test-install
```

repository: paul-reilly/helgoboss-midi-cpp

repo_name: paul-reilly/helgoboss-midi-cpp


text:
# Overview

Drone has a robust plugin model that allows you to extend the platform to meet your unique project needs. This documentation describes the Drone plugin architecture and will help you create your own custom plugins. If you are searching for existing plugins please see the [plugin marketplace](http://addons.drone.io).

## How Plugins Work

Plugins are simply Docker containers that attach to your build at runtime and perform custom operations. These operations may include deploying code, publishing artifacts and sending notifications.

Plugins are declared in the `.drone.yml` file. When Drone encounters a plugin it attempts to download from the registry (if not already downloaded) and then execute. This is an example of the [slack plugin](https://github.com/drone-plugins/drone-slack) configuration:

```yaml
---
notify:
  slack:
    image: plugins/slack
    webhook_url: https://hooks.slack.com/services/...
    username: captain_freedom
    channel: ics
```

Plugins receive plugin configuration data, repository and build data as an encoded JSON string. The plugin can use this data when executing its task. For example, the [slack plugin](https://github.com/drone-plugins/drone-slack) uses the build and repository details to format and send a message to a channel.

Plugins also have access to the `/drone` volume, which is shared across all containers, including the build container. The repository is cloned to a subdirectory of `/drone/src`, which means plugins have access to your source code as well as any generated assets (binary files, reports, etc). For example, the [heroku plugin](https://github.com/drone-plugins/drone-heroku) accesses your source directory and executes `git push heroku master` to deploy your code.

## Plugin Input

Plugins receive build details via `arg[1]` as a JSON encoded string. The payload includes the following data structures:

* `repo` JSON representation of the repository
* `build` JSON representation of the build, including commit and pull request
* `vargs` JSON representation of the plugin configuration, as defined in the `.drone.yml`

Drone provides a simple [plugin library](https://github.com/drone/drone-plugin-go) that helps read and unmarshal the input parameters:

```go
func main() {
    var repo = plugin.Repo{}
    var build = plugin.Build{}
    var vargs = struct {
        Webhook  string `json:"webhook_url"`
        Username string `json:"username"`
        Channel  string `json:"channel"`
    }{}

    plugin.Param("repo", &repo)
    plugin.Param("build", &build)
    plugin.Param("vargs", &vargs)
    plugin.Parse()

    // send slack notification
}
```

## Plugin Output

Plugins cannot send structured data back to Drone. Plugins can, however, write information to stdout so that it appears in the logs. Plugins can fail a build by exiting with a non-zero status code.

You may be asking yourself "how do I send reports or metrics back to Drone" or "how do I generate and store artificats in Drone"? The answer is that you cannot. Instead, you should use plugins to generate reports and send to third party services (like Coveralls) or generate and upload artifacts to third party storage services (like Bintray or S3).

## Plugin Reference

These are existing plugins that you can reference when building your own:

* [Slack](https://github.com/drone-plugins/drone-slack) - publish messages to a Slack channel when your build finishes
* [Heroku](https://github.com/drone-plugins/drone-heroku) - deploy your application to Heroku
* [Docker](https://github.com/drone-plugins/drone-docker) - build and publish your Docker image to a registry

repository: armhf-docker-library/drone

repo_name: armhf-docker-library/drone


text:
## redblack
A red-black tree that supports value lookups by nearest key.

## Acknowledgement
This implementation is based on (Julienne Walker's C Red Black Tree Tutorial)[http://eternallyconfuzzled.com/tuts/datastructures/jsw_tut_rbtree.aspx].

## Use

```javascript
	var rb = require( 'redblack' );
	var tree = rb();
```

The function to create a tree can take a custom comparator, but the default works fine for numbers and strings which are the only things you should be using for keys in this lib anyway.

## API

### add( key, value )
Adds the key value pair to the tree.

```javascript
	tree.add( 'one', 1 );
```

### count()
Returns the total number of key/value pairs stored in the tree.

```javascript
	tree.count();
```

### getValue( key )
Returns a value for the key if it exists.

```javascript
	tree.getValue( 'one' ); // returns 1
	tree.getValue( 'missing' ); //returns undefined
```

### nearest( key )
Returns either the value for the key or the value for the highest key less than the key provided.

```javascript
	tree.nearest( 'two' ); // returns 1
	tree.add( 'six', 6 );
	tree.nearest( 'seven' ); // returns 1
	tree.nearest( 'yolo' ); // returns 6
```

### remove( key )
Removes they key and corresponding value if found.

```javascript
	tree.remove( 'six' );
```

## Why another red black tree?
This lib really just exists to support a consistent hashing lib I wrote that uses a red black tree to keep nearest lookups O(log n). To do that, leaves needed to store a value in addition to the key to avoid having to perform an additional hash lookup once the nearest key is found.

If you're familiar w/ hash rings, this is probably a good enough explanation for why existing/traditional tree structures that only work with a key don't fit this use case.


text:
# seQuencing

![seQuencing logo](docs/source/images/sequencing-logo.svg)

``sequencing`` is a Python package for simulating realistic quantum control sequences using [QuTiP](http://qutip.org/docs/latest/index.html). Built for researchers and quantum engineers, ``sequencing`` provides an intuitive framework for constructing models of quantum systems
composed of many modes and generating complex time-dependent control Hamiltonians
for [master equation simulations](http://qutip.org/docs/latest/guide/dynamics/dynamics-master.html).

![PyPI](https://img.shields.io/pypi/v/sequencing) ![GitHub Workflow Status (branch)](https://img.shields.io/github/workflow/status/sequencing-dev/sequencing/lint-and-test/main) [![Documentation Status](https://readthedocs.org/projects/sequencing/badge/?version=latest)](https://sequencing.readthedocs.io/en/latest/?badge=latest) [![codecov](https://codecov.io/gh/sequencing-dev/sequencing/branch/main/graph/badge.svg?token=LLABAKBJ0C)](https://codecov.io/gh/sequencing-dev/sequencing) ![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/sequencing-dev/sequencing) ![GitHub](https://img.shields.io/github/license/sequencing-dev/sequencing)

## Documentation

The documentation for `sequencing` is available at:
[sequencing.readthedocs.io](https://sequencing.readthedocs.io/)

## Installation

```
pip install sequencing
```

For more details, see the [documentation](https://sequencing.readthedocs.io/en/latest/installation.html).

## Contributing

Want to contribute to `sequencing`? Check out our [contribution guidelines](CONTRIBUTING.md).

## Authors

Primary author and maintainer: [@loganbvh](https://github.com/loganbvh/).

repository: loganbvh/sequencing

repo_name: loganbvh/sequencing


text:
---
layout: post
title: "Revealing the Dark Secrets of BERT"
date: 2019-08-21 04:27:38
categories: arXiv_CL
tags: arXiv_CL Attention Quantitative
author: Olga Kovaleva, Alexey Romanov, Anna Rogers, Anna Rumshisky
mathjax: true
---

* content
{:toc}

##### Abstract
BERT-based architectures currently give state-of-the-art performance on many NLP tasks, but little is known about the exact mechanisms that contribute to its success. In the current work, we focus on the interpretation of self-attention, which is one of the fundamental underlying components of BERT. Using a subset of GLUE tasks and a set of handcrafted features-of-interest, we propose the methodology and carry out a qualitative and quantitative analysis of the information encoded by the individual BERT's heads. Our findings suggest that there is a limited set of attention patterns that are repeated across different heads, indicating the overall model overparametrization. While different heads consistently use the same attention patterns, they have varying impact on performance across different tasks. We show that manually disabling attention in certain heads leads to a performance improvement over the regular fine-tuned BERT models.

##### Abstract (translated by Google)

##### URL
[http://arxiv.org/abs/1908.08593](http://arxiv.org/abs/1908.08593)

##### PDF
[http://arxiv.org/pdf/1908.08593](http://arxiv.org/pdf/1908.08593)


text:
---
title: "Automating Gradle dependency updates with GitHub Actions"
date: 2020-06-05T17:34:21+09:00
author: Peter Evans
description: "How to automate Gradle dependency updates with GitHub Actions"
keywords: ["gradle", "lockfile", "dependencies", "update", "github", "github actions", "pull request", "automation"]
---

Using Gradle's [dependency locking](https://docs.gradle.org/current/userguide/dependency_locking.html) feature we can create an automated process to periodically create a pull request for dependency updates.

See an [example pull request](https://github.com/peter-evans/gradle-auto-dependency-updates/pull/2) using the method outlined in this article.

### Configuring dependency locking

1. Firstly, make sure the gradle wrapper is up to date. This is necessary in order to use the feature preview in the next step.

    ```
    gradle wrapper --gradle-version 6.5
    ```

2. Enable the `ONE_LOCKFILE_PER_PROJECT` feature preview in *settings.gradle.kts*. You can read more about this feature [here](https://docs.gradle.org/current/userguide/dependency_locking.html#single_lock_file_per_project).

    ```
    rootProject.name = "example-api"

    enableFeaturePreview("ONE_LOCKFILE_PER_PROJECT")
    ```

3. Add the following section to *build.gradle.kts* to version lock all configurations. See the [documentation here](https://docs.gradle.org/current/userguide/dependency_locking.html#enabling_locking_on_configurations) if you would like to customise this for specific configurations.

    ```
    dependencyLocking {
        lockAllConfigurations()
    }
    ```

4. **Optionally**, add the following if you would like to create a lockfile for the `buildscript` section. This can be used to version lock plugins.

    ```
    buildscript {
        repositories {
            mavenCentral()
            jcenter()
        }
        dependencies {
            classpath("com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.+")
        }
        configurations.classpath {
            resolutionStrategy.activateDependencyLocking()
        }
    }

    apply(plugin = "com.jfrog.bintray")
    ```

5. Write a `gradle.lockfile` for your current dependencies. If you followed step 4, you will also have a `buildscript-gradle.lockfile`.

    ```
    ./gradlew dependencies --write-locks
    ```

6. Check the lockfiles into source control. The lockfiles will now make sure that `./gradlew build` uses strict versions from the lockfile.

7. Specify [version ranges](https://docs.gradle.org/current/userguide/single_versions.html) for your dependencies. The range should include all versions that you are happy to accept version updates for. For example, `1.2.+` for just patch updates, `1.+` for minor updates, and `+` to include major version updates.

### Automate dependency updates

Add the following GitHub Actions workflow to periodically create a pull request containing dependency updates.
The following example uses the [create-pull-request](https://github.com/peter-evans/create-pull-request) action and executes once a week.

Note that if you want pull requests created by this action to trigger checks then a repo scoped [PAT](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token) should be used instead of the default `GITHUB_TOKEN`.
It is *highly recommended* to make sure checks run and build the new pull request in CI.
This will verify that the dependency versions in the new lockfile will build and pass tests.

name: Update Dependencies
on:
  schedule:
    - cron:  '0 1 * * 1'
jobs:
  update-dep:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-java@v1
        with:
          java-version: 1.8
      - name: Grant execute permission for gradlew
        run: chmod +x gradlew
      - name: Perform dependency resolution and write new lockfiles
        run: ./gradlew dependencies --write-locks
      - name: Create Pull Request
        uses: peter-evans/create-pull-request@v5
        with:
            token: ${{ secrets.PAT }}
            commit-message: Update dependencies
            title: Update dependencies
            body: |
              - Dependency updates

              Auto-generated by [create-pull-request][1]

              [1]: https://github.com/peter-evans/create-pull-request
            branch: update-dependencies

See the code in [this repository](https://github.com/peter-evans/gradle-auto-dependency-updates) for a complete example.

repository: peter-evans/blog

repo_name: peter-evans/blog


text:
# Baked Chicken

## Ingredients
- chicken breasts
- brine (.25c salt to 4c water)
- olive oil/melted butter
- seasonings

## Recipe
1. Brine chicken breasts for 15 minutes.
2. Rinse and pat dry chicken breasts.  Brush on olive oil/melted butter.
3. Sprinkle seasoning onto chicken breasts, bake at 450*F until 165*F, about 20 minutes.
4. When chickenn hits 140*F, turn on broiler.

repository: bertwagner/Recipes

path: /Dinner/Baked Chicken.md

filename: Baked Chicken.md

repo_name: bertwagner/Recipes


text:
---
title: Snow Creek Wall, Orbit
date: 2001-4-15
layout: post
location: Snow Creek Wall
guests: Dan
category: climbing
---

* Orbit (Grade III, 5.8, 6 pitches)
* April, 2001

Daniel Smith and I planned this climb a few weeks before. Amazingly,
nothing came up to knock us off course. We drove over Steven's Pass in
rain turning to snow, discussing climbs we had done and wanted to
do. Any non-climber would be bored to tears. We reached the Snow Creek
Trail parking lot at 9 am, and were espied by Ray Borbon, ensconced on
the ridge across the street. He came down and wished us luck.

{% image /cmaimages/2001/stelpitch.jpg %}
The coolest pitch

{% image /cmaimages/2001/danonorbt.jpg %}
Here's Dan

I had a new pack, a "crag pack," I guess. Very small! But it held our
rack, some water, my harness, shoes and a jacket, so it was
adequate. Dan had a real pack, and soon we were hiking up to the wall,
pretty happy with life and the weather thus far. The log crossing was
an awkward awakening from mindless hiking. Once at the base of the
rock, we scrambled around looking for the first pitch. Dan found the
3rd class route. We changed into rock gear and stowed the packs in a
tree. Dan suggested scrambling the first pitch, which was a good
idea. There was just one tricky move just before the tree belay, but
with a little thought it felt secure.

Now for the real climbing! Dan wanted to give me the "crux" pitch, so
it worked out that I should do the first one too, which starts with a
tricky chimney. I got some pro in the back wall of the chimney, and
wondered what to do next. Dan suggested climbing onto the face rather
than stemming or thrutching in the chimney. This worked marvelously,
and soon I was on easy ground, climbing an obvious leftward ramp. I
continued on the ramp to a small tree belay where the climbing looked
harder.  Dan said I was a better rock climber than he
expected, and my pro was good. This bloated my head sufficiently that
the rest of the route was a piece of cake! Anyway, Dan and I have
exchanged email for months, it was great to finally climb.

Due to rope drag, and not being able to communicate around the corner
very well, I kept Dan tight on the rope when he wanted to down-climb a
small section. "Take" and "Slack" can sound too much alike on a windy
day. I think the "Up Rope!" convention is better, and will start
saying that instead.  Aside from that, it was a great pitch, and a
great lead. Dan had some good pro in at the start of the crack, then
harder climbing continued up and finally leftward to join a crack on
the left. Now we were getting a taste of this great route!

With a little apprehension, I geared up for the next lead. Running out
of excuses to stand around at the belay, I moved up a tricky face to
two bolts. Above the bolts was a horizontal crack before a mysterious
corner that I'd have to go around. The crack took two thin wires, and
sweating a little, I edged around the corner to find...easier
climbing! I headed up, zigging this way and that among flakes and
edges. There was a fixed pin and an old bolt along the way. With Dan
out of sight around the corner, this pitch had a long and lonely
feel. I came to two old bolts and wondered if I should belay
here. Finally I went 15 feet higher to an awkward ledge with a loose
block. Two cams and a hex made the semi-hanging belay. "Wow," I
mentally said. The exposure was great. When Dan came around the
corner, I had a good time watching him discover the next moves just as
I had. From above, all these little ledges are very clear, but from
below you have to feel them out. I got a picture of Dan here.

Dan headed up the left-facing dihedral I belayed in. There was some
tough climbing here, and not so great pro as he moved around a corner
to find...easier climbing! At least long enough to get some gear. Then
he headed up to a roof, looked for another way around, then committed
to the roof.  This seemed like a fun pitch. Of course, I hadn't
brought a jacket, and the steady wind finally had me almost
shivering. I flexed muscles to stay warm. Dan put me on belay and I
started up. While cleaning the second cam, my foot slipped and I fell
onto the rope. Nice belay, Dan! There was a lot of air beneath me. The
cold had made me clumsy, but I think the fall sent a lot of blood to
my skin! So I went up and around the corner, over the overhang, and up
some fun knobs and overlaps. The belay was just below and right of a
large overhang. Dan sent me off right away for a chickenhead fest.

Long did I wander in the valley of the bodiless chickens. Around a
corner (a common theme), I grappled with these lifeless heads by the
dozen. I considered slinging their necks with cordage, but their
reassuring grip in the hand provided enough security. I came to a
ledge and continued up and left on the lichen-stained orbs, an eerie
soundtrack playing in my head. With a lot of rope drag, I reached a
ledge protected from the wind, placed a cam to back up my belay seat,
and enjoyed the view while Dan zoomed up. The view started to include
snow. Lots of snow. Dan arrived and set off on the final scramble to
the summit. By the time I got moving, the rock was becoming slick and
thoughts of an unpleasant, snowy descent were stewing in my brain. I
enjoyed a slot canyon with pine needles on the floor, and a bouldering
move by a tree to escape. Dan, wearing shorts, was crouching in an
alcove to get away from the snow.  He coiled the rope for descent, and
after waiting a few minutes, we headed down. I was really picturing
these scary "no fall allowed" scenarios on slippery slabs with blue,
frozen feet. I kept thinking we would want to rappel. But my fears
were groundless. Even with some snow, the descent wasn't as bad as I
remembered it. Dan told me about the advantages and disadvantages of
being single. I also learned about the attempt he made on Johannesburg
this winter, climbing 2000 feet of water ice 3 and 4. This sounded
like an amazing adventure. I think there is a war in many climber's
minds between checking a tick list, and bold adventure. I know I have
this. Do something obscure...but probably more likely to end in brush
and rain? Or something classic...great climbing, but often a
non-wilderness experience due to all the other people, and guidebook
that leads you through every pitch?  Well, chalk one up for Adventure
on that trip.

Back at the base, we chatted with other climbers who had done Outer
Space. Strings of climbers seemed to be rappelling from that route and
others, due to the snow. But already, the rock was drying and the sun
was shining. We hiked out. The log crossing was easy going back.

At the car, Ray left a note, hoping the rain didn't skunk us. Nope!

We drove to Classic Crack, met two guys from Marmot, Jody and
Pat. They climbed it, then I belayed Dan, who led this quickly and
easily. He had to deal with a weird inverted cam problem placing the
second or third piece, right at the crux! Dan came down, and I
immediately fell off the route on top-rope. Another try from the base
proved successful, and I enjoying the jamming immensely. I had come
the year before and top-roped this route, lie-backing until my lungs
felt like bursting. Naturally, I wondered how I could ever lead
it. Now that I can jam, I'm ready to give it a try.

We had a beer at Gustav's with Jody and Pat, hearing a great story
about a dehydrated climber on Adams who thought the rescue helicopter
was a UFO. He successfully hid from it for at least a day. Then, we
got a fascinating lecture on the "Tree Route," with info on accessing
the upper three pitches which aren't in the guidebook.  (Ma'am, if you
read this, send me that info...I was sad that I couldn't stay for the
full route description you had.)  On that happy note, we drove back.

Thanks to Dan for a great climbing day!

repository: ripsawridge/site

repo_name: ripsawridge/site


text:
# SSBU-TOOLS #

 - **XMBDec.py**
   - **Requires Python 3**
   - Decompiles an XMB file to XML and prints to standard output. To save, pipe standard output to file.
   - Usage: `XMBDec.py [xmb file]`

repository: Sammi-Husky/SSBU-TOOLS

repo_name: Sammi-Husky/SSBU-TOOLS


text:
# intro-to-ML-workshop
This repo was created for the " Intro to ML " workshop I animated on Feb,16th 2019

The practice notebook is avaiable via this [link](https://colab.research.google.com/github/Neofly4023/intro-to-ML-workshop/blob/master/Intro_to_ML_notebook.ipynb)

And you may find my presentation about Colab [here](https://drive.google.com/open?id=1gAz-sUAKUDvnwCATr_azcTwV4ac_TtJP1snVdVQplNk)

And Jason Mayes's " Machine Learning 101 " presentation [here](https://docs.google.com/presentation/d/1kSuQyW5DTnkVaZEjGYCkfOxvzCqGEFzWBy4e9Uedd9k)

If you have any comment or suggestion, please contact me at<EMAIL_ADDRESS>

repository: amineremache/intro-to-ML-workshop

repo_name: amineremache/intro-to-ML-workshop


text:
## Simple Akka Http

Project is uses [akka-http](https://doc.akka.io/docs/akka-http/current/introduction.html#using-akka-http).

**Two modules**
 1. core
 2. usage

Module `usage` depends on `core`.

- The `usage` module has `Server.scala` file, as the entry point.
- Within `Server`  we create an instance for `HttpService` with required `Config`. This configuration is taken from `resources/application.conf` as a call to `ConfigFactory.load()` method (see in `Server.scala`) and passed to `HttpService`.
- Within the `Server` object we also instantiate `ActorSystem` and `Materializer` as implicit, since these are required by `akka-http`.
- Within `HttpService`, we bind desired host and port from `application.conf` to server and run.
- Apart from `Config`, HttpService also takes `Route`, which is nothing but a *~~Hipster~~* term denoting:  **a way to convert http `Request` to `Response`**
- In object `HttpService`, we have [wired](https://github.com/softwaremill/macwire) `OrderRoutes` and passed.
- The class `OrderRoutes` requires `OrderService`, in other words `OrderService` dependency to be injected in `OrderRoutes`, hence that is also *wired*! This class provides routes for Order's API.
- `OrderService` contains slight dummy business logic and CRUD.

## Run
Open **Terminal/cmd prompt** :

From root directory, give below command to go in `simple-akka-http` directory.
`cd simple-akka-http`

To run the server, simply give the command
`sbt usage/run`

It should start the server at `localhost:8080`.

You may use [Postman](https://www.getpostman.com) to test APIs on this server. `OrderRoutes` lets you create an order through a POST call to `/orders`

In Postman, give a POST call to `localhost:8080/orders` with below request JSON:
```json
{
	"id": "323b78ec-1eb8-4410-c284-f75079b15719",
	"title": "Apple IPhone 11 Pro",
	"price": 1699.0,
	"quantity": 1
}
```

When you click on send, it should return a response in success case.
```json
{
    "message": {
        "id": "323b78ec-1eb8-4410-c284-f75079b15719",
        "price": 1699.0,
        "quantity": 1,
        "title": "Apple IPhone 11 Pro"
    },
    "success": true
}
```

Note: Didn't try to explain every detail, to understand `akka-http` refer to it's documentation.

gha_language: Scala


text:
smi-to-srt
==========

A command line tool to convert smi to srt subtitle files.

Usage
-----
- Ensure your source file (filename.smi) is saved in utf-8 encoding. (See below)
- Run the following command `$ python smi-to-srt.py file-to-convert.smi output-file.srt`

Features
--------
- Automagic detect local charset to UTF-8 conversion (courtesy of chardet.universaldetector)
- Retains supported font styling elements specified in source

Known Bugs
----------
- Fails when BODY element starts with a bunch of blank lines
  (Needs more robust start element seeking logic--during processing)
- Does not intelligently assigns missing end timestamps
  (Simply assigns 2 second duration--without considering next dialog line)

Areas for Improvement
---------------------
- Better missing end marker (duration) calculation
- Some code to properly package dependencies
- Much more pythonic refactoring needed

repository: kswchoo/smi-to-srt

repo_name: kswchoo/smi-to-srt