text:
# CryptoKit-Go

SHA1，SHA256, SHA384, SHA512, HMAC SHA1, HMAC SHA 256, MD5 16, MD5 32, AES 256, RSA 1024, RSA 4096 and Digital Signature.
```
USAGE:
   CryptoKit_Go.exe [global options] command [command options] [arguments...]

COMMANDS:
     md5      MD5 Hash Generator
     sha      SHA Hash Generator
     base64   Base64 Encode and Decode
     aes      AES-256 Encrypt and Decrypt
     rsa      RSA Encrypt and Decrypt
     help, h  Shows a list of commands or help for one command

GLOBAL OPTIONS:
   --help, -h     show help
   --version, -v  print the version
```


text:
# tdl-tdlib-ffi

[![npm](https://img.shields.io/npm/v/tdl-tdlib-ffi.svg)](https://www.npmjs.com/package/tdl-tdlib-ffi)

Node.js FFI bindings to [TDLib][]'s libtdjson. Uses [node-ffi-napi][].

It is meant to be used with the [tdl][] package.

`tdl-tdlib-ffi` provides TypeScript and Flow typings out of the box.

[TDLib]: https://github.com/tdlib/td
[tdl]: https://github.com/Bannerets/tdl
[node-ffi-napi]: https://github.com/node-ffi-napi/node-ffi-napi

## Installation

```console
$ npm install tdl-tdlib-ffi
```

## API

```javascript
const { TDLib } = require('tdl-tdlib-ffi')
```

##### constructor: `new TDLib(libraryFile?: string)`

`libraryFile`'s extension can be omitted.

`node-ffi` will append the extension and pass the library name to [`dlopen`](https://www.man7.org/linux/man-pages/man3/dlopen.3.html) (or [`LoadLibraryW`](https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibraryw) on Windows).

By default `libraryFile` is `tdjson` on Windows and `libtdjson` on a different OS.

Examples:

```javascript
new TDLib()
new TDLib('libtdjson')
new TDLib(path.join(__dirname, 'libtdjson'))
```

---

For other API see `TDLib_API.md` in the `tdl` repository root.

license: MIT

repository: gaithoben/tdl

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: gaithoben/tdl


text:
# protobuf-net

Unity Package Manager compatible version of [mgravell/protobuf-net](https://github.com/mgravell/protobuf-net).

# Usage

As git packages are not yet supported in the Package Manager GUI you'll have to reference it yourself via `manifest.json`, located under `<project path>/Packages/manifest.json`.

Simply add this package as a new dependency using the syntax shown below.
```js
"de.cryma.protobuf-net": "https://github.com/Cryma/protobuf-net.git"
```

After restarting Unity the package can be used.

**Important:** If you use Assembly Definitions, don't forget to add `de.cryma.protobuf-net.Runtime` as a reference.

repository: Cryma/protobuf-net

repo_name: Cryma/protobuf-net


text:
# Bazinga.AspNetCore.Authentication.Basic
[![Build status](https://ci.appveyor.com/api/projects/status/hnl0ixy7oa7mrq7x/branch/master?svg=true)](https://ci.appveyor.com/project/bruno-garcia/bazinga-aspnetcore-authentication-basic/branch/master) [![NuGet](https://img.shields.io/nuget/v/Bazinga.AspNetCore.Authentication.Basic.svg)](https://www.nuget.org/packages/Bazinga.AspNetCore.Authentication.Basic/)
[![codecov](https://codecov.io/gh/bruno-garcia/Bazinga.AspNetCore.Authentication.Basic/branch/master/graph/badge.svg)](https://codecov.io/gh/bruno-garcia/Bazinga.AspNetCore.Authentication.Basic)
Basic Authentication for Microsoft ASP.NET Core Security

Microsoft doesn't ship a Basic Authentication package with ASP.NET Core Security for a good reason.
While that doesn't stop us needing such implementation for testing, this is not advised for production systems due to the many pitfalls and insecurities.

Sample usages, with hard-coded credentials:

```csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();
    services.AddAuthentication(BasicAuthenticationDefaults.AuthenticationScheme)
        .AddBasicAuthentication(credentials =>
            Task.FromResult(
                credentials.username == "myUsername"
                && credentials.password == "myPassword"));
}
```

Or by defining a service to register. Allowing your validator to take dependencies through Dependency Injection:

```csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(BasicAuthenticationDefaults.AuthenticationScheme)
        .AddBasicAuthentication<DatabaseBasicCredentialVerifier>();
}

// With your own validator
public class DatabaseBasicCredentialVerifier : IBasicCredentialVerifier
{
    private readonly IUserRepository _db;

    public DatabaseBasicCredentialVerifier(IUserRepository db) => _db = db;

    public Task<bool> Authenticate(string username, string password)
    {
        return _db.IsValidAsync(username, password);
    }
}
```

And finally, since ASP.NET Core 2.0, the single middeware for authentication:

```csharp
public void Configure(IApplicationBuilder app)
{
    app.UseAuthentication();
    app.UseMvc();
}
```

If you need to include your own claim types, after the user is authenticated, an event called OnCredentialsValidated is dispatched, see the code below:

```csharp
public void ConfigureServices()
{
    services.AddAuthentication(BasicAuthenticationDefaults.AuthenticationScheme)
        .AddBasicAuthentication<BasicAuthenticationVerifier>(options => {
            options.Events = new BasicAuthenticationEvents()
            {
                OnCredentialsValidated = (context) =>
                {
                    context.Principal = new ClaimsPrincipal(); // New instance of claims principal with your claims
                    return Task.FromResult(context);
                }
            };
        });

}
```

If inside the function you need call a service from DI, you can use:

```csharp
public void ConfigureServices()
{
    services.AddAuthentication(BasicAuthenticationDefaults.AuthenticationScheme)
        .AddBasicAuthentication<BasicAuthenticationVerifier>(options => {
            options.Events = new BasicAuthenticationEvents()
            {
                OnCredentialsValidated = (context) =>
                {
                    var authService = context.HttpContext.RequestServices.GetRequiredService<AuthenticationService>();

                    context.Principal = authService.GetClaimPrincipal(); // New instance of claims principal with your claims
                    return Task.FromResult(context);
                }
            };
        });

}
```

Regardless the configuration above you choose to use, you need to ensure your controller expects an authenticated user.
That can be acomplished in different ways, one being the: `[Authorize]` attribute. [See Microsoft docs](https://docs.microsoft.com/en-us/aspnet/core/security/authorization/simple?view=aspnetcore-2.1) for more.

For better understanding of the ASP.NET Core Identity, see [Microsoft docs](https://docs.microsoft.com/en-us/aspnet/core/security/authentication/identity)
# License

Licensed under MIT

gha_language: C#

gha_license_id: MIT


text:
# Eye control

Eye control is a project that allows you to use your gaze to move mouse cursor.

## Requierements

* python>=3.6
* Tensorflow 2
* dlib
* openCV
* pillow (PIL)
* numpy
* matplotlib
* tkinter
* Jupyter notebook (if you want to train your NN yourself)

## Running the watcher

At the start of the program you have to calibrate it.

1. Run calibration_pic in fullscreen. If your screen isnt 1920x1080 then draw calibration pic
yourself or wait for future versions.

2. Run the program.

 Concentrate your view on the point for 5-10 seconds without closing your eyes then
press the button. Repeat this with all points.

4. Use the program.

**If you move the camera or the screen then you have to restart the program**

## Gaze vector estimation

[GazeML](https://github.com/swook/GazeML) is used for 3d gaze vector estimation.

 Then a
Perspective-n-Point problem is solved with with the 2d face landmarks and an average 3d
face model. The results are head rotation and translation vectors in 3d world coordinate
system.

#### Averaging
To increase the accuracy of the system, averaging is done.
Current gaze vectors and head positions are calculated as an average of N last estimated values.

### Calibration

The main idea of calibration is to find screen plane in 3d world coordinate system and the
relation between 3d world gaze point and pixel on screen. It is implied that
the user doesnt move his head at all during calibration.

#### Finding screen plane

![](.readme_pics/person_looks.png)
Red are gaze vectors from left eye, blue - from right eye.
Here you can see the perfect scenario of calibration where all gaze vectors from eyes do cross.
The user has to look to 5 targets(all corners and center of screen).

Unfortunately, there are no perfect tools that predict gazes or head position without error,
so we cannot guarantee that gaze vectors from 2 eyes to one point cross.

My solution is to estimate a point that has the smallest equal distances to gaze vectors from both eyes.
Then based on the 5 resulting 3d points(for each corner and center) it is easy to find the plane with
least squares(remember that the points are not exactly matching real screen points).

The following picture shows the points and estimated screen borders with green.

![](.readme_pics/person_looks_reality.png)

#### Finding relation between 3d world gaze point and pixel on screen

![](.readme_pics/seen_to_screen.png)
On the left is the screen in world coordinate system with red dot be estimated cross
point of gazes and the screen plane, on the right pixel screen.

The basic idea is to split the 3d screen and pixel screen into four triangles and match
them.

It is easy to find to which triangle on 3d screen the red point belongs.

![](.readme_pics/triangle_to_triangle.png)

Two vectors-sides a and b and point O of 3d screen triangle a form coordinate system in 2d space
of screen plane. The red point has coordinates ```(c, d)``` in aOb, c and d can be easily calculated.
The red dot has the same coordinates ```(c, d)``` in ```a'O'b'``` coordinate system so the
red dot pixel can be found by ```O' + c*a' + d*b'```.

The process that is described can be executed using matrix. During calibration
the matrix for each triangle pair is evaluated.

### Finding gaze target

![](.readme_pics/Untitled%20Diagram.png)

## Special thanks

*  yinguobing for pnp solve module from [Head pose estimation project](https://github.com/yinguobing/head-pose-estimation)
*  swook for [GazeML](https://github.com/swook/GazeML)
*  OpenFace for [3d average face model](https://github.com/TadasBaltrusaitis/OpenFace/blob/master/lib/local/LandmarkDetector/model/pdms/In-the-wild_aligned_PDM_68.txt)

gha_language: Python


text:
# Simple C Programming Language Projects

Following is a list of programs to do:-

Count: Letter Count, Word Count, Line Count, Paragraph Count, Comma Count, Space Count and Special Symbols Count.

Count with options: Letter Count, Word Count, Line Count and Paragraph Count.

Ask for File

Give Option to ask for count of word, letter, line and parragraph

Restrict and basic validation

CSV read and write

CSV read and write into multiple file

CSV read and write columns to a specific file

Binary Read and Binary write


text:
---
title: "GDS Bookshelf"
subtitle: "An interactive bundle of open books on Geographic Data Science"
author: "Dani Arribas-Bel"
output:
  tufte::tufte_html: default
---

The GDS Bookshelf is a project to bundle together a few freely available books that relate to Geographic Data Science in an interactive platform that can be accessed online or locally.

## Books

Currently, the shelf includes the following references:

- [*Geographic Data Science with PySAL and the PyData Stack*](https://geographicdata.science/book), by Serge Rey, Dani Arribas-Bel and Levi Wolf
- [*Spatial Analysis Notes*](https://gdsl-ul.github.io/san/), by Francisco Rowe and Dani Arribas-Bel
- [*Geocomputation in R*](https://geocompr.robinlovelace.net/), by Robin Lovelace, Jakub Nowosad and Jannes Muenchow
- [*Spatial Data Science in R*](https://keen-swartz-3146c4.netlify.app), by Edzer Pebesma and Roger Bivand

## Access the shelf

### Online

You can access the GDS Shelf online, with no install requirements through Binder by clicking on the button below:

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/darribas/gds_bookshelf/master)

### Locally

If you prefer, you can run the shelf locally through Docker. Assuming you have Docker installed  on your machine, you can install the shelf by running:

```shell
docker pull darribas/gds_bookshelf
```

This will take a while (among other things, it has to download a copy of the [`gds_env`](https://darribas.org/gds_env/)) and a good internet connection. Once finished, you can run the shelf with the following command:

```shell
docker run --rm \
           -ti \
           -p 8888:8888 \
           darribas/gds_bookshelf
```

Point your browser to `localhost:8888` and copy the token printed on the command line to access the running instance.

### Build

If you would like to build it manually to make sure you are pulling the latest
version of each book, you can do so by downloading the
[`Dockerfile`](Dockerfile) and the [`Makefile`](Makefile) of the project,
placing them on the same directory and, from there, running:

```shell
docker build -t gds_bookshelf .
```

## Suggestions and feedback

If you would like to see more books added to the shelf, please add an [issue on Github](https://github.com/darribas/gds_bookshelf/issues/new) or, even better, feel free to [send a pull request](https://github.com/darribas/gds_bookshelf/pulls).

[![](https://toppng.com/uploads/thumbnail/github-mark-logo-vector-11573976116oq3oau9n10.png)](https://github.com/darribas/gds_bookshelf)


text:
# weplay-compressor

Small script that compress incoming png Buffers with pngquant, and broadcasts it.

## How to install

```bash
$ npm install -g node-pngquant-native
$ npm install
```

And run it with the following ENV vars:

- `WEPLAY_REDIS` - redis uri (`localhost:6379`)
- `WEPLAY_IO_URL` - io server url (`http://localhost:3001`)

```bash
$ node index
```

## License

MIT

repository: iromu/weplay-compressor

branch_name: refs/heads/develop

gha_language: JavaScript

repo_name: iromu/weplay-compressor


text:
# coffeelint-no-trailing-commas

CoffeeLint rule that disallows trailing commas

## Description

This [CoffeeLint](http://www.coffeelint.org/) rule disallows trailing commas.

## Installation

```sh
npm install coffeelint-no-implicit-returns
```

## Usage

Add the following configuration to `coffeelint.json`:

```json
"no_trailing_commas": {
  "module": "coffeelint-no-trailing-commas"
}
```

## Configuration

There are currently no configuration options.

## Testing

To run tests:

```
~/coffeelint-no-trailing-commas]$ npm run test

><EMAIL_ADDRESS>test /Users/jasonku/coffeelint-no-trailing-commas
> coffee vowsrunner.coffee --spec test/RuleProcessor.test.coffee

  ♢ no_trailing_commas

...

✓ OK » 3 honored (0.083s)
```

repository: jasonku/coffeelint-no-trailing-commas

gha_language: CoffeeScript

repo_name: jasonku/coffeelint-no-trailing-commas


text:
---
title: "25/01/2020: This week in KISS (#8)"
---

More fun stuff this week.

## Index

<!-- vim-markdown-toc GFM -->

* [Website redesign](#website-redesign)
* [Packages page](#packages-page)
* [Eudev can now be replaced](#eudev-can-now-be-replaced)
* [Repology now tracks KISS maintainers](#repology-now-tracks-kiss-maintainers)
* [Merchandise](#merchandise)
* [sowm 1.2 released](#sowm-12-released)
* [Official Repositories](#official-repositories)
* [Community](#community)

<!-- vim-markdown-toc -->

## Website redesign

The first thing you will have noticed is that the website has had a redesign. The idea behind it was to mimic a markdown/txt file while keeping nice features like clickable links and images around.

- Code blocks now feature a scroll bar if wider than the screen (*instead of wrapping into an unintelligible mess*).
- The text width is now wider (*80 characters*) and the awful skinny column is gone.
- The website still features a lightweight size, with no ads, tracking, js or cookies. Here's a speed test! [Pingdom results](https://tools.pingdom.com/#5bf78e6f4e400000)

## Packages page

Another new addition to the website is the [packages page](/packages). This is a full listing of each package in the repositories with version and maintainer information.

The page is updated automatically with changes to the repositories. The raw repository data is also available as a simple `tsv` file.

- Package listings: <https://getkiss.org/packages>
- Raw data: <https://getkiss.org/packages/db.tsv>

## Eudev can now be replaced

This week I worked on making it possible to replace `eudev` with the device manager of your choosing.

I am now happy to announce that I now run my system using busybox `mdev` as my device manager. What's really neat is that I also managed to make my system work without a device manager.

There are caveats to replacing udev, however. Xorg loses its ability to automatically discover devices and libinput loses access to its "Quirks" database.

If these don't bother you, I have written a Wiki page which explains the process and includes all of the information you'll need.

- Wiki: [Replacing eudev with mdev (or another device manager)](https://getkiss.org/wiki/replacing-eudev-with-mdev-(or-another-device-manager))

I'd like to thank [Michael Forney](https://github.com/michaelforney) who maintains a [fork of libinput](https://github.com/oasislinux/libinput/tree/no-udev) which makes udev an optional dependency.

## Repology now tracks KISS maintainers

The packaging hub [Repology.org](https://repology.org/) has tracked KISS' repositories for a long while now. This week, support was added to also track who maintains each package.

Each maintainer of a KISS package now has their own page on Repology with additional feeds they are able to subscribe to. This eases the [burden on myself to notify maintainers](https://github.com/kisslinux/community/issues?q=is%3Aissue+out+of+date+is%3Aclosed) when their packages are out of date!

As an example, here is my Repology maintainer page: [link](https://repology.org/maintainer/dylan.araps%40gmail.com)

I'd like to thank [Dmitry Marakasov](https://github.com/AMDmi3) for providing this invaluable service and for his continued support of KISS.

## Merchandise

I have now included an additional method of showing your support to KISS. One in which you receive something physical in return!

T-shirts and stickers are available in the following link and feature... I'll let you decipher this puzzle.

- [teespring](https://teespring.com/kiss0?pid=389)

Thanks for supporting KISS!

## sowm 1.2 released

The "Simple Opinionated Window Manager" received an update this week to fix a widespread issue of keybindings not working on some systems.

This is a simple Window Manager I started working on a while ago which sees a lot of use by users of KISS.

You can find the new release on GitHub in the link below.

- <https://github.com/dylanaraps/sowm>

## Official Repositories

- **Dylan Araps**:
    - [`8b5f266`](https://github.com/kisslinux/repo/commit/8b5f266) libass: Remove fribidi dependency
    - [`ee0f44e`](https://github.com/kisslinux/repo/commit/ee0f44e) qt5: Remove udev dependency
    - [`b6494a9`](https://github.com/kisslinux/repo/commit/b6494a9) xorg-server: Make udev dependency optional
    - [`1973da2`](https://github.com/kisslinux/repo/commit/1973da2) libinput: optional udev
    - [`7b9d38a`](https://github.com/kisslinux/repo/commit/7b9d38a) libxkbcommon: move from community
    - [`5086edb`](https://github.com/kisslinux/repo/commit/5086edb) qt5-webengine: Fix udev removal
    - [`269b5ac`](https://github.com/kisslinux/repo/commit/269b5ac) bison: bump to 3.5.1
    - [`de5f9f2`](https://github.com/kisslinux/repo/commit/de5f9f2) make: bump to 4.3
    - [`0592cc4`](https://github.com/kisslinux/repo/commit/0592cc4) busybox: Add initial mdev
    - [`41b37a9`](https://github.com/kisslinux/repo/commit/41b37a9) busybox: mdev support
    - [`e33b642`](https://github.com/kisslinux/repo/commit/e33b642) busybox: Remove broken mdev rule
    - [`ab39775`](https://github.com/kisslinux/repo/commit/ab39775) nss: Fix depends
    - [`19829ea`](https://github.com/kisslinux/repo/commit/19829ea) baseinit: bump to 0.2.2
    - [`906e3e7`](https://github.com/kisslinux/repo/commit/906e3e7) busybox: mdev: Fix /dev/snd
    - [`d73defb`](https://github.com/kisslinux/repo/commit/d73defb) xf86-video-intel: Make eudev optional
    - [`5edc08f`](https://github.com/kisslinux/repo/commit/5edc08f) sowm: bump to 1.1
    - [`e12510b`](https://github.com/kisslinux/repo/commit/e12510b) libva: new package at 2.6.0
    - [`1b6cee8`](https://github.com/kisslinux/repo/commit/1b6cee8) libva-utils: new package at 2.6.0
    - [`96c0241`](https://github.com/kisslinux/repo/commit/96c0241) intel-vaapi-driver: new package at 2.4.0
    - [`7b518cc`](https://github.com/kisslinux/repo/commit/7b518cc) intel-media-driver: new package at 19.4.0r
    - [`3bc5d51`](https://github.com/kisslinux/repo/commit/3bc5d51) curl: Don't link to icu
    - [`db94c86`](https://github.com/kisslinux/repo/commit/db94c86) kiss: bump to 0.70.0
    - [`3dc27c4`](https://github.com/kisslinux/repo/commit/3dc27c4) kiss-utils: bump to 0.70.0
    - [`45f92eb`](https://github.com/kisslinux/repo/commit/45f92eb) curl: don't link to libpsl
    - [`8acef1f`](https://github.com/kisslinux/repo/commit/8acef1f) libva: bump to 2.6.1
    - [`249a5fa`](https://github.com/kisslinux/repo/commit/249a5fa) python-mako: bump to 1.1.1
    - [`0ce3c16`](https://github.com/kisslinux/repo/commit/0ce3c16) qt5: Fix libexec error
    - [`9933167`](https://github.com/kisslinux/repo/commit/9933167) util-linux: bump to 2.35
    - [`390d2f0`](https://github.com/kisslinux/repo/commit/390d2f0) qt5: Don't link against execinfo.h take two
    - [`8c01495`](https://github.com/kisslinux/repo/commit/8c01495) cmake: bump to 3.16.3
    - [`207b4c5`](https://github.com/kisslinux/repo/commit/207b4c5) dosfstools: new package at 4.1
    - [`f3a6a38`](https://github.com/kisslinux/repo/commit/f3a6a38) mandoc: Fix build with new gnumake
    - [`a870165`](https://github.com/kisslinux/repo/commit/a870165) nodejs: bump to 13.7.0
    - [`ee8f593`](https://github.com/kisslinux/repo/commit/ee8f593) glib: bump to 2.63.4
    - [`7f6c33c`](https://github.com/kisslinux/repo/commit/7f6c33c) git: Build with perl if available
    - [`c64afb1`](https://github.com/kisslinux/repo/commit/c64afb1) mandoc: Simplify package and fix pointless error
    - [`d7a4e9f`](https://github.com/kisslinux/repo/commit/d7a4e9f) gcc: fix libgomp relocation. Patch applied from @ioraff
    - [`b257d85`](https://github.com/kisslinux/repo/commit/b257d85) sqlite: bump to 3.31.0
    - [`ffcad57`](https://github.com/kisslinux/repo/commit/ffcad57) kiss: Track maintainers through CI
    - [`1e33ac8`](https://github.com/kisslinux/repo/commit/1e33ac8) kiss: Track maintainers through CI
    - [`818abe2`](https://github.com/kisslinux/repo/commit/818abe2) repo: Revert CI changes
    - [`b690ba2`](https://github.com/kisslinux/repo/commit/b690ba2) nss: bump to 3.49.2
    - [`f2aab2d`](https://github.com/kisslinux/repo/commit/f2aab2d) meson: bump to 0.53.1
    - [`86d283c`](https://github.com/kisslinux/repo/commit/86d283c) docs: update
    - [`65bd6ad`](https://github.com/kisslinux/repo/commit/65bd6ad) libevent: move to extra
    - [`72be609`](https://github.com/kisslinux/repo/commit/72be609) falkon: Added optional open-in-mpv extension

## Community

- **Aaron G**:
    - [`d26891b`](https://github.com/kisslinux/community/commit/d26891b) neatvi: update to latest git (#238)

- **Adam Schaefers**:
    - [`863972b`](https://github.com/kisslinux/community/commit/863972b) new package: youtube-dl 2020.01.15
    - [`bf615f9`](https://github.com/kisslinux/community/commit/bf615f9) new package dosfstools 4.1 (#239)
    - [`5f38736`](https://github.com/kisslinux/community/commit/5f38736) new package: strace 4.1
    - [`92e55a6`](https://github.com/kisslinux/community/commit/92e55a6) use git source
    - [`0b0ca02`](https://github.com/kisslinux/community/commit/0b0ca02) rename to youtube-dl-git
    - [`6b6f4f8`](https://github.com/kisslinux/community/commit/6b6f4f8) remove gawk dep from strace
    - [`88f223e`](https://github.com/kisslinux/community/commit/88f223e) fix deps
    - [`eb41e4b`](https://github.com/kisslinux/community/commit/eb41e4b) use "git" version, drop .git suffix
    - [`25e3d86`](https://github.com/kisslinux/community/commit/25e3d86) remove unneccesary
    - [`7beaa36`](https://github.com/kisslinux/community/commit/7beaa36) update chksm and build
    - [`b28870a`](https://github.com/kisslinux/community/commit/b28870a) fix #257
    - [`92b55df`](https://github.com/kisslinux/community/commit/92b55df) pkcs11-helper: bump to 1.26

- **Cem Keylan**:
    - [`d927e17`](https://github.com/kisslinux/community/commit/d927e17) sic-git: new package at git (#233)
    - [`5f18842`](https://github.com/kisslinux/community/commit/5f18842) gnupatch: new package at 2.7.6
    - [`70d390a`](https://github.com/kisslinux/community/commit/70d390a) vimb: new package at 3.6.0 (#244)
    - [`c1ee5f2`](https://github.com/kisslinux/community/commit/c1ee5f2) fix https
    - [`d8ed06d`](https://github.com/kisslinux/community/commit/d8ed06d) gnupatch: remove duplicate package
    - [`1b4c1d3`](https://github.com/kisslinux/community/commit/1b4c1d3) pinentry-dmenu: new package at 0.1.1
    - [`77febc9`](https://github.com/kisslinux/community/commit/77febc9) webkit2gtk: bump to 2.26.3
    - [`bc94b84`](https://github.com/kisslinux/community/commit/bc94b84) vimb: run make with /usr prefix
    - [`981b224`](https://github.com/kisslinux/community/commit/981b224) sic-git: change source
    - [`921b818`](https://github.com/kisslinux/community/commit/921b818) parted: new package at 3.3 (#249)

- **Cédric**:
    - [`2ba8232`](https://github.com/kisslinux/community/commit/2ba8232) New package: tdb at 1.4.3

- **Dylan Araps**:
    - [`6b19de7`](https://github.com/kisslinux/community/commit/6b19de7) imagemagick: bump to 7.0.9-17
    - [`206c82a`](https://github.com/kisslinux/community/commit/206c82a) libxkbcommon: move to official repositories
    - [`9f43304`](https://github.com/kisslinux/community/commit/9f43304) sxiv: bump to 26
    - [`acf4e65`](https://github.com/kisslinux/community/commit/acf4e65) tree: Fix mandir
    - [`2056a5a`](https://github.com/kisslinux/community/commit/2056a5a) dosfstools: move to official repos
    - [`dd3950a`](https://github.com/kisslinux/community/commit/dd3950a) docs: update
    - [`9c4393a`](https://github.com/kisslinux/community/commit/9c4393a) pcre: Fix by @ioraff
    - [`db8c71c`](https://github.com/kisslinux/community/commit/db8c71c) docs: update
    - [`dc5b2c3`](https://github.com/kisslinux/community/commit/dc5b2c3) libevent: move to official repositories.

- **Jonathan Dahan**:
    - [`fea6437`](https://github.com/kisslinux/community/commit/fea6437) osh: bump to 0.7.pre11

- **ioraff**:
    - [`fb14a6a`](https://github.com/kisslinux/community/commit/fb14a6a) doas: fix kiss env (#237)
    - [`5e9655a`](https://github.com/kisslinux/community/commit/5e9655a) doas: fix env and checksums (#240)

- **tristelune1**:
    - [`a1d1d4e`](https://github.com/kisslinux/community/commit/a1d1d4e) New package: fdm at 2.0 (#262)

repository: JamsNJellies/website

repo_name: JamsNJellies/website


text:
Twitter Connection

A python library that allows users to interface with Twitters API, specifically the standard API.
This does not utilize the Enterprise or Premium functionality.

```bash
python3 -m pip install --index-url https://test.pypi.org/simple/ --no-deps twitter_connection
```


text:
---
layout: post
title: "Continuous Integration, Delivery Using Mesos,Jenkins,Docker,Marathon.."
description: "Building a CI/CD pipeline for a scala sample project usning different technologies"
category:
tags: ["CI/CD","docker","jenkins","mesos","marathon","devops","continous integration","continous delivery"]
---
{% seo %}
{% include JB/setup %}
# The History
A few months ago I got through an interview with a company. I was asked to develop a complete CI/CD pipeline for a sample software.

Well, I failed in the interview, because of a lot of things including not doing the task as it should be,So here I am trying to make things go the right way, after researching and studying

# The plan

Here is our planned infrastructure

* Four Mesos nodes
* Docker registry on node1
* Mesos DNS on node1
* Cassandra cluster running on 3 of them using marathon
* Our app running on one node

Here is how the build will go

1. A change is pushed to github
2. Our main job is triggered
3. Main job will trigger Cassandra job
4. Cassandra job will start Cassandra docker for tests
5. Then the Tests job will run
6. All of the four tests will run in parallel
7. Once the tests passes the main job will trigger the build docker job
8. If the build went successfully the main job again will trigger the deployment job which will deploy the app docker using marathon

# The tools
- Jenkins
  - sbt plugin
  - build pipeline plugin
  - docker plugin
- Docker/Docker Registry
- Mesos
- Marathon

# The sample project
- https://github.com/aabed/activator-akka-cassandra

# Get down to business

I will be cutting the process of CI/CD into small jobs, as I was advised during the interview and also based on a small discussion on devopschat

Let's start by provisioning our environment

## Mesos and Marathon
Well, a friend of mine told me about it , so I said let's learn it, and then I though it will be a good practice to deploy using it

### Mesos
Apache Mesos abstracts CPU, memory, storage, and other compute resources away from machines (physical or virtual), enabling fault-tolerant and elastic distributed systems to easily be built and run effectively.
It's the underlying cluster management framework that groups any computing resources you have in one large pool

Mesos uses zookeeper to keep track of the current leader of the master servers.

### Zookeeper
ZooKeeper is a centralized service for maintaining configuration information, naming, providing distributed synchronization, and providing group services.

### Marathon
 A cluster-wide init and control system for services in cgroups or Docker containers
 It's job is to run your jobs on the cluster nodes provided by mesos in an init fashion to make sure your service is running and fault-tolerant,so if a job is killed it will be spawned just like the usual init system but this time on the scale of cluster so it will start on whatever node available or based on your settings

 So I tell marathon I want to run "nc -l 8080" for example, it will ask mesos for resources, and then run the command on the node that have enough resources, if I went to that node and killed the job, marathon will start it again

 Marathon accepts the job definition through either it's gui or through it's REST API

 An example will be

 {% highlight json %}
 {
  "id": "outyet",
  "cpus": 0.2,
  "mem": 20.0,
  "instances": 1,
  "constraints": [["hostname", "UNIQUE", ""]],
  "container": {
    "type": "DOCKER",
    "docker": {
      "image": "outyet",
      "network": "BRIDGE",
      "portMappings": [
        { "containerPort": 8080, "hostPort": 0, "servicePort": 0, "protocol": "tcp" }
      ]
    }
  }
}
{% endhighlight %}

then you use curl or rest client to send that JSON to the API URI in my case it was
{% highlight bash %}
curl -X POST http://<IP_ADDRESS>:8080/v2/apps -d @/vagrant/outyet.json -H "Content-type: application/json"
{% endhighlight %}

 I started learning from here [https://open.mesosphere.com/advanced-course/introduction/](https://open.mesosphere.com/advanced-course/introduction/)

 And I ended up building my test environment using this [https://open.mesosphere.com/advanced-course/recreating-the-cluster-using-ansible/](https://open.mesosphere.com/advanced-course/recreating-the-cluster-using-ansible/)
 You can check them if you want to build your own lab

## Mesos DNS

Mesos DNS provides dynamic DNS naming for services running on a Mesos cluster, Sounds good for service discovery and that's how I will use it

Go to your cluster node where you want to install mesos-DNS

{% highlight bash %}
sudo yum -y install golang git bind-utils
mkdir ~/go
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin
go get github.com/tools/godep
go get github.com/mesosphere/mesos-dns
cd $GOPATH/src/github.com/mesosphere/mesos-dns
godep go build .
{% endhighlight  %}

Modify the config.json to use your zookeeper ip and change the port from 8053 to 53 so it looks like this:
{% highlight json %}

{
  "zk": "zk://<IP_ADDRESS>:2181/mesos",
  "masters": ["<IP_ADDRESS>:5050"],
  "refreshSeconds": 60,
  "ttl": 60,
  "domain": "mesos",
  "ns": "ns1",
  "port": 53,
  "resolvers": ["<IP_ADDRESS>"],
  "timeout": 5,
  "listener": "<IP_ADDRESS>",
  "SOAMname": "root.ns1.mesos",
  "SOARname": "ns1.mesos",
  "SOARefresh": 60,
  "SOARetry":   600,
  "SOAExpire":  86400,
  "SOAMinttl": 60,
  "dnson": true,
  "httpon": true,
  "httpport": 8123,
  "externalon": true,
  "recurseon": true
}
{% endhighlight  %}

{% highlight bash %}

cp config.json.sample config.json

{% endhighlight  %}

In the Marathon GUI, create a new launcher named dns
and submit that command into it
don't forget to modify the path to your installation
{% highlight bash %}

sudo /home/vagrant/go/src/github.com/mesosphere/mesos-dns/mesos-dns -v=1 -config=/home/vagrant/go/src/github.com/mesosphere/mesos-dns/config.json
{% endhighlight  %}

## Docker registry

I started a docker registry on mesos using marathon by applying the following JSON

{% highlight json %}
{
  "id": "registry",
  "cpus": 0.2,
  "mem": 64,
"constraints":[[ "hostname","LIKE","node1" ]],
  "instances": 1,
  "container": {
    "type": "DOCKER",
    "docker": {
      "image": "registry:2",
      "network": "HOST"
    }
  }
}
{% endhighlight %}

So my registry will be at registry.mesos.marathon:5000

## Cassandra cluster

As the project implies we need Cassandra so we will start a Cassandra cluster and provision it for our first run
I will do that step manually because it's a one time job
replace the IP with your marathon host
this will automatically create the DNS record cassandra.marathon.mesos

***Note***: Modify ``` activator-akka-cassandra/src/main/resources/application.conf ```
to point to whatever cassandra host or cluster you are running

{% highlight bash %}

curl -X POST  http://<IP_ADDRESS>:8080/v2/apps/  -H "Content-type: application/json" -d '{
  "id": "cassandra",
  "cpus": 0.5,
  "mem": 256,
"constraints":[
[ "hostname","LIKE","node[1-3]" ],
["hostname", "UNIQUE"]
],

"ports": [
        7000
    ],

  "instances": 3,
  "container": {
    "type": "DOCKER",
    "docker": {
      "image": "cassandra",
"parameters": [
        { "key": "env", "value": "CASSANDRA_SEEDS=node1,node2,node3" }
      ],

"forcePullImage": true,
      "network": "HOST"
    }
}

}'
{% endhighlight  %}

Provision the Cluster with the required data and create the keyspaces
{% highlight bash %}
cd activator-akka-cassandra/src/data
/opt/apache-cassandra/bin/cqlsh cassandra.marathon.mesos -f keyspaces.cql
/opt/apache-cassandra/bin/cqlsh cassandra.marathon.mesos -f tables.cql -k akkacassandra
/opt/apache-cassandra/bin/cqlsh cassandra.marathon.mesos -f words.cql -k akkacassandra

{% endhighlight %}

## Installing Jenkins plugins

Search and install the following plugins

- [https://wiki.jenkins-ci.org/display/JENKINS/Docker+Plugin](https://wiki.jenkins-ci.org/display/JENKINS/Docker+Plugin)
- [https://wiki.jenkins-ci.org/display/JENKINS/sbt+plugin](https://wiki.jenkins-ci.org/display/JENKINS/sbt+plugin)
- [https://wiki.jenkins-ci.org/display/JENKINS/Git+Plugin](https://wiki.jenkins-ci.org/display/JENKINS/Git+Plugin)

## Configuring Jenkins

**Open Jenkins configuration page**

**Locate the Cloud secion in order to configure docker**

to enable docker api interface on your host enable
edit your /etc/init/docker or /etc/init/docker.io.conf based on your installation

and update the DOCKER_OPTS variable to the following

```DOCKER_OPTS='-H tcp://<IP_ADDRESS>:4243 -H unix:///var/run/docker.sock'```

**Now let's locate the Sbt section and configure your sbt installation**

# Jenkins Jobs

## Starting Cassandra Docker for our application for testing

**Create a new item, name it and chose Freestyle project**

**Add build step and chose Start/Stop Docker Containers**

**Configure the docker section to start the container and bind the required ports to the host**

Well you can use some service discovery tools, but come on we are just building a project

**Add build step and chose Execute Shell**

**Sleep 10 seconds waiting for the cassandra to fully boot**

## TweetActorSpec

**Add our repo**

**Configure Sbt plugin to run the test**

## TweetScannerActorSpec

Let's just copy TweetActorSpec and modify the sbt action

**Repeat the same steps for**

- TweetScanActorIntegrationSpec
- TweetActorsPerformanceSpec

## Tests Job

Let's wrap the tests tasks in a one big task
as we did many times so far start by creating a freestyle job

Now let's run the tests in parallel by typping their names comma separated

## Project's Build job

We will deliver our app in the form of a docker container
So let's first prepare our ``` build.sbt ``` to build out docker container and publish it to our private docker registry
here is the part that we care for in our build.sbt

{% highlight bash %}
maintainer in Docker := "Ahmad Aabed<EMAIL_ADDRESS>// The maintainer that will be added to your Dockerfile

dockerRepository := Some("registry.marathon.mesos:5000") // Domain name of your docker registry

dockerUpdateLatest := true // Overriding the latest version with the current build

dockerBaseImage := "java"
{% endhighlight %}

Alright, building this with sbt should be a piece of cake
Create a new freestyle job and add a build step **(Build using sbt)** then configure the sbt section to build and publish the docker image

## Deploying our project's docker image
Create a new job

Add build step (Execurte shell)
Then use marathon API to deploy your new docker to your mesos cluster
{% highlight bash %}
curl -X PUT  http://<IP_ADDRESS>:8080/v2/apps/activator  -H "Content-type: application/json" -d  '{
  "id": "activator",
  "cpus": 0.5,
  "mem": 256,
"constraints":[[ "hostname","LIKE","node[2]" ]],

  "instances": 1,
  "container": {
    "type": "DOCKER",
    "docker": {
      "image": "registry.marathon.mesos:5000/activator-akka-cassandra",

"forcePullImage": true,
      "network": "HOST"
    }
},
"upgradeStrategy": {
    "minimumHealthCapacity": 1

    }

}'
{% endhighlight %}

## Main Job

Now let's configure our main job that will trigger all the small jobs for to build

Create a new item, name it and chose Freestyle project

You will be taken to the configuration page
in the **Source Code Management** section
add the repo of the project,chose the branch to build, and you might add credentials if this is a private repo

On the **Build Triggers** section chose
Build when a change is pushed to GitHub

This how you make sure that when a change is accepted and merged in the branch you wish to build the whole process will start

Let's get our main job to trigger ther other tasks and run the tests in parallel

Chose add build step and chose Trigger/call builds on other projects

Add another build step which will provision the cassandra database with the required tests data

It's all ready for the tests to run

After the tests pass successfully we will build our project artifact which is in this case the a docker container

And finally the job that will deploy our new app image
Choose add post-build action and chose **Build other projects (manual step)** because you know, maybe you don't want to deploy that version right now so it will wait for a manual triger

Then choose the job that will deploy the new docker image

### Links

[https://wiki.jenkins-ci.org/display/JENKINS/Build+Pipeline+Plugin](https://wiki.jenkins-ci.org/display/JENKINS/Build+Pipeline+Plugin)

[https://docs.docker.com/registry/deploying/](https://docs.docker.com/registry/deploying/)

[https://open.mesosphere.com/advanced-course/building-and-running-mesos-dns/](https://open.mesosphere.com/advanced-course/building-and-running-mesos-dns/)

[https://mesosphere.github.io/marathon/docs/deployments.html](https://mesosphere.github.io/marathon/docs/deployments.html)


text:
There are 2 modes:

**Caregiver Mode**:
You need to create a caregiver account to use the app. Caregivers can create and assign children profiles for kids they will work with.

**Child Mode**:
This mode is designed for a child who performs tasks created by the caregiver.


text:
# RLlibPlayground
First playground for RLlib for CS294-112 demo in Lecture 21

## 1. Preparation of RLlib installation
Reference: https://ray.readthedocs.io/en/master/rllib.html#installation
```bash
pip install 'ray[rllib]'
# debugging purpose
pip install setproctitle
# bokeh 1.0.0 is incompatiable version
pip install bokeh==0.13.0
```
Version 0.6.0 for current experiment

## 2. Startup code
Reference: page 39 - 42 of http://rail.eecs.berkeley.edu/deeprlcourse/static/slides/lec-21.pdf

## 3. Issues:

* bokeh can't visualize issue : children not iterate
* pg.PGAgent with multiagent-env can't work


text:
# CS :: PLT :: Language Features :: Software design tradeoffs

- Software design tradeoffs
- Programming language design tradeoffs
- Programming language design (PLD)
- PLD tradeoffs
- PLD patterns

Life is a series of trade-offs, let alone programming language design (PLD). In fact, in PLD, but also generally in CS, tradeoffs are a tool of the trade.

## Trade-the-fuck-off

A tradeoff (trade-off) is a situational decision that stems from changes made to one quality at the expence of another. Related properties come as inter dependent n-tuples, generalizations of the elementary 2-tuple i.e. a pair of dependent properties or opposite qualities of one property.

Often, a property comes as a pair of correlated but opposite qualities or quantities (mhuh huh tities mhuh hah).

More generally, a property with a tradeoff aspect may be represented as a set of correlated values, where a change in one value is immediately reflected in the other values in the set. For example, any point on a sphere consists of 3 such correlated values, x, y and z, that define a point in 3d space *constrained* to lie somewhere on the sphere (sphere to a _ is what a circle is to a disk).

A unit circle, `x² + y² = 1`, has two correlated values, `x` and `y` that make up each point thatlies on the circle (circumference). A change in `x` is reflected in `y` (in the opposite way)
- at   0ᵒ `( 1, 0)`
- at  45ᵒ `( 0, 1)`
- at  90ᵒ `( 0, 1)`
- at 180ᵒ `(-1, 0)`
- at 270ᵒ `( 0,-1)`
- at 360ᵒ, `(1, 0)`, i.e. `x` is back to 1 and `y` to 0

r = 1
  x² + y² = 1
@ 0ᵒ
  1² + 0² = 1
@ 45ᵒ
  x² + y² = 1
  x = √(1 - y²)
  y = √(1 - x²)
@ 90ᵒ
  0² + 1² = 1

**impedance mismatche**

A unit sphere is defined by `x² + y² + z² = 1`.

- opposing polarities: increasing one decreases the other property
- opposing polarities: de/increasing one at the expence of another (others)

diminishing or losing one quality, quantity, or property of a set or design in return for gains in other aspects.

In simple terms, a tradeoff is where one thing increases, and another must decrease. Tradeoffs stem from limitations of many origins.

Tradeoffs also commonly refer to different configurations of a single item, such as the tuning of strings on a guitar to enable different notes to be played, as well as an allocation of time and attention towards different tasks. The concept of a tradeoff suggests a tactical or strategic choice made with full comprehension of the advantages and disadvantages of each setup.

A space-time trade off or time-memory trade-off in computer science is a case where an algorithm or program trades increased space usage with decreased time. Here, space refers to the data storage consumed in performing a given task (RAM, HDD, etc), and time refers to the time consumed in performing a given task (computation time or response time).

In software engineering, architecture tradeoff analysis method (ATAM) is a risk-mitigation process used early in the software development life cycle.

In statistics and machine learning, the bias-variance tradeoff is the property of a model that the variance of the parameter estimated across samples can be reduced by increasing the bias in the estimated parameters.

A detection error tradeoff (DET) graph is a graphical plot of error rates for binary classification systems, plotting the false rejection rate vs. false acceptance rate. The x- and y-axes are scaled non-linearly by their standard normal deviates (or just by logarithmic transformation), yielding tradeoff curves that are more linear than ROC curves, and use most of the image area to highlight the differences of importance in the critical operating region.

* General design criteria
  - generality, range of applicability
  - reliability
    - robustness vs brittleness
  - cost
    - production cost
    - maintainance cost
  - maintainability
  - portability
    - implementability
    - machine independence
  - efficiency
  - simplicity
  - readability
    - user documentation of programs
    - block comments
    - embeddable (in)line comments
  - debugability
    - Clear and concise (info, diagnostic, warning, error) messages
  - discoverability (of APIs)

## PLD dimensions

* Factors of PLD
  - Modifiability
    change the way the program works later
  - Extensibility
    add/remove functionality
  - Testability
    structuring code to facilitate the ancient art of unit test
  - Verifiability
    structuring code to facilitate the modern art of mathematical proof that it works correctly
- Performance
- Scalability
  How well does the system scale to lots of traffic (Hint: Scalability is not the same as performance, although improved performance usually improves scalability.)
- Usability
  How easy is it for the end-user to use and leverage the resulting system
- Understandability
  How easy is it for developers to understand and leverage the system This is especially important for APIs. (Barry Jaspan referred to this as DX at one point.)
- Maintainability
  All software requires updating and bug-fixing. How easy is it to do that
- Expediency
  How long does it take to actually write the damned thing

* Programming principles

## Refs

license: Unlicense


text:
# image-pixels [![Build Status](https://travis-ci.org/dy/image-pixels.svg?branch=master)](https://travis-ci.org/dy/image-pixels) [![unstable](https://img.shields.io/badge/stability-unstable-green.svg)](http://github.com/badges/stability-badges)

Get pixel data for a given URL, path, buffer, canvas, image or any other source. Intented for image based tests, first of all.

## Usage

[![$ npm install image-pixels](http://nodei.co/npm/image-pixels.png?mini=true)](http://npmjs.org/package/image-pixels)

```javascript
var pixels = require('image-pixels')

// load single source
var {data, width, height} = await pixels('lena.png')

// load multiple sources in parallel
var [a, b, c] = await pixels.all([
	'./a.jpg',
	{ source: './b.png', cache: false },
	canvas
])
```

## API

### `let {data, width, height} = await pixels(source, options?, cb?)`

Loads pixel data from a `source` based on options. Possibly provide a callback for old-style async calls. Function returns a promise that gets resolved once the source is ready, so that is handy for await call.

In browser the result is `ImageData` object to easily output to context:

```js
document.body.appendChild(document.createElement('canvas'))
	.getContext('2d')
	.putImageData(await pixels('lena.png'))
```

#### `source`

Type | Meaning
---|---
`url`, `path` | Relative/absolute path.
`data-uri`, `base64` | String with encoded or raw pixel data. Raw data requires `options.shape`. Encoded data may require `options.type` to skip mime type detection.
`HTMLImageElement`, `SVGImageElement`, `HTMLVideoElement`, `CSSImageValue` | DOM/SVG image elements.
`Image`, `ImageData`, `ImageBitmap` | Browser image data containers.
`File`, `Blob` | Encoded image data.
`Canvas`, `Context2D` | 2D drawing context, browser-only.
`WebGLContext` | GL context, node/browser.
`Buffer`, `ArrayBuffer`, `Uint8Array`, `Uint8ClampedArray` | Raw or encoded pixel data. Raw data requires `options.shape`. For encoded data `options.type`skips mime type detection. Supported formats: `png`, `bmp`, `gif`, `jpg`.
`Float32Array`, `Float64Array`, `Array`, `Array` of arrays | Float pixel data with values from `0..1` range.
`Promise` | Promise expecting resolution to an image source.
`ndarray` | [Ndarray](https://ghub.io/ndarray) container with pixel data, compatible with [get-pixels](https://ghub.io/get-pixels).
options object | If `source` argument is omitted, it is taken from `options.source`, useful for `pixels.all`.

#### `options`

Option | Meaning
---|---
`source` | Source data, one from the list above. Applicable for multiple sources.
`shape` or `width`/`height` | Input raw data shape `[width, height]`.
`type`/`mime` | Mime type, optional for raw data to skip detection.
`clip` | Clipping rectangle, `[left, top, right, bottom]` or `{x?, y?, width?, height?}`.
`cache` | Cache loaded data for the source/url for faster subsequent fetch.

### `let list|dict = await pixels.all(list|dict, options?)`

Load multiple sources or dict of sources in parallel. `options` can provide common for every source options.

```js
// load font atlas sprite dict
var atlas = require('font-atlas')({chars: 'abc', step: [10, 10], shape: [20, 20]})

var dict = await pixels({
	a: {clip: [0,0,10,10]},
	b: {clip: [10,0,10,10]},
	c: {clip: [0,10,10,10]}
}, {cache: true, source: atlas})
```

## Related packages

* [image-save](https://ghub.io/image-save) − save image/pixel data to a file, canvas or array.
* [image-equal](https://ghub.io/image-equal) − assert image with baseline.

## Similar packages

* [get-pixels](https://ghub.io/get-pixels) − get ndarray with pixel data, limited set of sources.
* [ndarray-from-image](https://github.com/thibauts/ndarray-from-image) − get-pixels with dtype.
* [get-image-pixels](https://ghub.io/get-image-pixels) − get pixel data for Canvas/Image/Video elements, browser-only.
* [get-image-data](https://ghub.io/get-image-data) − get image data for Canvas/Image/Video elements, browser-only.
* [readimage](https://ghub.io/readimage) − read pixels data into an array in sync fashion in node.

## License

© 2018 Dmitry Yv. MIT License.

repository: dy/image-pixels

repo_name: dy/image-pixels


text:
---
layout: sidebar-right
title: "Celebrate the 40th anniversary of Ipswich Town's FA Cup win with our best books about the Blues"
date: 2018-05-04
author: suffolk-libraries
category: articles
excerpt: "Sunday 6 May is the 40th anniversary of Ipswich Town's FA Cup victory. We've picked out some great books to mark the occasion."
featured-image: /images/featured/featured-ipswich-town-books.jpg
featured-alt: "Ipswich Town: a history, Bobby Robson: farewell but not goodbye: my autobiography, Ipswich Town FC: the 1970s: the glory years begin"
breadcrumb: articles
---

![Ipswich Town: a history, Bobby Robson: farewell but not goodbye: my autobiography, Ipswich Town FC: the 1970s: the glory years begin](/images/featured/featured-ipswich-town-books.jpg)

Sunday 6 May is the 40th anniversary of Ipswich Town's FA Cup victory. We've picked out some great books to mark the occasion.

Want to reminisce about the Blues with like-minded fans? Have a look at [our Sporting Memories groups](/events-activities/sporting-memories/).

## [Ipswich Town FC: the 1970s: the glory years begin, by Terry Hunt](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=495922)

> "The 1970s was the greatest decade in the history of Ipswich Town Football Club, and now all the memories have been encapsulated in one book. The book includes more than 300 photographs from the archives of the East Anglian Times and Evening Star newspapers."

## [On the Map: Sir Bobby Robson: the Ipswich Town years, by Nick Fuller](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=553095)

Bobby Robson was manager of Ipswich Town during the most successful period in their history. This book takes us back to that time.

## [Bobby Robson: farewell but not goodbye: my autobiography, by Bobby Robson & Paul Hayward](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=609719)

> "Sir Bobby Robson, national icon and widely admired footballing legend, tells his life story - from his playing days with Fulham and West Brom in the 1950s and 60s, his 20 England caps to his management career over the past 38 years. He also remembers epic incidents from the 'Hand of God' to the tears of Gazza."

By 2009 Bobby Robson had left Ipswich and gone on to success with England and in Europe. This autobiography covers his later career but also touches on his time at Ipswich Town.

## [The Beat: the autobiography of Kevin Beattie, by Kevin Beattie](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=587668)

Kevin Beattie was one of the stars of the 1978 FA Cup team but his career was wrecked by injury. The Beat tells his story.

## [Ipswich Town Football Club, by Tony Garnett](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=238525)

This book in the Images of Sport series tells the full story of Ipswich Town, including many pictures of their greatest moments.

## [Wark On, by John Wark](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=551564)

This book concentrates on Wark’s first spell at Ipswich and his time at Liverpool. It also includes tales from his time on the film set of Escape to Victory.

## [Got, Not Got: the lost world of Ipswich Town, by Derek Hammond & Gary Silke](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=1822254)

This is the kind of book you can dip into at will. You will find heroes of the past and pictures of big match programmes, football cards and petrol freebies covering the glory years and the 1978 Cup win.

## [Ipswich Town: a history, by Susan Gardiner](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=1469916)

> "This book presents the history of Ipswich Town Football Club, tracing some of the many ways it has changed and developed over time."

repository: suffolklibraries/sljekyll

repo_name: suffolklibraries/sljekyll


text:
# Robot Dance

This project was part of General Assembly prework.

It was fun to create the Robot using HTML and CSS and animate the party with CSS Animations, Transitions and jQuery.

## Future Improvements

1. Add Disco music
2. Make the robot dance in diferent directions

## Download instructions

To fork this repo, see instructions [here](https://docs.github.com/en/get-started/quickstart/fork-a-repo)

repository: xiomara-masmela/robot-dance

branch_name: refs/heads/main

repo_name: xiomara-masmela/robot-dance


text:
---
layout: post100
title:  Space Persistency
categories: XAP100NET
parent: programmers-guide.html
weight: 800
---

{% section %}
{% column  width=10% %}
![space-document.png](/attachment_files/subject/persistence.png)
{% endcolumn %}

{% column width=90% %}
XAP provides advanced persistency capabilities for the space architecture.
{% endcolumn %}
{% endsection %}

{%fpanel%}

[Overview](./space-persistency.html){%wbr%}
XAP persistency overview.

[Direct persistency](./direct-persistency.html){%wbr%}
Direct persistency mode support Read-Write Through.

[NHibernate External Data Source](./hibernate-space-persistency.html){%wbr%}
A walkthrough of a common scenario for using the GigaSpaces NHibernate External Data Source.

[Initial Data Load](./space-persistency-initial-load.html){%wbr%}
Space data source initial Load pre-loads the space with data before it is available for clients.

[Asynchronous Persistence](./asynchronous-persistency-with-the-mirror.html){%wbr%}
Reliable Asynchronous Persistency (Mirror)

[Transient Entries](./transient-entries.html){%wbr%}
How to specify that some objects in a persistent space should not be saved to the persistent storage.

[Advanced Concepts](./space-persistency-advanced-topics.html){%wbr%}
Space Persistency advanced topics such as advanced operations, tuning, troubleshooting, and limitations.

{%endfpanel%}

repository: barakb/gigaspaces-wiki-jekyll

extension: markdown

gha_language: HTML

repo_name: barakb/gigaspaces-wiki-jekyll


text:
What happens to the layout when you resize the screen to less than 550 px?
---

The site content enlarges again but is reformatted to only take up a single column layout, suitable for mobile devices and small browser windows.

How do you think that works?
---

The resizing of all of site content is achieved through the use of media queries. Once the browser detects that its width is smaller than 550px, it loads values best formatted for the browser width. These values are all preset by the designer/developer in the CSS file.

repository: marcus-crane/junkcode

repo_name: marcus-crane/junkcode


text:
# serverless

## Tools

This project use [serverless] to create cloud services.
To install NodeJS use [nvm] ([nvm-windows]).

## Setup

### AWS account

Prepare AWS user to create and deploy your services.
You can use [this gist](https://gist.github.com/ServerlessBot/7618156b8671840a539f405dea2704c8) to create a policy for that user. Additional permissions might be needed:

- `cloudformation:DeleteChangeSet`
- `logs:TagLogGroup`

Configure serverless to work with [AWS profiles].
You can [set default profile](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html#using-profiles) with:

```
export AWS_PROFILE=profile-name
```

### Usefull serverless commands

```
sls deploy
sls info
sls remove
```

## Authentication

If needed, authentication can be based on [serverless-authentication-boilerplate] project licensed under [MIT].

[serverless]: https://github.com/serverless/serverless
[nvm]: https://github.com/nvm-sh/nvm
[nvm-windows]: https://github.com/coreybutler/nvm-windows
[aws profiles]: https://serverless.com/framework/docs/providers/aws/guide/credentials/#using-aws-profiles
[serverless-authentication-boilerplate]: https://github.com/laardee/serverless-authentication-boilerplate
[mit]: https://github.com/laardee/serverless-authentication-boilerplate/blob/master/LICENSE.txt

repository: wiiitek/serverless

repo_name: wiiitek/serverless


text:
For this data preparation, the approach shared in the following resource is used:

https://github.com/daniel-codes/hospital-los-predictor

1- Download MIT MIMIC-III from:

https://physionet.org/content/mimiciii-demo/1.4/

2- We only need following CSV files and place them in the data folder:

_ADMISSIONS.csv_

_DIAGNOSES_ICD.csv_

_ICUSTAYS.csv_

_PATIENTS.csv_

3- execute:
> python Pr_Tensorization_v0.py


text:
# Lifecycles

Now that we have some environments, it's time to set the order we will use to deploy our applications.  Lifecycles let you define a promotion path for your applications.  You can also use them to automate deployments and set retention policies.

Early in your Octopus journey, you likely won't even know that lifecycles are there.  The default lifecycle will handle most cases for small or straight-forward configurations. Let's talk about the default lifecycle, and why we recommend updating it early on.

## The Default Lifecycle

Navigate to **Library > Lifecycles**, and you'll see a single lifecycle called "Default Lifecycle." Let's take a look at ours.

![](images/chapter002-default-lifecycle.png)

We can see the environments we created earlier are listed in order. These are phases created implicitly by the default lifecycle. By convention, the default lifecycle will create one phase per environment.  Those phases will be in the same order the environments are listed on the environments page. If we view the default convention, we can see this information in the phases section.

![](images/chapter002-default-lifecycle-view.png)

When we add a new environment, it will be automatically added to the default lifecycle. This also means that if we reorder the environments, it will change the order of the phases in the default lifecycle. In some cases, this can be a good thing, but in others, it can be a liability. Let's look at what phases are and how we can use them to explicitly configure the default lifecycle to an explicit configuration.

## Phases

A phase represents a stage in your deployment lifecycle. You deploy to phases in order, and you must have a successful deployment in one phase to move to the next phase. For example, there must be a successful deployment to the Development phase before you can proceed to the Testing phase. Phases can also include multiple environments, but we're going to focus on single environment phases in this chapter.

Let's create a phase for our lifecycle. We will give it the name "Development" and add the Development environment to the phase.

> ![](images/professoroctopus.png) Phase names usually match the environment it contains. While this is a good practice, it is not a rule.

We'll leave the radio button set to the default `manually deploy` on the add environment screen.  We'll also leave the `Required to progress` and `Retention policy` set to the default values.  We cover these later.

![](images/chapter002-default-lifecycle-add-development-phase.png)

Let's repeat the process to create phases for Testing, Staging, and Production.

![](images/chapter002-default-lifecycle-explicit-phases.png)

Now we have an explicit default lifecycle for deploying our applications.

## Other Lifecycles

### Hotfix Lifecycle

What happens when there's a critical bug in production, and you need to deploy a fix fast? Deploying to Development and Testing environments might take too much time.  But you still need to follow good deployment practices and validate the change before pushing to production. We often see hotfixes go directly to a Staging environment and then to Production after testing.

For this, we recommend creating a hotfix lifecycle. Our hotfix lifecycle will only have two phases, Staging and Production.  Yours might be different to account for your internal policies and how your team decides to handle hotfixes. In a later chapter, we'll look at how to configure your project to use this lifecycle in addition to the default. For now, we're content setting it so that it's ready to go later.

### Infrastructure as Code Lifecycle

We didn't include SpinUp, TearDown, or Maintenance in the default or hotfix lifecycles. We are going to create a lifecycle for our Infrastructure as Code projects that include SpinUp and TearDown. We'll cover the use of this lifecycle later, but for now, create the lifecycle with a SpinUp and TearDown phase. There is a twist with the SpinUp phase as we're going to make it an optional phase.

#### Optional Phases

One of the settings when creating a phase is the `Required to progress` setting.  The default value is `All must complete`.  All environments in the phase must be deployed to successfully before we can promote to the next phase.

The second choice is to set a minimum number of environments that must be successfully deployed to before promoting to the next phase. This is handy for cases where you have two or three QA environments, but only one is used for each release of your application. You can configure your Testing phase so that it contains three environments, but only one needs to be successful before you can promote to the Staging environment.

The last choice is to set the phase to be entirely optional. The phase can be skipped, and you can deploy directly to the next phase after it.

Because errors and issues can arise when building up infrastructure, especially when setting up the IaC scripts for the first time, we want the option to deploy directly to TearDown so that we can start fresh. As you're setting up these phases, make the SpinUp phase optional.

### Maintenance Lifecycle

The last lifecycle we created was a Maintenance lifecycle. The Maintenance lifecycle and environment will be used for projects that run maintenance tasks such as backups or software upgrades. It can be used for any tasks that you want to run regularly with the same benefits that Octopus provides for your application deployments.

Even though we have grouped the machines for these tasks in the Maintenance environment, you could also split them up into the Development, Testing, Staging, and Production environments if you want to run the tasks for machines in those environments at different times.

Whichever you choose, you know the steps now, so go ahead and create that lifecycle with the phases that you want.

## Conclusion

![](images/chapter001-alllifecycles.png)

In this chapter, we configured our default lifecycle. We also created some auxiliary ones to set ourselves up for future success. In the next chapter, we'll walk through retention policies and how to keep your server from being cluttered with old releases and packages.

repository: OctopusDeploy/OptimumSetupBook

repo_name: OctopusDeploy/OptimumSetupBook


text:
## WinNetworkBatch
Use Windows Batch File to change network interface.

## Why
I usually work on Windows PC. Sometimes I need to use Wi-Fi to connect to another Linux PC. I must disable my Lan network and enable my Wi-Fi network manually. When colleages ask me some questions, I must change my network interface again. This is a boring job. So I decide to use Windows Batch File to simplify my work. Jus for fun.

## Windows 10 (I only have Chinese Windows 10, please image it!)
The 'netsh' command needs administrator privilege to use it. I use steps below to chain my steps smoothly.
1. Add shortcut to my batch file.
2. Click mouse right botton to 'property' -> 'shortcut' -> 'advanced options'.
3. Then check 'Run as administrator'.


text:
# Overview

- https://en.wikipedia.org/wiki/Petroleum
- Petroleum, also known as crude oil, is a naturally occurring,
  yellowish-black liquid found in geological formations beneath Earth's
  surface.
    + It is commonly refined into various types of fuels through the
      process called fractional distillation.
    + https://en.wikipedia.org/wiki/Fractional_distillation
        * Temperature from high to low: asphalt, paraffin wax,
          lubricating oil; fuel oil; diesel oil; gasoline (petrol);
          natural gas


text:
# generator-simple-html

> A generator for simple html sites, powered by [Yeoman](http://yeoman.io)

This generator was for demonstration purposes. It's not intended to be used in a real project.

## Grunt tasks

There is one main task available:

```
grunt serve
```

This task will run a server for you on http://localhost:9000.

LESS files in `/less` will automatically be compiled into `www/css/main.css`. *If you create additional LESS files, make sure you `@import` them in `less/main.less`.

You can also run `grunt less` to compile the LESS to CSS if you're not using the server.

## License

MIT

repository: tcrammond/generator-simple-html

repo_name: tcrammond/generator-simple-html


text:
---
layout: layout.pug
navigationTitle:  Logging
title: Logging in Kibana
menuWeight: 30
beta: false
excerpt: Learn how to explore Dispatch logs in Kibana
---

# Dispatch Logging in Kibana

In Konvoy clusters, logs from Dispatch components and tasks can be found in Kibana.

## Dispatch Component logs

The Dispatch CLI supports viewing the logs of the Pipelines Controller and Event Sink components.

To view the logs for `pipelines-controller`:

```bash
dispatch debug pipelines-controller
```
Log levels can be adjusted by setting them in Deployment object for controller. Controller output is structured by default and contains information about the pipeline launches.

To view the logs for `event-sink` (which is responsible for listening and processing Git repo events):

```bash
dispatch debug event-sink
```

In order to view the Dispatch component logs from Kibana UI, query syntax can be used. For example:

* To view `event-sink` pod logs:
```json
{
  "query": {
    "match": {
      "kubernetes.labels.component": {
        "query": "event-sink",
        "type": "phrase"
      }
    }
  }
}
```

* To view the `repository-controller` pod logs:
```json
{
  "query": {
    "match": {
      "kubernetes.labels.component": {
        "query": "repository-controller",
        "type": "phrase"
      }
    }
  }
}
```

Component logs can be filtered by the following labels:

| Label | Example Value |
| ----- | ------------- |
| kubernetes.annotations.cni_projectcalico_org/podIP | <IP_ADDRESS>/32 |
| kubernetes.container_name | repository-controller |
| kubernetes.docker_id | 8d2e195a4487afa384e47b98ec27fb7b2c12c3431980ed71563fd0802543508e |
| kubernetes.host | ip-10-0-131-65.us-west-2.compute.internal |
| kubernetes.labels.component | repository-controller |
| kubernetes.labels.pod-template-hash | 6c6f675c9c |
| kubernetes.namespace_name | dispatch |
| kubernetes.pod_id | 0c84769a-25aa-497b-ba16-986969a694af |
| kubernetes.pod_name | dispatch-kubeaddons-repository-controller-6c6f675c9c-dqs7n |
| message | 2019-11-21T14:28:07.128Z DEBUG controller-runtime.controller Successfully Reconciled {"controller": "repository-controller", "request": "dispatch/gpaul-cicd-hello-world-9lb6b"} |
| stream | stderr |

## Dispatch pipeline and task logs

### Using the CLI to view the logs

In order to list pipeline runs:

```bash
dispatch ci list pipelineruns
```

The above command accepts an optional `namespace` flag to print pipelines from a specific namespace.

To list the tasks in a pipeline run (also prints the status of the task):

```bash
dispatch ci list tasks --pipelinerun <pipelineRunId>
```

Both the above commands accept `--json` flag for emitting JSON output for automation purposes

To view the logs of a task in a pipeline (or the pipeline logs if the pipeline is still active):

```bash
dispatch ci logs --pipelinerun <pipelineRunId> --task <taskName>
```

### Using the Kibana dashboard to view the logs

You can also view the task logs for individual tasks and pipelines in Kibana. For example:

If you have CI configured for a repository called `cicd-hello-world` under the
`your-user` GitHub account, and you create a PR from a branch called
`modify-readme`, you can find the output generated by the `build` task using the
following query:

```json
{
  "query": {
    "bool": {
      "must": [
        {
          "match_all": {}
        },
        {
          "match_phrase": {
            "kubernetes.labels.build": {
              "query": "modify-readme"
            }
          }
        },
        {
          "match_phrase": {
            "kubernetes.labels.tekton_dev/task": {
              "query": "build"
            }
          }
        },
        {
          "match_phrase": {
            "kubernetes.labels.owner": {
              "query": "your-user"
            }
          }
        },
        {
          "match_phrase": {
            "kubernetes.labels.repository": {
              "query": "cicd-hello-world"
            }
          }
        }
      ]
    }
  }
}
```

Task logs are annotated with the following labels, which can all be queried in Kibana:

| Label | Example Value |
| ----- | ------------- |
| kubernetes.annotations.cni_projectcalico_org/podIP | <IP_ADDRESS>/32 |
| kubernetes.annotations.tasks | test,build |
| kubernetes.annotations.tekton_dev/ready | READY |
| kubernetes.container_name | step-build-and-push |
| kubernetes.docker_id | c7561c4dc2425703e743d02d33b04acd21da32c2c479ef2dfd10aa9a64e14c36 |
| kubernetes.host | ip-10-0-131-119.us-west-2.compute.internal |
| kubernetes.labels.app_kubernetes_io/managed-by | tekton-pipelines |
| kubernetes.labels.build | gpaul-patch-2 |
| kubernetes.labels.commit | ca9249b5645808228928b83269676f42f2b19d9 |
| kubernetes.labels.owner	gpaul |
| kubernetes.labels.repository | cicd-hello-world |
| kubernetes.labels.tekton_dev/pipeline | gpaul-cicd-hello-world-gpaul-patch-2-cca9249-rpqsv |
| kubernetes.labels.tekton_dev/pipelineRun | gpaul-cicd-hello-world-gpaul-patch-2-cca9249-rpqsv |
| kubernetes.labels.tekton_dev/pipelineTask | build |
| kubernetes.labels.tekton_dev/task | build-hxskm |
| kubernetes.labels.tekton_dev/taskRun | gpaul-cicd-hello-world-gpaul-patch-2-cca9249-rpqsv-build-lg9wm |
| kubernetes.namespace_name | dispatch |
| kubernetes.pod_id | d867bc76-1121-42ca-a53f-a1806b132513 |
| kubernetes.pod_name | gpaul-cicd-hello-world-gpaul-patch-2-cca9249-rpqsv-build-lg9wm-pod-dfedbc |
| message | some line of output generated by the build |
| stream | stderr |

repository: mesosphere/dcos-docs-site

gha_language: SCSS

repo_name: mesosphere/dcos-docs-site


text:
---
layout: page
title: 1.16.x
permalink: /1.16.x/
---

# 1.16.x

This is for the **indev** version of TFC v2.x, currently targeting Minecraft 1.16.x. Note, due to this being indev, everything here is subject to change.

### [World Generation](worldgen/)

All of TFC's world generation is available to be customized through vanilla data packs. There are many different pieces, so this will hopefully explain what TFC does, how it does it, and what you can safely modify. (And also, what can be extended with addons or compatibility mods.)

### [Recipes](recipes/)

TFC defines a number of recipe types for everything from Collapsing and Landsliding to... oh wait it's indev that's all we got so far.

### [Data](data/)

In addition to custom recipe types, there are also completely custom data types for stuff such as defining new rocks or metals.

repository: Gaelmare/Documentation

repo_name: Gaelmare/Documentation


text:
---
title: Ph. D candidate selected in an interim interview.
---

An interim interview conducted on 5th Septermber 2015 and the
following candidates have been selected for Ph.D under the
[Visvesvaraya PhD Scheme][vishy].  Congratulations to you.

<!--more-->

1. Shivani Tripathi

2. Saurabh Kumar

Candidates who have applied to us via email in the meantime are
encouraged to apply in the [December session][dec-headsup].

[dec-headsup]: </announcements/2015-09-10-Heads-up-Phd-admissions-December-2015>

[vishy]: </announcements/2015-07-02-Visvesvaraya-PhD-Scheme>

repository: cseAtIITK/admissions-website

gha_language: Haskell

repo_name: cseAtIITK/admissions-website


text:
---
layout: post
title: 'The Desire to be Accepted'
link: '#one-must-go-in-alone'
image: '../img/post-images/jester.jpg'
alt-image: 'Jan Matejko - Stańczyk'
photographer: 'Jan Matejko'
category: [Emotions, Psychology, Spirituality]
description: "Maybe you don't yet know what you want and yet, maybe you shouldn't know what you want yet, maybe you're too young for that. But you know that you want more correct? That, at least, is guaranteed."
published: true
---
The desire to be accepted is a strange thing. But even more than that it is a human thing. Something that we all go through as being part of a social species.

Yet how often do we admit the selfish thoughts that bounce around in our minds? Have you ever done that? I know why we don't - that wasn't my question. My reasons are the same as your's though...

Because we are scared of losing our place in the world. We are afraid of what people would think if they knew the full spectrum of our personality and character. What if they abandon us, what if they fire us, what if they hurt us, what if they distance themselves or cease their support of us?

These are valid concerns. But they are only valid concerns for a person living in the world who is also of the world. The trouble stems first and foremost from a misunderstanding of ourselves. There is no one quote on quote person here, what there is, is a collection of both complementary and conflicting impulses. There is an amalgamation of different desires, attitudes, emotions, feelings, and faculties that all come together to form this feeling of a solidified, focal sense of self.

Different parts reign in others. Some boast and others hide. Some, through habituation and instinct, are at the mercy of others.

The nuance of it all though is very subtle, and to really understand it, one must also have an appreciation for the truth of partial truths.

From the position of sincere spirituality or even just intense inquiry, one finds that they are not, and have never been any sense or self. Through real introspection, one can come to find that by the fact that we can't be defined by any one quality of our character, we too then cannot be defined by any collection of them. Think of it as an ever-changing mosaic of the senses; a flux of feeling and especially thought.

This, however, is not the stage that most of us are at and thus any intellectual homage does us no good. Where we are lacking is in the full, boundless expression of ourselves across every facet.

Could you admit that you want to be valued; that you want to be admired, respected, and maybe even adored for some quality of character?  Perhaps you are attractive and want others to see how beautiful you are.

We come up with these personal and collective ideals and hide anything of ourselves that could jeopardize our resemblance to that.

We are all selfish on some level. We are all greedy, self-centered, and maniacal at times. That is just part of being a full human. The real boundary between our hiding and our honesty, however, is defined by our fear.

Sure it would be hard to tell people that you want to be known as the person who is adored, recognized, and revered for your various traits. It would be hard to admit that the idea of being on top and known as the best is satisfying on a very real level to you.

But, you don't say that because you don't want to be seen as a greedy bastard, the idea of that is too frightening. You want to be known as a humble, skillful person who is above all that. And yet, you aren't. Who is the good person then? The one who is honest about all their internal conflicts or the person who is too afraid to expose them.

The answer, again, is more nuanced than either or. The whole situation and world is too nuanced to be divided into good or bad. The best that could be said is that we are all doing our best, and the worst is that we are all doomed to a destruction let on by our best efforts to be better than the narrow apes that we are.

For me, if I am completely honest with myself and with you, I want to be admired, respected, and revered in a fashion akin to a public intellectual. I want to make a living and difference in the world by writing, speaking, conversing, and creating while being seen as 'wise beyond my years'. I want people to look up to me and ask me for guidance. I want to them to say that my work and 'my' words helped them change their lives for the better. Part of me wants to be seen as better than you and everyone else because I am a more conscious, clear, open, and forward-thinking person. I want to be better than you, more intelligent than you, and more compassionate than you and I want other people to see it; all the while acting like I am above all of that.

Part of me gets off on that. We could call it my ego, we could call it whatever we want. But if I acted like that wasn't there, like I was actually above all that vanity, I would be selling a facade that is less than myself solely so I could achieve the same acceptance and value in the first place.

Just as there is a part of me who gets off on that though, there is a part of me who sees all that with contempt and disgust. But that's exactly the point.  That self-righteous part though needs the other one to be an asshole so there is enough contrast to expose the difference // and employ a distinguishable hierarchy of value.

In either case, there is a denial of the full reality behind me as the person, and frankly, I would be shocked if you were so perfect as not to undergo the same level complexity within your own character. Are there not times where you are greedy; where you never malevolent, cynical, or self-centered? Maybe you show them to people and maybe you don't.

But, if they are there, can you not be honest enough with yourself to accept and own them as the fallible being that you are? It's okay. It's really okay to admit that because we all are that. We are all kind and we are all crude. We are all unique and we are all common. We are all decent and we are all disgraceful.

We are all of that - everything and more - and yet still we are beyond all that. Because when you can own every part of yourself; when you can let go of partial personas and expose every inch to the elements of humanity and its judgment, you get to be one of the few people who not only knew it as the farce it was, but felt it for the farce that it was. You get to be one out of the many who actually saw what was worth a damn and what wasn't.

And when I think about becoming a fuller human being and making a positive difference in the world without anyone knowing who was behind it, I know I would be happier. When I genuinely dig down honestly into myself, I know that is the case. I know that by producing the results without the recognition, I could thoughtfully give back the blessings I have been given and still maintain my relationship to life and humility on the existential level that I most value.

I know all that in more of a profound way than I could ever express and still,  stand here and tell you that those selfish desires aren't there; they are there. They are a substantial part of my psyche and if there is a way to transcend that, it is only done by first engaging and integrating them for what they are.  Living in that fear from any angle only imprisons us, and our time is too short to carry that at the cost of greater deeds.

That is one hell of a regret to have on on a deathbed; that is a pure waste of time. I know it's enticing, but it is a waste.

We are better off admitting it. Just as I, you too are self-centered in a plethora of ways. You want recognition, respect, admiration, and due diligence for how great you are compared to others. That's there.  Maybe all of us are bit douchey though. And for those who are total douche bags, well when they can own up to it they will be a little bit less of one, and that's all we can hope for. That's all each of us can hope for.

Provided I make it that far, I often think about myself in my later years. I think about what he would want to listen back and hear from me know as I speak. I know he would want the real me; the full, imperfect me instead of the fake front I can put on.

Here's to you man, I hope you found what you wanted and went through what you needed to get there. Part of me feels like you didn't though; like perhaps that was the wrong way to think about this all along.

I don't need to tell you that I'm trying because you and I know that I could've done better. Yes, I and everyone else deserves compassion for how hard of all this is, but we could do better.

repository: stevenhorkey/mm-site

branch_name: HEAD

repo_name: stevenhorkey/mm-site


text:
GitHub issues are for tracking bugs, not for general discussing like a forum.

If you have a general question to ask, send it to mailing list:

<EMAIL_ADDRESS>
Or visit:
https://groups.google.com/forum/#!forum/muduo-library

When file an issue muduo, please provide a [SSCCE](http://sscce.org):
Short, Self Contained, Correct (Compilable), Example.

If you can't compile muduo, make sure you install `cmake` and `boost` from the
official package repository, e.g. `apt` or `yum`, before opening a bug.
Don't open a bug if you installed boost from a third-party source or
downloaded it by yourself, and couldn't compile muduo, thank you.

Also specify the exact environment where the issue occurs:

## Linux distro and version? x86 or ARM? 32-bit or 64-bit?

## Branch (cpp98/cpp11/cpp17) and version of muduo?

## Version of cmake, gcc and boost? (If not from distro.)

repository: bingoabs/muduo

gha_license_id: NOASSERTION

repo_name: bingoabs/muduo


text:
# FaceIt

[![CI Status](http://img.shields.io/travis/tmukammel/FaceIt.svg?style=flat)](https://travis-ci.org/tmukammel/FaceIt)
[![Version](https://img.shields.io/cocoapods/v/FaceIt.svg?style=flat)](http://cocoapods.org/pods/FaceIt)
[![License](https://img.shields.io/cocoapods/l/FaceIt.svg?style=flat)](http://cocoapods.org/pods/FaceIt)
[![Platform](https://img.shields.io/cocoapods/p/FaceIt.svg?style=flat)](http://cocoapods.org/pods/FaceIt)

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

FaceIt is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod "FaceIt"
```

## Author

tmukammel<EMAIL_ADDRESS>
## License

FaceIt is available under the MIT license. See the LICENSE file for more info.

repository: tmukammel/FaceIt

repo_name: tmukammel/FaceIt


text:
# Cloud9-RoR1
RoR app using AWS Cloud9
Steps (from here: https://www.railstutorial.org/book/beginning#sec-prerequisites):
https://console.aws.amazon.com/
type “Cloud9” in the search box and choose it
click “Create environment”
section "Environment name and description"
Name = "rails-tutorial" and confirm till info about creating
Wait ~5 min, in "Project settings", "Ace", 'Soft tabs' = 2
Bottom window "bash...":
printf "install: --no-rdoc --no-ri\nupdate:  --no-rdoc --no-ri\n" >> ~/.gemrc
gem install rails -v 5.1.6
**************
Making a environment directory for Rails projects (!!!UNNECESSARY in the cloud).
$ cd               # Change to the home directory.
$ mkdir environment# Make a environment directory.
$ cd environment/  # Change into the environment directory
*************
cd ~/environment # Change into the environment directory
rails _5.1.6_ new hello_app #create new RoR app
*************
GIT: #go to your project directory
git status #info about project files

git init #start using git for project
git add . #add all project files to check status
git commit -m "your comment" #prepare files for commit
git rm file.fff #remove file from checking list (not physical deleting)

#add remote repo. with alias 'hw' and url = 'git://....'
git remote add hw git@github.com:<MyGitAccountName>/hw.git #ssh method
git remote add hw git://github.com/<MyGitAccountName>/hw.git #https method
#get info about remotes: git remote -v
#get all new files and put in your project: git pull
#delete remote rep: git remote rm ww # alias = 'ww'

        ++++++MOST IMPORTANT++++++
#create new remote repo:
    curl -u '<MyGitAccountName>' https://api.github.com/user/repos -d '{"name":"NewRep"}'
#push an existing repository to remote:
1.    git remote add origin https://github.com/<MyGitAccountName>/NewRep.git
#if you have any error do this: git remote rm origin #then repeat step 1.
2.    git push origin master
#after your work with files do this:
    git commit -m "your comment" -a #commit all changes
#or you can add only part of files to commit: git add [file_name]
    git push origin master #push to remote
*************
start Rails server:
cd ~/environment/hello_app/ #change env to current app
rails s #start server


text:
## About the Book

[GraphQL and Android](https://commonsware.com/GraphQL) is a book covering
what [GraphQL](http://graphql.org/) is, how to consume GraphQL-powered Web
services from Android apps, and related topics.
The book is updated several times a year and is available through
[the Warescription](https://commonsware.com/warescription) program. Subscribers also have access to office
hours chats and other benefits.

This repository contains the source code for the sample apps profiled in the book. These
samples are updated as the book is, with `git` tags applied to tie sample code versions to book
versions.

The book, and the samples, were written by Mark Murphy. You may also have run into him through
Stack Overflow:

All of the source code in this archive is licensed under the
Apache 2.0 license except as noted.

All of the projects should have a `build.gradle` file suitable for
importing the project into Android Studio. Note, though, that you
may need to adjust the `compileSdkVersion` in `build.gradle` if it
requests an SDK that you have not downloaded and do not wish to
download. Similarly, you may need to adjust the `buildToolsVersion`
value to refer to a version of the build tools that you have downloaded
from the SDK Manager.

The samples also have stub Gradle wrapper files, enough to allow for
easy import into Android Studio. However,
**always check the `gradle-wrapper.properties` file before importing anything into Android Studio**,
as there is always the chance that somebody has published material linking you to a hacked Gradle installation.


text:
### [CVE-2023-0103](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2023-0103)
![](https://img.shields.io/static/v1?label=Product&message=XBC-DN32U&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=%3D%20Operating%20System%20Version%2001.80%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=CWE-788%20Access%20of%20Memory%20Location%20After%20End%20of%20Buffer&color=brighgreen)

### Description

If an attacker were to access memory locations of LS ELECTRIC XBC-DN32U with operating system version 01.80 that are outside of the communication buffer, the device stops operating. This could allow an attacker to cause a denial-of-service condition.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/goheea/goheea

repository: trickest/cve

repo_name: trickest/cve


text:
# Substrate Uniform Resource Identifier

* **PSP Number:** 2
* **Authors:** @xlc
* **Status:** Draft
* **Created:** 2019-10-01
* **Reference Implementation** [To be implemented]

## Summary

A URI format that identifies a resource in the Polkadot ecosystem, which can be an independent chain, a module in a chain or one of the resource provided by a module in a chain (e.g. A smart contract in a chain with contracts module).

## References

- https://hackmd.io/gQKQGf42TeOODid3hM4_1w#Identifying-and-utilising-a-fungible-asset-on-Polkadot
- https://tools.ietf.org/html/rfc3986

## Motivation

In the cross-chain Substrate / Polkadot ecosystem, there will be multiple chains interacting with each other. Therefore it is esstenital to have a uniformed way to address each chain and the resources / services hosted by different chain.

Substrate Uniform Resource Identifier (SURI) provides a way to uniformally address a cross-chain resource.

A resource can be:

- A blockchain. e.g. Polkadot, Ethereum
- A runtime module in a chain. e.g. Balances in Polkadot (DOT), Crowdfunding module in Polkadot
- A resource provided by a runtime module in a chain. e.g.
- An instance of a non-fungible token. e.g. A particular Crypto Kitty
- A bridged token provided by a chain. e.g. XBTC on ChainX
- A utility token provided by runtime modules or smart contracts. e.g. MKR on Ethereum, SDOT on ChainX
- A service provided by a chain. e.g. DEX on exchange chain
- A trading pair in a exchange that provided by a chain. e.g. BTCETH pair on a DEX chain

## Specification

### URI format

A URI is made of various parts:

```
URI = scheme:[//authority]path[?query][#fragment]
authority = [userinfo@]host[:port]
```

For SURI, the format is defined as

- schema: TBD
  - `polkadot` or `substrate` or something more generalized?
- port: N/A
- userinfo: the parachain ID
- host: the relay chain index or address
  - Leave empty to point to current chain
- path: the resource path in a chain
  - Begin with the runtime module name and followed by runtime module specific path
- query & fragment: unspecified

### Encoding

There are two encoding formats for SURI.

- Standard encoding
  - Encoded as a URI string

- Custom SCALE encoding to avoid unnecessary space usage
  ```rust
  struct SURI {
    userinfo: Option<ParaId>,
    host: Option<ChainId>,
    path_components: Vec<RuntimeStr>,
    query: Option<RuntimeStr>,
    fragment: Option<RuntimeStr>
  };
  type RuntimeStr = Vec<u8>;
  type ParaId = u32; // per Polkadot implementation
  enum ChainId {
    Id(u32), // numeric chain id registry is out of scope of this proposol
    Name(RuntimeStr)
  };
  ```

## Tests

(using `polkadot` as the schema)

- Polkadot DOT: `polkadot://polkadot/balances`
- The Default instance Balances token on parachain 1: `polkadot://1@polkadot/srml-balances`
- The Instance2 Balances token on parachain 2<EMAIL_ADDRESS>- Generic Asset Asset ID 5 token on a independent chain: `polkadot://chain-name/srml-generic-asset/5`
- The smart contract module on parachain 3 on Kusama: `polkadot://3@kusama/srml-contracts`
- A NFT with ID of  `UniqueWeapon001` with provided by a smart contract with address of `0x1234abcd` on a Instance2 contracts module on parachain 4 on Kusama<EMAIL_ADDRESS>- The balances of user `0x1111aaaa` of a ERC20-like token contract with address of `0x2222bbbb` on a smart contract chain: `polkadot://smart-contract-chain-name/srml-contracts/0x2222bbbb/0x1111aaaa`

## Copyright

Each PSP must be labeled as placed in the [public domain](https://creativecommons.org/publicdomain/zero/1.0/).


text:
---
title: 'Actions'
---

The actions addon is used to display data received by event handler (callback) arguments in your stories.

<video autoPlay muted playsInline loop>
  <source
    src="addon-actions-demo-optimized.mp4"
    type="video/mp4"
  />
</video>

## Action args

Actions work via supplying special Storybook-generated “action” arguments (referred to as "args" for short) to your stories. There are two ways to get an action arg:

### Action argType annotation

You can use [argTypes](../api/argtypes.md) to tell Storybook that an arg to your story should be an action. Usually, it makes sense to do this at the component level (although you can apply it per individual story):

<CodeSnippets
  paths={[
    'angular/button-story-onclick-action-argtype.ts.mdx',
    'web-components/button-story-onclick-action-argtype.js.mdx',
    'web-components/button-story-onclick-action-argtype.ts.mdx',
    'common/button-story-onclick-action-argtype.js.mdx',
    'common/button-story-onclick-action-argtype.ts.mdx',
  ]}
/>

When Storybook sees this argType, it will create an arg set to a special “action” callback. If your component calls this arg (based on the user's interaction or through the `play` function), the event will show up in the action panel:

![Essential Actions addon usage](./addon-actions-screenshot.png)

### Automatically matching args

Another option is to use a global parameter to match all [argTypes](../api/argtypes.md) that match a certain pattern. The following configuration automatically creates actions for each `on` argType (which you can either specify manually or can be [inferred automatically](../api/argtypes.md#automatic-argtype-inference)).

<CodeSnippets
  paths={[
    'common/storybook-preview-matching-argtypes.js.mdx',
    'common/storybook-preview-matching-argtypes.ts.mdx',
  ]}
/>

If you need more granular control over which `argTypes` are matched, you can adjust your stories and include the `argTypes` parameter. For example:

<CodeSnippets
  paths={[
    'angular/button-story-matching-argtypes.ts.mdx',
    'web-components/button-story-matching-argtypes.js.mdx',
    'web-components/button-story-matching-argtypes.ts.mdx',
    'common/button-story-matching-argtypes.js.mdx',
    'common/button-story-matching-argtypes.ts.mdx',
  ]}
/>

💡 If you're generating argTypes with another addon (like [docs](../writing-docs/introduction.md), which is the common behavior), ensure the actions addon AFTER the other addon. You can do this by listing it later in the addons registration code in [`.storybook/main.js`](../configure/overview.md#configure-story-rendering). This is default in [essentials](./introduction.md).

## Action event handlers

It is also possible to detect if your component is emitting the correct HTML events using the `parameters.actions.handles` [parameter](../writing-stories/parameters.md).

<CodeSnippets
  paths={[
    'angular/button-story-action-event-handle.ts.mdx',
    'web-components/button-story-action-event-handle.js.mdx',
    'web-components/button-story-action-event-handle.ts.mdx',
    'common/button-story-action-event-handle.js.mdx',
    'common/button-story-action-event-handle.ts.mdx',
  ]}
/>

This will bind a standard HTML event handler to the outermost HTML element rendered by your component and trigger an action when the event is called for a given selector. The format is `<eventname> <selector>`. The selector is optional; it defaults to all elements.

## Advanced / legacy usage

There are also some older ways to use actions as documented in the [advanced README](../../addons/actions/ADVANCED.md).

repository: storybookjs/storybook

branch_name: refs/heads/next

gha_language: TypeScript

repo_name: storybookjs/storybook


text:
LogDog Coordinator
==================

The LogDog Coordinator is an AppEngine application that serves as a central
coordinating and interactive authority for a LogDog instance. The Coordinator
is responsible for:

* Supplying logs to end users through its logs API.
* Coordinating log stream state throughout its lifecycle.
* Handling Butler Prefix registration.
* Acting as a configuration authority for its deployment.
* Accepting stream registrations from **Collector** instances.
* Dispatching archival tasks to **Archivist** instances.

## Services

A **Coordinator** occupies the AppEngine space of a given cloud project, and
assumes ownership of that project's resources. It is composed of several
cooperative AppEngine services.

### Default

The [default](default/) service handles basic LUCI services. Most other requests are
redirected to other services by [dispatch.yaml](default/dispatch.yaml).

### Logs

The [logs](logs/) service exposes the
[Logs API](../../../api/endpoints/coordinator/logs/v1/) for log stream querying
and consumption.

It is a AppEngine Flex instance, since Flex is the only supported type of
AppEngine instance that can use gRPC, and gRPC is needed to read from BigTable.

### Services

The [services](services/) service exposes management endpoints to the instance's
microservices, notably the [Collector](../../../server/cmd/logdog_collector) and
[Archivist](../../../server/cmd/logdog_archivist) microservices. These endpoints
are used to coordinate the microservice-managed aspects of the log stream
lifecycle.

### Static

The [static](static/) service hosts static content, including:
* The LogDog Web Application
* The LogDog Lightweight Stream Viewer
* `rpcexplorer`

repository: asdfghjjklllllaaa/luci-go

gha_language: Go

repo_name: asdfghjjklllllaaa/luci-go