text:
## Expected/Desired Behavior

Fill with either one:

1. Expected behavior for bugs
1. Desired behavior for improvements/enhancements

## Actual Behavior

How does the application currently work.

## Steps to Reproduce the Problem/Current behavior

1. Step 1
1. Step 2
1. Step 3

## (Optional) Additional notes and links

Any other relevant informations helping in debugging/implementing.

repository: thedemodev/cli-table

repo_name: thedemodev/cli-table


text:
### This project was inspired by Mathologer's YouTube video:

### Times Tables, Mandelbrot and the Heart of Mathematics

This is a visualization of the multiplication tables, which produces some very beautiful patterns.

For a complete explanation, please watch the video. It's only 13:37 minutes long.

I wanted to create a quick project with native javascript modules, so this seemed like a good choice.
It's still pretty rough around the edges, but I'm happy with it so far.

Since this project uses modules you will need some kind of server to run it or you willll see
CORS errors in the console. https://www.npmjs.com/package/http-server and the development
servers built into PHP and python will all work.

I hope you enjoy it.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
title: Implementing a React Component for SPA
description: This article presents an example of how to adapt a simple, existing React component to work with the Adobe Experience Manager (AEM) SPA Editor.
contentOwner: bohnert
products: SG_EXPERIENCEMANAGER/6.5/SITES
topic-tags: spa
content-type: reference
docset: aem65
exl-id: f4959c12-54c5-403a-9973-7a4ab5f16bed
---
# Implementing a React Component for SPA{#implementing-a-react-component-for-spa}

Single page applications (SPAs) can offer compelling experiences for website users. Developers want to be able to build sites using SPA frameworks and authors want to seamlessly edit content within Adobe Experience Manager (AEM) for a site built using SPA frameworks.

The SPA authoring feature offers a comprehensive solution for supporting SPAs within AEM. This article presents an example of how to adapt a simple, existing React component to work with the AEM SPA Editor.

>[!NOTE]
>
>The SPA Editor is the recommended solution for projects that require SPA framework based client-side rendering (for example, React or Angular).

## Introduction {#introduction}

Thanks to the simple and lightweight contract that is required by AEM and established between the SPA and the SPA Editor, taking an existing JavaScript application and adapting it for use with an SPA in AEM is a straightforward matter.

This article illustrates the example of the weather component on the We.Retail Journal sample SPA.

You should be familiar with the [structure of an SPA application for AEM](/help/sites-developing/spa-getting-started-react.md) before reading this article.

>[!CAUTION]
>This document uses the [We.Retail Journal app](https://github.com/adobe/aem-sample-we-retail-journal) for demonstration purposes only. Do not use it for any project work.
>
>Any AEM project should use the [AEM Project Archetype](https://experienceleague.adobe.com/docs/experience-manager-core-components/using/developing/archetype/overview.html), which supports SPA projects using React or Angular and uses the SPA SDK.

## The Weather Component {#the-weather-component}

The weather component is found in the top-left of the We.Retail Journal app. It displays the current weather of a defined location, pulling weather data dynamically.

### Using the Weather Widget {#using-the-weather-widget}

![screen_shot_2018-06-08at143224](assets/screen_shot_2018-06-08at143224.png)

When authoring content of the SPA in the SPA Editor, the weather component appears as any other AEM component, complete with a toolbar, and is editable.

![screen_shot_2018-06-08at143304](assets/screen_shot_2018-06-08at143304.png)

The city can be updated in a dialog just like any other AEM component.

![screen_shot_2018-06-08at143446](assets/screen_shot_2018-06-08at143446.png)

The change is persisted and the component updates itself automatically with new weather data.

![screen_shot_2018-06-08at143524](assets/screen_shot_2018-06-08at143524.png)

### Weather Component Implementation {#weather-component-implementation}

The weather component is based on a publicly-available React component, called [React Open Weather](https://www.npmjs.com/package/react-open-weather). It has been adapted to work as a component within the We.Retail Journal sample SPA application.

The following are snippets of the NPM documentation of the usage of the React Open Weather component.

![screen_shot_2018-06-08at144723](assets/screen_shot_2018-06-08at144723.png) ![screen_shot_2018-06-08at144215](assets/screen_shot_2018-06-08at144215.png)

Reviewing the code of the customized weather component ( `Weather.js`) in the We.Retail Journal application:

* **Line 16**: The React Open Weather widget is loaded as required.
* **Line 46**: The `MapTo` function relates this React component to a corresponding AEM component so that it can be edited in the SPA Editor.

* **Lines 22-29**: The `EditConfig` is defined, checking if the city has been populated and defining the value if empty.

* **Lines 31-44**: The Weather component extends the `Component` class and provides the required data as defined in the NPM usage documentation for the React Open Weather component and renders the component.

```javascript
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 ~ Copyright 2018 Adobe Systems Incorporated
 ~
 ~ Licensed under the Apache License, Version 2.0 (the "License");
 ~ you may not use this file except in compliance with the License.
 ~ You may obtain a copy of the License at
 ~
 ~     https://www.apache.org/licenses/LICENSE-2.0
 ~
 ~ Unless required by applicable law or agreed to in writing, software
 ~ distributed under the License is distributed on an "AS IS" BASIS,
 ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ~ See the License for the specific language governing permissions and
 ~ limitations under the License.
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
import React, {Component} from 'react';
import ReactWeather from 'react-open-weather';
import {MapTo} from '@adobe/aem-react-editable-components';

require('./Weather.css');

const WeatherEditConfig = {

    emptyLabel: 'Weather',

    isEmpty: function() {
        return !this.props || !this.props.cq_model || !this.props.cq_model.city || this.props.cq_model.city.trim().length < 1;
    }
};

class Weather extends Component {

    render() {
        let apiKey = "12345678901234567890";
        let city;

        if (this.props.cq_model) {
            city = this.props.cq_model.city;
            return <ReactWeather key={'react-weather' + Date.now()} forecast="today" apikey={apiKey} type="city" city={city} />
        }

        return null;
    }
}

MapTo('we-retail-journal/global/components/weather')(Weather, WeatherEditConfig);

```

Although a back-end component must already exist, the front-end developer can use the React Open Weather component in the We.Retail Journal SPA with little coding.

## Next Step {#next-step}

For further information about developing SPAs for AEM see the article [Developing SPAs for AEM](/help/sites-developing/spa-architecture.md).

branch_name: refs/heads/main

gha_language: Groovy

gha_license_id: MIT


text:
# Getting started with Orchard Core as a NuGet package

In this article, we are going to see how easy it is to create a CMS Web application using the NuGet packages provided by Orchard Core.

You can find the original blog post written by Chris Payne here:
<http://ideliverable.com/blog/getting-started-with-orchard-core-as-a-nuget-package>

## Create an Orchard Core CMS application

In Visual Studio, create a new empty .NET Core web application. Ex: `Cms.Web`.

If you want to use the `dev` packages, add this OrchardCore-preview MyGet url to your NuGet sources:
<https://www.myget.org/F/orchardcore-preview/api/v3/index.json>

Right-click on the project and click on `Manage NuGet packages...`.
In the `Browse` tab, search for `OrchardCore.Application.Cms.Targets` and `Install` the package.

Open `Startup.cs` and modify the `ConfigureServices` method by adding this line:

```csharp
services.AddOrchardCms();
```

In the `Configure` method, replace this block:

```csharp
app.Run(async (context) =>
{
    await context.Response.WriteAsync("Hello World!");
});
```

with this line:

```csharp
app.UseOrchardCore();
```

## Setup your application

Launch your application (Ctrl+F5). The setup page is displayed.

Enter the required information about the site:

- The name of the site. Ex: `Orchard Core`.
- The theme recipe to use. Ex: `Agency`.
- The timezone of the site. Ex: `(+01:00) Europe/Paris`.
- The Sql provider to use. Ex: `SqLite`.
- The name of the admin user. Ex: `admin`.
- The email of the admin. Ex<EMAIL_ADDRESS>- The password and the password confirmation.

Submit the form and your site is generated after a few seconds.

Then, you can access to the admin using the `/admin` url. Enjoy.

repository: ThisNetWorks/OrchardCore

branch_name: refs/heads/dev

gha_language: JavaScript

gha_license_id: NOASSERTION

repo_name: ThisNetWorks/OrchardCore


text:
---
layout: post
title: GSoC 2019 - Second Week
description: "Google Summer of Code 2019: First week"
modified: 2019-06-08
tags: [gsoc19]
categories: [code]
comments: false
image:
    feature: gsoc19/post-header.png
    credit: casals
---

Continuing on the first month of <abbr title="Google Summer of Code">[(GSoC)](https://summerofcode.withgoogle.com/)</abbr> it was finally time to start coding.

<!-- more -->

## Thou shalt not make a machine in the likeness of a human mind

After some discussion with the mentors, in the previous week I had determined that the group structure would be implemented using the hivemind model. The next logical step was to start working on the actual group structure implementation, so - following previous discussions on the topic - I started exploring the existing work on _Sectors_. The concept of Sectors was explored and implemented [in a previous GSoC project](https://vizaxo.github.io/2017/08/26/gsoc-2017-final-post.html), and the basic idea involves grouping Entities into groups (which is exactly what I need). Based on this implementation, the hivemind structure could work as a Pool, minus the different simulation rate (please check the associated GSoC project link for a full understanding on the structure of Sectors).

I presented this idea during our weekly meeting, and the following discussion on the use of Sectors was really good - there were, however, other possible group structure mechanisms that could be implemented (a result of past discussions on Discord). Each of these mechanisms was discussed due to possible future constraints in different scenarios - which are very difficult to predict at this point, of course, so all discussions were based in previous experiences with similar mechanisms. By the end of the discussion, we had three different implementation paths to follow:

* Creating a "transparent" Entity to be used as an Entity aggregator ("ex-machina parent");
* Creating a Sector-derived implementation for Entity grouping; and
* Creating a specialized Entity register within the code.

Since we had reached the limits of a theoretical discussion, I decided to start working on a proof-of-concept (PoC) module so I could actually test each of the above alternatives. I chose the existing WildAnimals module as a primary reference for the PoC. The objective is to use the existing entities in the reference module (deers) and create entity groups without modifying the spawning mechanism as it is right now. That means: when the first deer is created, it is assigned to a group. If a second deer is created, it should be able to recognize the existence of a local group and join it. Crerating a separate model allow us to test the different group structure alternatives without interfering with the existing (working) module. As soon as a group implementation is chosen, I can then proceed to assign behaviors to groups and start the next task (how a group behavior can superpose an individual behavior).

## Weekly report

### What have you achieved in the last week?
* Determined how the group structure would be implemented
* Started working on the group structure implementation

### What are you currently working on?
* Documentation on model/API
* Sample module (using WildAnimals as a base)

### What problems are you currently facing?
* Just a few doubts about:
    * prefab structure: Trigger
    * Sectors use case?
    * spawnPrefab mechanism
    * FindNearbyPlayersSystem

### Is anything blocking you from making progress?
* (none)

### List of PRs and opened/closed Issues
* (none)

### Something else (pictures of new content, code snippets, new wiki content, …)
* (Updated the Github project board)

## Permanent links

* [GSoC proposal]({{ site.url }}/docs/gsoc19/GSoC 2019 - Arthur Casals.pdf)
* [GitHub project board](https://github.com/orgs/Terasology/projects/20)
* [Forum thread](https://forum.terasology.org/threads/gsoc-2019-collective-behavior.2255/)
* [Bibliography (BibTex format, subject to constant change)]({{ site.url }}/docs/gsoc19/gsoc-references.bib)


text:
---
title: B-Scope Radar Display
description: A rectilinear display of radar returns
date: 2009-10-13 12:18:02+01:00
author: Brad Howes
tags: Qt, OpenGL, Radar
template: post.hbs
layout: post.hbs
image: 2karga0gtstkeq.jpg
---

Although most people have seen a radar display that is basically a polar plot in range and azimuth coordinates,
there is also a radar display that shows data in a Cartesian coordinate space, with azimuth running along the X
axis (and overwriting as the sweep repeats azimuth values), and the range running along the Y axis. As for the
polar display I wrote about in a [previous post](/articles/radardisplay), I created this using
[Qt](http://www.qt.io) and OpenGL using pretty much the same compositing approach.

![ppi.jpg](2karga0gtstkeq.jpg)

I add the ability to save snapshots of a scan just before the azimuth wraps to the left. Such snapshots appear
on the right side of the image above. There are actually two snapshot views, one showing all images as a list
and the other showing them as a movie. The rest of the functionality of the B-Scope is the same as the PPI.

repository: bradhowes/keystrokecountdown

gha_language: Jupyter Notebook

repo_name: bradhowes/keystrokecountdown


text:
# Function Exercises

 [![License](http://img.shields.io/badge/license-MIT-blue.svg)](http://en.wikipedia.org/wiki/MIT_License)

**Author:** McKenna Sheridan

**Due date:** Friday, March 18, 2016

## Description

This assignment required me to complete six different tasks. First, I had to write a code that computes the Heaviside function, which is a piecewise function. Second, I had to write a more complex version of the piecewise function. Third, I had to write a code counting the number of a particular base pair in a DNA sequence. Fourth, I had to write a code that would print a histogram of a given set of data. The fifth task required me to print the same histogram but with a particular format. Finally, I had to write a code that counted the number of digits in a particular number. All of these exercises required me to use definitions and loops (for,if, and while).

## What I Learned from This

These exercises enhanced my understanding of loops as well as definitions and strings.

## Honor Pledge

I pledge that all the work in this repository is my own with only the following exceptions:

* Content of starter files supplied by the instructor;
* Code borrowed from another source, documented with correct attribution in the code and summarized here.

Signed,

McKenna Sheridan


text:
# llehs
![forthebadge](https://forthebadge.com/images/badges/made-with-python.svg)

A python implementation of a reverse shell.

## Note for contributors
The project is open for contributions and is hacktoberfest registered!
llehs uses the following technologies:

+ Python [Learn](https://docs.python.org/3/tutorial/)
+ Reverse Shells [Learn](https://www.acunetix.com/blog/web-security-zone/what-is-reverse-shell/)

If you want to contribute to this project, then have a look [here](https://github.com/archi-007/llehs/blob/main/CONTRIBUTING.md).

Make valid changes to make the project better!
 Also do refrain from spamming the repository to maintain the integrity of the open source community.

repository: RishitaModak/llehs

repo_name: RishitaModak/llehs


text:
# Release Process

## Pre Release

1: Upgrade to latest [semantic-conventions](docs/semantic-conventions.md)
if required.

2: Make sure all relevant changes for this release are included under
`Unreleased` section in `CHANGELOG.md` and are in language that non-contributors
to the project can understand.

3: Run the pre-release script. It creates a branch `pre_release_<new-tag>` and
updates `CHANGELOG.md` with the `<new-tag>`:

```sh
./buildscripts/pre_release.sh -t <new-tag>
```

4: Verify that CHANGELOG.md is updated properly:

```sh
git diff main
```

5: Push the changes to upstream and create a Pull Request on GitHub. Be sure to
include the curated changes from the [Changelog](./CHANGELOG.md) in the
description.

## Tag

Once the above Pull Request has been approved and merged it is time to tag the
merged commit.

***IMPORTANT***: It is critical you use the same tag that you used in the
Pre-Release step! Failure to do so will leave things in a broken state.

1: Note down the commit hash of the master branch after above PR request is
merged: `<commit-hash>`

```sh
git show -s --format=%H
```

2: Create a github tag on this commit hash:

```sh
git tag -a "<new-tag>" -s -m "Version <new-tag>" "<commit-hash>"
```

3: Push tag to upstream remote

```sh
git push upstream
```

## Versioning

Once tag is created, it's time to use that tag for Runtime Versioning

1: Create a new brach for updating version information in
`./sdk/src/version.cc`.

```sh
git checkout -b update_version_${tag} master
```

2: Run the pre-commit script to update the version:

```sh
./buildscripts/pre-commit
```

3: Check if any changes made since last release broke ABI compatibility. If yes,
update `OPENTELEMETRY_ABI_VERSION_NO` in
[version.h](api/include/opentelemetry/version.h).

4: Push the changes to upstream and create a Pull Request on GitHub.

5: Once changes are merged, move the tag created earlier to the new commit hash
from step 4.

```sh
git tag -f <previous-tag> <new-commit-hash>
git push --tags --force
```

## Release

Finally create a Release for the new `<new-tag>` on GitHub. The release body
should include all the release notes from the Changelog for this release.

## Post Release

Update the OpenTelemetry.io document
[here](https://github.com/open-telemetry/opentelemetry.io/tree/main/content/en/docs/instrumentation/cpp)
by sending a Pull Request.

repository: open-telemetry/opentelemetry-cpp

repo_name: open-telemetry/opentelemetry-cpp


text:
### [CVE-2008-2912](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-2912)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

Multiple PHP remote file inclusion vulnerabilities in Contenido CMS 4.8.4 allow remote attackers to execute arbitrary PHP code via a URL in the (1) contenido_path parameter to (a) contenido/backend_search.php; the (2) cfg[path][contenido] parameter to (b) move_articles.php, (c) move_old_stats.php, (d) optimize_database.php, (e) run_newsletter_job.php, (f) send_reminder.php, (g) session_cleanup.php, and (h) setfrontenduserstate.php in contenido/cronjobs/, and (i) includes/include.newsletter_jobs_subnav.php and (j) plugins/content_allocation/includes/include.right_top.php in contenido/; the (3) cfg[path][templates] parameter to (k) includes/include.newsletter_jobs_subnav.php and (l) plugins/content_allocation/includes/include.right_top.php in contenido/; and the (4) cfg[templates][right_top_blank] parameter to (m) plugins/content_allocation/includes/include.right_top.php and (n) contenido/includes/include.newsletter_jobs_subnav.php in contenido/, different vectors than CVE-2006-5380.

### POC

#### Reference
- https://www.exploit-db.com/exploits/5810

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# apparat (DISCONTINUED!)

**this was an experiment. don't use it. [promises](https://github.com/petkaantonov/bluebird) are a much better way to organize async code in nodejs!**

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

apparat is a simple but powerful way to organize async code for nodejs

### install

    npm install apparat

### use

read domain from file `domain.txt`.

write resolved IPV4 addresses to `addresses4.txt` and
write resolved IPV6 addresses to `addresses6.txt` in parallel.

remove `domain.txt` when both files have been written successfully.

```coffeescript
fs = require 'fs'
dns = require 'dns'

apparat = require 'apparat'

{receive, send, onError, debug} = apparat

debug console.log
onError (err) -> throw err

fs.readFile 'domain.txt', send 'contents'

receive 'contents', (contents) ->
    domain = contents.toString().trim()
    # parallel
    dns.resolve4 domain, send 'addresses4'
    dns.resolve6 domain, send 'addresses6'

receive 'addresses4', (addresses) ->
    fs.writeFile 'addresses4.txt', addresses.join('\n'), send 'addresses4 written'

receive 'addresses6', (addresses) ->
    fs.writeFile 'addresses6.txt', addresses.join('\n'), send 'addresses6 written'

receive 'addresses4 written', 'addresses6 written', ->
    fs.unlink 'domain.txt', send 'deleted'

receive 'deleted', ->
    console.log 'OK'
```

#### license: MIT

repository: snd/apparat

repo_name: snd/apparat


text:
# Arduino/ESP8266/ESP32 library for HC-SR04 ultrasonic distance sensor.

This library is used for measuring distance with the HC-SR04, which is an ultrasonic sensor that measures distances from 2 to 400cm. My library features a temperature correction and can utilize one trigger pin with multiple echo pins in parallel. I based this library on two other libraries.
1. https://github.com/Martinsos/arduino-lib-hc-sr04 --> I basically used the temperature calculation
2. https://github.com/gamegine/HCSR04-ultrasonic-sensor-lib --> I basically used the idea of using one trigger and multiple echos. But instead of measuring them in series, I tried to do that in parallel.

![HC-SR04](/HC-SR04.png)

## Usage

## Example

```c
#include <HCSR04.h>

byte triggerPin = 21;
byte echoCount = 2;
byte* echoPins = new byte[echoCount] { 12, 13 };

void setup () {
  Serial.begin(115200);
  HCSR04.begin(triggerPin, echoPins, echoCount);
}

void loop () {
  double* distances = HCSR04.measureDistanceCm();

  for (int i = 0; i < echoCount; i++) {
    if (i > 0) Serial.print(" | ");
    Serial.print(i + 1);
    Serial.print(": ");
    Serial.print(distances[i]);
    Serial.print(" cm");
  }

  Serial.println("");
  delay(500);
}
```


text:
XamlStyler
==========
A fork of the original Xaml Styler plugin as found on http://xamlstyler.codeplex.com
This fork has been created to continue development on the awesome XAML styler plugin created by Chris Chaochen. To support the efforts Chris has put into this project my fork will only support Visual Studio 2013 and higher. For Visual Studio 2012 support please install Chris his version.

####Join the discussion####
[![Join the chat at https://gitter.im/Xavalon/XamlStyler](https://badges.gitter.im/Xavalon/XamlStyler.svg)](https://gitter.im/Xavalon/XamlStyler?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

Features
==========
* Format/Beautify Xaml markup in one click.

* Sort attributes based on following rules:
  * x:Class
  * XML Namespaces
    * WPF built-in namespaces
    *  User defined namespaces
  * Key, Name or Title attributes
    * x:Key
    * x:Name
    * Title
  * Grid or Canvas related attached layout attributes
    * Numeric layout attributes Width/MinWidth/MaxWidth
    * Height/MinHeight/MaxHeight
    * Margin
  * Alignment related attributes HorizontalAlignment/ContentHorizontalAlignment
    * VerticalAlignment/ContentVerticalAlignment
    * Panel.ZIndex
  * Other attributes
* Short attributes tolerance.
  * When an element contains 2 or less than 2 attributes, line break is not applied for * better readability.
* Special characters(e.g., &) are preserved.
* Respect "significant" whitespace situation.
  * No new linefeed will be added to <Run/>, if it is immediatly following *another element to prevent the rendering of unexpected space.

Significant Whitespace between <Run/>

No Whitespace between <Run/>

 vs

<TextBlock>
  <Run>A</Run>
  <Run>B</Run>
</TextBlock>

 vs

<TextBlock>
  <Run>A</Run><Run>B</Run>
</TextBlock>

* Indent Xaml markup based on "Tab Size/Indent Size/Indent Charater" settings available in "Option/Text Editor/XAML/Tabs" page.

* XamlStyler specific options.
  * Define your own attribute ordering rules
  * Define your own attribute line break rules
  * Markup extension formatting
  * Automatically reformat Xaml file on saving

* Import/Export XamlStyler settings.

Thanks to our contributers!
===========================
* Bart Lannoeye
* Kevin Dockx
* Philip Hoppe
* Pedro Lamas
* RandomEngy

repository: benlacey/XamlStyler

repo_name: benlacey/XamlStyler


text:
# gopher-game

gopher-game is a simple game in a terminal.

I was inspired by awesome game [zombies-on-ice](https://github.com/loov/zombies-on-ice).

![gopher-game](https://github.com/austinov/gopher-game/blob/assets/screenshot.gif)

In the beginning, as usual, run:
```
    $ go get github.com/austinov/gopher-game
    $ cd $GOPATH/github.com/austinov/gopher-game
    $ glide up
    $ go build
    $ ./gopher-game
```

### Download

Alfa version:

* [Linux 64bit](https://github.com/austinov/gopher-game/blob/assets/gopher-game.linux-64bit.tar.gz)

#### Prerequisites

- [go-gl/gl](https://github.com/go-gl/gl)
- [go-gl/glfw](https://github.com/go-gl/glfw)
- [go.geo](https://github.com/paulmach/go.geo)

#### TODO

- more realistic gravity
- enemies intelligence

repository: austinov/gopher-game

repo_name: austinov/gopher-game


text:
# Stock Forecasting using Kats

Using Kats to perform forecasting of stock prices. Data retrieved from [yfinance](https://pypi.org/project/yfinance/).

repository: charlescsr/stock-forecasting-with-kats

repo_name: charlescsr/stock-forecasting-with-kats


text:
[![build status](http://teamcity.codebetter.com/app/rest/builds/buildType:id:FluentTc/statusIcon)](http://teamcity.codebetter.com/viewType.html?buildTypeId=FluentTc&guest=1) [![code coverage](https://img.shields.io/teamcity/coverage/FluentTc.svg)](http://teamcity.codebetter.com/viewType.html?buildTypeId=FluentTc&guest=1) [![NuGet version](https://badge.fury.io/nu/FluentTc.svg)](https://badge.fury.io/nu/FluentTc)  [![Chat on gitter](https://img.shields.io/gitter/room/QualiSystems/FluentTc.svg)](https://gitter.im/QualiSystems/FluentTc) [![Stories in Ready](https://badge.waffle.io/QualiSystems/FluentTc.png?label=ready&title=Ready)](https://waffle.io/QualiSystems/FluentTc)

# FluentTc
Easy-to-use, readable and comprehensive library for consuming TeamCity REST API. Written using real scenarios in mind, enables variuos range of queries and operation on TeamCity

# Getting started

Install __FluentTc__ nuget package from from Manage Nuget packages

Or from Nuget Package Manager Console:
__install-package FluentTc__

# Example
```C#
var builds = new RemoteTc().Connect(_ => _.ToHost("tc"))
    .GetBuilds(
        _ => _.BuildConfiguration(x => x.Id("bt2"))
              .NotPersonal()
              .NotRunning()
              .Branch(_ => _.NotBranched()),
        _ => _.Start(10).Count(5),
        _ => _.IncludeStartDate().IncludeFinishDate());
```

For more examples and documentation read the [Wiki](https://github.com/QualiSystems/FluentTc/wiki)

## License
[Apache License 2.0](https://github.com/QualiSystems/FluentTc/blob/master/LICENSE)

## Credits
[![Continuous Integration powered by TeamCity and CodeBetter](https://resources.jetbrains.com/assets/banners/jetbrains-com/Codebetter.png)](http://codebetter.com/codebetter-ci/)

repository: IgalShkolnikXPO/FluentTc

repo_name: IgalShkolnikXPO/FluentTc


text:
---
title: How to Save UI Designers and Developers 50% of Their Time
date: "2018-06-23T22:40:32.169Z"
template: "post"
draft: true
slug: "/posts/how-to-save-ui-designers-and-developers-up-to-50%-of-their-time"
category: "Design"
tags:
  - "Design"
  - "UI"
  - "Design Systems"
description: "In my life as a UI Designer, I enjoyed a similar child-like excitement when exploring the Sketch App for the first time."
---

Warning: This article has a lot of funny & unfunny memes, as well as detailed graphics. Hook up to some of that WiFi stuff first unless you want to haemorrage data. It’s also really long, so grab some popcorn & a cold drink.

## Christmas in January?

When you were a young child, Christmas was really, really exciting. Literally I-am-going-to-pee-myself-with-excitement exciting. Contemplating what presents Santa would bring, as well as opening them, constituted a month of unimaginable excitement & joy.

In my life as a UI Designer, I enjoyed a similar child-like excitement when exploring the Sketch App for the first time:

“Are you serious?!  Why did no-one tell me about this before?! This is incredible.”

As a designer, there have been two stages in my professional life: Life ‘Before Sketch’ (BS) & life ‘After Sketch’ (AS).

Let’s not talk about life BS.  Everything looked a bit different, a bit off, a bit pixelated. It took about a week to create a header, let alone a single screen.

Life AS has been great. You could probably get a team of toddlers together to make up a design team in the AS world.

You can re-use stuff. It’s all beautifully vectorised. Nice & organised. It’s quick. Intuitive. Easy.

It may be early January, but Christmas has come early this year. Welcome to the world of object-driven design.

N.B. Whilst writing this in Jerusalem & the West Bank, I saw a number of Christmas trees still up… It has since come to my attention that Christmas is, in fact, in January in some Orthodox Christian calendars. And there I was thinking my headline was absurd & attention-grabbing…

In this informative & fun-filled article, I will identify:

What object-driven design is
Why the problem has not been solved already
Why not adopting it is such a big risk
How to implement it in your design process
By implementing my methodology, your design-to-development (what I’ll refer to as ‘D2D’) process will genuinely improve ten-fold, allowing your UI Designers to spend more time designing for delight & your Front-End Developers to nerd out on actually building stuff, rather than editing pixel distances.

## Why should you care?

Many a Product Manager & UI Designer will read this & think,

“Tell me something I don’t know. I’ve been using Sketch’s Symbols feature & typography classes for 3 years.

And they wouldn’t be wrong. I imagine most designers do create re-usable Symbols (‘objects’ in programming terms) in their Sketch files to some extent.

However, not a single UI Designer I have worked with in the last 2 years has created a comprehensive approach to neutralising inefficiency in the D2D handover process.

## 3 Reasons Why The Problem Exists

Before delving into the D2D problem itself, it is important to clarify precisely why D2D inefficiencies exist in the first place when there are so many design tools out there.

1. Benchmarking to Mediocrity

Unfortunately many readers will confidently assume that this is not a problem they or their company suffer from.

This is because productivity & efficiency are relative. Very few UI Designers & Product Managers are aware that there is a better design process than their current one.

We tend to benchmark off other startups & UI Designers around us. If everyone is working the same way, it’s probably the most efficient one, right?

Wrong.

It is a common human bias to base our conception of anything — efficiency in this case — off the information available to us.

An example:

Say I am overweight, but all my friends are obese. Because those around me are obese, I will think that I am a healthy guy because my points of references (i.e. my obese friends) are less healthy than I am.

However, just because they are less healthy than me does not necessarily mean that I am healthy. I am still overweight.

Therefore, to overcome benchmarking & potential mediocrity, always try to innovate in order to make great leaps in efficiency, rather than small, incremental changes.

“If I had asked people what they wanted, they would have said faster horses.”
— Henry Ford
2. Unwarranted trust in product development methodologies

D2D inefficiencies also tend to occur because we assume that whatever product management methodology we work with in our company has already nullified any major inefficiences.

This is not the case with the D2D process.

Firstly, regardless of whether you follow agile, lean or design thinking — or a mixture of these — there will always be inefficiencies. Particularly inefficiencies that you are never even aware of.

Secondly, you will inevitably find that, as projects start, as Jeff Gothelf, author of LeanUX, states, teams immediately start “pulling away from each other, as opposed to collaborating more effectively” due to lack of alignment or to competing methodologies.

This tends to mean that a designer’s resources are stretched, shared out between a few PMs & a horde of developers. It means that everything tends to be chaotic & disorganised. The UI Designer therefore rarely feels able to stop & apply the design thinking necessary to accelerate their design process & lend it greater agility.

Only by following an object-driven design process is this velocity & agility possible.

3. Designers & Developers are Different

Furthermore, we all tend to assume that weekly design reviews, retrospectives & omniscient PMs effectively align everyone. True, alignment on what is being worked on is achieved, but not how it should be worked on.

And this comes down to a fundamental misunderstanding — or knowledge gap — between UI Designers & Front-End Developers.

UI Designers tend to consider themselves artists. Their work is a work of art. If only users could understand the beauty of their work, they would have millions of users.

They tend to love typography & be passionate about artesanal, hand-crushed coffee. Their favourite colour is #FEB4B1.

Developers, on the other hand, just want to programme cool stuff. They don’t care what it looks like. ‘Style’ to them is an elusive concept left to the artists, as alien to them as ‘dating’. They don’t really understand why that shade of red is too red or why that header text should be just a little bit to the left.

They are happiest when left alone to programme some weirdly complex new project.

In essence, they are different people. With very different skills. Different ways of thinking. Different interests.

They each think that each other’s area of expertise is mind-bogglingly complex & completely incomprehensible. They therefore avoid each other’s domain at all costs.

Both groups tend to be unaware — or, quite frankly, don’t care — that the visual work of a UI Designer & a Front-End Developer nowadays shares a lot of cross-over.

If both groups therefore aligned over a definitive design language (i.e. the objects (‘Symbols’ in Sketch)) that they used, the D2D process would be incredibly simple & fast.

However, because each group remains siloed & uninterested in each other’s craft, there remains a significant knowledge gap between them that leads to inefficiencies in a team’s D2D process.

It therefore makes sense to align your UI Designers & Front-End Developers to nullify these inefficiencies:

“Patterns that yield good outcomes should be amplified. Those that are causing problems should be remedied.”
— Jeff Gothelf, Author of Lean UX

## 4 Reasons Failing To Follow Object-Driven Design is a Big Problem

1. Not creating a design system wastes a huge amount of designer & developer time

Simple UI vs. Complex UI
The UI Designer

Theoretically, a D2D handover should be fairly straight-forward.

Theoretically, the UI Designer will have already aligned with the Front-End Developer & they will seemlessly work together on a simple solution.

Theoretically, both will re-use elements from a predefined design language that both know well. A quick copy & paste in Sketch; a simple line of code.

However, theory rarely translates into reality.

The reality is that the majority of UI Designer’s spend a lot of time designing custom, new elements.

Firstly, this is because they are not developers & therefore do not understand why it is a lot more work to actually implement something new.

Secondly, many UI Designer’s consider their work an art, rather than a science, & are therefore unwilling to sacrifice perceived beauty for pragmatism.

Can’t make money being an artist. Dreams shattered. Becomes UI Designer.
Rather than shipping something quickly — as well as something that is easy to implement — they will spend the majority of their time making small tweaks to existing elements.

They focus too much time on the minor (e.g. moving text a few pixels) rather than the major (e.g. building & testing that big new feature).

The minutiae is important, but it is difficult to justify when an existing UI element would serve well already.

This problem is also aggregated by the fact that a UI Designer focusing on the minutiae slows down any iterative process in place. Design reviews are pushed back, the PM isn’t up-to-date & the designer tends to spends a lot more time siloed in their own work.

### The Front-End Developer

By the time the Front-End Developer receives the final design he or she is expected to implement, there have likely already been a few meetings to ensure everyone is clear on the expectations.

However, we tend to still see a number of inefficiencies here because:

Front-End Developers tend to assume that there is some very important reason each design is exactly as it is. They assume that difficult-to-implement clock dial has to look exactly like that initial design because they view all the UI Designer’s work as that of an expert. They therefore don’t try to simplify or discuss. They just assume there is some clever reasoning behind everything & that the UI Designer will create the perfect solution on the first attempt

Front-End Developers tend to hate meetings more than most. Therefore, rather than wanting a long, drawn-out debate about whether the font size should be 12px or 14px, they just want to agree on a design, finish the meeting ASAP & happily go back to programming

Front-End Developers tend to be introverted and/or timid. They are therefore unlikely to stand up to the more confident PM & more egotistical UI Designer
Therefore, despite the meetings & the design reviews, they still end up implementing something that is new, something that is difficult to implement & something that has not been properly critiqued.

Pretending to listen, but dreaming about that really sweet class he just created

2. D2D inefficiencies compounds over time

The longer you leave D2D inefficiencies, the greater the waste of resources over time for existing, as well as future, team members. This seems obvious, but is usually over-looked.

We focus on short-term goals (finishing the sprint or getting through the backlog), rather than investing in our long-term success goals — and ultimate success.

We don’t stop to solve the inefficiencies in the race to fulfil our sprint goals or to get through that long list of features & bugs to build.

Because it’s easier to focus on the short-term. Because we are stressed. Because we rarely ever stop to think in our pursuit of ‘being busy’ & the sense of purpose it provides us.

3. No design system = design debt

The less structured a UI Designer’s approach to the design process is, the more design debt you are building up.

Let’s take an example:

Say I design all of my icons in different sizes. Some at 24x24, some 40x24, some 12x16. Not only is this wasting a developer’s resources (as highlighted in my first point), but it also means that any future development changes are impeded. That is because, if we want to then change these icons in future, they have to be designed at the exact same size for each case in order to not cause mis-alignment or stretching in both our design file & our final product.

Creating all your icons as a consistent size means a developer can replace them with one word of code & the designer with a quick scroll down their list of Symbols in Sketch

Furthermore, within a UI Designer’s Sketch file, by not creating very strict typography & colour classes, as well as re-usable Symbols (e.g. all buttons being 24x24), we impede our ability to edit existing elements.

Rather than being able to make a major change to a text style throughout the product with one click, for example, we need to manually go through every single screen within Sketch to make that change. For an app with more than just a handful of screens, going through & making such changes can waste the majority of a UI Designer’s time (and that is no exaggeration).

4. Not creating a design system impedes collaboration

Without a design system in place, the majority of a UI Designer’s time is spent creating new designs or painstakingly editing existing designs.

This means they have less time to brainstorm & try new ideas within Sketch with a PM or Front-End Developer.

Having a design review where the team can test out different options — or edit the designs being discussed live — is great for getting the entire team’s input & support for a design.

“Teams with a continuous exchange of feedback will build better products.”
— Jim Semick, InVision

Furthermore, it avoids the need for the UI Designer to go back to the drawing board & to organise another one or two design reviews to discuss the same thing again. This saves the entire team a lot of time.

## How To Implement Object-Driven Design

Hopefully I have convinced you of the importance of implementing a design system by now.

In the following section, I will discuss the importance of changing your UI Designer’s approach to their work, before delving into the specifics of building & maintaing a design system.

#### Step 1: Taking ownership of the D2D process

Before committing to following object-driven design, it is essential to ensure that the UI Designer is properly motivated.

If they are doing this because of some vague idea that it will make the team more efficient — or they are just being told to do it — then don’t bother.

If, however, your UI Designer considers the D2D-handoff a key part of their role & entirely their responsibility, then they will be motivated enough to not only complete the work of building a design system, but to maintain & build upon it in the long-term.

Let me emphasise an important point: Building a design system is not just a one-off task. Every time you create new designs or test out ideas, they should all be properly structured & organised within your design system for future use.

Taking full responsibility for the D2D process must be something the UI Designer believes in completely. If not, then they will never learn enough — or ask enough — about how designs are programatically implemented to help them improve their design process.

They need to be reading articles such as this one, doing a basic programming course, reading Material Design guidelines, watching a Front-End Developer work for a few hours a week, learning from the PM, developers, other designers, etc.

In short, they cannot retreat back into Sketch & Dribbble, sacrificing important learnings in order to focus on what they enjoy & feel comfortable with.

#### Step 2: Building a Design System

Building a design system’s purpose, at its core, is to create a comprehensive list of elements based on the principles of object-orientated programming. The desired outcome is to closely align designers with programmers around the design system you create in Sketch to radically increasing their velocity as a team.

Better communication between these two groups leads to a better understanding between them, which in turn leads to your team creating better products.

1/7 Start with the basics: colour & typography

Object-driven design requires starting with the basics, namely defining your colours & typography classes. This is because other elements will require this information: A button needs a colour, a row of text requires a typography class.

2/7 Create objects for one screen

By building an example screen, you will rapidly understand how the principles of object-driven design work in practice. In my experience, only by applying the theory in an iterative manner can you effectively learn how to create a full design system.

On your first attempt, don’t worry about being too comprehensive. This is because you will quickly realise how creating elements* works once you try to build a few example screens.

Maybe start with a header (with text & buttons), some text rows & whatever else you want to experiment with. Remember that consistency requires minimalising how many elements you create.

(Elements refer to a group of Symbols, such as a row or a header).

3/7 Overrides (changing the information within an element)

You’ll see on the right-hand panel (under ‘Overrides’) in Sketch that, if you select a Symbol, the information within that object can be changed, such as the text within a header.

Notice how the style does not change, however. This is essentially how front-end programming works:

You define the visual UI (e.g. font-size, position, left-align) but you pull the information for the actual content (a name, address, icon, etc.) from your database.

You can define where a button goes & its size, for example, but you pull the actual image from a data-base where all your button images are stored.

4/7 Create a few example screens

Now that you have seen the power of Overrides, you see what types of Symbols you will need to create, as well as how Symbols can fit within other Symbols (such as a button within a header).

Hopefully you also realise how much organisation & thoughtful planning this process requires. You may have defined some typography classes, for example, but I doubt you created a variation for left-, center- or right-aligned.

Try to create 4–5 screens now, all based on pre-defined Symbols. Don’t worry if it’s still disorganised & some screens don’t quite work: Realising your errors & learning from them is essential to the learning process.

5/7 Naming your Symbols correctly

By now, you should have a good understanding of how to build a full design system.

Information architecture essentially refers to structuring information in a logical, optimal manner.

In the case of a design system, this means structuring all of your objects so that the commonly used objects are easily accessible, they are named logically & there is a clear hierarchy.

To do this comprehensively, make sure you go through the entire product & identify all the Symbols you need to create & how best to organise them. What do you use most often? How would another designer find these Symbols? What would they expect each Symbol to be called?

Failing to do this correctly will mean a huge amount of time wasted finding objects, re-naming them in future & an inability to add Symbols in future in a logical manner.

6/7 Creating a comprehensive Design System

Now that you’ve created a few Symbols, have identified which Symbols you will need to build for your product & have created a naming structure, it’s time to complete the entire design system.

Set aside a day or two to fully focus on this task in order to immerse yourself in it & to keep the design system’s structure clear in your head.

As you work through it, you are likely to realise errors in your naming structure. Therefore keep checking your naming structure, building test screens & checking for consistency as you go.

Your product is unique, so the Symbols you need to create will be unique. Therefore you will have to think for yourself how best to structure your design system, as well as what to include.

7/7 Design Review

Organise a design review with your PMs, UX/UI Designers & Front-End Developers to present the new design system.

You are likely to find that all members of the team will instantly see value in it. The Front-End Developers are happy because they have a definitive document to work from, PMs because they can rapidly prototype with the designers, designers because they can all work off the same design system within Sketch.

Once you’ve finished high-fiving, popping bottles & generally celebrating in a exuberant manner, save your design system as a ‘Template’ under Sketch & share with the other UI Designers.

#### Step 3: Maintaining your Design System

Once completed, you will also need to maintain your design system moving forward.

Any new design ideas should be correctly built & organised as Symbols, even if they are unlikely to be included in the final product.

This is because you are most likely a busy person with a lot on your plate. It’s therefore pretty unlikely you’ll remember to go back, re-design the final designs as Symbols & name them correctly. It’s also going to waste more time than just doing it right in the first place.

Remember: However busy you are, working as fast as possible in the short-term will build up long-term technical debt.

Furthermore, if you work in a team of more than one UI Designer, you will all need to contribute to the design system moving forward.

This requires every member of your team to be organised. It also requires somebody to take charge of the design system, adding any new Symbols to your product’s ‘Library’ within Sketch so that all team members have access to all pre-existing & new Symbols.

This UI Designer should also regularly update the master file online, so that all team members have access to the most recent version, as well as avoiding any wasted time with losing unsaved files. I would recommend using Github for this or Sketch Cloud. You can also pay for Abstract, which is a more visual, designer-friendly way of tracking your file versions.

Being so organised may seem unnecessary if you’re in a small team, but at some point you are likely to scale your team. If you don’t have an up-to-date design system in place, how will new UI Designers even know where to start? How will you be able to onboard them? Why waste their — and your — time?

#### Step 4: Innovation never ends

As I stated in Step 1, a core ingredient to this process is taking responsibility. It’s easy to just stick to what’s expected of you. It’s hard to take responsibility & to be an entrepreneur yourself within the company.

But it’s essential to success.

You must be vigilant, constantly learning, constantly looking for new tools to skill up & improve your workflow.

Sketch App is constantly improving. The community is constantly making cool new plugins. Other platforms are emerging as competitors, such as Adobe XD. Test these tools out. Actively search for them.

Top companies spend 5–15% of revenue on training employees. If you are a UI Designer, insist on spending an afternoon each week on new technologies. Test products out with a free trial or ask for a budget.

Always remember that the short-term, the urgent, the seemingly important — that’s not the key to success. A failure to invest in yours & your company’s long-term future is.

repository: henrylatham/portfolio

repo_name: henrylatham/portfolio


text:
# Real-time Message Routing

## Usage scenarios

Jiguang can help developers achieve the following scenarios:

    1. Save chat history in real time on APP's own server
    2. Developers can automatically respond to the content of customer messages

If developers need to activate this feature, please contact: [Business customer service](https://www.jiguang.cn/accounts/business/form); if developers do not have real-time requirements, it is recommended to use the free IM REST Report to pull history messages.

## Current service supports https and http callbacks

Regarding developer authentication, in order to prevent developer services from being called at will, the verification of developer service uses HTTP Basic mechanism, that is, adding a field (Key/Value pair) to the HTTP Header:

Authorization: Basic base64_auth_string

The generation algorithm of base64_auth_string is：base64(appKey:masterSecret)

That is, adding a colon to the appKey, plus the string assembled by masterSecret, and do a base64 conversion then.

Msg callback brings Authorization: Basic base64_auth_string to verify developer service when requested

### The https interface uses the post method

**Request header**

```
Content-Type: application/json; charset=utf-8
```

**Request Body**
```
 {
 "total":1,
 "messages":[
 {
  "target_type":"single",
  "msg_type":"text",
  "target_name":"JMessage",
  "target_id":"10000002",
  "from_id":"10000001",
  "from_name":"JPush",
  "from_type":"user",
  "from_platform":"a",
  "msg_body":{
   "text":"text",
   "extras":{
   }
  },
 "create_time":1446016259,
 "version":1,
 "msgid":12345678,
 "msg_level": 0,
 "msg_ctime" :<PHONE_NUMBER>352 // 服务器接收到消息的时间，单位毫秒
 }
 ]
}
```

Same format as the REST Report history message

### Successful response required by msg callback

Response

```
  HTTP/1.1 200
  Content-Type: application/json; charset=utf-8
```


text:
> [Wiki](Home) ▸ [[Documentation]] ▸ **Marks**

Marks are the basic visual building block of a visualization. Similar to other mark-based frameworks such as [Protovis](http://protovis.org), marks provide basic shapes whose properties can be set according to backing data. Mark properties can be simple constants or data fields, and [Scales](Scales) can be used to map from data to property values. The basic supported mark types are rectangles (`rect`), plotting symbols (`symbol`), general paths or polygons (`path`), circular arcs (`arc`), filled areas (`area`), lines (`line`), images (`image`) and text labels (`text`).

Each mark supports a set of visual _properties_ which determine the position and appearance of mark instances. Typically one mark instance is generated per input data element; the exceptions are the `line` and `area` mark types, which represent multiple data elements as a contiguous line or area shape.

There are three primary property sets: _enter_, _exit_ and _update_. _Enter_ properties are evaluated when data is processed for the first time and a mark instance is newly added to a scene. Similarly, _exit_ properties are evaluated when the data backing a mark is removed, and so the mark is leaving the visual scene. The _update_ properties are evaluated for all existing (non-exiting) mark instances. To better understand how enter, exit and update sets work, readers may wish to peruse [related D3 tutorials](http://bost.ocks.org/mike/join/). In addition, an optional _hover_ set determines visual properties when the mouse cursor hovers over a mark instance. Upon mouse out, the _update_ set is applied.

There is also a special group mark type (`group`) that can contain other marks, as well as local scale, axis and legend definitions. Groups can be used to create visualizations consisting of grouped or repeated elements; examples include stacked graphs (each stack is a separate group containing a series of data values) and small multiples displays (each plot is contained in its own group). See [Group Marks](Group-Marks) for more.

A mark definition typically looks something like this:
```json
{
  "type": "rect",
  "from": {"data": "table"},
  "properties": {
    "enter": {...},
    "exit": {...},
    "update": {...},
    "hover": {...}
  }
}
```

### Top-Level Mark Properties

| Property      | Type          | Description    |
| :------------ |:-------------:| :------------- |
| type          | String        | The mark type (`rect`, `symbol`, `path`, `arc`, `area`, `line`, `rule`, `image`, `text`, `group`)|
| name          | String        | A unique name for the mark instance (optional). As of Vega v1.4.0, the SVG renderer adds the _unaltered_ name value as CSS class names on the enclosing SVG group (`g`) element for mark instances.|
| description   | String        | An optional description of this mark. Can be used as a comment.|
| from          | Object        | An object describing the data this mark set should visualize. The supported properties are `data` (the name of the data set to use) and `transform` (to provide an array of data transformations to apply). If the `data` property is not defined, the mark will attempt to inherit data from its parent group mark, if any. Otherwise, a default, single element data set is assumed.|
| properties    | Object        | An object containing the property set definitions.|
| key           | String        | A data field to use as a unique key for data binding. When a visualization's data is updated, the key value will be used to match data elements to existing mark instances. Use a key field to enable object constancy for transitions over dynamic data.|
| delay         | ValueRef -> Number | The transition delay, in milliseconds, for mark updates. The delay can be set in conjunction with the backing data (possibly through a scale transform) to provide staggered animations.|
| ease          | String        | The transition easing function for mark updates. The supported easing types are `linear`, `quad`, `cubic`, `sin`, `exp`, `circle`, and `bounce`, plus the modifiers `in`, `out`, `in-out`, and `out-in`. The default is `cubic-in-out`. For more details please see the [D3 ease function documentation](https://github.com/mbostock/d3/wiki/Transitions#wiki-d3_ease).|

### Mark Property Sets

The rest of this page describes the available mark properties in greater detail. All visual mark property definitions are specified as name-value pairs in a property set (such as `update`, `enter`, or `exit`). The name is simply the name of the visual property. The value should be a _ValueRef_ or _Production Rule_, as defined below.

### Value References

A value reference (or _ValueRef_) specifies the value for a given mark property. The value may be a constant or a value in the backing data, and may include the application of a scale transform to either.

| Name          | Type          | Description  |
| :------------ |:-------------:| :------------|
| value         | *             | A constant value. If _field_ is specified, this value is ignored.|
| field         | String, Object| A field (property) from which to pull a data value. The corresponding data set is determined by the mark's _from_ property. Dot notation (`"price.min"`) is used to access nested properties; if a dot character is actually part of the property name, you must escape the dot with a backslash: `"some\.field"`.|

If the _field_ property is an object, the following properties may be used

| Property      | Type          | Description    |
| :------------ |:-------------:| :------------- |
| datum         | String, Object| Perform a lookup on the current data value (the default operation when `field` is a string).|
| group         | String, Object| Use a property of the enclosing group mark element (e.g., `width` or `height`).|
| parent        | String, Object| Use a property of the enclosing group mark's datum.|

These properties can be arbitrarily nested in order to perform _indirect_ field lookups. For example, `"field": {"parent": {"datum": "f"}}` will first retrieve the value of the `f` field on the current mark's data object. This value will then be used as the property name to lookup on the enclosing group mark's datum.

**Advanced Use**

`group` and `parent` properties can be given an optional `level` to access grandparents, and higher ancestors. For example, `"field": {"parent": "f", "level": 2}` will use the value of the `f` field of the grandparent's datum. By default, `level = 1` (i.e., parents).

| Property      | Type          | Description    |
| :------------ |:-------------:| :------------- |
| scale         | String, Object| The name of a scale transform to apply. If the input is an object, it indicates a field value from which to dynamically lookup the scale name and follows the format described above. For example `{"datum": "s"}` will use the value of `s` on the current mark's data as the scale name, whereas `{"parent": "t"}` will use the value of `t` on the current group's data as the scale name.|
| mult          | Number        | A multiplier for the value, equivalent to (mult * value). Multipliers are applied after any scale transformation.|
| offset        | Number        | A simple additive offset to bias the final value, equivalent to (value + offset). Offsets are added _after_ any scale transformation and multipliers.|
| band          | Boolean       | If true, and _scale_ is specified, uses the range band of the scale as the retrieved value. This option is useful for determining widths with an ordinal scale.|

##### Examples

The constant value `5`.
```
{"value": 5}
```

The value of `price`, for the current datum.
```
{"field": "price"}
```

The value of `index` for the current datum, multiplied by 20.
```
{"field": "index", "mult": 20}
```

The result of running the value `0` through the scale named `x`.
```
{"scale": "x", "value": 0}
```

The result of running `price` for the current datum through the scale named `y`.
```
{"scale": "y", "field": "price"}
```

The range band width of the ordinal scale `x`. Note that the scale must be ordinal
```
{"scale": "x", "band": true}
```

The range band width of the ordinal scale `x`, reduced (negative offset) by one pixel.
```
{"scale": "x", "band": true, "offset": -1}
```

### Color References

Typically color values are specified as a single value indicating an RGB color. However, sometimes a designer may wish to target specific color fields or use a different color space. In this case a special Value Reference format can be used. In the following example, we can set the red and blue channels of an RGB color as constants, and determine the green channel from a scale transform.
```
"fill": {
 "r": {"value": 255},
 "g": {"scale": "green", "field": "g"},
 "b": {"value": 0}
}
```

Vega supports the following color spaces

| Name          | Description  |
| :------------ | :------------|
| [RGB](http://en.wikipedia.org/wiki/RGB_color_space)| with properties `"r"`, `"g"`, and `"b"`.|
| [HSL](http://en.wikipedia.org/wiki/HSL_and_HSV)| (hue, saturation, lightness), with properties `"h"`, `"s"`, and `"l"`.|
| [CIE LAB](http://en.wikipedia.org/wiki/Lab_color_space)| with properties `"l"`, `"a"`, and `"b"`. A perceptual color space with distances based on human color judgments. The "L" dimension represents luminance, the "A" dimension represents green-red opposition and the "B" dimension represents blue-yellow opposition.|
| [HCL](https://en.wikipedia.org/wiki/Lab_color_space#Cylindrical_representation:_CIELCh_or_CIEHLC)            | (hue, chroma, lightness) with properties `"h"`, `"c"`, and `"l"`. This is a version of LAB which uses polar coordinates for the AB plane.|

### Templates

For String-type properties (e.g., `text` for text marks), a special `template` property can be used instead of a Value Reference. The specified template string can make sure of handlebars, such as ``{{datum.price}}``, to refer to data fields. `datum`, `parent`, and `group` are available for use within the handlebars, and dot notation may be used to refer to nested properties.

Handlebars also support a number of *filters* for text transformation. Filters are specified within a template variable using a pipe-delimited syntax (`{{property | filter1 | filter2 }}`). Some filters may take one or more arguments (`{{property | filter:arg1,arg2 }}`). The available filters are:

| Name          | Description  |
| :------------ | :------------|
| length        | return the length of a string.|
| lower         | maps a string to lowercase (calls `String.toLowerCase()`).|
| upper         | maps a string to uppercase (calls `String.toUpperCase()`).|
| lower-locale  | maps a string to lowercase (calls `String.toLocaleLowerCase()`).|
| upper-locale  | maps a string to uppercase (calls `String.toLocaleUpperCase()`).|
| trim          | remove whitespace at the beginning and end of a string (calls `String.trim()`).|
| left:n        | returns the _n_ left-most characters of a string.|
| right:n       | returns the _n_ right-most characters of a string.|
| mid:n         | returns the _n_ central characters of a string.|
| slice:a,b     | returns a substring according to `String.slice(a, b)`.|
| pad:n,pos     | pads the string with whitespace using the provided length (_n_) and optional position argument (_pos_).|
| truncate:n,pos| truncates the string with the provided length (_n_) and an optional position argument (_pos_).|
| number:fmt    | formats the string as a number using the provided format (_fmt_) string. The filter uses [D3's formatting utilities](https://github.com/mbostock/d3/wiki/Formatting) and accepts a valid D3 number format pattern.|
| time:fmt      | formats the string as a date/time using the provided format (_fmt_) string. The filter uses [D3's time formatting utilities](https://github.com/mbostock/d3/wiki/Time-Formatting) and accepts a valid D3 time format pattern.|

For example,
```json
"text": {
  "template": "{{datum.name}} was bought on {{parent.stamp|time:'%A'}}."
}
```

### Production Rules

Visual properties can also be set by evaluating an `if-then-else` style chain of _production rules_. A single `rule` property is specified as an array of _ValueRef_ objects, each of which must contain an additional `predicate` property. This is used to invoke a [predicate](Predicates) definition and supply any necessary arguments. A single ValueRef without a predicate may be specified as the final element within the rule to serve as the `else` condition.

The visual property is set to the ValueRef corresponding to the first predicate that evaluates to `true` within the rule. If none do, the property is set to the final, predicate-less, ValueRef if one is specified. For example, the following specification sets a mark's fill colour using a production rule:

```json
"fill": {
  "rule": [
    {
      "predicate": {
        "name": "isSelected",
        "id": {"field": "_id"}
      },

      "scale": "c",
      "field": "species"
    },
    {"value": "grey"}
  ]
}
```

Here, the `isSelected` predicate is invoked with an `id` argument (argument values are ValueRefs too!) and, if it evaluates to true, the fill colour is determined by a scale transform. Otherwise, the mark is filled grey.

### Shared Visual Properties

| Property            | Type                | Description  |
| :------------------ |:-------------------:| :------------|
| x                   | ValueRef -> Number  | The first (typically left-most) x-coordinate.|
| x2                  | ValueRef -> Number  | The second (typically right-most) x-coordinate.|
| width               | ValueRef -> Number  | The width of the mark (if supported).|
| y                   | ValueRef -> Number  | The first (typically top-most) y-coordinate.|
| y2                  | ValueRef -> Number  | The second (typically bottom-most) y-coordinate.|
| height              | ValueRef -> Number  | The height of the mark (if supported).|
| opacity             | ValueRef -> Number  | The overall opacity.|
| fill                | ValueRef -> Color   | The fill color.|
| fillOpacity         | ValueRef -> Number  | The fill opacity.|
| stroke              | ValueRef -> Color   | The stroke color.|
| strokeWidth         | ValueRef -> Number  | The stroke width, in pixels.|
| strokeOpacity       | ValueRef -> Number  | The stroke opacity.|
| strokeDash          | ValueRef -> Array   | An array of alternating stroke, space lengths for creating dashed or dotted lines.|
| strokeDashOffset    | ValueRef -> Number  | The offset (in pixels) into which to begin drawing with the stroke dash array.|

For marks involving Cartesian extents (e.g., __rect__ marks), the horizontal dimensions are determined by (in order of precedence) the _x_ and _x2_ properties, the _x_ and _width_ properties, and the _x2_ and _width_ properties. If all three of _x_, _x2_ and _width_ are specified, the _width_ value is ignored. The _y_, _y2_ and _height_ properties are treated similarly. For marks without Cartesian extents (e.g., __path__, __arc__, etc) the same calculations are applied, but are only used to determine the mark's ultimate _x_ and _y_ position. That is, a _width_ property may affect the ultimate position, but otherwise is not visualized.

_Note:_ at the time of writing, the _strokeDash_ and _strokeDashOffset_ use bleeding-edge HTML5 canvas support, which can vary across browsers. Browsers with canvas implementations that do not support line dash or line dash offset will ignore these properties. Firefox only supports _strokeDash_ (through the `mozDash` proprietary canvas extension), not _strokeDashOffset_.

### rect

| Property            | Type                | Description  |
| ------------------- |:-------------------:| :------------|
|                     |                     | (No additional properties.)|

### symbol

| Property            | Type                | Description  |
| :------------------ |:-------------------:| :------------|
| size                | ValueRef -> Number  | The pixel area of the symbol. For example: in the case of circles, the radius is determined in part by the square root of the size value.|
| shape               | ValueRef -> String  | The symbol shape to use. One of `circle` (default), `square`, `cross`, `diamond`, `triangle-up`, or `triangle-down`|

### path

| Property            | Type                | Description  |
| :------------------ |:-------------------:| :------------|
| path                | ValueRef -> PathString| A path definition in the form of an SVG Path string.|

### arc

| Property            | Type                | Description  |
| :------------------ |:-------------------:| :------------|
| innerRadius         | ValueRef -> Number  | The inner radius of the arc, in pixels.|
| outerRadius         | ValueRef -> Number  | The outer radius of the arc, in pixels.|
| startAngle          | ValueRef -> Number  | The start angle of the arc, in radians. A value of `0` indicates up or "north", increasing values proceed clockwise.|
| endAngle            | ValueRef -> Number  | The end angle of the arc, in radians. A value of `0` indicates up or "north", increasing values proceed clockwise.|

### area

| Property            | Type                | Description  |
| :------------------ |:-------------------:| :------------|
| interpolate         | ValueRef -> String  | The line interpolation method to use. One of `linear`, `step-before`, `step-after`, `basis`, `basis-open`, `cardinal`, `cardinal-open`, `monotone`.|
| tension             | ValueRef -> Number  | Depending on the interpolation type, sets the tension parameter.|

### line

| Property            | Type                | Description  |
| :------------------ |:-------------------:| :------------|
| interpolate         | ValueRef -> String  | The line interpolation method to use. One of `linear`, `step-before`, `step-after`, `basis`, `basis-open`, `basis-closed`, `bundle`, `cardinal`, `cardinal-open`, `cardinal-closed`, `monotone`.|
| tension             | ValueRef -> Number  | Depending on the interpolation type, sets the tension parameter.|

### image

| Property            | Type                | Description  |
| :------------------ |:-------------------:| :------------|
| url                 | ValueRef -> String  | The URL from which to retrieve the image.|
| align               | ValueRef -> String  | The horizontal alignment of the image. One of `left`, `right`, `center`.|
| baseline            | ValueRef -> String  | The vertical alignment of the image. One of `top`, `middle`, `bottom`.|

### text

| Property            | Type                | Description  |
| :------------------ |:-------------------:| :------------|
| text                | ValueRef -> String  | The text to display.|
| align               | ValueRef -> String  | The horizontal alignment of the text. One of `left`, `right`, `center`.|
| baseline            | ValueRef -> String  | The vertical alignment of the text. One of `top`, `middle`, `bottom`.|
| dx                  | ValueRef -> Number  | The horizontal margin, in pixels, between the text label and its anchor point. The value is ignored if the _align_ property is `center`.|
| dy                  | ValueRef -> Number  | The vertical margin, in pixels, between the text label and its anchor point. The value is ignored if the _baseline_ property is `middle`.|
| radius              | ValueRef -> Number  | Polar coordinate radial offset, in pixels, of the text label from the origin determined by the `x` and `y` properties.|
| theta               | ValueRef -> Number  | Polar coordinate angle, in radians, of the text label from the origin determined by the `x` and `y` properties. Values for `theta` follow the same convention of `arc` mark `startAngle` and `endAngle` properties: angles are measured in radians, with `0` indicating "north".|
| angle               | ValueRef -> Number  | The rotation angle of the text, in degrees.|
| font                | ValueRef -> String  | The typeface to set the text in (e.g., `Helvetica Neue`).|
| fontSize            | ValueRef -> Number  | The font size, in pixels.|
| fontWeight          | ValueRef -> String  | The font weight (e.g., `bold`).|
| fontStyle           | ValueRef -> String  | The font style (e.g., `italic`).|

### group

Group marks have the same visual properties as __rect__ marks. They can also contain children marks, as well as scales, axes and legends. See the [Group Marks](Group-Marks) page for more details.

repository: smclements/vega

repo_name: smclements/vega


text:
# IPCServiceManager

Android进程间通信框架

## 设计 ##
设计相关大图均在代码根目录下， 更多请参考[源码分析](http://blog.csdn.net/degwei);

![](https://raw.githubusercontent.com/devyok/IPCServiceManager/master/ServiceManager.png)

**各组件依赖关系，见下图：**

![](https://raw.githubusercontent.com/devyok/ServiceManager/master/lib_design_component.png)

**包依赖，见下图：**

![](https://raw.githubusercontent.com/devyok/ServiceManager/master/lib_design_package.png)

**lib-core类图，见下图：**

![](https://raw.githubusercontent.com/devyok/ServiceManager/master/lib_design_class_core.png)

**lib-exception类图，见下图：**

![](https://raw.githubusercontent.com/devyok/IPCServiceManager/master/lib_design_class_exception.png)

**各模块调用时序，见下图：**

![](https://raw.githubusercontent.com/devyok/IPCServiceManager/master/lib_design_seq_module_between_communication.png)

**初始化(ServiceManager#init)，见下图：**

![](https://raw.githubusercontent.com/devyok/IPCServiceManager/master/lib_design_seq_servicemanager_init.png)

**获取服务(ServiceManager#getService)，见下图：**

![](https://raw.githubusercontent.com/devyok/ServiceManager/master/lib_design_seq_servicemanager_getservice.png)

**添加服务(ServiceManager#addService)，见下图：**

![](https://raw.githubusercontent.com/devyok/IPCServiceManager/master/lib_design_seq_servicemanager_addservice.png)

## 插件执行流程 ##
![](https://raw.githubusercontent.com/devyok/IPCServiceManager/master/plugin_design_flow.png)

[如何集成使用](https://github.com/devyok/IPCServiceManager/blob/master/README.md)

## License ##
ServiceManager is released under the [Apache 2.0 license](https://github.com/devyok/ServiceManager/blob/master/LICENSE).

Copyright (C) 2017 DengWei.

repository: kakustham/IPCServiceManager

repo_name: kakustham/IPCServiceManager


text:
---
layout: post
title: newsgator-upgrade-aggrevations
---
NewsGator sent me an email today explaining how I should upgrade to the
latest and greatest version of their software.  I've been putting off
the upgrade for awhile now since I've heard tons of complaints about the
new version, but those complaints have died down and I've been hearing
good things again.  So I download the new "Outlook Edition" and run
through the setup.  I then proceed to open up Outlook and then I see
nothing.  No NewsGator.  w00t.

"No worries", I think. "I'll just head over to the support site."

On the support site I find a [knowledge base
article](http://newsgator.mykbpro.com/Article_2CBAA.aspx) that would
seem to help.  I try both of the ideas listed in the article.  One
required a registry tweak and the other had me validate that NewsGator
was not disabled by Outlook.  It's a pretty quick check so I followed
the directions:

- Go to Help | About MS Office Outlook

- Click the [Disabled Items] button and if NewsGator is listed

- If it is, select it and click the [Enable] button

- Restart Outlook

Well, NewsGator didn't show up disabled so I was out of luck.  I then
decided to shoot an email off to support:

"NewsGator is not loading when outlook starts up.  I already tried both
of the ideas listed here:
[http://newsgator.mykbpro.com/Article\_2CBAA.aspx](http://newsgator.mykbpro.com/article_2cbaa.aspx "http://newsgator.mykbpro.com/Article_2CBAA.aspx")

and here is the output of NewsGator diagnostics:

[diagnostics removed for brevity]"

So a few hours go by and I receive an email back:

"If the NewsGator button is missing:

- Go to Help | About MS Office Outlook

- Click the [Disabled Items] button and if NewsGator is listed

- If it is, select it and click the [Enable] button

- Restart Outlook

Regards,

[Name withheld]"

Okay.  WTF.  Did this person even read my email?  Talk about
exasperating.

Why even bother to have customer service and support when the person
doesn't take the time to even try to help?  The other frustrating part
of this email is that the author didn't leave the communication open.
There is no "I hope this helps" or "If you have any questions, please
let me know.".  That's important!  Rattling off some knowledge base
entry and then saying "Good bye" isn't any better than a bot.

I'm off to try to figure out what the heck happened to my NewsGator and
if I can't get this resolved soon I guess I'm going to have to find
another RSS aggregator.

extension: markdown


text:
## Build CLI and services

### Requirements

* [Go 1.15](https://golang.org/dl) or newer

### Clone the repository

```shell
$ git clone https://github.com/podops/podops.git
```

If you don't have git, you can download the source code as a file [archive from GitHub](https://github.com/podops/podops).
Each [release](https://github.com/podops/podops/releases) has a source snapshot.

### Command-line-interface (CLI)

#### Build

```shell
$ cd podops/cmd/cli
$ go build po.go
```

### API service

TBD

### CDN service

TBD

repository: gitter-badger/podops

repo_name: gitter-badger/podops


text:
| [Home](home.md) | [News](news.md) | [Gallery](gallery.md) | [Examples](examples.md) | [Downloads](downloads.md) | [Documentation](documentation.md) | [Support](support.md) | [Sources](https://github.com/gammasoft71/xtd) | [Project](https://sourceforge.net/projects/xtdpro/) | [Gammasoft](gammasoft.md) | [Website](https://gammasoft71.github.io/xtd) |

# Design Guidelines for Exception

Exception handling has many advantages over return-value-based error reporting. Good framework design helps the application developer realize the benefits of exceptions. This section discusses the benefits of exceptions and presents guidelines for using them effectively.

## In This Section

* [Exception Throwing](exception_throwing.md)
* [Using Standard Exception Types](using_standard_exception_types.md)
* [Exceptions and Performance](exceptions_and_performance.md)

## See also

* [Design Guidelines](design_guidelines.md)
* [Documentation](documentation.md)

______________________________________________________________________________________________

© 2023 Gammasoft.


text:
---
sub-product: Compliance in AEM as a Cloud Service
user-guide-title: Compliance in AEM as a Cloud Service
breadcrumb-title: Compliance Guide
user-guide-description: For an overview on compliance in  Experience Manager as a Cloud service, including an privacy and accessibility, start here.
feature: Release Information
role: Leader, Architect, Developer, Data Architect, Data Engineer, Admin, User
---

# Experience Manager as a Cloud Service Help {#compliance}

+ [Compliance in AEM as a Cloud Service](/help/compliance/home.md)
+ Data Privacy and Protection Readiness {#data-privacy}
  + [AEM Readiness for Data Protection and Data Privacy Regulations](/help/compliance/data-privacy-and-protection-readiness/aem-readiness.md)
  + [AEM Foundation Readiness for Data Protection and Data Privacy Regulations](/help/compliance/data-privacy-and-protection-readiness/foundation-readiness.md)
  + [AEM Sites Readiness for Data Protection and Data Privacy Regulations](/help/compliance/data-privacy-and-protection-readiness/sites-readiness.md)
+ Accessibility {#accessibility}
  + [AEM as a Cloud Service and the Web Accessibility Guidelines](/help/compliance/accessibility/web-accessibility.md)
  + [A Quick Guide to WCAG 2.1](/help/compliance/accessibility/quick-guide-wcag.md)


text:
# mkdocs-replace-markdown

An MkDocs plugin to replace text in Markdown on build.

## Installation & Setup

Install the package with pip:

```
pip install mkdocs-replace-markdown
```

Enable the plugin in your mkdocs.yml:

```yaml
plugins:
    - search
    - replace_markdown:
        patterns:
            - pattern_1: # Pattern name, can be anything
                url: "my/url/scheme" # Only replace text on pages that match the given URL
                oldvalue: "replace me"
                newvalue: "with this"
            - pattern_2: # Next pattern
                url: "my/other/url/scheme"
                oldvalue: "other text"
                newvalue: "new value"
```

> **Note:** If you have no `plugins` entry in your config file yet, you'll likely also want to add the `search` plugin. MkDocs enables it by default if there is no `plugins` entry set, but now you have to enable it explicitly.

repository: wilhelmer/mkdocs-replace-markdown

repo_name: wilhelmer/mkdocs-replace-markdown


text:
# DCML C2C

## Contains
- [x] [React](https://facebook.github.io/react/)
- [x] [React Native](https://facebook.github.io/react-native/)
- [x] [Typescript](https://www.typescriptlang.org/)
- [x] [Redux](https://github.com/reactjs/redux)
- [x] [Immutable](http://facebook.github.io/immutable-js)
- [x] [React Router 4](https://reacttraining.com/react-router/)
- [x] [Redux Navigation](https://reactnavigation.org/)
- [x] [React Intl](https://github.com/yahoo/react-intl)
- [x] [Redux Actions](https://github.com/acdlite/redux-actions)
- [x] [Redux Saga](https://github.com/yelouafi/redux-saga)
- [x] [Redux Form](http://redux-form.com)
- [x] [Reselect](https://github.com/reactjs/reselect)
- [x] [PostCSS](https://github.com/postcss/postcss)
- [x] [CSS modules](https://github.com/outpunk/postcss-modules)
- [x] [Flexbox](https://css-tricks.com/snippets/css/a-guide-to-flexbox/)
- [x] [Enzyme](https://github.com/airbnb/enzyme)
- [x] [Webpack 4](https://webpack.js.org)
- [x] [Babel](https://babeljs.io/)
- [x] [Express](https://github.com/expressjs/express)

## add full icu to node for i18n
```sh
npm install -g full-icu
```

## Setup
```sh
yarn install
```

## run
It's served in http://dev.btcchina.com:3009 .
```sh
yarn start
```

## test
```sh
yarn test
```

## build
It's served in ./static folder.
```sh
yarn run build
```
```sh
yarn run build:staging
```
```sh
yarn run build:dev
```

## client rendering
```sh
yarn run client
```

## server rendering
```sh
yarn run server
```


text:
# ink-command-router

![Integration](https://github.com/LeeCheneler/ink-command-router/workflows/Integration/badge.svg) ![Publish](https://github.com/LeeCheneler/ink-command-router/workflows/Publish/badge.svg)

A simple [React](https://reactjs.org/) based router for [ink](https://github.com/vadimdemedes/ink) CLI commands.

# Getting started

Install the package.

```sh
yarn add ink-command-router
```

Configure your commands.

```tsx
import { Text, render } from "ink";
import { CommandRouter, Command, NoMatch, useArgs } from "ink-command-router";

const Help = () => {
  return <Text>I should probably tell you how to use this tool... 😅</Text>;
};

const Version = () => {
  return <Text>1.0.0</Text>;
};

const PrintParsedArgs = () => {
  const args = useArgs();

  return <Text>{JSON.stringify(args, null, 2)}</Text>;
};

const App = () => {
  return (
    <CommandRouter args={process.argv}>
      <Command name="help">
        <Help />
      </Command>
      <Command name="version">
        <Version />
      </Command>
      <Command name="print-parsed-args">
        <PrintParsedArgs />
      </Command>
      <NoMatch>
        <Help />
      </NoMatch>
    </CommandRouter>
  );
};

render(<App />);
```

You can then use the tool like so:

```sh
> tool help
> I should probably tell you how to use this tool... 😅
>
> tool version
> 1.0.0
>
> tool print-parsed-args -hello world -foo=bar --one=two --three four final-arg
> {
>   "_": ["final-arg"],
>   "hello":"world",
>   "foo": "bar",
>   "one":"two",
>   "three":"four"
> }
>
> tool this-does-not-exist
> I should probably tell you how to use this tool... 😅
```

## Argument parsing

Arguments are parsed using [minimist](https://www.npmjs.com/package/minimist).

repository: LeeCheneler/ink-command-router

repo_name: LeeCheneler/ink-command-router


text:
# Upgrade Guide

Cotes Chung edited this page on Mar 18 · [14 revisions](https://github.com/cotes2020/jekyll-theme-chirpy/wiki/Upgrade-Guide/_history)

The way to update the theme depends on how you use it.

## Upgrade from starter

If you are using the theme gem (there will be `gem "jekyll-theme-chirpy"` in the `Gemfile`), editing the `Gemfile` and update the version number of the theme gem, for example:

```
- gem "jekyll-theme-chirpy", "~> 3.2"
+ gem "jekyll-theme-chirpy", "~> 4.0"
```

And then execute the following command:

```
$ bundle update jekyll-theme-chirpy
```

As the version upgrades, the critical files (for details, see the [startup template](https://github.com/cotes2020/chirpy-starter)) and configuration options will change. We can use the GitHub API to get the file changes in the version upgrade.

The URL format is as follows:

```
https://github.com/cotes2020/chirpy-starter/compare/<older_version>...<newer_version>
```

For instance, to upgrade from `v4.0.0` to `v5.0.0`, visit:
*https://github.com/cotes2020/chirpy-starter/compare/v4.0.0...v5.0.0*

## Upgrade the fork

If you forked from the source project (there will be `gemspec` in the `Gemfile` of your site), then merge the [latest upstream tags](https://github.com/cotes2020/jekyll-theme-chirpy/tags) into your Jekyll site to complete the upgrade. The merge is likely to conflict with your local modifications. Please be patient and careful to resolve these conflicts.

Starting with `v5.6.0`, the JS distribution files have been removed from the repository, so for all future upgrades, you should compile the JS files yourself.

```
npm run build
```

And then make sure to add them to your repository files.

```
git add assets/js/dist -f
```

gha_language: Ruby


text:
---
# Display name
name: M. Kundegorski (Miks)

# Username (this should match the folder name)
authors:
- admin

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

# Role/position
role: IT consultant, scientist

# Organizations/Affiliations
organizations:
- name: Fjelltopp
  url: "https://fjelltopp.org"
- name: University of Glasgow
  url: "https://www.gla.ac.uk/researchinstitutes/bahcm/"

# Short bio (displayed in user profile at end of posts)
bio:

interests:
# photography
#- music

education:
#  courses:
#  - course: MSc in Computational Techniques in Engineering
#    institution: Cranfield University
#    year: 2013
#  - course: BSc in Electronics
#    institution: AGH University, Krakow Poland
#    year: 2012

# Social/Academic Networking
# For available icons, see: https://sourcethemes.com/academic/docs/widgets/#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: fabs
  link: '#contact'
- icon: twitter
  icon_pack: fab
  link: https://twitter.com/mkundegorski
- icon: google-scholar
  icon_pack: ai
  link: https://scholar.google.com/citations?user=Svbwr14AAAAJ&hl=en&oi=ao
- icon: github
  icon_pack: fab
  link: https://github.com/mixmixmix
- icon: linkedin
  icon_pack: fab
  link: https://www.linkedin.com/in/mikolaj-kundegorski-01988865
- icon: instagram
  icon_pack: fab
  link: https://www.instagram.com/mkundegorski/
- icon: flickr
  icon_pack: fab
  link: https://www.flickr.com/photos/126050630@N02/

# Link to a PDF of your resume/CV from the About widget.
# To enable, copy your resume/CV to `static/files/cv.pdf` and uncomment the lines below.
# - icon: cv
#   icon_pack: ai
#   link: files/cv.pdf

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

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

I study mathematical modelling of collective behaviour of animals in Glasgow, Scotland. I'm also an IT consultant, working for my company Fjelltopp to help developing countries with epidemiological surveillance.

repository: mixmixmix/academic-kickstart

repo_name: mixmixmix/academic-kickstart


text:
# Contributte Cache

## Content

- [Setup](#setup)
- [CacheFactory](#cache-factory)
- [Storages](#storages)
- [Debug panel](#debug-panel)

## Setup

```bash
composer require contributte/cache
```

## Cache Factory

Don't waste time by passing `Nette\Caching\IStorage` directly to your classes. Use our tuned `CacheFactory`.

```neon
extensions:
	cache.factory: Contributte\Cache\DI\CacheFactoryExtension
```

By default `Nette\Caching\Cache` is provided when `$cacheFactory->create()` is called. You can change it to your implementation.

```neon
services:
	cache.factory.factory: App\Model\MyCacheFactory
```

## Storages

- MemoryAdapterStorage

    - Optimized for reading of same key multiple times during one application run

```php
use Contributte\Cache\Storages\MemoryAdapterStorage;
use Nette\Caching\Storages\FileStorage;
use Nette\Caching\Storages\SQLiteJournal;

$storage = new MemoryAdapterStorage(
	new FileStorage($path, new SQLiteJournal($path))
);
```

## Debug panel

Show all calls to storage in Tracy panel

```neon
extensions:
	cache.debug: Contributte\Cache\DI\DebugStorageExtension

cache.debug:
	debug: %debugMode%
```

![Debug panel screenshot](_misc/debug-panel-screenshot.png)

repository: contributte/cache

gha_language: PHP

repo_name: contributte/cache


text:
### [CVE-2022-45290](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-45290)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

Kbase Doc v1.0 was discovered to contain an arbitrary file deletion vulnerability via the component /web/IndexController.java.

### POC

#### Reference
- https://github.com/HH1F/KbaseDoc-v1.0-Arbitrary-file-deletion-vulnerability/blob/main/README.md

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/HH1F/KbaseDoc-v1.0-Arbitrary-file-deletion-vulnerability


text:
---
title: How to speak
tags:
---
Patrick Winston's How to Speak talk has been an MIT tradition for over 40 years. Offered every January, the talk is intended to improve your speaking ability in critical situations by teaching you a few heuristic rules.

00:16 - Introduction
03:11 - Rules of Engagement
04:15 - How to Start
05:38 - Four Sample Heuristics
10:17 - The Tools: Time and Place
13:24 - The Tools: Boards, Props, and Slides
36:30 - Informing: Promise, Inspiration, How To Think
41:30 - Persuading: Oral Exams, Job Talks, Getting Famous
53:06  - How to Stop: Final Slide, Final Words
56:35 - Final Words: Joke, Thank You, Examples

<iframe width="560" height="315" src="https://www.youtube.com/embed/Unzc731iCUY" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>


text:
# Catcsv
This utility will concatenate CSV files.

Use -help to show:
```
$ catcsv -help
Help Message

Usage: catcsv [options] input1.csv input2.csv ...
  -f    Force concatenation of different width CSV files
  -headers
        CSV has headers (default true)
  -help
        Show usage message
  -keep
        Keep CSV headers on output (default true)
  -o string
        Output CSV filename; default STDOUT
```

## Examples
This first example shows an error due to different number of columns
in the input files.
```
$ go run catcsv.go test1.csv test2.csv
2017/12/01 09:18:16 Individual file row counts include header row
2017/12/01 09:18:16 Total row count does not include header rows
2017/12/01 09:18:16 File test1.csv had 4 rows
2017/12/01 09:18:16 csv.Read:
line 1, column 0: wrong number of fields in line
exit status 1
$
```
This example shows use of the force option to concatenate anyway.
```
$ go run catcsv.go -f test1.csv test2.csv
2017/12/01 09:18:28 Individual file row counts include header row
2017/12/01 09:18:28 Total row count does not include header rows
2017/12/01 09:18:28 File test1.csv had 4 rows
2017/12/01 09:18:28 File test2.csv had 4 rows
A,B
1,2
3,4
5,6
1,2,3
4,5,6
7,8,9
2017/12/01 09:18:28 Total rows in output  has 6 rows
$
```

repository: mandolyte/csv-utils

repo_name: mandolyte/csv-utils


text:
---
title: "Privacy Disclosure"
icon: "/images/icons/lock.svg"
description: "Execute Big is a non-profit organization that strongly believes your right to privacy, especially given we work with students on a regular basis. We only ask for your information when we actually need it, and we are very careful when handling data."
---

Execute Big is a non-profit organization that strongly believes your right to privacy, especially given we work with students on a regular basis. We only ask for your information when we actually need it, and we are very careful when handling data.

We hope this privacy disclosure can give you some clarity with how we handle your personal information.

## Third-Parties

### Data Processors

The only third parties that we share data with are trusted, and we only share what's required:

- [**Stripe**](https://stripe.com/privacy), for third-party payment processing. We use industry-standard methods when handling your transaction information, and we do not store or collect your payment details.
- [**Airtable**](https://airtable.com/privacy), for storing our operations data (ex. when you apply to our programs, or become a supporter).
- [**Zapier**](https://zapier.com/privacy), for automation our data-processing workflow (ex. sending you a confirmation email after you apply to our program).
- [**Substack**](https://substack.com/privacy), to send emails and newsletters to people who have consented to be on our mailing list. We only share your name and email address with them, and we only share that information when you have consented for that information to be shared (ex. when you sign up for our newsletter, or become a supporter).

### Program-Specific Providers

When participating in our events and programs, you may also be asked to use the following platforms and services to register yourself or communicate with us:

- [**GSuite**](https://support.google.com/googlecloud/answer/6056650?hl=en) (including Gmail, Drive, Photos, and Forms)
- [**Pipedrive**](https://www.pipedrive.com/en/privacy)
- [**Zoom**](https://zoom.us/privacy)
- [**OpenPhone**](https://www.openphone.co/privacy)
- [**Notion**](https://www.notion.so/Privacy-Policy-3468d120cf614d4c9014c09f6adc9091)

Additionally, if we are shipping you physical material, your information (name, address, and shipment details) will be shared with **USPS**.

### Hosting

We host our software systems in the cloud via the following infrastructure providers:

- [**Cloudflare**](https://www.cloudflare.com/privacypolicy/)
- [**Vercel**](https://vercel.com/legal/privacy-policy)
- [**DigitalOcean**](https://www.digitalocean.com/legal/privacy-policy)

## Tracking & Data Collection

To get information about the behavior of our visitors, we use
[Umami](https://umami.is/). Our instance of Umami is deployed and shown as **`umami.executebig.org`**,
and all information collected by Umami is stored on our own servers.

This analytics software gives us insight about our visitors only in general. Umami does not collect any personally
identifiable information and anonymizes all data collected. Users cannot be identified and are never tracked across websites.
Umami does not use any cookies in the tracking code, either.

## Additional Policies

Aside from our organizational privacy disclosure, you may also be interested in reading about our commitment to privacy in other
programs of Execute Big. These policies outline the steps that we are taking to ensure we collect, process, and potentially release the right
information to create a safe environment for you to be involved in our programs.

* **Research**: [Privacy Promise for Research Data](/research-privacy)

## Questions & Data Control

You may request a copy of your data or ask us questions about this privacy disclosure by [contacting us](/contact) through
emailing, calling, or writing to us.

**Execute Big will never sell your personal information to third parties.**

*Last updated: September 29, 2020*

repository: OzFounry/magenta-neptune

repo_name: OzFounry/magenta-neptune