text:
---
tags: weekly, rustc
---

# T-compiler Meeting Agenda 2020-06-18

[Tracking Issue](https://github.com/rust-lang/rust/issues/54818)

## Announcements

- Major Changes Proposals:
  - New accepted proposals
    - "Preserve `PlaceContext` through projections" [#300](https://github.com/rust-lang/compiler-team/issues/300)
    - "Make lang-items private" [#301](https://github.com/rust-lang/compiler-team/issues/301)
  - Seconded proposals (in FCP)
    - "illumos toolchain builds" [#279](https://github.com/rust-lang/compiler-team/issues/279)
    - "Make `CONTRIBUTING.md` into a series of tutorials" [#296](https://github.com/rust-lang/compiler-team/issues/296)
    - "Support const parameters in type dependent paths" [#304](https://github.com/rust-lang/compiler-team/issues/304)
    - "`#[deny(unsafe_op_in_unsafe_fn)]` in liballoc" [#306](https://github.com/rust-lang/compiler-team/issues/306)
  - New proposals (not seconded)
    - "Move Rust provided objects, libraries and binaries meant for self-contained linkage to separate directory" [#310](https://github.com/rust-lang/compiler-team/issues/310)
    - "RISC-V Linux Tier 2 Host support" [#312](https://github.com/rust-lang/compiler-team/issues/312)
    - "Switch from libbacktrace to gimli" [#313](https://github.com/rust-lang/compiler-team/issues/313)
  - Old proposals (not seconded)
    - "Integration of the Cranelift backend with rustc" [#270](https://github.com/rust-lang/compiler-team/issues/270)
    - "Decentralize queries" [#277](https://github.com/rust-lang/compiler-team/issues/277)
    - "--extern-location to specify where an --extern dependency is defined" [#303](https://github.com/rust-lang/compiler-team/issues/303)

- Unilateral beta backport approvals
    - "Make novel structural match violations not a `bug`" [#73446](https://github.com/rust-lang/rust/pull/73446)
    - "Don't create impl candidates when obligation contains errors" [#73005](https://github.com/rust-lang/rust/pull/73005)

### WG checkins

@*WG-prioritization* checkin by @**spastorino**:
>- We are now executing our process fully async and have bi-weekly planning/steering meetings to think about things to improve.
>- We've prioritized all `I-unsound 💥` issues for `T-compiler` and `libs-impl`.
>  - From now on, new issues tagged with `I-unsound 💥` will automatically add `I-prioritize` and then request prioritization to the wg.
>- There are not unprioritized regressions anymore :tada:
>  - We've prioritized all `regression-from-stable-to-stable` issues for `T-compiler` and `libs-impl`.
>  - From now on new issues tagged with `regression-from-stable-to-stable` will automatically add `I-prioritize` and then request prioritization to the wg.
>  - Same happens for `regression-from-stable-to-beta` and `regression-from-stable-to-nightly`.
>- We are in the process of automating most of our procedure.

@*WG-rfc-2229* checkin by @**nikomatsakis**:
> * We've created a repository to track the issues and work, [rust-lang/project-rfc-2229](https://github.com/rust-lang/project-rfc-2229)
> * Currently doing some core refactorings, improving the "HIR place" datastructure to /IU be sufficiently precise, and refactoring how closures represent captures to use that instead of individual variables

## Beta-nominations

[T-compiler](https://github.com/rust-lang/rust/issues?q=is%3Aall+label%3Abeta-nominated+-label%3Abeta-accepted+label%3AT-compiler)
- "Ensure stack when building MIR for matches" [#72941](https://github.com/rust-lang/rust/pull/72941)
  - [Fixes stack overflow](https://github.com/rust-lang/rust/issues/72933)
- "Fix link error with #[thread_local] introduced by #71192" [#73065](https://github.com/rust-lang/rust/pull/73065)
  - Fixes an error introduced by "[Make TLS accesses explicit in MIR #71192 ](https://github.com/rust-lang/rust/pull/71192)"
- "Reoder order in which MinGW libs are linked to fix recent breakage" [#73184](https://github.com/rust-lang/rust/pull/73184)
  - "Recent upstream mingw-w64 changes made libmsvcrt depend on libmingwex breaking compilation in some cases when using external MinGW."
- "Allow inference regions when relating consts" [#73225](https://github.com/rust-lang/rust/pull/73225)
  - Fixes ICE "generator_interior.rs impossible case reached" [#73050](https://github.com/rust-lang/rust/issues/73050)
- "Disable the `SimplifyArmIdentity` pass" [#73262](https://github.com/rust-lang/rust/pull/73262)
  - This is the beta nomination for a `P-critical` issue.
- "linker: Never pass `-no-pie` to non-gnu linkers" [#73384](https://github.com/rust-lang/rust/pull/73384)
  - Fixes "linking error: unknown agrument `-no-pie`" [#73370](https://github.com/rust-lang/rust/issues/73370)

[libs-impl](https://github.com/rust-lang/rust/issues?q=is%3Aall+label%3Abeta-nominated+-label%3Abeta-accepted+label%3Alibs-impl)
There are no issues this time.

[T-rustdoc](https://github.com/rust-lang/rust/issues?q=is%3Aall+label%3Abeta-nominated+-label%3Abeta-accepted+label%3AT-rustdoc)
There are no issues this time.

:back: / :shrug: / :hand:

## Stable-nominations

[T-compiler](https://github.com/rust-lang/rust/issues?q=is%3Aall+label%3Astable-nominated+-label%3Astable-accepted+label%3AT-compiler)
There are no issues this time.

[libs-impl](https://github.com/rust-lang/rust/issues?q=is%3Aall+label%3Astable-nominated+-label%3Astable-accepted+label%3Alibs-impl)
There are no issues this time.

[T-rustdoc](https://github.com/rust-lang/rust/issues?q=is%3Aall+label%3Astable-nominated+-label%3Astable-accepted+label%3AT-rustdoc)
There are no issues this time.

:back: / :shrug: / :hand:

## PR's S-waiting-on-team

[T-compiler](https://github.com/rust-lang/rust/pulls?utf8=%E2%9C%93&q=is%3Aopen+label%3AS-waiting-on-team+label%3AT-compiler)
- "Implement `--extern-location`" [#72603](https://github.com/rust-lang/rust/pull/72603)
  - This was already discussed last week
  - [an MCP is pending](https://github.com/rust-lang/compiler-team/issues/303)

[libs-impl](https://github.com/rust-lang/rust/pulls?utf8=%E2%9C%93&q=is%3Aopen+label%3AS-waiting-on-team+label%3Alibs-impl)
There are no issues this time.

## Issues of Note

### Short Summary

- [3 T-compiler P-critical issues](https://github.com/rust-lang/rust/issues?utf8=%E2%9C%93&q=is%3Aopen+label%3AT-compiler+label%3AP-critical+)
  - [1 of those are unassigned](https://github.com/rust-lang/rust/issues?utf8=%E2%9C%93&q=is%3Aopen+label%3AT-compiler+label%3AP-critical+no%3Aassignee)
- [49 T-compiler P-high issues](https://github.com/rust-lang/rust/issues?utf8=%E2%9C%93&q=is%3Aopen+label%3AT-compiler+label%3AP-high+)
  - [26 of those are unassigned](https://github.com/rust-lang/rust/issues?utf8=%E2%9C%93&q=is%3Aopen+label%3AT-compiler+label%3AP-high+no%3Aassignee)
- [2 P-critical, 1 P-high, 4 P-medium, 0 P-low regression-from-stable-to-beta](https://github.com/rust-lang/rust/labels/regression-from-stable-to-beta)
- [1 P-critical, 1 P-high, 4 P-medium, 1 P-low regression-from-stable-to-nightly](https://github.com/rust-lang/rust/labels/regression-from-stable-to-nightly)
- [0 P-critical, 14 P-high, 45 P-medium, 4 P-low regression-from-stable-to-stable](https://github.com/rust-lang/rust/labels/regression-from-stable-to-stable)

### P-critical

[T-compiler](https://github.com/rust-lang/rust/issues?utf8=%E2%9C%93&q=is%3Aopen+label%3AP-critical+label%3AT-compiler)
- "Slice index becomes wrong (beta regression)" [#73223](https://github.com/rust-lang/rust/issues/73223)
  - It's a regression from stable to beta
  - [PR is merged already on nightly](https://github.com/rust-lang/rust/pull/73262)
  - It's beta nominated
- "ICE: could not fully normalize" [#73249](https://github.com/rust-lang/rust/issues/73249)
  - It's a regression from stable to nightly
  - [It has a PR already r+ed](https://github.com/rust-lang/rust/pull/73257)
- "ICE: MIR const-checker found novel structural match violation" [#73431](https://github.com/rust-lang/rust/issues/73431)
  - ICE when matching with a trait constant
  - Beta regression caused by [#67343](https://github.com/rust-lang/rust/pull/67343) (@**ecstatic-morse**)
  - Breaks previously accepted code, should be fixed and backported before it gets to stable

[libs-impl](https://github.com/rust-lang/rust/issues?utf8=%E2%9C%93&q=is%3Aopen+label%3AP-critical+label%3Alibs-impl)
There are no issues this time.

[T-rustdoc](https://github.com/rust-lang/rust/issues?utf8=%E2%9C%93&q=is%3Aopen+label%3AP-critical+label%3AT-rustdoc)
There are no issues this time.

### Unassigned P-high regressions

[Beta regressions](https://github.com/rust-lang/rust/issues?utf8=%E2%9C%93&q=is%3Aopen+label%3Aregression-from-stable-to-beta+P-high+no%3Aassignee)
- "Unreasonably long (and useless) error message doing modulo on non-existent variable: overflow evaluating the requirement `typenum::UInt<typenum::UInt..." [#72839](https://github.com/rust-lang/rust/issues/72839)
  - [PR is merged already](https://github.com/rust-lang/rust/pull/73005)
  - It's already beta accepted
  - So this is waiting for a beta backport

[Nightly regressions](https://github.com/rust-lang/rust/issues?utf8=%E2%9C%93&q=is%3Aopen+label%3Aregression-from-stable-to-nightly+P-high+no%3Aassignee)
There are no issues this time.

## Performance logs

[Triage done by njn](https://github.com/rust-lang/rustc-perf/tree/master/triage#triage-logs)

Some bustage involving Cargo meant that some merges in this period didn't get measured.

Regressions:
- [Rollup of 10 pull requests](https://github.com/rust-lang/rust/pull/73367#issuecomment-644456094) ([instructions](https://perf.rust-lang.org/compare.html?start=ce6d3a73b514e9649e57cee812ad129bb2112016&end=d4ecf31efc2309fb6df8c2a8af9aaf8176ab1c8d&stat=instructions:u)):
  Regressed up to 3.5% on multiple benchmarks. Maybe [#71824](https://github.com/rust-lang/rust/pull/71824) is the cause?
- [Disable the `SimplifyArmIdentity` pass](https://github.com/rust-lang/rust/pull/73262#issuecomment-644451010) ([instructions](https://perf.rust-lang.org/compare.html?start=7c78a5f97de07a185eebae5a5de436c80d8ba9d4&end=f4fbb93113aa4f0a0cd08e74afb35381bbfbc7f0&stat=instructions:u)):
  A small regression on a couple of benchmarks from disabling a buggy pass,
  which may be re-enabled in the future?
- A small regression occurred for `syn-opt`, but I can't tell which PR was
  responsible because the improvement occurred in one of the merges that wasn't
  measured due to the Cargo bustage.

Improvements:
- Some huge improvements occurred for `clap-rs-opt`, but I can't tell which PR was responsible because the improvement occurred in one of the merges that wasn't measured due to the Cargo bustage.
- [Rollup of 8 pull requests](https://github.com/rust-lang/rust/pull/73316#issuecomment-644453724) ([instructions](https://perf.rust-lang.org/compare.html?start=1fb612bd15bb3ef098fd24c20d0727de573b4410&end=06e47688bf15d0215edbe05b21603062f6d2eb5d&stat=instructions:u)):
  A small improvement on `many-assoc-items`, and a tiny regression on a couple of other benchmarks.

## Nominated Issues

[T-compiler](https://github.com/rust-lang/rust/issues?q=is%3Aopen+label%3AI-nominated+label%3AT-compiler)
- "Type mismatching cased by duplicate associated type resolution" [#59326](https://github.com/rust-lang/rust/issues/59326)
  - Unassigned P-high regression
  - Culprit likely to be [#56837](https://github.com/rust-lang/rust/pull/56837)
- "Incorrect compilation / STATUS_ACCESS_VIOLATION when linking with lld with target-cpu set" [#72145](https://github.com/rust-lang/rust/issues/72145)
  - Metabug: "Use lld by default on x64 msvc windows" [#71520](https://github.com/rust-lang/rust/issues/71520)
- "mv std libs to std/" [#73265](https://github.com/rust-lang/rust/pull/73265)
  - PR to move the stdlib crates to the `std/` folder
  - [Proposes](https://github.com/rust-lang/rust/pull/73265#issuecomment-643416610) the following directory structure: `std/<crate>/src/*.rs` (i.e. one `src/` folder per crate)
- "f32::powi on Windows returns different results between 1.44 and 1.45 beta" [#73420](https://github.com/rust-lang/rust/issues/73420)
  - Nominated with intention of raising awareness of this LLVM 10 change and to discuss briefly what to do. Do we want to add some relnotes?.

[libs-impl](https://github.com/rust-lang/rust/issues?q=is%3Aopen+label%3AI-nominated+label%3Alibs-impl)
There are no issues this time.

repository: rust-lang/compiler-team

path: /content/minutes/triage-meeting/T-compiler Meeting Agenda 2020-06-18.md

filename: T-compiler Meeting Agenda 2020-06-18.md

repo_name: rust-lang/compiler-team


text:
# `cfg`

Configuration conditional checks are possible through two different operators:

* the `cfg` attribute: `#[cfg(...)]` in attribute position
* the `cfg!` macro: `cfg!(...)` in boolean expressions

While the former enables conditional compilation, the latter conditionally
evaluates to `true` or `false` literals allowing for checks at run-time. Both
utilize identical argument syntax.

`cfg!`, unlike `#[cfg]`, does not remove any code and only evaluates to true or false. For example, all blocks in an if/else expression need to be valid when `cfg!` is used for the condition, regardless of what `cfg!` is evaluating.

```rust,editable
// This function only gets compiled if the target OS is linux
#[cfg(target_os = "linux")]
fn are_you_on_linux() {
    println!("You are running linux!");
}

// And this function only gets compiled if the target OS is *not* linux
#[cfg(not(target_os = "linux"))]
fn are_you_on_linux() {
    println!("You are *not* running linux!");
}

fn main() {
    are_you_on_linux();

    println!("Are you sure?");
    if cfg!(target_os = "linux") {
        println!("Yes. It's definitely linux!");
    } else {
        println!("Yes. It's definitely *not* linux!");
    }
}
```

### See also:

[the reference][ref], [`cfg!`][cfg], and [macros][macros].

[cfg]: https://doc.rust-lang.org/std/macro.cfg!.html
[macros]: ../macros.md
[ref]: https://doc.rust-lang.org/reference/attributes.html#conditional-compilation

repository: rust-lang/rust-by-example

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: rust-lang/rust-by-example


text:
# Changelog

## Mocked Streams 1.7.0

* Bumping versions of dependencies
* Build against Apache Kafka 1.1.0
* Daniel Wojda added new way of supplying topologies (withTopology)
* Added Daniel Wojda to CONTRIBUTORS.md

## Mocked Streams 1.6.0

* Build against Apache Kafka 1.0.1
* Updated Scala 2.12 version to 2.12.4

## Mocked Streams 1.5.0

* Build against Apache Kafka 1.0
* Updated ScalaTest version to 3.0.4
* Updated RocksDB version to 5.7.3
* KStreamBuilder -> StreamsBuilder
* Updated stream creation with Consumed.with

## Mocked Streams 1.4.0

* Build against Apache Kafka <IP_ADDRESS>
* Added record order and multiple emissions by Svend Vanderveken
* Updated SBT to 1.0.2
* Added Svend Vanderveken to CONTRIBUTORS.md

## Mocked Streams 1.2.2

* Build against Apache Kafka <IP_ADDRESS>

## Mocked Streams 1.2.1

* Build against Apache Kafka <IP_ADDRESS>
* Added calling of clean up method after driver run
* Updated ScalaTest version to 3.0.2
* Updated Scala Versions
* Added CodeCov and SCoverage coverage report

## Mocked Streams 1.2.0

* Build against Apache Kafka 0.10.2
* Added support for Scala 2.12.1
* Added .stateTable and .windowStateTable method for retrieving the content of the state stores as Map
* Added contributors file
* Removed dependencies to Log4j and Slf4j
* Updated RocksDB version to 5.0.1
* Updated ScalaTest version to 3.0.1
* Added more assertions in the test for input validation

## Mocked Streams 1.1.0

* Build against Apache Kafka <IP_ADDRESS>

## Mocked Streams 1.0.0

* Support for Scala 2.11.8
* Support for Apache Kafka <IP_ADDRESS>
* Released on Maven Central Repository
* Multiple input and output streams
* Specification of topology as a function: (KStreamBuilder => Unit)
* Added .config method to pass configuration to Kafka Streams instance
* Added .outputTable method will return compacted table as Map[K,V]
* Test suite

repository: zenreach/mockedstreams

gha_language: Scala

repo_name: zenreach/mockedstreams


text:
GCTagList
=========

GCTagList like iOS Mail app's sender or recivers tags.

![](Screenshot.png)
![](Screenshot2.png)

## Installation

Simple copy over the `classes` folder and `assets` folder into your project and make sure you have linked the framework `QuartzCore.framework`, and import the `GCTagList.h`.

### CocoaPods

use GCTagList with CocoaPods

```
pod 'GCTagList', '~> 1.3'
```

## What's new

> I split up the class to three parts, `GCTagList`、`GCTagLabel` and `UIColor+Uitiles` with v1.3.1; I hope this way could more easy to read and maintain.

* custom font for TagList, use the property `labelFont` with __GCTagList__.
* support xib. [after v1.2]
* you can custom the label's gradient colors and color locations. [after v1.1]

```Objective-C

/**
 * labelBackgroundColor's Priority > gradientColors,
 * if labelBackgroundColor and gradientColors all nil,
 * will use default color #E0EAF4
 */
@property (nonatomic, GC_STRONG) UIColor *labelBackgroundColor;

/**
 * if gradientColors's count is less 2, will use default labelBackgroundColor;
 */
@property (nonatomic, GC_STRONG) NSArray *gradientColors; ///< ...
@property (nonatomic, GC_STRONG) NSArray *gradientLocations; ///< can be nil …
```

## Features

* custom the label gradient colors and colors locations (for GradientColors) [after] v1.1
* support MaxRow.
* TagLabel could set not show selectedState. (selectedEnabled)
* reload/delete/insert with range.

```Objective-C
- (void)reloadTagLabelWithRange:(NSRange)range withAnimation:(BOOL)animated;
- (void)deleteTagLabelWithRange:(NSRange)range withAnimation:(BOOL)animated;
- (void)insertTagLabelWithRange:(NSRange)range withAnimation:(BOOL)animated;
```

I try to imitate UITableView's way - @greenchiu

## next version(1.4) will support

* custom accessoryButton.
* more accessoryType for TagLabel.

## Supports

* ARC
* iOS 5.0 ~

## How to use
implementation the GCTagListDataSource and call the public method `reloadData`

```Objective-C
-(void)viewDidLoad {
	[super viewDidLoad];
	GCTagList* taglist = [[GCTagList alloc] initWithFrame:CGRectMake(0, 180, 320, 200)];
    taglist.firstRowLeftMargin = 80.f;
    taglist.dataSource = self;
    [self.view addSubview:taglist];
    [taglist reloadData];
}
```

```Objective-C
- (NSInteger)numberOfTagLabelInTagList:(GCTagList *)tagList {
    return self.tagNames.count;
}

- (GCTagLabel*)tagList:(GCTagList *)tagList tagLabelAtIndex:(NSInteger)index {

    static NSString* identifier = @"TagLabelIdentifier";

    GCTagLabel* tag = [tagList dequeueReusableTagLabelWithIdentifier:identifier];
    if(!tag) {
        tag = [GCTagLabel tagLabelWithReuseIdentifier:identifier];
        tag.labelBackgroundColor = [UIColor colorWithRed:84/255.f green:164/255.f blue:222/255.f alpha:1.f];
    }

    [tag setLabelText:self.tagNames[index]
        accessoryType:GCTagLabelAccessoryCrossFont];

    return tag;
}
```

## GCTagListDelegate Protocol

```Objective-C
/**
 * after reloadData, if the height of TagList has changed, will call this method.
 */
- (void)tagList:(GCTagList *)taglist didChangedHeight:(CGFloat)newHeight;

/**
 * Tapped the TagLabel, will call this mehtod.
 */
- (void)tagList:(GCTagList *)taglist didSelectedLabelAtIndex:(NSInteger)index;

/**
 * Tapped the TagLabel's accessoryButton, will call this mehtod.
 */
- (void)tagList:(GCTagList *)tagList accessoryButtonTappedAtIndex:(NSInteger)index;

/**
 * if implement protocol <GCTagLabelListDataSource> method 'maxNumberOfRowAtTagList'
 * and the taglist's rows is more than the maxRow, this method will be call.
 *
 * @retVal NSString the text for the TagLabel of theMaxRow's last one.
 */
- (NSString*)tagList:(GCTagList *)tagList labelTextForGroupTagLabel:(NSInteger)interruptIndex;
```

## GCTagListDataSource Protocol
```Objective-C
/**
 * how many count for taglist to display.
 */
- (NSInteger)numberOfTagLabelInTagList:(GCTagList*)tagList;

/**
 * the taglabel At index in the taglist.
 */
- (GCTagLabel*)tagList:(GCTagList*)tagList tagLabelAtIndex:(NSInteger)index;

@optional
/**
 * the max row at taglist.
 */
- (NSInteger)maxNumberOfRowAtTagList:(GCTagList*)tagList;

/**
 * accessory type of the group taglabel.
 */
- (GCTagLabelAccessoryType)accessoryTypeForGroupTagLabel;
```

## Reference

* [DWTagList](https://github.com/domness/DWTagList)
* [ColorUtils](https://github.com/nicklockwood/ColorUtils)

## License

Use this control in your apps? Let me know!

Copyright (c) 2013  Green Chiu, http://greenchiu.github.com/ Licensed under the MIT license (http://www.opensource.org/licenses/mit-license.php)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘Software’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

license: MIT

repository: greenchiu/GCTagList

gha_language: Objective-C

repo_name: greenchiu/GCTagList


text:
# mutt

## Required softwares
apt-get install mutt w3m

Create cache directory:
```mkdir -p ~/.mutt/cache```

### .muttrc file
```
# About Me
set from = "<<YOUR.EMAIL.ADDRESS@HERE>>"
set realname = "<<YOUR NAME>>"

# My credentials
set smtp_url = "smtp://<<YOUR.EMAIL.ADDRESS@HERE>>@mobile.serpro.gov.br:465/"
set smtp_pass = "<<YOUR PASSWORD>>*"
set imap_user = "<<YOUR.EMAIL.ADDRESS@HERE>>"
set imap_pass = "<<YOUR PASSWORD>>"

# My mailboxes
set folder = "imaps://mobile.serpro.gov.br:993"
set spoolfile = "+INBOX"

# Caching
set header_cache = "~/.mutt/cache/headers"
set message_cachedir = "~/.mutt/cache/bodies"
set certificate_file = "~/.mutt/certificates"

# Update settings
set mail_check = 30
set move = no
set imap_keepalive = 10
set sort = threads
set ssl_starttls = yes
set ssl_force_tls = yes
unset imap_passive
set imap_check_subscribed
set mail_check = 32
set timeout = 10
set net_inc = 5

# Default editor
set editor = "vim"

# Sorting
set sort = reverse-threads
set sort_aux = date-received

# Using .mailcap to view html mails
auto_view text/html

# Wrapping
set wrap = 80

# Visuals
color status white blue
color index green  default ~N  # new
color index red default ~D  # deleted
color index brightmagenta default ~T  # tagged
color index brightyellow default ~F  # flagged
color header green default "^Subject:"
color header yellow default "^Date:"
color header yellow default "^To:"
color header yellow default "^Cc:"
color header yellow default "^Bcc:"
color header yellow default "^From:"
color header red default "^X-.*:"
unset mark_old
```

### .mailcap file
```
text/html; w3m -I %{charset} -T text/html; copiousoutput;
```

repository: marciofrayze/myshortcuts

repo_name: marciofrayze/myshortcuts


text:
# SCRIBE.StreamDeck
This is an application I created to allow me to use my Stream Deck with SCRIBE Online

Check out the project [wiki](https://github.com/medicstuder/SCRIBE.StreamDeck/wiki) for more information

To learn more about SCRIBE Online please check out [SCRIBE's](https://www.scribesoft.com/) website or my [blog](https://livinginscribeonline.blogspot.com/) about SCRIBE Online.


text:
# gnome-better-window-placement
gnome-shell extension to place new windows better

By default the first window on each workspace is placed in the top-left
corner but with a padding. This method is described in the mutter source code:

> The point here is to tile a window such that "extra"
> space is equal on either side (i.e. so a full screen
> of windows tiled this way would center the windows
> as a group)

This extension removes this padding or extra space.

## Install
* Run install.sh to install extension in `~/.local/share/gnome-shell/extensions`
* Enable extension in gnome-tweak-tool


text:
# Made_Up_Programming_Language

A simple language interpreter implemented by Racket.

## Syntax Defination

- If s is a Racket string, then (var s) is a mupl expression (a variable use).

- If n is a Racket integer, then (int n) is a mupl expression (a constant).

- If e1 and e2 are mupl expressions, then (add e1 e2) is a mupl expression (an addition).

- If s1 and s2 are Racket strings and e is a mupl expression, then (fun s1 s2 e) is a mupl expression (a function). In e, s1 is bound to the function itself (for recursion) and s2 is bound to the (one) argument. Also, (fun #f s2 e) is allowed for anonymous nonrecursive functions.

- If e1, e2, and e3, and e4 are mupl expressions, then (ifgreater e1 e2 e3 e4) is a mupl expression. It is a conditional where the result is e3 if e1 is strictly greater than e2 else the result is e4. Only one of e3 and e4 is evaluated.

- If e1 and e2 are mupl expressions, then (call e1 e2) is a mupl expression (a function call).

- If s is a Racket string and e1 and e2 are mupl expressions, then (mlet s e1 e2) is a mupl expression (a let expression where the value resulting e1 is bound to s in the evaluation of e2).

- If e1 and e2 are mupl expressions, then (apair e1 e2) is a mupl expression (a pair-creator).

- If e1 is a mupl expression, then (fst e1) is a mupl expression (getting the first part of a pair).

- If e1 is a mupl expression, then (snd e1) is a mupl expression (getting the second part of a pair).

- (aunit) is a mupl expression (holding no data, much like () in ML or null in Racket). Notice (aunit) is a mupl expression, but aunit is not.

- If e1 is a mupl expression, then (isaunit e1) is a mupl expression (testing for (aunit)).

- (closure env f) is a mupl value where f is mupl function (an expression made from fun) and env is an environment mapping variables to values. Closures do not appear in source programs; they result from evaluating functions.


text:
# Predicates and Quantified Statements

## Predicate
A predicate is a sentence that contains a finite number of variables and becomes a statement when specific values are substituted for the variables.
```
P: X → {true, false}
```

## Quantifier

### Universal Quantifier: ∀
```
∀x ∈ D, Q(x)
```
Read as, for all x in D, Q(x) is true

### Existential Quantifier: ∃
```
∃x ∈ D, Q(x)
```
Read as, there exists an x for which Q(x) is true

## Predicate Translation
```
A student of mine is wearing a blue shirt.

B(x): "x is wearing a blue shirt"
S(x): "x is my student"
∃x ∈ P such that B(x) ∧ S(x)
```

```
All good students are in class.

C(x): "x is in class"
G(x): “x is a good student"
∀x ∈ P such that G(x) → C(x)
```

## Negation of Quantified Statements
```
~(∃x ∈ D, Q(x)) ≡ ∀x ∈ D, ~Q(x)
~(∀x ∈ D, Q(x)) ≡ ∃x ∈ D, ~Q(x)
```

## Variants of Quantified Statements
Same applies to existential quantifiers.

### Statement
```
(∀x ∈ D) [P(x) → Q(x)]
```
### Converse
```
(∀x ∈ D) [Q(x) → P(x)]
```
### Contrapositive
```
(∀x ∈ D) [~Q(x) → ~P(x)]
```
### Inverse
```
(∀x ∈ D) [~P(x) → ~Q(x)]
```

## Multiple Quantification
```
Let C = {all chairs} and P = {all people}, and S(c,p) represent “person p is sitting in
chair c"

(∀p ∈ P) (∀c ∈ C) [S(c,p)]
(∀c ∈ C) (∀p ∈ P) [S(c,p)]
(∃p ∈ P) (∃c ∈ C) [S(c,p)]
(∃c ∈ C) (∃p ∈ P) [S(c,p)]
```

### Quantification Order
```
The below two are diffrent.

(∀x) (∃y) [y > x]
(∃x) (∀y) [y > x]
```

### Negation of Multiply Quantified Statements
```
~((∃p ∈ P) (∀c ∈ C) [L(c,p)]) ≡ ~((∀p ∈ P) (∃c ∈ C) [~L(c,p)])
```


text:
## Installation

Make sure you're using Node >= 4.0.0.

```bash

	npm install
	npm install babel-loader babel-core babel-preset-es2015 babel-preset-react --save-dev
	npm run dev


text:
Testing Your Application
========================

This chapter describes how to test your application against a Varnish instance.

* [VarnishTestCase](#varnishtestcase)
* [Configuration](#configuration)
  * [Setting Constants](#setting-constants)
  * [Overriding Getters](#overriding-getters)
  * [Enable Assertions](#enable-assertions)
* [Usage](#usage)

VarnishTestCase
---------------

The FOSHttpCache library provides a base test case to help you write functional
tests against a Varnish instance. This may be helpful to test the way your
application sets caching headers and invalidates cached content.

By having your test classes extend `VarnishTestCase`, you get:

* independent tests: all previously cached content is removed by restarting
  Varnish in the test setUp method
* `$this->varnish` referring to an instance of this library’s Varnish client
  that is configured to talk to your Varnish server
* convenience methods for executing HTTP requests to your application:
  `$this->getClient()` and `$this->getResponse()`
* custom assertions `assertHit` and `assertMiss` for validating a cache hit/miss.

Configuration
-------------

By default, the `VarnishTestCase` starts and stops a Varnish server for you.
All you have to do, is to refer the class to your Varnish configuration (VCL)
file. The recommended way to configure the test case is by setting constants
in your `phpunit.xml`. Alternatively, you can override the getter methods:

| Constant             | Getter                 | Default    | Description                                 |
| -------------------- | ---------------------- | ---------- | ------------------------------------------- |
| `VARNISH_FILE`       | `getConfigFile()`      |            | your Varnish configuration (VCL) file       |
| `VARNISH_BINARY`     | `getBinary()`          | `varnishd` | your Varnish binary                         |
| `VARNISH_PORT`       | `getCachingProxyPort()`| `6181`     | port Varnish listens on                     |
| `VARNISH_MGMT_PORT`  | `getVarnishMgmtPort()` | `6182`     | Varnish management port                     |
| `WEB_SERVER_HOSTNAME`| `getHostName()`        |            | hostname your application can be reached at |

### Setting Constants

Compare this library’s configuration to see how the constants are set:

```xml
<?xml version="1.0" encoding="UTF-8"?>

<phpunit ...>
    <php>
        <const name="VARNISH_FILE" value="./tests/FOS/HttpCache/Tests/Functional/Fixtures/varnish/fos.vcl" />
        <const name="WEB_SERVER_HOSTNAME" value="localhost" />
    </php>
</phpunit>
```

### Overriding Getters

You can override getters in your test class in the following way.

```php
use FOS\HttpCache\Tests\VarnishTestCase;

class YourFunctionalTest extends VarnishTestCase
{
    protected function getVarnishPort()
    {
        return 8000;
    }
}
```

### Enable Assertions

For the `assertHit` and `assertMiss` assertions to work, you should add a
[custom `X-Debug` header](varnish-configuration#debugging) to responses served by your Varnish.

Usage
-----

This example shows how you can test whether the caching headers your
application sets influence Varnish as you expect them to.

```php
use FOS\HttpCache\Tests\VarnishTestCase;

class YourFunctionalTest extends VarnishTestCase
{
    public function testCachingHeaders()
    {
        // Varnish is restarted, so you don’t have to worry about previously
        // cached content. Before continuing, the VarnishTestCase waits for
        // Varnish to become available.

        // Retrieve an URL from your application
        $response = $this->getResponse('/your/resource');

        // Assert the response was a cache miss (came from the backend
        // application)
        $this->assertMiss($response);

        // Assume the URL /your/resource sets caching headers. If we retrieve
        // it again, we should have a cache hit (response delivered by Varnish):
        $response = $this->getResponse('/your/resource');
        $this->assertHit($response);
    }
}
```

This example shows how you can test whether your application purges content
correctly:

```php
    public function testCachePurge()
    {
        // Again, Varnish is restarted, so your test is independent

        $url = '/blog/articles/1';

        // First request must be a cache miss
        $this->assertMiss($this->getResponse($url));

        // Next requests must be a hit
        $this->assertHit($this->getResponse($url));

        // Purge
        $this->varnish->purge('/blog/articles/1');

        // First request after must again be a miss
        $this->assertMiss($this->getResponse($url));
    }
```

For more ideas, see this library’s [functional tests](../tests/FOS/HttpCache/Tests/Functional).

repository: ddeboer/FOSHttpCache

repo_name: ddeboer/FOSHttpCache


text:
# remix-run-apigateway

## Description

`remix-run-apigateway` is an request handler that allows you to run
[Remix](http://remix.run/) on AWS API Gateway v2 & Lambda.

This is the AWS Lambda equivalent of `@remix-run/express` when using Remix with
Express. This could be used in any project deploying to AWS Lambda, regardless
of the deployment method (CDK, Amplify, etc).

## Installation

To install this project you can run the following command to pull the latest version directly from GitHub:

```bash
npm install m14t/remix-run-apigateway
```

## Example usage

```typescript
const { createRequestHandler } = require('@m14t/remix-run-apigateway');

exports.handler = createRequestHandler({
  getLoadContext() {
    // Whatever you return here will be passed as `context` to your loaders.
  },
});
```

## Demo project

A demo project using this adapter is available at: https://github.com/m14t/starter-aws-cdk.

## Known limitations

- AWS API Gateway has a [known limitation][api-gateway-known-issues]:

  > Path segments can only contain alphanumeric characters, hyphens, periods, commas, and curly braces.

  This means that it can not serve URLs that include the `@` symbol, which is required to serve scoped NPM packages.

  The work-around for this is to serve static files from the `public/build` directory from another source. This can be done by configuring a AWS CloudFront CDN distribution with a behavior to serve these files from an S3 bucket, with a fall-back default behavior that serves all other requests from the Lambda. An example of this can be found in [m14t/starter-aws-cdk's CDN configuration][cdn-example].

[api-gateway-known-issues]: https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-known-issues.html#api-gateway-known-issues-rest-apis
[cdn-example]: https://github.com/m14t/starter-aws-cdk/blob/6186fc434cbd8dbec8bbda75846e4efdfd471787/cdk/lib/cdn.ts#L48-L69

repository: MathieuGilbert/remix-run-aws-lambda

branch_name: refs/heads/main

repo_name: MathieuGilbert/remix-run-aws-lambda


text:
---
layout: default
title: Forms Plugin
description: Plugin to submit forms with transitions
parent: Plugins
nav_order: 6
permalink: /plugins/forms-plugin
repo_link: /forms-plugin
---

# Forms plugin
Plugin adds support for forms. Any form that matches the [formSelector](#formSelector) is sent via swup (with transition).

Swup will take the form data and submit it with appropriate `method` and `action` based on form attributes, where method defaults to `GET` and action defaults to current url.
In case of `GET` method, swup serializes the data into url.
For `POST` requests, swup wraps the data and sends it via POST request.

This form also considers the `data-swup-transition` attribute on the form element to use the appropriate animation.

**Note:** This feature is rather experimental and serves to enable submission of simple forms such as "search on website" form.
The response from the server must be a valid page with all containers that need to be replaced by swup.
This method does not support submission of files, or other advanced features.
If you're looking for such features, please, use swup [API]({{ "/api" | relative_url }}) to send requests.

## Installation
This plugin can be installed with npm

```bash
npm install @swup/forms-plugin
```

and included with import

```shell
import SwupFormsPlugin from '@swup/forms-plugin';
```

or included from the dist folder

```html
<script src="./dist/SwupFormsPlugin.js"></script>
```

## Usage
To run this plugin, include an instance in the swup options.

```javascript
const swup = new Swup({
  plugins: [new SwupFormsPlugin()]
});
```

## Options
### formSelector
`formSelector` option defines a selector for forms which should be sent via swup (with transition as any other request).
By default, any form with `data-swup-form` attribute is selected.

```javascript
new SwupFormsPlugin({formSelector: 'form[data-swup-form]'});
```

## Changes of swup instance
Plugin adds `submitForm` and `openFormSubmitInNewTab` events to swup, that can be listened to with `on` method.

repository: GetTKd/docs

repo_name: GetTKd/docs


text:
# Prestashop-SQL-queries
These are some handy Prestashop SQL queries that I programmed for my e-commerce.

removeOrderDuplications.SQL
These code eliminates order duplications that appear when order statuses are not configured correctly.

customersNoReviews.SQL
Retrieves data for emailing containing customers that have ordered more than once and didn't leave a review on the page.
Posible customizations:
c.id_lang = 4: selects the language of the customers
Where 'newsletter' = 1: for filtering only opt-in clients
o.date_add BETWEEN DATE_SUB(NOW(), INTERVAL 15 DAY) AND NOW(): ordered in the past 15 days

newsletterWhole.SQL
Retrieves data from customers that signed to the newsletter via the account creation or the newsletter footer addon. Has last order date information and number of orders for each client

orderReferencesWeight.SQL
For exporting orders with number references and weights. Useful for checking carrier's billing

repository: carlosul/Prestashop-SQL-queries

repo_name: carlosul/Prestashop-SQL-queries


text:
# Recycle Bin {#concept_ncs_jvr_q2b .concept}

DataWorks has its own recycle bin, click **Recycle Bin** in the upper left corner of the page.

![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/16334/15427065248242_en-US.png)

On the Recycle Bin page, you can check all deleted nodes in the current project. You can also right-click a node to restore or permanently delete it.

Click **Show My Files** on the right of the Recycle Bin page to view your deleted nodes.

![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/16334/15427065248255_en-US.png)

**Note:** If a node is permanently deleted from the recycle bin, it cannot be restored.

repository: xiaoyeziji/ide

path: /intl.en-US/User Guide/Data development/Recycle Bin.md

filename: Recycle Bin.md

gha_license_id: MIT

repo_name: xiaoyeziji/ide


text:
# Tutorial 10: Training a Zero-shot Classifier (TARS)

* __NOTE: (23.10.2020)__ *At the moment you would need to install flair from master branch to be able to follow this.*

Task Aware Representation of Sentences (TARS) was introduced by Halder et. al. It formulates the
traditional document level text classification problem as a universal binary text classification
problem. It uses the label names in the classification process, and leverages on the attention mechanism
of transformer based language models. This model is implemented by the `TARSClassifier` class. In this
tutorial, we will show you how to use this class in different scenarios involving training, testing on
unseen datasets.

Once a TARS classification model is trained on one (or multiple) dataset(s), the final
model can be used in many different ways such as:
 1. [A regular text classifier.](#use-case-1-as-a-regular-text-classifier)
 2. [A Zero-shot predictor on an arbitrary ad-hoc set of labels.](#use-case-2-as-a-zero-shot-predictor-on-arbitrary-ad-hoc-set-of-labels)
 3. [A Zero-shot predictor on a previously unseen classification dataset.](#use-case-3-as-a-zero-shot-predictor-on-an-unseen-task)
 4. [A base model to continue training on other datasets.](#use-case-4-as-a-base-model-to-continue-training-on-other-datasets)

## Training a TARS Classification Model
```python
import flair
from flair.data import Corpus
from flair.datasets import TREC_6
from flair.models.text_classification_model import TARSClassifier
from flair.trainers import ModelTrainer

# 1. define label names in natural language since some datasets come with cryptic set of labels
label_name_map = {'ENTY':'question about entity',
                  'DESC':'question about description',
                  'ABBR':'question about abbreviation',
                  'HUM':'question about person',
                  'NUM':'question about number',
                  'LOC':'question about location'
                  }

# 2. get the corpus
corpus: Corpus = TREC_6(label_name_map=label_name_map)

# 3. create a TARS classifier
classifier = TARSClassifier(task_name='TREC_6', label_dictionary=corpus.make_label_dictionary())

# 4. initialize the text classifier trainer
trainer = ModelTrainer(classifier, corpus)

# 5. start the training
trainer.train(base_path='resources/taggers/trec', # path to store the model artifacts
              learning_rate=0.02, # use very small learning rate
              mini_batch_size=16,
              mini_batch_chunk_size=4, # optionally set this if transformer is too much for your machine
              max_epochs=10, # terminate after 10 epochs
              )

```

## Use Case #1: As a Regular Text Classifier
```python

# 1. Load the trained model
classifier = TARSClassifier.load('resources/taggers/trec/best-model.pt')

# 2. Prepare a test sentence
sentence = flair.data.Sentence("What is the full form of NASA?")
classifier.predict(sentence)
print(sentence)

```
The output should look like:
```
loading file resources/taggers/trec/best-model.pt
Sentence: "What is the full form of NASA ?"   [− Tokens: 8  − Sentence-Labels: {'label': [question about abbreviation (0.9922)]}]
```

## Use Case #2: As a Zero-shot Predictor on Arbitrary Ad-hoc Set of Labels
```python

# 1. Load the trained model
classifier = TARSClassifier.load('resources/taggers/trec/best-model.pt')

# 2. Prepare a test sentence
sentence = flair.data.Sentence("I am so glad you liked it!")
classifier.predict_zero_shot(sentence, ["happy", "sad"])
print(sentence)

```
The output should look like:
```
loading file resources/taggers/trec/best-model.pt
Sentence: "I am so glad you liked it !"   [− Tokens: 8  − Sentence-Labels: {'label': [happy (0.9874)]}]
```

## Use Case #3: As a Zero-shot Predictor on an Unseen Task
```python

# 1. Load the trained model
classifier = TARSClassifier.load('resources/taggers/trec/best-model.pt')

# 2. Define a new task
classifier.add_and_switch_to_new_task("sentiment", label_dictionary=["happy", "sad"])

# 3. Prepare a test sentence
sentence = flair.data.Sentence("I am so glad you liked it!") # no need to provide the labels in this way
classifier.predict(sentence)
print(sentence)

```
The output should look like:
```
loading file resources/taggers/trec/best-model.pt
Sentence: "I am so glad you liked it !"   [− Tokens: 8  − Sentence-Labels: {'label': [happy (0.9874)]}]
```

## Use Case #4: As a Base Model to Continue Training on other Datasets
```python
from flair.datasets import GO_EMOTIONS

# 1. Load the trained model
classifier = TARSClassifier.load('resources/taggers/trec/best-model.pt')

# 2. load a new flair corpus e.g., GO_EMOTIONS, SENTIMENT_140 etc
new_corpus = GO_EMOTIONS()

# 3. make the model aware of the desired set of labels from the new corpus
classifier.add_and_switch_to_new_task( "GO_EMOTIONS",
                                     label_dictionary=new_corpus.make_label_dictionary())

# 4. initialize the text classifier trainer
trainer = ModelTrainer(classifier, new_corpus)

# 5. start the training
trainer.train(base_path='resources/taggers/go_emotions', # path to store the model artifacts
              learning_rate=0.02, # use very small learning rate
              mini_batch_size=16,
              mini_batch_chunk_size=4, # optionally set this if transformer is too much for your machine
              max_epochs=10, # terminate after 10 epochs
              )

```
At the end of this training, the resultant model should be able make predictions for both TREC_6 and GO_EMOTIONS tasks with full supervision accuracy.

## Switching between Tasks

TARS can encapsulate the relationship between label names and the text in the underlying
language model. A single model can be trained on multiple corpora like above. For convenience, it
internally groups set of labels into different tasks. A user can look up what existing
tasks a TARS model was trained on, and then switch to one of them as needed.

```python

# 1. Load a pre-trained TARS model
classifier = TARSClassifier.load('resources/taggers/go_emotions/best-model.pt')

# 2. Check out what datasets it was trained on
classifier.list_existing_tasks()

# 3. Switch to a particular task that exists in the above list
classifier.switch_to_task("GO_EMOTIONS")

# 4. Prepare a test sentence
sentence = flair.data.Sentence("I absolutely love this!")
classifier.predict(sentence)
print(sentence)
```
The output should look like:
```
loading file resources/taggers/go_emotions/best-model.pt
Existing tasks are:
TREC_6
GO_EMOTIONS
Sentence: "I absolutely love this !"   [− Tokens: 5  − Sentence-Labels: {'label': [LOVE (0.9708)]}]
```

## Please cite the following paper when using TARS:

```
@inproceedings{halder2020coling,
  title={Task Aware Representation of Sentences for Generic Text Classification},
  author={Halder, Kishaloy and Akbik, Alan and Krapac, Josip and Vollgraf, Roland},
  booktitle = {{COLING} 2020, 28th International Conference on Computational Linguistics},
  year      = {2020}
}
```

repository: jinzijian/flair

gha_language: Python

gha_license_id: NOASSERTION

repo_name: jinzijian/flair


text:
# dartdoc

A documentation generator for Dart. This tool produces static HTML files,
produced from Dart source code.

[![Build Status](https://travis-ci.org/dart-lang/dartdoc.svg)](https://travis-ci.org/dart-lang/dartdoc)
[![Coverage Status](https://img.shields.io/coveralls/dart-lang/dartdoc.svg)](https://coveralls.io/r/dart-lang/dartdoc)

Note: This tool is currently in alpha stage.

## Installing dartdoc

Run `pub global activate dartdoc` to install the `dartdoc` tool.

## Running dartdoc

### Generating documentation for a package

Run `dartdoc` from the root directory of package. By default, the documentation
is output to the `docs` directory. You can use `--output` to specify the output directory.

### Generating documentation for Dart SDK

Run `dartdoc` with the following command line arguments:

- `--dart-sdk /pathTo/dart-sdk`
- `--sdk-docs`
- `--sdk-readme /pathTo/sdk_readme.md`

The `sdk-readme` is found in the SDK source repo. Specifically, `$DART_SDK_SOURCE/dart/sdk/api_readme.md`.
In the future, this file might be included in an SDK distribution (see https://code.google.com/p/dart/issues/detail?id=23203).

## FAQ

#### What about docgen/dartdocgen/dartdoc-viewer?
This new tool intends to replace our existing set of API documentation
tools. We'll take the best ideas and implementations from our existing doc
tools and fold them into this tool.

#### Can I help?
Yes! Start by using the tool and filing issues and requests. If you want
to contribute, check out the [issue tracker][issues] and see if there's an issue
that you're passionate about. If you want to add a new feature that's not
yet in the issue tracker, start by opening an issue. Thanks!

## Issues and bugs

Please file reports on the [GitHub Issue Tracker][issues].

## Developing

### Publishing to pub

It's easy to publish to pub. The following command will bump the build version
and run `pub publish`.

`grinder publish`

## License

You can view our license
[here](https://github.com/dart-lang/dartdoc/blob/master/LICENSE).

[issues]: https://github.com/dart-lang/dartdoc/issues

repository: seaneagan/dartdoc

repo_name: seaneagan/dartdoc


text:
---
layout: default
---

# 1998-02-23 - PGP's Response

## Header Data

From: "Steve Orrin"<EMAIL_ADDRESS>To: "cypherpunks toad"<EMAIL_ADDRESS>Message Hash: daed114d43d4d11ec312987e2e968b9fb80cf368c59ba27187caf776bfb846ec

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1998-02-23 19:01:29 UTC

Raw Date: Mon, 23 Feb 1998 11:01:29 -0800 (PST)

## Raw message

```
{% raw  %}From: "Steve Orrin"<EMAIL_ADDRESS>Date: Mon, 23 Feb 1998 11:01:29 -0800 (PST)
To: "cypherpunks toad"<EMAIL_ADDRESS>Subject: PGP's Response
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

The following is PGP's official response (from there web site) to the TIS
acquisition by NETA. What it infers is that while PGP for Personal use
won't (at least until NETA decides otherwise) incorporate TIS technology,
it leaves the door wide open for PGP for Business use....

Network Associates and Key Recovery

With the acquisition of Trusted Information Systems (TIS) by
Network Associates, NAI has added a new technology to its product
portfolio -- key recovery. This TIS-developed technology
addresses the market needs for encryption key recovery and
management. NAI will continue to provide this technology to the
market.

NAI's PGP product group already provides the capability for
corporations to recover information from PGP products deployed in
corporate environments. The requirement for this capability from
corporations has been evident and well-known for quite sometime.

However, NAI does not believe there is a need for key recovery in
PGP products for the individual. NAI will develop and market
products that its customers need and want but will not include
any technology that is not required by its customers.

A Picture Tells A Thousand Words.
                    STEGO

{% endraw %}
```

## Thread

+ Return to [February 1998](/archive/1998/02)

+ Return to "["Steve Orrin" <sorrin@syndata.com>](/authors/steve_orrin_sorrin_at_syndata_com_)"

+ 1998-02-23 (Mon, 23 Feb 1998 11:01:29 -0800 (PST)) - PGP's Response - _"Steve Orrin"<EMAIL_ADDRESS>


text:
# FLASH CARDS

Flash Cards is a command-line application that allows the user to play an interactive quiz from a question set of their choice.

## Getting Started

This is a command-line application that runs directly from the terminal. You can play by downloading this repository, running 'npm install' via command line from within the directory, and then running node index.js from the command line.

## Project Goals

* Implement TDD processes to build an application that sucessfully follows SOLID and OOP principles
* Begin building and utilizing asynchronous functions in javascript
* Build an application that leverages node modules to limit/control scope and memory usage
* Develop understanding of non-FE logic that ultimately influences UI decisions

## Built With

* Vanilla JS
* Node.js
* Inquirer npm package

## Authors

* **[Ryan Bahan](https://github.com/ryanbahan)**

## License

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

gha_language: JavaScript


text:
---
layout: event
categories:
  - events
links:
title: "Working HackNight"
description: "This HackNight will not have a speaker, so it’s full-on hacking and learning!"
speakers: "No Speakers"
image: /images/events/working-hacknight.png
date: 2019-01-29T18:30:00
event_id: 43
youtube_id:
agenda: https://github.com/ProgressiveHackNight/project-ideas
rsvp: https://www.eventbrite.com/e/progressive-hacknight-at-thoughtworks-tickets-52887854998
sponsor:
asl_provided: false
has_slides: false
slidedeck_link:
published: true
---

On January 15, we had a huge gathering of tech workers discussing climate change: how organizations are demonstrating on the streets, and lobbying for legislation that will solve the climate crisis that we are currently in. [The Climate Mobilization](https://www.theclimatemobilization.org), [Extinction Rebellion](https://xrebellion.org/nyc), [Sunrise Movement](https://sunrisemovement.org), and [Justice Democrats](https://justicedemocrats.com) are all working towards a clear path to combat the climate crisis we're facing.

As tech workers, we have got to support the important work being done to fix the climate crisis. Here are things you can do right now:

-   If you haven't yet, [join the Progressive HackNight slack](http://bit.ly/joinHackNight) and join the #climate-manatweeter to organize and work on a twitter bot that will call out journalist that don't connect the dots of the atrocities they cover to #ClimateBreakdown.

-   On February 5, [Sunrise NYC will have a #GreenNewDeal livestream party](https://www.facebook.com/events/776068426074419/) that will kickoff the Sunrise Movement national campaign for a Green New Deal.

-   This Saturday, Xtinction Rebellion will have a national day of action. [Join the event here](https://xrebellion.org/nyc)

Next week is a Working HackNight -- which means there'll be no speakers, but we're going to work on a open-source projects, discuss strategies to help grassroots organizations, and learn from each other.

If you have a project, please [create an issue](https://github.com/ProgressiveHackNight/project-ideas/issues/new) at our [Projects Page](https://github.com/ProgressiveHackNight/project-ideas). We're looking forward to working with you! We'll have a list of breakouts on Monday next week.

#########

[Subscribe for Updates](https://proghacknight.us16.list-manage.com/subscribe?u=597c1a32f8812c62dfc1126f5&id=90e62cddff) • [Sign up to the Slack](https://join.slack.com/t/progressivehacknight/shared_invite/enQtMjY4MTkyMzg4OTYxLWU2MGRiZTMwY2NkZDk2ZmJhZDA3NDc5MjAxOWI1MTM1ZjRkYjJmODFkYTc4ZjQzMTJiNTNhNGJiZTEwZjQ0OWQ) • [Code of Conduct](http://www.progressivehacknight.org/culture/2017/07/01/code-of-conduct.html)  • [Start a Breakout Group](https://github.com/ProgressiveHackNight/project-ideas)

This HackNight will not have a speaker, so it’s full-on hacking and learning!

Start a new breakout group or meet up with an existing one. Feel free to use the space provided to us by ThoughtWorks NYC. Our directors and organizers will be available throughout the HackNight to provide support, collaborate, or a sounding board for your projects. Help us reserve a space for your group by [announcing your breakout group](https://github.com/ProgressiveHackNight/project-ideas).


text:
# groovy-excel-builder

[![Build Status](https://travis-ci.org/jameskleeh/groovy-excel-builder.svg?branch=master)](https://travis-ci.org/jameskleeh/groovy-excel-builder)

A Groovy DSL for Building Excel Files

This table describes the two major versions of this library and its compatibility with the various dependent platforms/libraries.

| Version  | Java  | Groovy  | Apache POI  | Documentation |
|---|---|---|---|---|
| 0.4.x  | 7+  | 2.4.x  | 3.1.x (XSSF based) | http://jameskleeh.com/groovy-excel-builder/0.4  |
| 1.0.x  | 8+  | 2.5.x  |  4.1.x (SXSSF based) | http://jameskleeh.com/groovy-excel-builder/1.0  |

repository: czhig/groovy-excel-builder

repo_name: czhig/groovy-excel-builder


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

### Description

A malicious admin user could edit the state of objects in the Airflow metadata database to execute arbitrary javascript on certain page views.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/SexyBeast233/SecBooks

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# Lab 9 - City Explorer API

**Author**: Carly Dekock

**Version**: 1.2.0 (increment the patch/fix version number if you make more commits past your first submission)

## Overview

Beginning to build an API server for the City Explorer Application. This will allow a user to search for a location, be presented with a map and some interesting information about the area they've selected. There are fully functionining APIs for location information, weather, and nearby parks. There is also a database to store previously searched locations. Today, we added movies as well as yelp information for restaurants showing 5 results at a time.

## Getting Started

### What you need
- Get API keys:
  - LocationIQ
  - Weatherbit
  - National Parks Service
  - The Movie Database API (TMDb)
  - Yelp
- Generate .env with variables of:
  - PORT
  - GEOCODE_API_KEY
  - WEATHER_API_KEY
  - PARKS_API_KEY
  - MOVIE_API_KEY
  - YELP_API_KEY
- Get a connection for database URL
- Install node modules: express, cors, dotenv, superagent, pg
- Set up PORT

### Steps to take
- In Terminal:
  - ```touch server.js``` to create server file
  - ```npm init```
  - ```npm install -S cors dotenv superagent pg``` to install cors, dotenv, superagent, pg libraries
  - ```touch .env``` to create environment file
- Open up server in VS code or another code editor. Put all necessary API keys in .env file as well as PORT info and database info.
- Open up server.js file
- Load any packages first, declare variables for all packages needed
- Configure app
  - ```const app = express();```
  - ```app.use(cors());```
- Set global variables
  - ```const PORT = process.env.PORT```
- Routes
  - ```/location => {}```
  - ```/weather => [{}, {}]```
  - ```/parks => [{}, {}]```
- Route callbacks
- Helper functions
- Start the app
  - ```app.listen(PORT, () => {console.log('server is listening on Port ${PORT})});```

## Architecture

Languages: HTML, CSS, JavaScript, SQL
Libraries: jQuery, Mustache, express, cors, dotenv, superagent, pg

## Time Estimates

- Number and name of feature: To-do #1 - Movies
- Estimate of time needed to complete: 1 hour
- Start time: 4:00pm
- Finish time: 5:15pm
- Actual time needed to complete: 1 hour 15 minutes

- Number and name of feature: To-do #2 - Yelp
- Estimate of time needed to complete: 1 hour
- Start time: 5:30pm
- Finish time: 6:45pm
- Actual time needed to complete: 1 hour 15 minutes

- Number and name of feature: To-do #3 - Pagination
- Estimate of time needed to complete: 30 min
- Start time: 6:45pm
- Finish time: 7:30pm
- Actual time needed to complete: 45 minutes

## Change Log

- 01-18-2021 5:45pm - Application files set up, basic express server deployed to Heroku
- 01-18-2021 8:15pm - Application has fully-functional GET route for the location resource
- 01-18-2021 9:30pm - Application has fully-functional GET route for the weather resource
- 01-18-2021 9:40pm - Application has status of 500 error message displayed to page
- 01-19-2021 4:45pm - Application has .map method implemented for formatted data
- 01-19-2021 5:45pm - Application has api fully-functional for location data
- 01-19-2021 7:00pm - Application has api fully-functional for weather data
- 01-19-2021 8:45pm - Application has api fully-functional for parks data
- 01-20-2021 6:30pm - Application has working database to store location data
- 01-20-2021 7:45pm - Application has ability to search database for previously selected location
- 01-21-2021 5:15pm - Application has api fully-functional for movie data
- 01-21-2021 6:45pm - Application has api fully-functional for yelp restaurant data
- 01-21-2021 7:30pm - Application has pagination fully-functional to display 5 yelp results at a time

## Credits and Collaborations

- Jan 18: Worked at lab table with Jason Q and Dar-Ci
- Jan 18: Jason D helped troubleshoot locations to-do
- Jan 18: Michael Eclavea (TA) helped with weather to-do
- Jan 19: Worked at lab table with Jason Q and Sang
- Jan 19: Jason D helped with rendering all location address data
- Jan 20: Used class demo for guidance in setting up database
- Jan 20: Worked at lab table with Jason Q, Sang, and Dar-Ci
- Jan 21: Worked at lab table with Jason Q, Stephen, and Dar-Ci
- Jan 21: Chance (TA) helped with Yelp API troubleshooting
- Jan 21: Used class demo for guidance in setting up pagination


text:
# Computer-Generated Music for Tabletop Role-Playing Games

This repository contains the source code to reproduce the results of the [AIIDE'20](https://webdocs.cs.ualberta.ca/~santanad/aiide/)
paper [Computer-Generated Music for Tabletop Role-Playing Games](https://arxiv.org/abs/2008.07009).
This paper presents *Bardo Composer*, a system to generate background music for tabletop role-playing games. Bardo Composer uses a
speech recognition system to translate player speech into text, which is classified according to a model of emotion. Bardo Composer
then uses Stochastic Bi-Objective Beam Search, a variant of Stochastic Beam Search that we introduce in this paper, with a neural
model to generate musical pieces conveying the desired emotion.

## Examples of Generated Pieces

- [Piece 1](https://raw.githubusercontent.com/lucasnfe/bardo-composer/master/output/piece1_ag_sus.wav)
- [Piece 2](https://raw.githubusercontent.com/lucasnfe/bardo-composer/master/output/piece2_ag_calm.wav)
- [Piece 3](https://raw.githubusercontent.com/lucasnfe/bardo-composer/master/output/piece3_sus_ag.wav)

## Installing Dependencies

## Reproducing Results

Bardo Composer uses a fine-tuned BERT to classify the story emotion and a fine-tuned GPT2 to classify the music emotion.
In the paper, we report the accuracy of these models. This section describes how to reproduce the results we found.

### Story Emotion Classification

We compared the fine-tuned BERT model for story emotion classification with the simpler Naıve Bayes approach of [Padovani, Ferreira, and
Lelis (2017)].

#### Fine-tune Pre-trained BERT

```
cd composer/clf_dnd/
python3 clf_bert.py --data ../../data/dnd/
```

#### Train Naive Bayes

```
cd composer/clf_dnd/
python3 clf_nbayes.py --data ../../data/dnd/
```

Both these scripts will perform and report accuracy experiments on the Call of the Wild dataset [Padovani, Ferreira, and
Lelis (2017)].

### Music Emotion Classification

We compared the fine-tuned GPT2 model for music emotion classification with the simpler LSTM approach of [Ferreira and Whitehead (2019)].

#### Download Pre-trained GPT-2

In the paper, the GPT-2 model was pre-trained using a new dataset called [ADL-Piano-Midi](https://github.com/lucasnfe/adl-piano-midi). The pre-trained model can be download as follows:

```
$ wget https://github.com/lucasnfe/bardo-composer/releases/download/0.1/pre-trained-gpt2.zip
```

#### Fine-tune Pre-trained GPT-2

```
cd composer/clf_vgmidi/
python3 clf_gpt2.py --conf clf_gpt2.json
```

#### Train LSTM

```
cd composer/clf_vgmidi/
python3 clf_lstm.py --conf clf_lstm.json
```

## Citing this Work

If you use this method in your research, please cite:

```
@inproceedings{ferreira2020computer,
  title={Computer-generated music for tabletop role-playing games},
  author={Ferreira, Lucas and Lelis, Levi and Whitehead, Jim},
  booktitle={Proceedings of the AAAI Conference on Artificial Intelligence and Interactive Digital Entertainment},
  volume={16},
  number={1},
  pages={59--65},
  year={2020}
}
```

repository: TwinMooon/bardo-composer

repo_name: TwinMooon/bardo-composer


text:
[musicScapes](https://musicscapes.herokuapp.com/)
-------------------------------------------------

Hack for Spotify's devX Stockholm 2017

Log into Spotify to get a generative landscape based on the last songs you've listened to.

Using [p5.js](https://p5js.org/), [randomColor](https://randomcolor.llllll.li/)


text:
# 📄 TSX Docs

Minimalist documentation with React Typescript powered by [Next.js](https://nextjs.org/), [Styled Components](https://www.styled-components.com/) and [Rebass](https://rebassjs.org/).

[![Latest Release][github-release]][npm]
[![Downloads][downloads-badge]][npm]
[![Version][version-badge]][npm]
[![MIT License][license]](LICENSE.md)

[npm]: https://npmjs.com/package/tsx-docs
[downloads-badge]: https://flat.badgen.net/npm/dt/tsx-docs
[version-badge]: https://flat.badgen.net/npm/v/tsx-docs
[license]: https://flat.badgen.net/badge/license/MIT/blue
[github-release]: https://flat.badgen.net/github/release/petecorreia/tsx-docs

**Create a new documentation site**
```sh
npx tsx-docs init
```

**Once the application has been generated**
```sh
npm run dev
```

## Goals

- ⚛ **Simplicity** by focusing on React and Typescript
- 💨 **Fast and accessible** effortlessly
- ◾ **Minimalist** with easy customisation

## Getting Started

To create a new documentation site, run `npx tsx-docs init` and follow the prompts.
Once the application has been generated run `npm run dev`.

## Documentation

Read more at **[tsx-docs.now.sh](https://tsx-docs.now.sh)** (powered by tsx-docs!).

## Examples

* **[tsx-docs](https://tsx-docs.now.sh)**
* **[react-circular-input](https://react-circular-input.now.sh)**

Enjoy! 🎉

#### Prior Art

[mdx-docs](https://github.com/jxnblk/mdx-go),
[docz](https://github.com/pedronauck/docz)

#### Related

[Next.js](https://github.com/zeit/next.js),
[Styled Components](https://github.com/styled-components/styled-components),
[Rebass](https://github.com/rebassjs/rebass),
[Inter typeface](https://github.com/rsms/inter)

---

[Contributing](CONTRIBUTING.md)
|
[Code of Conduct](CODE_OF_CONDUCT.md)
|
[MIT License](LICENSE.md)

repository: petecorreia/tsx-docs

gha_language: TypeScript

repo_name: petecorreia/tsx-docs


text:
# VACUUM
Db-less website framework based on json files. Vacuum is different from static generated websites. You can treat it like static files and still counting with some conveniences like template cache and flexible routing.

Powered by a template system (Twig) and a routing system (Fast Route), Vacuum can be fast and extremely versatile.
You can, for example extend it with a Control Panel or generating json content from other CMS's.

## WORDPRESS TO STATIC
If you would like to turn your Wordpress into Json files, please take a look at this project: https://github.com/ogabrielguerra/wordpress-to-static-files

## FEATURES

Vacuum supports almost all the features a regular blog woud do.
* Categories
* Pages
* Posts
* Tags
* Media

## DOCKERIZED
Give it a shot with Docker. Just run:
```
docker-compose up -d
```
In your browser go to http://localhost/public_html/

## TESTS
We have a couple of basic tests.

```
docker exec app-vacuum appVacuum/vendor/bin/phpunit appVacuum/tests/
```

repository: ogabrielguerra/vacuum

gha_language: PHP

repo_name: ogabrielguerra/vacuum


text:
Welcome to simple react server side rendering 👋

> implement expressjs server side rendering using reactjs component

### 🏠 [Homepage](https://github.com/alhashmicode/setup-exreact#readme)

## Install

```sh
npm install
```

## Usage

```sh
npm run build

npm run start
```

## Author

👤 **alhashmicode**

* Website: https://www.instagram.com/alhashmicode/
* Github: [@alhashmicode](https://github.com/alhashmicode)

## 🤝 Contributing

Contributions, issues and feature requests are welcome!
Feel free to check [issues page](https://github.com/alhashmicode/setup-exreact/issues). You can also take a look at the [contributing guide](https://github.com/alhashmicode/setup-exreact/blob/master/CONTRIBUTING.md).

## Show your support

Give a ⭐ if this project helped you!

## 📝 License

Copyright © 2021 [alguerocode](https://github.com/alguerocode).

This project is [ISC](https://github.com/alhashmicode/setup-exreact/blob/master/LICENSE) licensed.

***
_This README was generated with ❤ by [readme-md-generator](https://github.com/kefranabg/readme-md-generator)_

repository: alguerocode/simple-react-ssr

repo_name: alguerocode/simple-react-ssr


text:
# Docker CI Testing

Docker files in this directory are used to build images used by CircleCI. These are directly referenced in the `circle.yml` after publishing to dockerhub. There are two types of images:

* Base image for Linux distribution to use for testing (e.g. `ubuntu1910_j11.docker`)
* Caching image that contains git sources, maven and ccm dependencies

## Building Images

Build images from the parent directory using the following commands. Change tag (`-t`) as needed (prefix and current date):

Base image:

`docker build -t nastra/cassandra-testing-ubuntu1910-java11:20200603 -t nastra/cassandra-testing-ubuntu1910-java11:latest -f ubuntu1910_j11.docker .`

Caching image:

`docker build  --no-cache -t nastra/cassandra-testing-ubuntu1910-java11-w-dependencies:20200603 -t nastra/cassandra-testing-ubuntu1910-java11-w-dependencies:latest -f ubuntu1910_j11_w_dependencies.docker .`

Please make sure to always tag also by date, so we can go back to that version in case anything breaks after the next update!

## Publishing Images

We are using Docker Hub for storing published images. See [Quick Start Guide](https://docs.docker.com/docker-hub/) on how to setup docker.

Push both image references:

```
docker push nastra/cassandra-testing-ubuntu1910-java11-w-dependencies:20200603
docker push nastra/cassandra-testing-ubuntu1910-java11-w-dependencies:latest
```

## Updating circleci.yml

Check if the correct image is used in `.circleci/config-2_1.yml` by looking for the `- image:` value. It should either be set to the date dervived tag created above, or `:latest`.

repository: amitkrazzy/cassandra-builds

repo_name: amitkrazzy/cassandra-builds


text:
# Standortanalyse

This is a web based visualization of location data in an Airtable, developed by @loleg as part of the [Urbane Dörfer](https://www.urbanedoerfer.ch/) project.

The underlying project can be used to publish any spreadsheet published on Airtable, provided it has the (not yet configurable) columns _Name, Adresse, Lat, Lon, Kategorie_ (for the legend), _Notizen_ (free text), and _Bilder_ (image attachments).

![Screenshot](static/screenshot.jpg)

Points on the map for each row along with a details popup on tap are shown. Right clicking anywhere on the map shows the current latitude and longitude. A legend is automatically generated from the category field. A button, "Hinzufügen", links to an Airtable form where new data points can be added. The data is refreshed by tapping "Neuladen" and your current position can be shown with the target button.

### Components

* [Airtable](https://airtable.com) for super-spreadsheets
* [Flask](https://flask.palletsprojects.com/), a [Python](https://python.org) web framework
* [Flask-API](http://www.flaskapi.org/) to expose public data
* [Leaflet.js](https://leafletjs.com/reference-1.6.0.html) geodata mapping
* [OpenStreetMap](https://osm.ch) via [Mapbox](https://mapbox.com/) as map base
* [Mustache](https://github.com/janl/mustache.js/) UI templating
* [Zepto](https://zeptojs.com/) UI tooling
* [Gunicorn](https://gunicorn.org/) web server support
* [Heroku](https://heroku.com) deployment support

### Project structure

| Location                |  Content                             |
|-------------------------|--------------------------------------|
| `/data`                 | Sample data structure                |
| `/static`               | Frontend resources                   |
| `/templates`            | Web templates                        |
| `/app.py`               | Flask API (`/api`)                   |

## Configuration

The following environment keys can be used to configure this project:

- `MAPBOX_KEY` get an access token [here](https://docs.mapbox.com/api/#access-tokens-and-token-scopes) or [here](view-source:https://leafletjs.com/examples/choropleth/example.html) for the base layer
- `AIRTABLE_BASE`, `AIRTABLE_TABLE` and `AIRTABLE_KEY` from the [Airtable API](https://airtable.com/api)
- `AIRTABLE_FORM` (optional) is the URL of the shared add (Form) view
- `AIRTABLE_LINK` (optional) is the URL of the shared detail (Gallery) view
- `POPUP_FIELDS` (optional) are a comma-delimited list of columns which are shown in the detail pop-up
- `SORT_KEY` (optional) to indicate which column to sort on

These can be added using Heroku's add project or Settings interface:

[![Deploy on Heroku](https://www.herokucdn.com/deploy/button.svg)](https://heroku.com/deploy?template=https://github.com/loleg/standortanalyse)

## Installation

First, clone this repository and make sure to set up the following dependencies:

- [X] [Python 3](https://python.org)
- [X] [Poetry](https://python-poetry.org/docs/)
- [X] [Heroku CLI](https://devcenter.heroku.com/articles/heroku-cli) (optional)

Setup a virtual environment, install dependencies, and activate it using Poetry:

```
$ poetry shell
$ poetry install
```

Create a file called `.flaskenv` in the root folder and add development settings and required keys from the Configuration section above - for example:

```
POPUP_FIELDS=Kategorie,Eingetragen,Notizen,Relevanz
SORT_KEY=Kategorie

AIRTABLE_BASE=...
AIRTABLE_KEY=...
AIRTABLE_TABLE=Standorte
AIRTABLE_LINK=https://airtable.com/shr...
AIRTABLE_FORM=https://airtable.com/shr...

MAPBOX_KEY=pk...

# When not in production:
FLASK_ENV=development
FLASK_DEBUG=true
```

Now start the development server:

```
$ flask run
```

- The API will be served from http://localhost:5000/items/
- The frontend will be served from http://<IP_ADDRESS>:5000/

### Dependency management

We are using poetry (and GitHub bots) to keep this project up to date. To check if you have the latest versions of upstream libraries, run:

`poetry update`

Heroku's buildpack currently does not support loading Python dependencies from poetry automatically. [We're working on it](https://github.com/heroku/heroku-buildpack-python/issues/796#issuecomment-611198469) ... in the meantime, please remember to run this command after upgrading dependencies:

`poetry export -f requirements.txt > requirements.txt`

repository: Ceeced/standortanalyse

repo_name: Ceeced/standortanalyse


text:
---
layout: post
title: "Oh! The places you'll go"
date: 2013-05-01 10:18
comments: true
categories: journal
tags:
 - inspiration
 - poem
---

This is a beautiful poem I found from the movie Fracture. It's written
by [Dr. Seuss][seuss]. It's inspiring!

> Congratulations!
> Today is your day,
> You're off to Great Places!
> You're off and away!
>
> You have brains in your head.
> You have feet in your shoes.
> You can steer yourself
> any direction you choose.
> You're on your own.  Look 'em over with care.
> About some you will say, "I don't choose to go there."
> With your head full of brains, and your shoes full of feet,
> you're too smart to go down any not-so-good street.
>
> And you may not find any
> you'll want to go down.
> In that case, of course,
> you'll head straight out of town.
>
> It's opener there
> in the wide open air.
>
> Out there things can happen
> and frequently do
> to people as brainy
> and footsy as you.
>
> And when things start to happen,
> don't worry. Don't stew.
> Just go right along.
> You'll start happening too.
>
> OH!
> THE PLACES YOU'LL GO!
>
> You'll be on your way up!
> You'll be seeing great sites!
> You'll join the high fliers!
> who soar to high heights.
>
> You won't lag behind, because you'll have the speed.
> You'll pass the whole gang and you'll soon take the lead.
> Wherever you fly, you'll be best of the best.
> Wherever you go, you will top all the rest.
>
> Except when you don't.
> Because, sometimes, you won't.
>
> I'm sorry to says so
> but, sadly, it's true
> that Bang-ups
> and Hang-ups
> can happen to you
>
> You can get all hung up
> in a prickle-ly perch.
> And your gang will fly on.
> You'll be left in a Lurch.
>
> You'll come down from the Lunch
> wuth an unpleasant bump.
> And the chances are, then,
> that you'll be in a Slump.
>
> And when you're in a Slump,
> you're not in for much fun.
> Un-slumping yourself
> is not easily done.
>
> You will come to a place where the streets are not marked.
> Some windows are lighted. But mostly they're dark.
> A place that could sprain both elbow and chin!
> Do you dare to stay out? Do you dare to go in?
> How much can you lose? How much can you win?
>
> And IF you should go in,should you turn left or right...
> or right-and-three-quaters? Or maybe not quite?
> Or go around and back and sneak from behind?
> Simple it's not, I'm afraid you will find,
> for a mind-maker-upper to make up his mind.
>
> You can get so confused
> that you'll start in to race
> down long and wiggled roads at a break-necking pace
> and grind on for miles across weirdish wild space,
> headed, I fear, toward a most usless place
>
> The Waiting Place...
>
> ...for people just waiting.
>
> Waiting for a train to go
> or a bus to come, or a plane to go
> or the mail to come, or the rain to go
> or the phone to ring, or the snow to snow
> or waiting around for a Yes or a No
> or waiting for their hair to grow.
> Everyone is just waiting.
>
> Waiting for the fish to bite
> or waiting for wind to fly a kite
> or waiting around for Friday night
> or waiting, perhaps, for their uncle Jake
> or a pot to boil, or a Better Break
> or a string of pearls, or a pair of pants
> or a wig with curls, or Another Chance.
> Everyone is just waiting.
>
> NO!
> That's not for you!
>
> Somehow you'll escape
> all that waiting and staying.
> You'll find the bright places
> where boom bands are playing.
>
> Oh, the places you'll go! There is fun to be done!
> There are points to be scored. There are games to be won.
> And the magical things you can do with that ball
> will make you the winning-est winner of all.
> Fame! You'll be famous as famous can be,
> with the whole wide world watching you win on TV.
>
> Except when they don't.
> Because, sometimes, they won't.
>
> I'm afraid that some times
> you'll play lonely games too.
> Games you can't win
> 'cause you'll play against you.
>
> All Alone!
> Whether you like it or not.
> Alone will be something
> you'll be quite a lot.
>
> And when you're alone, theres a very good chance
> you'll meet things that scare you right out of your pants.
> There are some, down the road between hither and yon,
> that can scare you so much you won't want to go on.
>
> But on you will go
> though the whether be foul.
> On you will go
> though your enemies prowl.
> On you will go
> though the Hakken-Kraks howl.
> Onward up many
> a frightening creek,
> though you arms may get sore
> and your sneakers may leak.
>
> On and on you will hike.
> And I know you'll hike far
> and face up to your problems
> whatever they are.
>
> You'll get mixed up of course,
> as you already know.
> You'll get mixed up
> with many stray birds as you go.
> So be sure when you step.
> Step with care and great tact
> and remember that Life's
> a Great Balancing Act.
> Just never forget to be dexterous and deft.
> And never mix up your right foot with you left.
>
> And will you succeed?
> Yes! You will indeed!
> (98 and 3/4 percent garanteed!)
>
> KID YOU'LL MOVE MOUNTAINS!
>
> So...
> be your name Buxbaum or Bixby or Bray
> or Mordecai Ali Van Alenn O'Shea
> you're off to Great Places!
> Today is your day!
> Your mountain is waiting.
> So... get on your way!

[seuss]: http://en.wikipedia.org/wiki/Oh,_the_Places_You'll_Go!

extension: markdown


text:
SortOrder: 1
# Sample Flows
This article shares some use cases your app could support, as well as a sample flow that could support each use case. You're certainly not limited to these use cases, but they can be a helpful jumping off point as you plan your app's implementation.

## SEO List Suggested Keywords Flow

A Wix user wishes to determine the strongest SEO keywords for their site. When the `quotaEnabled` parameter is set to `true` in the configuration, you return a quota object in addition to the data object.

1. The Wix user provides a keyword to Wix to check its SEO strength.

2. Wix sends a [List Suggested Keywords](https://dev.wix.com/api/rest/marketing/seo-keyword-suggestions-spi/list-suggested-keywords) request to your app using the configured `baseUri`.

    ```json
    {
        "keyword": "pizza",
        "countryCode": "US"
    }
    ```

3. Your app sends a response.

   Wix expects an object containing either a 4xx HTTP status code (and some errors) or a 200 HTTP status code and the List Suggested Keywords response.

You can see an example of the response in the [List Suggested Keywords](https://dev.wix.com/api/rest/marketing/seo-keyword-suggestions-spi/list-suggested-keywords) code example.

## Get Quota Flow

When a Wix user initially opens the SEO page in the Dashboard, Wix requests information about the current quota plan.

1. The Wix user opens the SEO page in the Dashboard.

2. Wix sends a [Get Quota](https://dev.wix.com/api/rest/marketing/seo-keyword-suggestions-spi/get-quota) request to your app using the configured `baseUri`. No parameters are sent.

3. Your app sends a response.

   Wix expects an object containing either a 4xx HTTP status code (and some errors) or a 200 HTTP status code and the Get Quota response.

You can see an example of the response in the [Get Quota](https://dev.wix.com/api/rest/marketing/seo-keyword-suggestions-spi/get-quota) code example.

repository: wix-incubator/wix-rest-docs

repo_name: wix-incubator/wix-rest-docs


text:
Runway
======

Runway is the official ORM (Object-Record Mapping) framework for Concourse. Runway provides a framework for persisting simple POJO-like objects to Concourse while automatically preserving transactional security.

Persistable types must extend the `Record` class. Like Concourse, Runway doesn't insist on being given an explicit schema for Records. The class definition and some optional annotations are all that are required to define the storage schema. By default, Runway respects Java access rules. For example, private fields are saved but never exposed and transient fields are not stored in the database.

Java inheritence is supported, so member variables extend to subclasses.

Runway intelligently detects variable types and stores the correct data in Concourse. For example, variables that are instances of the `Record` class are stored in Concourse as links. Variables that hold arrays or collections have each unique value stored individually for the appropriate key in the record. Finally, variables that are non-primitive serializable types have their serializable forms stored.

### Constraints
You can use annotations to declare optional database contraints on member variables within the class. Runway checks for these annotations when saving records and enforces the appropriate constraint.
  * `Required` - the record cannot be saved if the value of the variable is `null` or an empty collection/array
  * `Unique` - the record cannot be saved if another record in the class has the same value
  * `ValidatedBy` - the record cannot be saved in the value does not pass the specified validator

### Creating a Record type
Each Record type should extend the `Record` class. Once the class is created, you can define the schema using the member variables in the class. All non-transient variables are stored in the database. All non-private variables are automatically printed out when creating a `dump` or `toString` representation of the record.

Each Record has a unique `id` that is automatically assigned during creation. You can get the id for any record using the `getId()` method.

```
public class User extends Record {

    /**
     * Login and load the appropriate user instance that has the {@code email}
     * and {@code password} login information. If those credentials do not
     * identify a user, then return null.
     *
     * @param email
     * @param password
     * @return the User instance or {@code null} if the credentials are not
     *         correct.
     */
    @Nullable
    public static User login(String email, String password) {
        try {
            User user = Iterables.getOnlyElement(Record.findEvery(User.class,
                    Criteria.where().key("email").operator(Operator.EQUALS)
                            .value(email).build()));
            if(user.password.equals(Secrets.getExpectedPasswordHash(email,
                    password, user.salt, user.rounds))) {
                return user;
            }
            else {
                return null;
            }
        }
        catch (NoSuchElementException | IllegalArgumentException e) {
            return null;
        }
    }

    /**
     * The user's human readable name
     */
    public String name;

    /**
     * The email account associated with the user account that also functions as
     * a username for login purposes. This is a unique key within the database.
     */
    @Unique
    @Required
    @ValidatedBy(EmailValidator.class)
    protected String email;

    /**
     * The hashed password.
     */
    @Unique
    @Required
    private String password;

    /**
     * The number of rounds user to hash the {@link #salt}.
     */
    @Required
    private int rounds = 0;

    /**
     * The salt used when hashing the password.
     */
    @Required
    private String salt = null;

    /**
     * Return the email address for this user. To set this value, use the
     * {@link #setLoginInfo(String, String)} method so that the password hash is
     * appropriately updated.
     *
     * @return the email address
     */
    public String getEmail() {
        return email;
    }

    /**
     * Set the login information for this user.
     *
     * @param email
     * @param password
     */
    public void setLoginInfo(String email, String password) {
        initSecurityData();
        this.email = email;
        this.password = Secrets.getExpectedPasswordHash(email, password, salt,
                rounds);
    }

    /**
     * Initialize the data that is necessary to perform security functions (e.g.
     * assign a number of hash rounds and select a random salt).
     */
    private void initSecurityData() {
        if(rounds == 0 || Strings.isNullOrEmpty(salt)) {
            rounds = Secrets.SRAND.nextInt(10) + 1;
            salt = BaseEncoding.base64().encode(
                    Longs.toByteArray(Crypt.srand.nextLong()));
        }
    }

}
```
#### Creating a Record instance
You can create a Record instance by calling the class-defined constructor.

#### Loading a Record instance
Use the static `load` method to load a previously stored Record instance. You will need to pass along the class of the Record type you wish to load and the `id` of the record.
```
Runway db = Runway.connect();
User user = db.load(User.class, 1);
```

### Saving a Record
Once you have made changes to a record, you need to save it before those changes are persisted to Concourse. Every record exposes a `save()` method that calculates diffs and stores those to the database. If the save succeeds, the method returns `true`. Otherwise, it returns `false`, which usually means that a constraint was violated.
```
user.name = "Jeff Nelson";
<EMAIL_ADDRESS>"ihatesecurity");
user.save();
```

If a record fails to save for some reason, you can always throw an Exception with a complete stacktrace of the failure's cause using the `throwSuppressedExceptions()` method.

### Saving multiple Records at once
The `save()` method saves changes to a record within an ACID transaction to ensure that the state remains consistent. You can save multiple records within a single transaction using the `Record.saveAll()` method. This is useful in situations when changes to multiple records are dependant or newly created records link to one another.
```
Runway db = Runway.connect()
User user1 = User.create();
User user2 = User.create();
user1.followers.add(user2);
db.save(user1, user2);
```

repository: cinchapi/runway

branch_name: refs/heads/develop

gha_language: Java

repo_name: cinchapi/runway


text:
# ES6 demo
This folder is demo of ES6 features.

To support ES6, babel.js is used [https://github.com/thejameskyle/babel-handbook/blob/master/translations/en/user-handbook.md]

repository: mocheng/computer

repo_name: mocheng/computer


text:
# Figure 17b:  Performance Test on a Single GPU

The goal of this experiment is to get the end-to-end performance between DGL, TSOTA and GNNLab over a single GPU.

- `run.sh` is the runner script.

## Hardware Requirements

- Paper's configurations: **8x16GB** NVIDIA V100 GPUs, **2x24** cores Intel 8163 CPU
- For other hardware configurations, you may need to modify the ①Number of vertex(in percentage, 0<=pct. <=1) to be cached.
  - **GNNLab**: Modify the arguments `cache-percentage` of L27-L37 in run.sh.
  - **TSOTA**: Modify the arguments `cache-percentage` of L40-L50 in run.sh.

## Run Command

```sh
> bash run.sh
```

## Output Example

`bash run.sh` will create a new folder(e.g. `run-logs/single/2022-01-30_02-23-22`) to store log files.

```sh
> tree -L 3 .
.
├── fig17b.dat          # the results of this test
├── fig17b.eps          # fig17b
├── fig17b.plt          # drawing script of fig17b
├── run-logs
│   └── single
│       └── 2022-01-30_02-23-22 # running log files
└── run.sh              # the main running script

```

```sh
> cat fig17b.dat
dataset	dgl	fgnn	sgnn	app
PR	4.47	1.62	1.52	GCN
TW	11.74	2.72	4.14	GCN
PA	16.17	4.97	9.42	GCN
PR	2.29	.47	0.43	GraphSAGE
# ...

```

## FAQ

repository: SJTU-IPADS/fgnn-artifacts

repo_name: SJTU-IPADS/fgnn-artifacts


text:
# _Scrabble letters!_

#### _Some back end for letter/number conversion_

#### By _**Michael Wells and Ike Esquivel-Pilloud**_

## Description

_Yes._

|Behavior|Input|Output|
|---|---|---|
| The program will take a word | "pencil" | "pencil" |
| The program will check for the characters a, e, i, o, u, l, n, r, s, t, and their capital equivalents, assigning a score based on the letters that are found. | "apple" | "3" |
| The program will check for the characters d, g, and their capital equivalents, assigning a score based on the letters that are found. | "dog" | "4" |
| The program will check for the characters b, c, m, p, and their capital equivalents, assigning a score based on the letters that are found. | "crab mop" | "12" |
| The program will check for the characters f, h, v, w, y, and their capital equivalents, assigning a score based on the letters that are found. | "food house version wood yellow" | "20" |
| The program will check for the character k, and their capital equivalent, assigning a score based on the letters that are found. | "Kørn" | "5" |
| The program will check for the characters j, x and their capital equivalents, assigning a score based on the letters that are found. | "juice wax" | "16" |
| The program will check for the characters q, z, and their capital equivalents, assigning a score based on the letters that are found. | "queen zebra" | "20" |
| The program will check for all characters and their capital equivalents, and return a total score | "cheese" | "11" |

## Setup/Installation Requirements

* _Launch <https://michael-wayne-wells.github.io/(---------)> in your browser._
### OR ###
* clone and open the file locally
* _in terminal run:_
>$git clone https://github.com/Michael-Wayne-Wells/(------).git
* _open index.html in your browser._

## Known Bugs

_No known bugs_

## Support and contact details

_If you have any issues with the program or want to reach out, email [mwells1286@gmail.com](href="mailto:mwells1286@gmail.com")_

## Technologies Used

_This program utilized:_
* _RUBY_
_and was built on Atom_
### License

*Licensed under MIT license*

Copyright (c) 2019 **_Michael Wells_**


text:
# Introduction

```sh
go build
./sink -h
```
```txt
Usage:
    ./sink [OPTION]...

Description:
    Sink server accepts TCP (or TLS with -tls option) handshakes and data packets. It never sends any data back to server. When timeout, the sink server closes the connection. By default, print CSV results to stdout and log to stderr.

Examples:
    Listening on port 3000, 4000, 4001, and 4002 of <IP_ADDRESS> as a TCP server. Close each TCP connection after 5 seconds (if the client has not closed it yet):
	./sink -ip <IP_ADDRESS> -p 3000,4000-4002 -timeout 5s

    Listening on port 4000 of <IP_ADDRESS> as a TLS server. Write CSV output, including the header, to ouptput.csv. Log to log.txt.
	./sink -tls -tlsCert ./server.crt -tlsKey ./server.key -p 4000 -header=true -out output.csv -log log.txt

Notes:
    The CSV field "len" records the total number of bytes received in a connection.
    The CSV field is called "truncatedPayload" because it only keeps the first -buffSize bytes of payload for each connection, which may not be complete. When len <= -buffSize, the payload is complete without being truncated.

Options:
  -buffSize int
    	Set recv buffer size. This is also the max number of bytes to keep in CSV's truncatedPayload field. (default 2048)
  -flush
    	flush after every output. (default true)
  -header
    	print CSV header.
  -ip string
    	IP address to listen on. (default listen on <IP_ADDRESS> and ::/0)
  -log string
    	log to file.  (default stderr)
  -out string
    	output csv file.  (default stdout)
  -p string
    	comma-separated list of ports to listen on. eg. 3000,4000-4002 (default "12345")
  -timeout duration
    	timeout value. (default 1m0s)
  -tls
    	listen with TLS.
  -tlsCert string
    	specify TLS certificate file (PEM) for listening. (default "server.crt")
  -tlsKey string
    	specify TLS private key (PEM) for listening. (default "server.key")
```

## Motivation

**go version is significantly more efficient, compared to tcpserver:**

50% of a single core + 100 MB (300 - 200) is enough to handle 1 Million TCP connections per minute.

While the 100% of a single core + 1000 MB is enough to handle 0.3 million TCP connections per minute

## Firewall rules rationale

We need firewall rules to suppress outgoing RST.

This is because the program cannot guarantee not to send RSTs. As introduced in [this post](https://github.com/net4people/bbs/issues/26), "[i]f a user-space process closes a socket without draining the kernel socket buffer, the kernel sends a RST instead of a FIN".

The best a program can do is to try reading from the buffer as fast and as possible; however, as long as the server actively close a connection, it is sometimes unavoidable that some bytes are still left in the buffer.

This is especially likely to happen when the client sends data to the server at a very high speed. For example, the following example will cause the server to send a RST when timeout:

```sh
./sink -ip <IP_ADDRESS> -p 12345
```

```sh
nc -nv <IP_ADDRESS> 12345 </dev/random
```

This is because, when the server timeout and calls close(), there is a chance that more data has arrived at the server but hasn't been read.

Even if we let the program read forever without timing out, there are still other cases where the server has to actively close the connection. For example, when a "too many open files" error occurs.