text:
# NAME

Dist::Zilla::Plugin::Git::FilePermissions - fix the file permissions in your Git repository with Dist::Zilla

# VERSION

Version 1.002

# SYNOPSIS

    # in dist.ini:
    [Git::FilePermissions]
    perms = ^bin/         0755
    perms = ^scripts/     0755

# DESCRIPTION

This plugin fixes the file permissions of all the files in the Git repository
where your project is saved. Files not in the Git index, and directories, are
ignored.

Without configuration, every file is changed to the default permission of
0644\. The default permissions can be changed with the `default` option
and you can configure different permissions for some files with the
`perms` option in the `dist.ini`.

The plugin runs in the before build phase, which means it will fix the file
permissions before the files are picked up in the file gather phase. The new
permissions are therefore also the ones used in the build.

The plugin should ensure that you always commit your files with the correct
permissions.

## perms

The `perms` configuration option takes the form of:

    perms = REGEX WHITESPACE PERMS

or

    perms = REGEX WHITESPACE -

The `perms` configuration options are processed in order for every file. If
a file matches the `REGEX` the file permissions are changed to the
corresponding `PERMS` instead of the default permissions of 0644. If the
`PERMS` are `-` the file is ignored.

# SUPPORT

## Bugs / Feature Requests

Please report any bugs or feature requests through the issue tracker
at [https://github.com/skirmess/Dist-Zilla-Plugin-Git-FilePermissions/issues](https://github.com/skirmess/Dist-Zilla-Plugin-Git-FilePermissions/issues).
You will be notified automatically of any progress on your issue.

## Source Code

This is open source software. The code repository is available for
public review and contribution under the terms of the license.

[https://github.com/skirmess/Dist-Zilla-Plugin-Git-FilePermissions](https://github.com/skirmess/Dist-Zilla-Plugin-Git-FilePermissions)

    git clone https://github.com/skirmess/Dist-Zilla-Plugin-Git-FilePermissions.git

# AUTHOR

Sven Kirmess<EMAIL_ADDRESS>
# SEE ALSO

[Dist::Zilla::Plugin::Git::RequireUnixEOL](https://metacpan.org/pod/Dist%3A%3AZilla%3A%3APlugin%3A%3AGit%3A%3ARequireUnixEOL)


text:
sailsJs-sockeIO
===============
A SailsJs simple emit Application with socke.io

This app is based on the "Working with data in Sails.js with socke.io" tutorial. The code base has been to use the latest version of Sails.js v0.9.8.

Feel free to create issues or pull request where the code could be improved.

Installation:

You must have Node.js, sailsJs (IF not use : sudo npm install -g sails) installed, which includes npm (node package manager).

From terminal-

* cd into the directory you'd like to install the app.

sails new MessageEmitApp

cd MessageEmitApp

* Run "git clone https://github.com/Jaydeep717/sailsJs-sockeIO.git"

copy into the newly created directory.

* Run "sails lift"

To see : localhost:1337

* server config dir : config/local.js
* route : config/routes.js
* socke.io connection : config/sockets.js
* update view : under view .ejs files

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# React Boilerplate (Quick Starter for React, Redux & Saga) #

This React boilerplate is a very basic one which helps you do a quick start in React project while using Redux for state management and Saga for effect management..

### System Requirements ###

* Node version

`v8.12.0`
### Setup ###

* Clone the project and go inside the project folder.

```sh
 git clone https://github.com/Daham/react-boilerplate.git
```
* Go inside the project folder.

```sh
 cd react-boilerplate
```

* Since `webapp` directory is seperately located within the `src`, first change the directory as

```sh
 cd src/web-app
```
* Install dependencies by hitting

```sh
 yarn
```
* To start web application in developer mode

```sh
 yarn start
```
This will start dev server on `http://localhost:3000`

* To build the web application

```sh
 yarn build
```

* To build & deploy the web application

```sh
 yarn deploy
```
### Complementary ###

In this boilerplate, a basic authentication layout and a sophisticated sidebar are readily available.

* In authentication page provide following as credentials to proceed.

```
email: admin
password: admin
```

### Tools & Tech ###

* User Interface Library

* State Management

* Effect Management

* Module Bundler

* Transpiler

* Task Runner

* Web Application is Served by a Minimalistic Express Server

repository: Daham/react-ducks-boilerplate

repo_name: Daham/react-ducks-boilerplate


text:
---
layout: default
---

# 1993-10-18 - key management workshop

## Header Data

From: zeek<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 38b4a2e763dc77517cc47c62a33dbf6475d36ae8b0c91bf33a7eef6402519567

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-10-18 01:42:04 UTC

Raw Date: Sun, 17 Oct 93 18:42:04 PDT

## Raw message

```
{% raw  %}From: zeek<EMAIL_ADDRESS>Date: Sun, 17 Oct 93 18:42:04 PDT
To<EMAIL_ADDRESS>Subject: key management workshop
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text

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

I'm interested in starting a key management workshop for the purpose of
learning more about how to properly manage keys, the use of anon
remailers, hopping mail, and pgp in general.

I would appreciate copies of your public key if you are interested in
participating.

Please keep in mind this exersise is for EXPERIMENTAL PURPOSES ONLY.  I'm
running pgp on a shared system, therefore the security here is not fully
tamperproof (ie. passwords can be picked up on the line from this local
machine to the remote site). If you would rather submit a "test" key,
please do so.

I would like to know if anyone on either list has objections to using the
<EMAIL_ADDRESS>and/or<EMAIL_ADDRESS>list as
places of exchange of group messages.

One last thing; any information on the format for hopping mail through
encryption supported remailers would be appreciated.

I look forward to your support and participation.

Thank you,

- -z

- -----BEGIN PGP PUBLIC KEY BLOCK-----
Version: 2.3a

mQCNAiy/d2oAAAEEAPEFrakegXbaR6SYC8/aG0Fy6I0BFF8jjzim/6ekJP3wdVXb
EGqjnRGoL9yJHNuLQudDBoHmV1LfJdsy1gzONcEbM2mmuxKGUSh1KUypbtZVc23Z
FD/LmQmOs1cl3yQgs5d8r1/2H1TWl80sWS+RAg02lMqkTxhL/GH4Xujemt89AAUR
tCtLZXZpbiBULiBLcnV6aWNoIDx6ZWVrQGJvbmdvLmNjLnV0ZXhhcy5lZHU+
=TgqV
- -----END PGP PUBLIC KEY BLOCK-----

-----BEGIN PGP SIGNATURE-----
Version: 2.3a

iQCVAgUBLMHzrGH4Xujemt89AQG7ZQP/Qlbp/VVNRYp1J+z9IbFhGU1866rzxTyh
ErPNxyJ2HLIs4iSBQDMFRbHLCwtoZw7qnPXyBY4EH1Xjwdbp/bbq+vChH7n7mA0E
s05u4zKNklT5bTjX0WC0tNXSX87YrDvcnysCbdxQWpXJzu9TbHBJwfVFEPA+f98B
E8Cwl0/TMWs=
=un/i
-----END PGP SIGNATURE-----

{% endraw %}
```

## Thread

+ Return to [October 1993](/archive/1993/10)

+ Return to "[zeek <zeek@bongo.cc.utexas.edu>](/authors/zeek_zeek_at_bongo_cc_utexas_edu_)"

+ 1993-10-18 (Sun, 17 Oct 93 18:42:04 PDT) - key management workshop - _zeek<EMAIL_ADDRESS>

gha_license_id: MIT


text:
Bitcoin ABC
===========

https://bitcoinabc.org

What is Bitcoin?
----------------

Bitcoin is an experimental digital currency that enables instant payments to
anyone, anywhere in the world. Bitcoin uses peer-to-peer technology to operate
with no central authority: managing transactions and issuing money are carried
out collectively by the network.

What is Bitcoin ABC?
--------------------

Bitcoin ABC is the name of open source software which enables the use of Bitcoin.
It is designed to facilite a hard fork to increase Bitcoin's block size limit.
"ABC" stands for "Adjustable Blocksize Cap".

Bitcoin ABC is a fork of the [Bitcoin Core](https://bitcoincore.org) software project.

License
-------

Bitcoin ABC is released under the terms of the MIT license. See [COPYING](COPYING) for more
information or see https://opensource.org/licenses/MIT.

Development Process
-------------------

Bitcoin ABC development takes place at https://reviews.bitcoinabc.org/

repository: bitprim/bitcoin-abc

repo_name: bitprim/bitcoin-abc


text:
# Meeting 11 Oct 2018

Zulip thread: [meeting 2018-10-11](https://rust-lang.zulipchat.com/#narrow/stream/136281-wg-unsafe-code-guidelines/subject/meeting.202018-10-11)

The main discussion was about how to finish up with the structs+tuples
PR ([#31]). We opted to pull out several "unresolved questions" into
sub-issues and call for a "final comment period" on the PR. This means
we will merge the PR next meeting, presuming nothing arises.

[#31]: https://github.com/rust-rfcs/unsafe-code-guidelines/pull/31

We also reviewed the assignments for writing summaries of other
issues, which hasn't really happened yet. It seems like it'd be good
to get some "fresh blood" to take a look. For reference, here are a
list of other issues. For all of them, there is at least some
tentative consensus on certain issues, and so it would be great to
have people volunteer to write up a PR (similar to [#31]) that
documents what is known and pulls out important unresolved questions.
You can kind the list of issues by searching for [the writeup-needed
label](https://github.com/rust-rfcs/unsafe-code-guidelines/issues?utf8=%E2%9C%93&q=is%3Aopen+is%3Aissue+label%3A%22active+discussion+topic%22+label%3Awriteup-needed):

- References and raw pointers (#16)
- Fn pointers (#14)
- Unions (#13)
- Enums (#10)
- Integers and floating points (#9)

repository: rust-lang/unsafe-code-guidelines

repo_name: rust-lang/unsafe-code-guidelines


text:
# .NET Core Console Application Template

Leverage [cookiecutter](https://cookiecutter.readthedocs.io/en/1.7.2/overview.html) and use this repository as a template for your next .NET Core console application.

## Aim

As a developer, creating a console application is often the easiest way to perform basic actions. Having a template should remove some bolier-plate code from each of the applications that you write. It should also help to enforce best practices are adhered to.

## Features

- .NET Core 3.1
- Dependency Injection using the built-in [ServiceCollection](https://docs.microsoft.com/en-us/archive/msdn-magazine/2016/june/essential-net-dependency-injection-with-net-core)
- Strongly typed command-line arguments via [CommandLineParser](https://github.com/commandlineparser/commandline)
- Unit testing via [NUnit](https://github.com/nunit/nunit) and [FluentAssertions](https://fluentassertions.com/introduction)

## Usage

- Install [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
- Install [.NET Core 3.1 SDK](https://dotnet.microsoft.com/download/dotnet/3.1)
- Install cookiecutter - [guidance](https://cookiecutter.readthedocs.io/en/1.7.2/installation.html)
- Open CMD prompt/bash (shell of choice)
- Navigate to the directory you want your application to sit in
- Decide on a project name
- Execute `cookiecutter https://github.com/mikerogers123/Dotnet.Cli.CookieCutter.git`, supplying your desired project name when prompted

branch_name: refs/heads/main


text:
# Manage updates

Updates is a way to keep your community posted on your progress. They are sent by email to all you contributors and followers. In this section, you can either activate or deactivate updates by clicking on the checkbox.

![Updates section](../../.gitbook/assets/fiscal-host_fiscal-host-settings_settings-manage-updates_2020-07-13.png)


text:
---
published: true
title: Make (build tool)
tags: build-system
---
> Check proper tab usage: "`cat -e -t -v  Makefile`" - [ tab inferno](https://stackoverflow.com/questions/16931770/makefile4-missing-separator-stop/16945143#16945143)

as a simpler, faster and modern alternative see [Ninja]({% post_url 2020-08-12-build-ninja %})

### [Your Makefiles are wrong](https://tech.davis-hansson.com/p/make/) - Your Makefiles are full of tabs and errors. An opinionated approach to writing (GNU) Makefiles that I learned from Ben may still be able to salvage them.

The big things I hope you take away are:
- The file system is a fundamental part of Make, don’t fight it
- Use sentinel files for targets that do not yield exactly one file
- Don’t use tabs, set -ea -o pipefail, and a few other sensible defaults
- Use the above as guidelines, not dogma

# [Make (1976)](https://en.wikipedia.org/wiki/Make_(software))

First tool to allows to break build operation in 2 parts:
- a set of task, and dependencies between them
- a set of recipes to execute the task

Make concept had give birth to a lot tools, trying to improve it or extends it in some ways.

{% highlight make %}
CFLAGS ?= -g

all: helloworld

helloworld: helloworld.o
	# Commands start with TAB not spaces
	$(CC) $(LDFLAGS) -o $@ $^

helloworld.o: helloworld.c
	$(CC) $(CFLAGS) -c -o $@ $<

clean: FRC
	rm -f helloworld helloworld.o
{% endhighlight %}

Done at a time were library or module were fewer than now.
Use of shell one line for building recipes give some flexibility, but does not scale well
to when operation becames more complex (this was latter adressed by tool like CMake).

Recursive build description for package of package, was an issue.

Mixing description of build inside the build, make them non portable (when moving to an other compiler for ex).

Pros:
- very simple concept and low learning curve
- easy to customize and versatile
- available everywhere on UNIX

Cons:
- tab format (bite everyone)
- shell limit: in term of expression and execution:
	- one shell process instanciated by row
	- no possibility of sharing state except using file.

## [I keep looking for a more modern replacement](https://news.ycombinator.com/item?id=29718446)

Make is really a complicated combination of these components:

- a dependency definition language with in-place evaluation and half-assed wildcards

- A functional language with extremely limited datatypes (effectively just space-separated strings)

- a clunky macro system

- A "distributed" topological execution engine (did you know Make can coordinate job slots across recursive executions of Make? It's impressive! And shouldn't have to exist!) [1](https://www.gnu.org/software/make/manual/html_node/Job-Slots.html)

All the alternative build systems wisely choose to tackle only some of these features.

The most interesting development in this space is the paper "Build Systems A La Carte" [2](https://www.microsoft.com/en-us/research/uploads/prod/2018/03/build-systems.pdf) by Mokhov, Mitchell, & Peyton Jones, who did a great job of breaking down build systems to their fundamental concepts, and along the way found one particular point of the design space that wasn't fulfilled (Table 2, p79:16).


text:
# passport-publickey

[Passport](http://passportjs.org/) strategy for authenticating using a public/private key pair to sign a nonce challenge.

This module lets you authenticate using a public/private key pair in your Node.js
applications.  By plugging into Passport, local authentication can be easily and
unobtrusively integrated into any application or framework that supports
[Connect](http://www.senchalabs.org/connect/)-style middleware, including
[Express](http://expressjs.com/).

## Install

    $ npm install passport-publickey

## Usage

#### Configure Strategy

The public key authentication strategy authenticates users by verifying a signature was made by someone in possession of the private key. The strategy takes in an optional `options` object, and a required `verify` callback.

- The `options` object accepts to fields (below are the defaults):
```
{
  findBy: 'id', // or 'email' or 'nonce' or 'publicKey' or any unique field in your database for your users
  in: 'body' // or 'headers'
}
```
The `in` parameter specifies where in the request is the authentication data, i.e. in `req.body` or in `req.headers`. The `findBy` parameter specifies by which (unique) field we should find the user in the database.

- The `verify` function accepts these credentials and calls done providing a user:
```
passport.use(new PublicKeyStrategy(
  {
    findBy: 'email',
    in: 'body'
  },
  function(findByValue, signature, done) {
    User.findOneBy({ email: findByValue }, function (err, user) {
      if (err) { return done(err); }
      if (!user) { return done(null, false); }

      var verifier = crypto.createVerify("RSA-SHA256");
      verifier.update(user.nonce);

      var publicKeyBuf = new Buffer(user.publicKey, 'base64');

      var result = verifier.verify(publicKeyBuf, signature, "base64");

      if (result) {
        return done(null, user);
      } else {
        return done(null, false);
      }
    });
  }
));
```

#### Authenticate Requests

Use `passport.authenticate()`, specifying the `'publicKey'` strategy, to
authenticate requests.

For example, as route middleware in an [Express](http://expressjs.com/)
application:

    app.post('/login',
      passport.authenticate('publicKey', { failureRedirect: '/login' }),
      function(req, res) {
        res.redirect('/');
      });

## Examples

For an example incorporated inside [FeathersJS](https://feathersjs.com), please see [here](https://github.com/amaurymartiny/feathers-authentication-publickey/tree/master/example)

## Tests

    $ npm test

repository: timfpark/passport-publickey

gha_language: JavaScript

gha_license_id: NOASSERTION

repo_name: timfpark/passport-publickey


text:
# Meteor Guide

This is a setup to generate a static site from the markdown files location in `/source` using [Hexo](https://hexo.io/).

### Notes on Content Authoring

- In order for Hexo to pick up the title of a page, each markdown file should provide a `title` field using [YAML front matter](http://jekyllrb.com/docs/frontmatter/). We can optionally include more meta information for each article, e.g. `authors`, if needed.

- Use **relative links** when linking to other pages in the guide. This is necessary because we are deploying multiple versions/branches of the site into nested folders.

### Theme Development

``` bash
git submodule update --init

npm install -g hexo-cli

npm install
# serve at localhost:4000
hexo server
```

The static site theme is `meteor`, loaded from an npm package, is responsible for the visual representation of the site. For more information, check out the [Hexo docs](https://hexo.io/docs/index.html).

### Continuous Deployment

- `devel` is automatically deployed as the production site via Netlify.

- Any branch that starts with `version-` will be automatically deployed in a sub-folder on every push. A branch with the name `version-1.2` will be deployed under the `v1.2` folder.

- To make a branch available in the site's version selection dropdown, make sure to add it to the `versions` list in `_config.yaml`!

- Pull Requests will generate deploy previews.

- All other branches are ignored.

### Manual Deployment

In the `site` directory:

1. Create `keys.json` (search for "guide_push" in LastPass):

  ``` json
  {
    "key": "xxx",
    "secret": "xxx"
  }
  ```

2. `node deploy`.

repository: meteor/meteor

branch_name: refs/heads/devel

repo_name: meteor/meteor


text:
# Concept: Nanny Share Program Website

This repository is for a simple font-end concept for a neighborhood nanny share program. This concept was designed for a fictional neighborhood.

Please note that this project does not include any server side processing of form submission data. "Successful" submission of the form will generate a `405` error message; please go back to the previous page to continue viewing the demo.

A demo for the site can be viewed here: [http://devashrlucas.github.io/nanny-share-concept](http://devashrlucas.github.io/nanny-share-concept)

A blog post about the development of this project will be posted soon.

## Built With

* HTML: website markup
* CSS: website styling
* JavaScript: event handling and copyright year auto-update

## License

This project is licensed under the MIT License. Refer to the [LICENSE.md](LICENSE.md) file for full details.

repository: devashrlucas/nanny-share-concept

repo_name: devashrlucas/nanny-share-concept


text:
# Mysh3ll's TDD sandbox for NestJs

A very simple boilerplate to have fun with TDD and experiments

### Requirements

- _With Docker_
    - make
    - docker && docker-compose
- _Without Docker_
    - node
    - npm/yarn

:arrow_right: **Note**: you could run the commands with `npm` or `make` with docker-compose. _Make_ raises the container with docker-compose, executes the task and removes the container.

## Installation

```bash
$ npm i
or
$ make install
```

## Running the app

```bash
# development
$ npm run start
or
$ make start

# watch mode
$ npm run start:dev
or
$ make start-dev

# production mode
$ npm run start:prod
or
$ make start-prod
```

## Test

```bash
# unit tests
$ npm run test
or
$ make test

# e2e tests
$ npm run test:e2e
or
$ make test-e2e

# test coverage
$ npm run test:cov
or
$ make test-cov

# test in watch mode
$ npm run test:watch
or
$ make test-watch
```

## Linter

```bash
# execute eslint fix
$ npm run lint
or
$ make lint
```

- Eslint uses mainly the `standard` and `recommended` set of rules, with few personal preferences, feel free to change it in : `.eslintrc.json` to be confortable.

:warning: **Warning**: If you execute the command `make test-watch` make sure to exit with the `q` and not with `Ctrl C`, otherwise the docker container will not be destroyed.

## Stay in touch

- Author - [@Mysh3ll](https://github.com/Mysh3ll/)
- LinkedIn - [@Michel Pompas](https://www.linkedin.com/in/michel-pompas)

## License

Nest is [MIT licensed](LICENSE).


text:
jPiano
======

Keyboard Piano jQuery Plugin

## Requirements
- `Sound Manager 2` http://www.schillmania.com/projects/soundmanager2/

## How to use

```javascript
$("#piano").jPiano({
    preferFlash: false,
    soundsDir: "sounds/",
    debug: true,
    defaultPressCallback: test,
    keySounds: {
      "a": ["C.wav", "#key_01"],
      "w": ["CS.wav", "#key_02"],
      "s": ["D.wav", "#key_03"],
      "e": ["DS.wav", "#key_04"],
      "d": ["E.wav", "#key_05"],
      "f": ["F.wav", "#key_06"],
      "t": ["FS.wav", "#key_07"],
      "g": ["G.wav", "#key_08"],
      "y": ["GS.wav", "#key_09"],
      "h": ["A.wav", "#key_10"],
      "u": ["AS.wav", "#key_11"],
      "j": ["B.wav", "#key_12"],
      "k": ["2C.wav", "#key_13"],
      "o": ["2CS.wav", "#key_14"],
      "l": ["2D.wav", "#key_15"]
    }
});
```

## License

(The MIT License)

Copyright (c) 2013 Ali Sait TEKE<EMAIL_ADDRESS>
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.

THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
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.

repository: aksee/jPiano

repo_name: aksee/jPiano


text:
## Power Manager Plugin Samples / Cookbooks

Example cookbooks to perform use cases with respect to Power Manager - Alerts & Reports

## Use Cases

* Python\get_power_manager_alerts.py
    Script to get the list of Power Manager Specific Alerts in OpenManage Enterprise

* Python\get_power_manager_reports.py
    Script to get the list of Power Manager Specific Device and Group Reports (Pre-Canned
	& Custom) in OpenManage Enterprise

## Authors
Mahendran Panneerselvam

## License

Copyright Dell EMC

## Acknowledgments

repository: prasadrao-dell/OpenManage-Enterprise

path: /Plugins/Power Manager/Alerts & Reports/README.md

gha_language: Python

repo_name: prasadrao-dell/OpenManage-Enterprise


text:
# CozyCar

## Description

### MITRE Description

> [CozyCar](https://attack.mitre.org/software/S0046) is malware that was used by [APT29](https://attack.mitre.org/groups/G0016) from 2010 to 2015. It is a modular malware platform, and its backdoor component can be instructed to download and execute a variety of modules with different functionality. (Citation: F-Secure The Dukes)

## Aliases

```
CozyCar
CozyDuke
CozyBear
Cozer
EuroAPT
```

## Platforms

```
['Windows']
``

# Techniques

* [Web Protocols](../techniques/Web-Protocols.md)

* [Windows Command Shell](../techniques/Windows-Command-Shell.md)

* [Bidirectional Communication](../techniques/Bidirectional-Communication.md)

* [Windows Service](../techniques/Windows-Service.md)

* [Security Software Discovery](../techniques/Security-Software-Discovery.md)

* [Registry Run Keys / Startup Folder](../techniques/Registry-Run-Keys---Startup-Folder.md)

* [Rename System Utilities](../techniques/Rename-System-Utilities.md)

* [Scheduled Task](../techniques/Scheduled-Task.md)

* [System Information Discovery](../techniques/System-Information-Discovery.md)

* [Security Account Manager](../techniques/Security-Account-Manager.md)

* [Rundll32](../techniques/Rundll32.md)

* [Obfuscated Files or Information](../techniques/Obfuscated-Files-or-Information.md)

* [Virtualization/Sandbox Evasion](../techniques/Virtualization-Sandbox-Evasion.md)

* [LSASS Memory](../techniques/LSASS-Memory.md)

# Actors

* [APT29](../actors/APT29.md)


text:
# f5-auto-uploader

[![License](https://img.shields.io/badge/license-BSD%203--Clause-yellow.svg?style=flat)](https://github.com/e-XpertSolutions/f5-auto-uploader/blob/master/LICENSE)
[![Travis](https://travis-ci.org/e-XpertSolutions/f5-auto-uploader.svg?branch=master)](https://travis-ci.org/e-XpertSolutions/f5-auto-uploader)

`f5-auto-uploader` is a small service that watches for changes in a directory
and automatically uploads the files either to create them or to update them.
Uploaded files are also linked to iFiles for the LTM module.

## Contributing

Contributions are greatly appreciated. The project follows the typical
[GitHub pull request model](https://help.github.com/articles/using-pull-requests/)
for contribution.

## License

The sources are release under a BSD 3-Clause License. The full terms of that
license can be found in `LICENSE` file of this repository.


text:
---
date: 2021-03-27 14:10:23
title: Twitch Tech Streamer
template: blogpost.twig
devto: https://dev.to/andi1984/twitch-tech-streamers-23l0
---

I stopped watching TV nearly five years ago in favor of Youtube and Twitch content that I can choose myself.

In this note I want to share a list of tech streamers on Twitch that I regularly watch:

## German

- [Jens Krüger](https://www.twitch.tv/jhkrueger) is a german scientist and a university professor in real life. The streams are feeling like having a 1-to-1 session during your study time.
- [DialogikTV](https://www.twitch.tv/dialogiktv) is a very funny, entertaining streamer doing a lot of Twitch related tech projects.

## English

- I follow [Salma](https://www.twitch.tv/whitep4nth3r) since a few weeks. Her
  streams are really cozy and welcoming.
- [Tim Beaudet](https://www.twitch.tv/timbeaudet) is an Indie gamedeveloper working on his own racing games. And he also does a lot of pair programming with
- [Codico](https://www.twitch.tv/codico) is a younger developer, lately streaming about setting up Vim and working on his speed typing tool [SpeedTyper](https://speedtyper.dev).
- [Stefan Judis](https://www.twitch.tv/stefanjudis) is a german based developer
  that occasionally streams on Twitch. He has a pretty [famous newsletter](https://www.stefanjudis.com/newsletter/) you
  should subscribe to as well!
- [Kitze](https://www.twitch.tv/thekitze) is the founder of
  [sizzy](https://sizzy.co/) and [React Academy](https://www.reactacademy.io/).
  I really like his unique humor. Lately he seems to be less streaming, but if
  you see him live, stop by and have a chat with him.
- [James Werner](https://www.twitch.tv/jmswrnr) is a senior software developer with various streaming topics, also playing video games from time to time.
- If you want to see a VIM power user, watch [The
  Primeagen](https://www.twitch.tv/theprimeagen)! He is so much talented in
  making up a funny, entertaining show while developing heavy complex code. For
  me he is a real master of Twitch dev entertainment.
- [Cassidoo](https://www.twitch.tv/cassidoo) is a keyboard fanatic, female
  streamer, working for Netlify. She does a lot of AMA and Just chatting
  streams, speaking about tech careers, news and of course... keyboards! She
  motivated me to buy a new mechanical keyboard, I'm currently writing this text
  with.
- [ClarkIO](https://www.twitch.tv/clarkio) is a super nice and funny developer.
  He is pretty famous for his alliance with the VSCode editor and his content
  around working with the editor. His streams are famous for [Clark's nice vocals](https://www.kliptok.com/clip/BraveAltruisticVelociraptorKappaRoss-2lZAJf5HB0YrkAW0). :)
- [BaldBeardedBuilder](https://www.twitch.tv/baldbeardedbuilder) aka. Michael
  Jolley is a "real" bald, bearded builder. He is a funny guy, mostly doing
  JS/Node related projects. Sometimes he seems to light aroma candles. :)
- [Jason Lengstorf](https://www.twitch.tv/jlengstorf) is for me THE most
  professional tech streamer out there with an amazing [schedule](https://www.learnwithjason.dev/schedule). He is normally
  always do streams where Jason invites partners that bring in their own topic.
  If you want to learn something new every week, you should learn together with
  Jason in his streams!

## Suggestions?

Do you have any suggestions to this list? Let me know! I'm always interested in
new tech streamers to watch and I really like to see so many technical streams
lately.

## Start streaming!

I [reported lately](../../../posts/personal/streaming/index) that I started
streaming end of 2020 and in case you're asking yourself whether to stream
yourself: _Do it if you want to do it!_

See you on [Twitch](https://www.twitch.tv/andi1984)!

Greets,

Andi

branch_name: refs/heads/develop


text:
# histogram

Calculate histograms of time series data to Visual cyclic activity.

The primary indended use case is to visualize when people are logged into a
server, e.g. shared computer, game server, or IRC channel. If you have a log
file that shows when users enter and leave a shared space, you can use this
histogram utility/library to visualize the average number of users present
throughout a time cycle.

## Install
```
make
[sudo] make install [PREFIX=/usr/local]
```

## Usage
```
histogram [num_buckets] [bucket_size]
```

### Options
* `num_buckets`: number of buckets to divide the time into
* `bucket_size`: the size in time units of each bucket

### Input format
Each line should have two numbers separated by a space:
```c
long time, double value
```
`value` indicates the number of events starting (if positive) or ending (if
negative) at `time`. If `value` is 0, the event is counted as instantaneous
(taking up fully the one bucket that `time` falls into).

## API

```c
struct histogram *histogram_new(int num_buckets, int bucket_size);
```
Allocate a new histogram, with the given number of buckets and sizes of buckets. The range of the histogram will be `num_buckets` * `bucket_size`.

```c
void histogram_free(struct histogram *hist);
```
Free the memory for a histogram and its values.

```c
void histogram_read_value(struct histogram *hist, long time, double value);
```
Insert event occurences into the histogram. Options are as in the [input
format](#options) for the command line program.

```c
void histogram_done(struct histogram *hist);
```
Calculate the results of a histogram.

```c
histogram_read_results(hist, time, value) { ... };
```
Iterate through the results of a histogram, after calculating the results using
`histogram_done`.
- `hist` should be of type `struct histogram *`
- `time` should be of integer type of big enough size to hold the number of
buckets in the histogram.
- `value` should be a double to match the type of the values of the histogram.

## License

MIT

repository: clehner/histogram

repo_name: clehner/histogram


text:
brain-duino V0.1
=======================================

7 Dec 2014

BrainA1-11Nov2014
is brain-duino V0.1 curcuit and PCB

=========================================
“char6BSLED1_analogIN_4chBrain_intwithClock_UNO_Bluetooth_2.ino” is Arduino code for use Arduino AD input. can use for 2 ch mode and 4 ch mode.
512 Hz sampling.
change to 256 Hz sampling need to set Line 209 to comment and use Line 208 : de-comment

============
use brain-duino with Mac IBVA application, can use 512 Hz sampling and 256 Hz sampling.
but use brain-duino with PC BrainBay V1.9.2 application, can use only 256 Hz sampling.
with PC BrainBay V1.7 application can use 512 Hz sampling and 256 Hz sampling.


text:
Raspbian includes a low-compatibility RealVNC server, which I have been unable to connect to, so I did the following:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get autoremove
sudo apt-get remove realvnc-vnc-server
sudo apt-get purge realvnc-vnc-server
sudo apt-get install tightvncserver
sudo apt-get install xrdp

Now I was able to access my Pi server using Windows remote desktop.  VNC should work as well, but I get an actively refused error when I try, suggesting I need to lower security or manually share a public cert.  RDP works for me.

I had a bit of trouble connecting until I used my Pi's IPV4 local address instead of its hostname.

repository: mstasak/PiMicroServer

repo_name: mstasak/PiMicroServer


text:
# Changelog

All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

### [2.0.2](https://github.com/jaredLunde/react-router-typed/compare/v2.0.1...v2.0.2) (2021-02-18)

### Bug Fixes

* 🐛 make switch work w/ parameterized routes ([0fdfaf8](https://github.com/jaredLunde/react-router-typed/commit/0fdfaf8fcc82e33b7ecbbfc79f692648644524cc))

### [2.0.1](https://github.com/jaredLunde/react-router-typed/compare/v2.0.0...v2.0.1) (2021-02-17)

### Bug Fixes

* 🐛 repair path-to-regexp import ([b6f6c61](https://github.com/jaredLunde/react-router-typed/commit/b6f6c61bc1a36384e10e6ab36f4940ea52132f2f))

## 2.0.0 (2021-02-17)

### ⚠ BREAKING CHANGES

* 🧨 Everything breaks here. It's back to v5 :)

### Features

* 🎸 revert to v5 and add better typing ([a052b60](https://github.com/jaredLunde/react-router-typed/commit/a052b60e96d41fa17391102dd91bc176359a95c1))

repository: jaredLunde/react-router-typed

gha_language: TypeScript

repo_name: jaredLunde/react-router-typed


text:
[![Version](https://img.shields.io/badge/version-0.2.0-green.svg?style=for-the-badge)](#) [![mantained](https://img.shields.io/maintenance/yes/2018.svg?style=for-the-badge)](#)

[![maintainer](https://img.shields.io/badge/maintainer-%20%40gerard33-blue.svg?style=for-the-badge)](#)

# custom_component for Dutch E-thermostaat (ICY)
A platform which allows you to interact with the Dutch E-Thermostaat (ICY).

To get started put `/custom_components/climate/e_thermostaat.py` here:

`<config directory>/custom_components/climate/e_thermostaat.py`

**Example configuration.yaml:**

```yaml
climate:
  - platform: e_thermostaat
    username: !secret icy_user
    password: !secret icy_pass
    comfort_temperature: 20
    saving_temperature: 17
    away_temperature: 12
```

**Configuration variables:**

key | description
:--- | :---
**platform (Required)** | The platform name.
**username (Required)** | The username of your E-Thermostaat account.
**password (Required)** | The password of your E-Thermostaat account.
**comfort_temperature (Optional)** | The comfort temperature (Comfortstand), defaults to 20.
**saving_temperature (Optional)** | The saving temperature (Bespaarstand), defaults to 17.
**away_temperature (Optional)** | The away temperature (Lang-weg-stand), defaults to 12.

This platform is using the [E-Thermostaat API](https://www.e-thermostaat.nl/) to get the information from the thermostat.
This component is only usefull for Dutch users as the E-Thermostaat is only sold in The Netherlands.

***
Due to how `custom_componentes` are loaded, it is normal to see a `ModuleNotFoundError` error on first boot after adding this, to resolve it, restart Home-Assistant.

***


text:
# RL Project
UE18CS400SH

1. Sumukh Aithal K
2. Dhruva Kashyap

## States and Actions
States is a tensor of shape: [?, 3, 210, 160].\
Action is a tensor of shape: [?, 9].

## Get Started
```
pip install -r requirements.txt
```
Download the Enduro ROM from this [link](http://www.atarimania.com/rom_collection_archive_atari_2600_roms.html).
```
ale-import-roms <path to the ROM>/
```
## How to run:
### To record your own video
```
python play.py --record --store_path <path to save the video> --trial_name <name of the trial>
```
### To Train:
Download our dataset from this [link](https://drive.google.com/drive/folders/1htqUDA1bmSQpJXIZFqcGUoAd4ubQkHOD?usp=sharing).

```
python main.py --batch_size=64 --store_path="../trials/" --trial_names t1 t2 t3 --train --model Simple --epochs=25 --num_workers=2 --train_run_name="resnet_train"
```

### To see the model play:
Download the weights of our best model from this [link](https://drive.google.com/drive/folders/1a6GFLtML6oousfi_xwAiBGzwYHpWhAAL?usp=sharing).

```
python main.py --model ResNet --model_path models/ --train_run_name test/ --play
```


text:
# com.amplifino.nestor.bundles.rest #

sample code to use rest whiteboard provided by com.amplifino.jersey.whiteboard in osgi.
As an alternative to Hello World we adopt the static [DependencyWheel](http://www.redotheweb.com/DependencyWheel) to the dynamic world of OSGI.
Also provides some graphical bundle wiring views using the GrapViz dot program.
Static resources are published using http whiteboard.

rest api published at /api/bundles
static resources published at /apps/bundles
initial web pages /apps/bundles/wheel.html and /apps/bundles/overview.html

repository: lepirus/nestor

repo_name: lepirus/nestor


text:
# Install

Binlog comes with complete CMake support.
Binlog consist of three main components:

 - A header only part for producing logs
 - A compiled executable to read the logs
 - A compiled library to read the logs programmatically

In addition, as an **optional** dependency, performance tests depend on [Google Benchmark][].

## Build and Use

Building requires `cmake`, version 3.1 or higher. The build files are generated in a separate directory.

    $ git clone <URL> binlog
    $ mkdir binlog/Release
    $ cd binlog/Release
    binlog/Release/$ cmake ..
    binlog/Release/$ make VERBOSE=1
    binlog/Release/$ make install DESTDIR=/path/to/binlog/install

The installed package can be depended on using CMake:

    find_package(binlog 0.1.0 REQUIRED)

    add_executable(YourApp your_app.cpp)
        target_compile_features(YourApp PRIVATE cxx_std_14)
        target_link_libraries(YourApp binlog::headers)

Then configure your application with `CMAKE_PREFIX_PATH`:

    your/project$ CMAKE_PREFIX_PATH=/path/to/binlog/install cmake

## Build the documentation

The documentation is generated from markdown files, with code snippets
automatically included from source files. To build the documentation,
`python` and the `markdown` python package are required.

    Release/$ make Documentation

The most recent documentation is available at [binlog.org][]

[binlog.org]: http://binlog.org/

## Further Build Options

To be used when invoking `cmake`.

 - `-DBINLOG_USE_CLANG_TIDY`: runs clang-tidy on built sources. Requires cmake 3.6 or greater.
 - `-DBINLOG_SOURCE_BROWSER_URL`: if specified, links to code in documentation will use this prefix
 - `-DBINLOG_USE_ASAN`: use [address sanitizer][] (with gcc or clang) - also enables the Leak Sanitizer
 - `-DBINLOG_USE_TSAN`: use [thread sanitizer][] (with gcc or clang)
 - `-DBINLOG_USE_UBSAN`: use [undefined behavior sanitizer][] (with gcc or clang)
 - `-DBINLOG_GEN_COVERAGE`: generate coverage data

[address sanitizer]: https://github.com/google/sanitizers/wiki/AddressSanitizer
[thread sanitizer]: https://github.com/google/sanitizers/wiki/ThreadSanitizerCppManual
[undefined behavior sanitizer]: https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html

## Different Build Flavours

Useful mostly for Binlog developers or debugging.

### Debug Build

    $ mkdir Debug
    $ cd Debug
    Debug/$ cmake .. -DCMAKE_BUILD_TYPE=Debug
    Debug/$ make VERBOSE=1

### Address Sanitized Build

    $ mkdir AddressSanitized
    $ cd AddressSanitized
    Sanitized/$ cmake .. -DBINLOG_USE_ASAN=On
    Sanitized/$ make VERBOSE=1

### Thread Sanitized Build

    $ mkdir ThreadSanitized
    $ cd ThreadSanitized
    Sanitized/$ cmake .. -DBINLOG_USE_TSAN=On
    Sanitized/$ make VERBOSE=1

### Debug Build with Code Coverage

When building with `GCC`, requires: `gcov`, `lcov`, `genhtml`.
When building with `clang`, requires: `llvm-profdata`, `llvm-tools`.

    $ mkdir Coverage
    $ cd Coverage
    Coverage/$ cmake .. -DCMAKE_BUILD_TYPE=Debug -DBINLOG_GEN_COVERAGE=On
    Coverage/$ make
    Coverage/$ make coverage_init
    Coverage/$ make test
    Coverage/$ make coverage

### Clean

    $ rm -rf Release/ Debug/ AddressSanitized/ ThreadSanitized/ Coverage/

## Test

Make sure that the targets are up-to-date, `ctest` doesn't check that by default.

    Release/$ ctest -VV

## Performance Test

Performance tests require the [Google Benchmark][] library.
If installed to a non-standard location, `cmake` can still use it:

    $ ls /path/to/benchmark/install
    benchmarkConfig.cmake  benchmarkConfigVersion.cmake  benchmarkTargets-relwithdebinfo.cmake  benchmarkTargets.cmake
    Release/$ CMAKE_PREFIX_PATH=/path/to/benchmark/install cmake ..

[Google Benchmark]: https://github.com/google/benchmark

repository: morganstanley/binlog

repo_name: morganstanley/binlog


text:
Run the tests
==============

In order to run the tests, please make sure you have the `Docker Engine <https://docs.docker.com/engine/install/>`_
and `Docker Compose <https://docs.docker.com/compose/install/>`_ installed.

Move into tests/ directory

`cd tests/`

Run service dependencies:

`docker-compose up -d`

Install library dependencies:

`make install`

Run tests:

`make test`


text:
# DelphiRabbitMQ

RabbitMQ driver for Delphi

This is a Delphi package supporting access to RabbitMQ, only convert headers from rabbitmq-c.

rabbitmq_c https://github.com/alanxz/rabbitmq-c

Delphi的RabbitMQ驱动，使用AMQP协议，翻译自C语言驱动rabbitmq_c

rabbitmq_c地址：https://github.com/alanxz/rabbitmq-c

repository: Godwottery/Delphi-RabbitMQ

repo_name: Godwottery/Delphi-RabbitMQ


text:
On success, a pointer to
a valid **struct ncdirect** is returned. **NULL** is returned on failure.
Before the process exits, **ncdirect_stop(3)** should be called to reset the
terminal and free up resources.

An appropriate **terminfo(5)** entry must exist for the terminal. This entry is
usually selected using the value of the **TERM** environment variable (see
**getenv(3)**), but a non-**NULL** value for **termtype** will override this. An
invalid terminfo specification can lead to reduced performance, reduced
display capabilities, and/or display errors. notcurses natively targets
24bpp/8bpc RGB color, and it is thus desirable to use a terminal with the
**rgb** capability (e.g. xterm's **xterm-direct**).

**ncdirect_dim_x** returns the current number of columns, and **ncdirect_dim_y**
the current number of rows.

**ncdirect_clear** clears the screen using a control code if one exists in
terminfo. Otherwise, it prints successive newlines to scroll everything off.

**ncdirect_cursor_move_yx** moves the cursor to the specified coordinate. -1 can
be specified for either **y** or **x** to leave that axis unchanged.

**ncdirect_enable_cursor** and **ncdirect_disable_cursor** always flush the
output stream, taking effect immediately.

**ncdirect_cursor_up** and friends all move relative to the current position.
Attempting to e.g. move up while on the top row will return 0, but have no
effect.

# RETURN VALUES

**ncdirect_init** returns **NULL** on failure. Otherwise, the return value
points to a valid **struct ncdirect**, which can be used until it is provided
to **ncdirect_stop**.

All other functions return 0 on success, and non-zero on error.

# SEE ALSO

**getenv(3)**,
**termios(3)**,
**notcurses(3)**,
**notcurses_plane(3)**,
**terminfo(5)**

repository: sikfeng/notcurses

repo_name: sikfeng/notcurses


text:
# `detect-es-version`

Given a package name, filepath, or string of code, returns the [ecma version](https://developer.mozilla.org/en-US/docs/Glossary/ECMAScript). You can try out the web app version [here](https://detect-es-version.glitch.me/)!

## Usage
```javascript
const { getEcmaVersion } = require('detect-es-version');
const ecmaVersion = getEcmaVersion('const foo = 123;');
console.log(ecmaVersion); // prints 2015
```

## API
### getPackageEcmaVersion(packageString, resolverOptions)
- `packageString` (`String`): A string representing a package. e.g. “react”<EMAIL_ADDRESS>to be pulled from npm.
- `resolverOptions` (`Object`): An options object to pass to [enhanced-resolve](https://github.com/webpack/enhanced-resolve#resolver-options). This can be used to control which entry points are analyzed.
- Returns (`Number`): The ecma version of the package. e.g. 2017.

### getLocalPackageEcmaVersion(packagePath, resolverOptions)
- `packagePath` (`String`): An absolute path to a package’s directory. The directory must contain an index file or package.json.
- `resolverOptions` (`Object`): An options object to pass to [enhanced-resolve](https://github.com/webpack/enhanced-resolve#resolver-options). This can be used to control which entry points are analyzed.
- Returns (`Number`): The ecma version of the package. e.g. 2017.
### getEntryPointEcmaVersion(entryPoint, resolverOptions)
- `entryPoint` (`String`): An absolute path to an entry point.
- `resolverOptions` (`Object`): An options object to pass to [enhanced-resolve](https://github.com/webpack/enhanced-resolve#resolver-options). This can be used to control which entry points are analyzed.
- Returns (`Number`): The ecma version of the package. e.g. 2017.
### getEcmaVersion(content)
- `code` (`String`|`Object`): The source code or AST to inspect
- Returns (`Number`): The ecma version of the source code or AST. e.g. 2017.
### isEcmaVersionModern(ecmaVersion)
- `ecmaVersion` (`Number`): A number representing an ECMA version. e.g.  5, 2015, or 2016
- Returns (`Boolean`): True if the ECMA version is considered modern; False otherwise

repository: GoogleChromeLabs/detect-es-version

repo_name: GoogleChromeLabs/detect-es-version


text:
# ITSLanguage JavaScript SDK

## Documentation

[Read the GitHub Pages website](https://itslanguage.github.io/itslanguage-js/)

## Installing

To add the ITSLanguage SDK to your project:

```js
npm install itslanguage --save
```

## Usage

Simply import `itslanguage` in your project. For example:

```js
import { AdministrativeSDK } from 'itslanguage';
```

The ITSLanguage SDK will be included in your build. For example using [webpack](https://webpack.js.org)

For more usage examples, see the
[ITSLanguage JavaScript SDK Examples](https://github.com/itslanguage/itslanguage-js-examples).

repository: Lehren/itslanguage-js

repo_name: Lehren/itslanguage-js


text:
### exceptiom
Make python exceptions fun.

### Installation

Install exceptiom using pip.

`pip install exceptiom`

We are on [PyPi](https://pypi.org/project/exceptiom/)

Visit us on [Github](https://github.com/aqua-regia/exceptioms)

### Usage

Import Exceptiom

`from exceptiom import Exceptiom`

and then raise exceptiom like

```
try:
    5 / 0
except Exception:
    raise Exceptiom('Failed while performing division')
```

You can also make it as the base class for all your derived exception.

Instead of doing `class MyException(Exception)` you can write `class MyException(Exceptiom)`

### Contributon

To add jokes, just add joke in exceptiom/jokes_en and raise a PR.

For any other features raise a PR

### For Developers

* Version bump
    ```bumpversion --current-version 1.2.0 minor setup.py```

* Publishing to PyPi

    1.`python setup.py sdist`

    2.`twine upload dist/* --verbose`

repository: aqua-regia/exceptioms

repo_name: aqua-regia/exceptioms


text:
---
title: Nivenly.com
body_classes: 'title-center title-h1h2'
hero:
    title: {  }
process:
    markdown: true
    twig: true
media_order: 'portrait.jpeg,portrait-full.jpeg'
---

## Biography

Kris Nóva is an author, engineer, public speaker and transgender activist best known for her work on Aurae, Linux, and Kubernetes.

She specializes in Linux kernel security, distributed systems, infrastructure management, and open source software engineering. In 2022 she authored [Hacking Capitalism](https://hackingcapitalism.io) an independently published book about modeling the tech industry as a system. In 2017 she co-authored [Cloud Native Infrastructure published by O’Reilly Media](https://cnibook.info) with [Justin Garrison](https://www.justingarrison.com/).

Nóva is well known for her open source work. She has created many successful open source projects and has contributed to projects like Linux, Kubernetes, Rust, Go, etc. A popular public speaker, she is best known for her Kubernetes clusterfuck talks.

Today she works as a principal engineer at GitHub focusing on infrastructure platform engineering.

[lightbox image="portrait-full.jpeg" zoomable="false" draggable="false"]
![Author Photograph](portrait-full.jpeg?cropZoom=400,600)
[/lightbox]

gha_language: HTML


text:
# Assignment

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**state** | **str** | State of the assignment | [optional]
**title** | **str** | Title of the assignment | [optional]
**classroom** | **str** | The unique identifier of the class where this assignment was posted | [optional]
**description** | **str** | Description and content of the assignment | [optional]
**attachments** | [**list[MediaAttachment]**](MediaAttachment.md) |  | [optional]
**submissions** | [**list[AssignmentSubmission]**](AssignmentSubmission.md) |  | [optional]
**creator** | **str** | The User unique identifier of the creator of this assignment  | [optional]
**creation_date** | **datetime** | The creation date of this assignment | [optional]
**scheduled_date** | **datetime** | The publication (scheduled) date of the assignment. If this one is specified, the assignment will only be listed to the teachers of the class.  | [optional]
**due_date** | **datetime** | The due date of this assignment, late submissions will be marked as paste due.  | [optional]
**google_classroom** | [**GoogleClassroomCoursework**](GoogleClassroomCoursework.md) |  | [optional]

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

repository: iamdeepakram/api-client-python

repo_name: iamdeepakram/api-client-python


text:
Screenshot

Automagically converts URLs into images and PDFs.

  statically.io |
  Twitter |
  Community |
  Become A Backer

## :sparkles: Overview

**Screenshot** is a simple application to automagically convert URLs into images and PDFs. It's designed to be simple and easy to install anywhere. This application is split into two distinct components, the core service to process the URL and then send it to a remote browser (Chrome). The remote browser to screenshot and generate PDF from a URL.

## :bulb: Features

- Screenshot website in desktop view.
- Screenshot website in mobile view.
- Converts URL into PDF.

## :zap: Installation

We'll be using Docker as an easy way to install. However since this is a Node.js application, you can run it with your current setup, if you choose this method, please see [config/index.js](config/index.js) to change the remote browser endpoint.

### Run the browser

We'll be using the **browserless/chrome** Docker image to do most of this work.

```bash
docker run -d \
  --name chrome \
  -e "ENABLE_DEBUGGER=false" \
  -e "DISABLE_AUTO_SET_DOWNLOAD_BEHAVIOR=true" \
  -e "DEFAULT_BLOCK_ADS=true" \
  -p 3000:3000 \
  browserless/chrome:latest
```

To see more options, you can check [full documentation](https://docs.browserless.io/docs/docker.html).

### Run the app

```bash
docker run -d \
  --name screenshot \
  -e "REMOTE_BROWSER=ws://<IP_ADDRESS>:3000" \
  -p 5000:5000 \
  statically/screenshot:latest
```

Replace the `REMOTE_BROWSER` variable with the remote browser endpoint that you set above. In this example we are using Docker's internal IP address, it should work if you are running both components on one machine.

## :fire: Fire it up

The application avalaible through `/screenshot/` path.

- Visit http://localhost:5000/screenshot/github.com for desktop view.

![Screenshot Desktop](https://cdn.statically.io/gh/staticallyio/screenshot/master/public/screenshot-desktop.png)

- Visit http://localhost:5000/screenshot/mobile/github.com for mobile view.

![Screenshot Mobile](https://cdn.statically.io/gh/staticallyio/screenshot/master/public/screenshot-mobile.png)

- Visit http://localhost:5000/screenshot/pdf/news.ycombinator.com for PDF.

![Screenshot PDF](https://cdn.statically.io/gh/staticallyio/screenshot/master/public/screenshot-pdf.png)

repository: not-gaje-lashh/screenshot

repo_name: not-gaje-lashh/screenshot


text:
---
layout: post
title: GAP.jl 0.7.2 released
author: TagBot
---

Today [GAP.jl 0.7.2](https://github.com/oscar-system/GAP.jl/releases/tag/v0.7.2) has
been released.

[Diff since v0.7.1](https://github.com/oscar-system/GAP.jl/compare/v0.7.1...v0.7.2)

**Closed issues:**
- Better gap.sh support (#611)
- Make a JLL for JuliaInterface?! (#619)
- Tweak `ImportJuliaModuleIntoGAP`: take Julia module object as argument (#687)
- Teach Julia how to get bound names in GAP records so that Tab completion works (#752)
- `GAP_jll.MPtr` is still visible (#756)

**Merged pull requests:**
- Optimize use of locks in calling out to GAP. (#483) (@rbehrends)
- Use GAP_pkg_juliainterface_jll (#742) (@fingolfin)
- Turn some gap_to_julia methods into constructors (#745) (@fingolfin)
- OscarCI: add OscarDevTools based workflow to run Oscar tests (#746) (@benlorenz)
- Fix GAP_CXX handling (#748) (@fingolfin)
- JuliaInterface: don't use GAP_SYNC macros before InitGapSync (#749) (@fingolfin)
- When selecting compilers, try cc/c++ first (#751) (@fingolfin)
- Move GAP.Globals code to separate source file (#753) (@fingolfin)
- Better tab complection (#754) (@fingolfin)
- Detect if there is an exception while exiting (#755) (@fingolfin)
- Hack the typename of GAP.GapObj (#757) (@fingolfin)
- Add note on how to update GAP_pkg_juliainterface_jll (#759) (@fingolfin)

repository: oscar-system/oscar-website

branch_name: refs/heads/gh-pages

gha_language: Jupyter Notebook

repo_name: oscar-system/oscar-website


text:
# GameShopAdvance

GameShopAdvance is a POS (Point-of-sale) software system, designed specifically for a videogame store.

GameShopAdvance was specifically designed and developed as project work for Software Engineering course at University of L'Aquila by three students:

- Andrea Salini[@mrsalx]
- Lorenzo Di Giuseppe[@Loki88]
- Matteo Gentile[@darkwiz]

>The system is focused on the sale of video
>games, consoles, manuals, accessories, gadgets
>and their exchange, foreseeing exchange
>and/or recycling policies. The system relies on
>a distributed architecture, in this way, many
>different users can use part of application
>according to their needs.

### Version
1.0

The version you can get from here is fully working, but some requirements needs to be met!

### Technology constraints

GameShopAdvance needs some open source software to work properly:

* [Java Runtime Environment] - Java SE Runtime Environment 7
* [db4o] - database for objects, Java Version
* [joda] - Joda-Time is the *de facto* standard date and time library for Java. (2.3 release and greater)

### How to run

On a Debian/Ubuntu based machine:

- Open your favorite Terminal and run these commands.
- Open your /etc/hosts as superuser with your favorite editor
- Comment out the following line
- `<IP_ADDRESS>  <your-username>` to `#<IP_ADDRESS> <your-username>`
- Add ` <your-ip-address> <your-username> ` just below the commented out line

To run the Application server:

```
$ git clone [git-repo-url]
$ cd GameshopAdvance/build/Server
$ sh ./GSA_server.sh
```

To run the Customer client (assuming that the clone step has already been executed):

```
$ cd GameshopAdvance/build/Client\ Customer
$ sh ./GSA_client_customer.sh
```

On a Windows based machine:

- Open a Command window

To run the Application server:
```
C:\your-home-directory> cd C:\path-to-cloned-GameShopAdvance-directory\build\Server
C:\path-to-cloned-GameShopAdvance-directory\build\Server> GSA_server.bat
```
To run the Employee client
```
C:\your-home-directory> cd C:\path-to-cloned-GameShopAdvance-directory\Client Employee
C:\path-to-cloned-GameShopAdvance-directory\build\Client Employee> GSA_client.bat
```

How to test:

If you want to test the customer client, you have to insert products code and quantity to conclude a sale. Quantity is just a number, codes at this point of development are just strings but they generally follow some standard. These are the available products and them codes:

| Product Code  | Product Name | Price |
|---------------|--------------|-------|
| ab1           | Half Life 2  | 29.98 |
| ab2           | Enemy Territory: Quake Wars  | 19.99 |
| ab3           | Diablo 2  | 40.98 |
| ab4           | Super Mario Galaxy  | 40.98 |
| ab5           | GTA IV  | 70.98 |
| ab6           | Guitar Hero III  | 53.73 |
| ab7           | Minecraft  | 20.00 |
| ab8           | Il segreto di Monkey Island  | 43.50 |
| ab9           | NBA Live 2014  | 41.98 |
| ab10          | Pes 2014  | 30.98 |
| ab11          | Skyrim  | 40.98 |
| ab12          | South Park: il bastone della verità  | 50.98 |
| ab13          | Super Mario Bros U  | 35.98 |
| ab14          | Watch Dogs  | 60.98 |
| ab15          | Angry Birds: Star Wars  | 39.98 |
| ab16          | Call of Duty 4: Modern Warfare  | 30.98 |
| ab17          | Diablo 3  | 40.98 |
| ab18          | Doom 2  | 9.99 |
| ab19          | Metal Gear Solid 5  | 53.73 |
| cd1           | Xbox One  | 499.99 |
| cd2           | Joystick PS4  | 40.98 |
| cd3           | Cuffie Wi-Fi  | 80.98 |

NB. Prices are not realistic.

Warning:

When a Client is started for the first time must be configured it from the configuration menu in the window. You should insert the IP address of the machine where the application server is running.

GSA stores products in a data-base. Since some products prices or discounts expire in time, if you experiment problems with the application it's suggested to delete the db, that will be created again at runtime. To delete the data-base simply open the server folder and remove "GSA.db".

License
----

MIT License (MIT)

Copyright (c) 2015 Andrea Salini, Lorenzo Di Giuseppe, Matteo Gentile

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.

[@darkwiz]:https://github.com/mrsalx
[@mrsalx]:https://github.com/mrsalx
[@Loki88]:https://github.com/Loki88
[Java Runtime Environment]:http://www.oracle.com/technetwork/java/javase/downloads/jre7-downloads-1880261.html
[db4o]:http://supportservices.actian.com/versant/default.html
[joda]:https://github.com/Joda
[git-repo-url]:https://github.com/GameShopAdvance/GameShop-Advance.git

repository: GameShopAdvance/GameShop-Advance

repo_name: GameShopAdvance/GameShop-Advance


text:
# Arduino "Self-Driving" Car
![Project Logo](/Images/Final_bb.png)
A Self driving with ultrasonic sensor

# Parts List

- RC toy car
- Arduino Uno
- Ultra sonic sensor (HC-SR04)
- Dual H Bridge (L298N)
- 9g servo for steering (SG90S)
- 9v battery to power the arduino and the servo
- 1.2v 5 AA battery to power thew motor

# Requirements
The code uses MsTimer2 library, this is due the fact that timer one and timer 3 were taking for serial and servo handling. you can download the code for MsTimer2 from here
http://playground.arduino.cc/Main/MsTimer2

# Demonstration Video
  - https://youtu.be/ygR1z7xQZBs

repository: zdeveloper/Hardware-Challenge

repo_name: zdeveloper/Hardware-Challenge


text:
# Group 14 IN4400
This repository contains the Python code for the Bitcoin analysis of the course Program and Datascience for the 99%. In the directory "src" the Python scripts can be found.

### blockchain.py
This is the script that collects real-time data (run this first for a few minutes)

### blockchainDataAnalyzer.py
This is the script that analyzes the collected data (make sure that blockchain.py has run long enough for some data to be analyzed)

Note that both the script are written in python 2. To run it just use the python2 blockchain.py or python2 blockchainDataAnalyzer.py command in a terminal from the src directory.


text:
# Changelog

## NEXT RELEASE

* **BREAKING** It is no longer possible to not define any package configuration
* **BREAKING** The `cache_dir` config no longer exists. Caching has been rewritten to allow
  bridging the native Symfony cache in addition to all the cache stores `tus-php` provides.

  If you want to keep the old behaviour, you need to change your config from

  ```yaml
  tus:
    cache_dir: 'your_value'
  ```

  to

  ```yaml
  tus:
    cache_type:
      file:
        dir: 'your_value'
  ```

  However, starting with this release, it is recommended to use the native cache instead:

  ```yaml
  tus:
    cache_type:
      native:
        enabled: true
  ```

## v0.5.1

* Minor autowiring fixes

## v0.5

First release.

repository: eFrane/TusBundle

gha_language: PHP

repo_name: eFrane/TusBundle


text:
[github]: https://github.com/neopoly/tagfiles
[doc]: http://rubydoc.info/github/neopoly/tagfiles/master/file/README.md
[gem]: https://rubygems.org/gems/tagfiles
[gem-badge]: https://img.shields.io/gem/v/tagfiles.svg
[travis]: https://travis-ci.org/neopoly/tagfiles
[travis-badge]: https://secure.travis-ci.org/neopoly/tagfiles.svg?branch=master
[codeclimate]: https://codeclimate.com/github/neopoly/tagfiles
[codeclimate-climate-badge]: https://codeclimate.com/github/neopoly/tagfiles.svg
[codeclimate-coverage-badge]: https://codeclimate.com/github/neopoly/tagfiles/badges/coverage.svg
[inchpages]: https://inch-ci.org/github/neopoly/tagfiles
[inchpages-badge]: https://inch-ci.org/github/neopoly/tagfiles.svg?branch=master&style=flat

# Tagfiles

[![Travis][travis-badge]][travis]
[![Gem Version][gem-badge]][gem]
[![Code Climate][codeclimate-climate-badge]][codeclimate]
[![Test Coverage][codeclimate-coverage-badge]][codeclimate]
[![Inline docs][inchpages-badge]][inchpages]

[Gem][gem] |
[Source][github] |
[Documentation][doc]

Tagfiles provides the `tagfile` helper for Rails.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'tagfiles'
```

And then execute:

    $ bundle

## Basic Usage

Tagfile: `app/views/tagfiles/_box.html.haml`

```haml
.box
  %h2= title
  %p= yield
```

HAML file using `box` tagfile: `app/views/admin/page/index.html.haml`

```haml
= tf :box, title: "Box title"
  Some box content
```

See [examples/](https://github.com/neopoly/tagfiles/tree/master/examples) and [specs](https://github.com/neopoly/tagfiles/blob/master/spec/integration/rails_spec.rb) for more examples.

## Lookup order

Rendering the `box` tagfile from the example above will trigger with following lookups:

* `app/views/admin/page/tagfiles/_box.html.erb`
* `app/views/admin/tagfiles/_box.html.erb`
* `app/views/tagfiles/_box.html.erb`

## Rails support

Following Rails versions are supported:

* 6.0
* 5.2
* 4.2

Feel free to test earlier Rails versions. Feedback is welcome!

## Ruby support

Ruby versions from 2.4.9 to 2.7.0 are supported.

## Contributing

1. [Fork it](https://github.com/neopoly/tagfiles/fork)
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request

repository: neopoly/tagfiles

gha_language: Ruby

repo_name: neopoly/tagfiles


text:
R Course for VTT Technical Research Center of Finland
=====

Dear data-savvy colleagues, you have landed on the homepage of R programming language course, given by me (Ouz).
Everything you will need for this course will appear (somewhat on-the-go) under this repository.
This course is aimed for anyone who has anything to do with any kind of *data*. It is composed of online, real-time lectures & some exercises for post-lecture fun (exercises are optional, fun is definitely optional). Lectures will be hands-on and practical (still accompanied by short lecture notes).

I will try to adjust the implementation (content, pace, requirements etc.) according to your needs and will try to add some homour and games whenever possible.
Please feel free to contact me anytime for questions, comments and/or feedback.

Contents of the Course
--------
* Basics of R & RStudio :heavy_check_mark:
  * What exactly is R?
  * What about this RStudio thingy?
  * When to use / avoid R?
  * Basic data types, functions
  * Reading & writing data
  * Debugging
* Data frames :heavy_check_mark:
  * Data frame paradigm and why it is cool
* Data munging & wrangling :heavy_check_mark:
  * *melt*, *reshape*, *cast*, *aggregate* etc.
  * *plyr* & *dplyr* packages
  * *applys*
* Reading and writing data :heavy_check_mark:
* Visualization & plotting :heavy_check_mark:
  * base
  * *lattice*
  * *ggplot2*
* Statistics for researchers :heavy_check_mark:
  * Answering the question: *Conference deadline is in 1 week, so which one of this is the p-value?*
  * Useful statistical tests
* Markdown & reporting :heavy_check_mark:
  * Reproducible research
  * *knitr*
  * Interactive plots
* What to do with missing data? :heavy_check_mark:
* Signal processing :heavy_check_mark:
  * Filter design
  * Frequency domain analysis
* Machine learning :heavy_check_mark:
  * Some cool stuff
  * More cool stuff
* Profiling your code :heavy_check_mark:
  * Answering the question: *I already had lunch and 2 coffee breaks, when will I get my results?*
  * Tips for speeding up the code
* Interacting with other languages and environments (tentative)
  * python, SQL, MATLAB, LATEX, mongodb etc.
* Applications (some of the below, suggestions are welcome) :heavy_check_mark:
  * Text mining
  * Mining PubMed
  * Mining Wikipedia hits
  * Time series forecasting
  * Network analysis
  * Survival analysis
  * Anomaly/outlier detection
* Parallel processing :heavy_check_mark:
  * Running your code on multiple cores
* Shiny app (tentative)

Schedule
--------
All lectures are at 14:00 - 16:00 (EEST). A link for attending the lectures will be provided to each one of you via email.

| Lecture   |       Date           |                    |
| ---       |   ---                |      ---           |
| Lecture 1 | Wednesday 27.04.2016 | :heavy_check_mark: |
| Lecture 2 | Tuesday 03.05.2016   | :heavy_check_mark: |
| Lecture 3 | Wednesday 04.05.2016 | :heavy_check_mark: |
| Lecture 4 | Wednesday 11.05.2016 | :heavy_check_mark: |

Getting Ready
--------

For this course, we will be needing **R** (the actual programming language) and **RStudio** (the IDE for R as we don't want to kill ourselves while getting things done in R).

* Go to [R homepage](https://www.r-project.org/) and click the *download R* link.
* Choose a mirror (doesn't really matter) and afterwards your operating system.
  * If you are on Windows, click on "Install R for the first time" and "Download R 3.2.x for Windows" (x is 5 as of 25.04.2016).
  * If you are on Mac, click on the file containing the latest version of R under *Files* (R-3.2.4.pkg as of 25.04.2016).
* Follow the regular installation steps (if asked choose 64 bit R).

---
* Go to [RStudio download page](https://www.rstudio.com/products/rstudio/download/)
* Under *Installers for Supported Platforms* choose your own OS. (RStudio 0.99.896 as of 25.04.2016)
* Follow the regular installation steps

---
Required packages/libraries for the course are listed in [required_packages.txt](https://github.com/ogencoglu/R_for_VTT/blob/master/required_packages.txt)

Lectures
--------
* [Lecture 1](https://github.com/ogencoglu/R_for_VTT/tree/master/Lectures/Lecture_1)
* [Lecture 2](https://github.com/ogencoglu/R_for_VTT/tree/master/Lectures/Lecture_2)
* [Lecture 3](https://github.com/ogencoglu/R_for_VTT/tree/master/Lectures/Lecture_3)
* [Lecture 4](https://github.com/ogencoglu/R_for_VTT/tree/master/Lectures/Lecture_4)

Exercises
-------
There will be exercises related to the lectures almost as if you are not spending enough time in front of your computer day and night.
These exercises are not mandatory at all.
I will try to to gamify these as much as possible and hopefully provide some options to choose from as well.
All exercises have the same deadline: 31.05.2016

* [Exercise 1](https://github.com/ogencoglu/R_for_VTT/tree/master/Exercises/Exercise_1)
* [Exercise 2](https://github.com/ogencoglu/R_for_VTT/tree/master/Exercises/Exercise_2)
* [Exercise 3](https://github.com/ogencoglu/R_for_VTT/tree/master/Exercises/Exercise_3)
* [Exercise 4](https://github.com/ogencoglu/R_for_VTT/tree/master/Exercises/Exercise_4)

To-do
-------
This part is basically for myself.
- [x] Create a course page
- [x] Add instructions for installation R & RStudio
- [x] Publish the course content
- [x] Add logos
- [x] Check the code in Linux, Mac and Windows machines just in case
- [x] Lecture 1 notes & exercises
- [x] Brush up your statistics knowledge and double check the results in python
- [x] Lecture 2 notes & exercises
- [x] Collect opinions for application examples
- [x] Ease down the machine learning stuff
- [x] Lecture 3 notes & exercises
- [x] Prepare the actual lecture 4
- [x] Lecture 4 notes & exercises
- [ ] Collect feedback
- [ ] Have a cold beer

License
-------
[MIT](https://github.com/ogencoglu/R_for_VTT/blob/master/license.txt) license.

Contact
---------------
Oguzhan (Ouz) Gencoglu<EMAIL_ADDRESS>


text:
# noise-rs

[![Build Status](https://travis-ci.org/brendanzab/noise-rs.svg?branch=master)](https://travis-ci.org/brendanzab/noise-rs)

A procedural noise generation library for Rust.

[Documentation](https://docs.rs/noise/)

```rust
use noise::modules::Fbm;

let fbm = Fbm::new();

let val = fbm.get([42.0, 37.0, 2.0]);
```

## API

### Gradient Noise

Gradient noise produces a smooth, continuous value over space. It's achieved by
dividing space into regions, and placing a random gradient at each vertex, then
blending between those gradients.

#### Perlin noise

A very fast and reasonable quality gradient noise:

- `Perlin::new()`

#### OpenSimplex noise (To be deprecated)

A slower but higher quality form of gradient noise:

- `open_simplex2`
- `open_simplex3`
- `open_simplex4`

### Value Noise (To be deprecated)

Value noise (sometimes mistaken with gradient noise) produces lower quality
smooth noise. It exhibits pronounced grid artifacts, but can be slightly faster
than gradient noise. Benchmarks show it's about 1.2–1.3× faster than Perlin noise.

Cell neighbours are blended using a weighted S-curve linear interpolation
method. This removes any discontinuities across grid edges.

- `value2`
- `value3`
- `value4`

### Fractional Brownian Motion

A way of combining multiple octaves of a noise function to create a richer and
more varied output:

- `Fbm::new()`

### Worley Noise

Named after Steven Worley, and also called voronoi noise, is based on dividing
space into cells based on proximity to a random set of seed points.

- `Worley::new()`

#### Noise Modules

These are the actual noise modules, which just take a coordinate using `get()` and return
a value. They can be chained together when declared, creating very complex noise results.

See the individual module pages for their descriptions, and the examples for their usage.

repository: jeffparsons/noise-rs

repo_name: jeffparsons/noise-rs


text:
# Workload

Distribute simple tasks to multiple threads with ease.

This is an dead simple implementation of multithreaded [producer-consumer](http://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem) pattern we at [Monterail](http://monterail.com/) are using quite often during imports/exports and all sort of data migration between systems. I'm just tired of writing all that again and again so that's why I put that into a 80LOC gem.

![Schema](https://dl.dropboxusercontent.com/s/8dfzs3k2qajcico/2013-10-25%20at%2012.12%20AM.png)

Each `producer` and `consumer` instance gets it's own thread.

## Installation

```bash
$ gem install workload
```

## Usage

Let's say we have some big file that we need to read and then do something
with every line of that file and that processing can be done in parallel.

```ruby
# job.rb
require "rubygems"
require "workload"

Workload.run do |w|
  w.produce(1) do |queue|       # 1 is the default number of producer threads
    while line = STDIN.gets
      queue << line             # The pipe is simple ruby Queue
    end
  end

  w.consume(5) do |line|        # Here we are spawning 5 consumer threads
    print "[#{Thread.current[:id]}] consuming line: #{line}"
    # do something useful with that input
  end
end
```

and then just run

```
$ cat huge-file.txt | ruby job.rb
```

## FAQ

- What about distributing using sidekiq (or any other queue)?
  - It's too much for such simple task and usually requires some storage (e.g. redis)

- So why not celluloid?
  - It's also too big and complicated

- What about thread safety?
  - There is none. I mean, ruby's [Queue](http://ruby-doc.org/stdlib-2.0.0/libdoc/thread/rdoc/Queue.html) is thread safe and all that but if you use some global state inside `produce` or `consume` blocks than you gonna have a bad time.

- Error handling?
  - If something bad happen inside `consume` block it will be recorded and all errors will be displayed at the end of execution

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: monterail/workload

repo_name: monterail/workload


text:
# December 2020

## Accessibility: Post of the Year, 2020

+ Benjy Stanton (2020), **A plan for accessible maps** → https://www.benjystanton.co.uk/blog/a-plan-for-accessible-maps/
  - Nearly complete guide to planning, building, testing, and fixing applications focusing on *accessibility first*.

## Accessibility: Color Palettes

+ Steve Schoger & Adam Wathan (2020), **Building Your Color Palette** → https://refactoringui.com/previews/building-your-color-palette/
  - Adapted from their book and video series, [Refactoring UI](https://refactoringui.com/book/).

## Accessibility: Data Visualization

+ Sarah L. Fossheim (2020), **How (not) to make accessible data visualizations, illustrated by the US presidential election.** → https://fossheim.io/writing/posts/accessible-dataviz-us-elections/

## Accessibility: Input

+ Adam Silver (2020), **Form design: multiple inputs versus one input** → https://adamsilver.io/articles/form-design-multiple-inputs-versus-one-input/

## Accessibility: Landmarks

+ Graham Armfield (2020), **How to use HTML5 sectioning elements to create useful accessible landmarks** → https://www.hassellinclusion.com/blog/html5-sectioning-elements-accessible-landmarks/

## Accesibility: Links

+ Stefan Judis (2020), **How to let all your users know what to expect when they click a link** → https://www.stefanjudis.com/snippets/how-to-let-all-your-users-know-what-to-expect-when-they-click-a-link/
+ Adrian Roselli (2019), **Showing File Types in Links** → https://adrianroselli.com/2019/12/showing-file-types-in-links.html

## Accessibility: Speech

+ Josh W. Comeau (2020), **Coding with Voice Dictation using Talon Voice** → https://joshwcomeau.com/accessibility/hands-free-coding/
+ James Robertson (2020), **Voice Recognition: Build a simple voice controlled web app** →  https://rephrased.substack.com/p/voice

## Accessibility: Text

+ Steve Faulkner (2020), **Not so short note on aria-label usage – Big Table Edition** → https://html5accessibility.com/stuff/2020/11/07/not-so-short-note-on-aria-label-usage-big-table-edition/

## Bryan Braun posts on ES6, letting go of React, *et al*

+ Oct 2020, **ES modules in production: my experience so far** → https://www.bryanbraun.com/2020/10/23/es-modules-in-production-my-experience-so-far/
+ Sept 2019, **Web-dev nirvana, and why I needed to let go of React to reach it** → https://www.bryanbraun.com/2019/09/11/web-dev-nirvana-and-why-I-needed-to-let-go-of-reactjs-to-reach-it/
  - > Unfortunately, modern JavaScript development is full of nonsense, and the React ecosystem is no exception.
+ April 2019, **Nonsense** → https://www.bryanbraun.com/2019/04/16/nonsense/

## Dynamic Logic or Knowledge Update

+ Elliot Evans (2020), **Dynamic Epistemic Logic Playground** → https://vezwork.github.io/modallogic/
  - based on Ross Kirsling's [Modal Logic Playground](http://rkirsling.github.io/modallogic/)
+ Explain Algorithms (2020), **How you could have come up with Paxos yourself** → https://explain.yshui.dev/distributed%20system/2020/09/20/paxos.html
+ Nicholas Carlo (2020), **The key points of "Working Effectively with Legacy Code"** → https://understandlegacycode.com/blog/key-points-of-working-effectively-with-legacy-code/
+ `@_______lord` (2020), **How to Recalculate a Spreadsheet** → https://lord.io/blog/2020/spreadsheets/
+ Kristof Claes (2017), **My beef with the open/closed principle** → https://kristofclaes.github.io/2017/01/02/my-beef-with-the-open-closed-principle/

## Tools, Libraries

+ Microsoft TypeScript Wiki (2020), **Performance `>` Writing Easy-to-Compile Code** → https://github.com/microsoft/TypeScript/wiki/Performance#writing-easy-to-compile-code
+ Ruan Martinelli (2020), **What You Need To Know About npm Workspaces** → https://hyperfoo.io/posts/npm-7-workspaces-1
+ Nathan Sebhastian (2020), **Redux-Free State Management with Jotai** → https://blog.bitsrc.io/redux-free-state-management-with-jotai-2c8f34a6a4a
+ David Nicholas Williams (2020), **`React Frontload`: Simple full-stack data loading for React** → https://davnicwil.com/react-frontload/
+ Matthew Williams (2020), **How to Check Your Globally Installed `npm` Packages** → https://medium.com/better-programming/how-to-check-your-globally-installed-npm-packages-32a14469b95a
+ Vivek Chauhan (2020), **7 `Git` tricks that changed my life** → https://dev.to/vivekagent47/7-git-tricks-that-changed-my-life-3aj3
+ Graphery SVG (2020), **`Graphery` JavaScript SVG library** → https://www.graphery.org/svg/guide/
+ Polypane (2020), **`Polypane`: The browser for developing responsive & accessible websites** → https://polypane.app/

repository: dfkaye/dev-links

repo_name: dfkaye/dev-links


text:
# Intro

We implement all machine learning algorithms, concepts and ideas here, with following principles:

- [X] Only use [Numpy](http://www.numpy.org/)

- [X] All in modules/blocks

- [X] No dirty/garbage codes

- [X] As more matrix calculation as possible

- [X] As less for loops as possible

- [X] Write tests

- [X] Self-explained naming convention

# Machine Learning

Technically, we can create a mathematical model for any problems in the world with following elements:

- [X] Problem Definition

- [X] Historical Data

- [X] Model (Hypothesis)

- [X] Error (Loss, cost function, object function)

- [X] Optimizer

# Index

- [X] [Linear Regression](https://github.com/KleinYuan/numpy-ml/blob/master/models/linear_regression.py)

- [X] [Gradient Descent](https://github.com/KleinYuan/numpy-ml/blob/master/optimizers/gradient_descent.py)

# Some Basic Functions

![](http://adilmoujahid.com/images/activation.png)

repository: KleinYuan/numpy-ml

repo_name: KleinYuan/numpy-ml


text:
# OneNeuron_pypi
OneNeuron_pypi

## How to use this module

--python
from oneNeuron.perception import *

## get X and y and then use below commands
model = Perceptron(X, y)


text:
# @iov/cli

[![npm version](https://img.shields.io/npm/v/@iov/cli.svg)](https://www.npmjs.com/package/@iov/cli)

## Installation and first run

The `iov-cli` executable is available via npm. We recommend local installations
to your demo project. If you don't have one yet, just
`mkdir iov-cli-installation && cd iov-cli-installation && yarn init -y`.

### locally with yarn

```
$ yarn add @iov/cli --dev
$ ./node_modules/.bin/iov-cli
```

### locally with npm

```
$ npm install @iov/cli --save-dev
$ ./node_modules/.bin/iov-cli
```

### globally with yarn

```
$ yarn global add @iov/cli
$ iov-cli
```

### globally with npm

```
$ npm install -g @iov/cli
$ iov-cli
```

## How to use the IOV-Core command line interface

1. Install `@iov/cli` and run `iov-cli` as shown above
2. Start a local BNS blockchain as described in
   [scripts/bnsd/README.md](https://github.com/iov-one/iov-core/tree/master/scripts/bnsd/README.md)
3. Play around as in the following example code:

```
> const profile = new UserProfile();
> const signer = new MultiChainSigner(profile);
> const { connection } = await signer.addChain(bnsConnector("ws://localhost:23456"));
> const chainId = connection.chainId();

> chainId
'test-chain-esuZ1V'

> const wallet = profile.addWallet(Ed25519HdWallet.fromMnemonic("degree tackle suggest window test behind mesh extra cover prepare oak script"));

> profile.getIdentities(wallet.id)
[]

> const faucet = await profile.createIdentity(wallet.id, chainId, HdPaths.iov(0))

> faucet.pubkey
{ algo: 'ed25519',
  data:
   Uint8Array [
     224,
     42, ...

> profile.setIdentityLabel(faucet, "blockchain of value faucet")

> profile.getIdentities(wallet.id)
[ { chainId: 'test-chain-esuZ1V',
    pubkey: { algo: 'ed25519', data: [Uint8Array] } } ]

> const faucetAddress = signer.identityToAddress(faucet);
> faucetAddress
'tiov1k898u78hgs36uqw68dg7va5nfkgstu5z0fhz3f'
> (await connection.getAccount({ address: faucetAddress })).balance

> const recipient = await profile.createIdentity(wallet.id, chainId, HdPaths.iov(1));
> const recipientAddress = signer.identityToAddress(recipient);

> .editor
const sendTx: SendTransaction = {
  kind: "bcp/send",
  creator: faucet,
  recipient: recipientAddress,
  memo: "My first transaction",
  amount: {
    quantity: "33123456789",
    fractionalDigits: 9,
    tokenTicker: "CASH" as TokenTicker,
  },
};
^D
> await signer.signAndPost(sendTx);
> (await connection.getAccount({ address: recipientAddress })).balance;

> await connection.searchTx({ sentFromOrTo: faucetAddress });
> await connection.searchTx({ sentFromOrTo: recipientAddress });
```

3. Congratulations, you sent your first money!
4. Add an additional wallet

```
> profile.wallets.value
[ { id: 'ReYESw51lsOOr8_X', label: undefined } ]

> const wallet2 = profile.addWallet(Secp256k1HdWallet.fromMnemonic("organ wheat manage mirror wish truly tool trumpet since equip flight bracket"))

> profile.wallets.value
[ { id: 'ReYESw51lsOOr8_X', label: undefined },
  { id: 'FtIcQqMWcRpEIruk', label: undefined } ]

> profile.getIdentities(wallet.id)
[ { chainId: 'test-chain-esuZ1V',
    pubkey: { algo: 'ed25519', data: [Uint8Array] } } ]

> profile.getIdentities(wallet2.id)
[]

> profile.setWalletLabel(wallet.id, "ed")
> profile.setWalletLabel(wallet2.id, "secp")

> profile.wallets.value
[ { id: 'ReYESw51lsOOr8_X', label: 'ed' },
  { id: 'FtIcQqMWcRpEIruk', label: 'secp' } ]
```

5. Now store to disk

```
> const db = levelup(leveldown('./my_userprofile_db'))
> await profile.storeIn(db, "secret passwd")
```

6. and restore

```
> const profileFromDb = await UserProfile.loadFrom(db, "secret passwd");
> profileFromDb
UserProfile {
  createdAt: 2018-07-04T16:07:14.583Z,
  keyring:
   Keyring { wallets: [ [Ed25519HdWallet], [Secp256k1HdWallet] ] },
  ...
```

### Register a BNS username NFT

Assuming you have a `profile`, a `signer` and a `recipient` identity with
transactions associated from above

```
> .editor
const registration: RegisterUsernameTx = {
  kind: "bns/register_username",
  creator: recipient,
  addresses: [],
  username: "hans",
};
^D
> await signer.signAndPost(registration);
> const bnsConnection = connection as BnsConnection;
> await bnsConnection.getUsernames({ owner: recipientAddress });
[ { id: 'hans',
    owner: 'tiov14cn8m57wtrlewmlnjucctsahpnxlj92l0crkvq',
    addresses: [] } ]
> await bnsConnection.getUsernames({ username: "hans" });
[ { id: 'hans',
    owner: 'tiov14cn8m57wtrlewmlnjucctsahpnxlj92l0crkvq',
    addresses: [] } ]
```

### Disconnecting

When you are done using a WebSocket connection, disconnect the connection

```
> (await connection.getAccount({ address: faucetAddress })).balance
[ { quantity: '123456755876543211',
    fractionalDigits: 9,
    tokenTicker: 'CASH' } ]
> connection.disconnect()
undefined
> (await connection.getAccount({ address: faucetAddress })).balance
Error: Socket was closed, so no data can be sent anymore.
    at ...
```

## Faucet usage

When using a Testnet, you can use the IovFaucet to receive tokens.

In this example we connect to a public test network.

```
> const mnemonic = Bip39.encode(await Random.getBytes(16)).toString();
> mnemonic
'helmet album grow detail apology thank wire chef fame core private cargo'
> const profile = new UserProfile();
> const wallet = profile.addWallet(Ed25519HdWallet.fromMnemonic(mnemonic));

> const signer = new MultiChainSigner(profile);
> const { connection } = await signer.addChain(bnsConnector("https://bns.hugnet.iov.one"));
> const chainId = connection.chainId();

> const alice = await profile.createIdentity(wallet.id, chainId, HdPaths.iov(0));
> const aliceAddress = signer.identityToAddress(alice);

> const faucet = new IovFaucet("https://iov-faucet.hugnet.iov.one");

> await faucet.credit(aliceAddress, "IOV" as TokenTicker)
> (await connection.getAccount({ address: aliceAddress })).balance
[ { quantity: '10000000000',
    fractionalDigits: 9,
    tokenTicker: 'IOV' } ]
```

## License

This package is part of the IOV-Core repository, licensed under the Apache
License 2.0 (see
[NOTICE](https://github.com/iov-one/iov-core/blob/master/NOTICE) and
[LICENSE](https://github.com/iov-one/iov-core/blob/master/LICENSE)).

repository: cosmostation/iov-core

repo_name: cosmostation/iov-core


text:
# PyTorch Helper Bot
[WIP] a high-level PyTorch helper package

This project is intended for my personal use. Backward compatibility will not be guaranteed. Important releases will be tagged.

## Motivation

[*fast.ai*](https://github.com/fastai/fastai) is great, and I recommend it for all deep learning beginners. But since it's beginner-friendly, a lot of more sophisticated stuffs are abstracted heavily and hidden from users. Reading the source code is often required before you can tweak the underlying algorithms. The advent of `doc` function greatly speeds up the process by quickly directing the user to the source code and documentation.

However, *fast.ai* has become stronger and bigger. Not everyone has time to keep up with its codebase. Hence the creation of this project. I built a relatively thin layer of abstraction upon PyTorch from scratch, with a lot of ideas and code borrowed from various sources (mainly *fast.ai*). Only features that are relevant to my use cases are added.

Another similar project is [pytorch/ignite](https://github.com/pytorch/ignite).

## Examples

There are almost no unit tests yet. The following example(s) are somewhat functional tests.

* [Imagenette Image Classification](examples/imagenette/)


text:
# qrc-exfil

A simple demonstration of using rapidly cycling QR codes to
visually exfiltrate data from a restricted environment.

The encoder uses [qrcode-js](https://github.com/davidshimjs/qrcodejs) to
create QR codes on the fly, and the decoder uses [zxing-cpp](https://github.com/nu-book/zxing-cpp)
for decoding QR codes found in images.

## Encoder Prerequisites
* Chromium-based browser
* Click here for [hosted version](https://spectrophagus.github.io/qrc-exfil/encoder/qrc-encoder.html) or download the
[self-contained version](https://spectrophagus.github.io/qrc-exfil/encoder/qrc-encoder-combined.html).

## Decoder Prerequisites
* cmake / make / c++ compiler
* ffmpeg
* perl

## Building
To build zxing-cpp:
```
$ cd decoder/zxing-cpp
$ mkdir build && cd build
$ cmake ../
$ make
```

## Example
Load the [encoder](encoder/qrc-encoder.html) in a browser (tested only on Chromium-based
browsers, including Edge).  Set up your camera to focus on the displayed example QR code
and begin recording.

Select a file to encode using the dialog box, and capture all of the QR frames with your camera.

Once you have captured all the frames, transfer the video file to your computer and use [ffmpeg](https://ffmpeg.org/)
to extract all of the video frames into still images.
```
$ mkdir /tmp/qrc-out/
$ ffmpeg -i VID_20210324_164101.mp4 /tmp/qrc-out/out%08d.png
ffmpeg version 3.4.8-0ubuntu0.2 Copyright (c) 2000-2020 the FFmpeg developers
  built with gcc 7 (Ubuntu 7.5.0-3ubuntu1~18.04)
   [...]
frame= 1557 fps= 35 q=-0.0 size=N/A time=00:00:51.63 bitrate=N/A speed=1.17x

$ ls /tmp/qrc-out/out*.png | head
/tmp/qrc-out/out00000001.png
/tmp/qrc-out/out00000002.png
/tmp/qrc-out/out00000003.png
/tmp/qrc-out/out00000004.png
/tmp/qrc-out/out00000005.png
/tmp/qrc-out/out00000006.png
/tmp/qrc-out/out00000007.png
/tmp/qrc-out/out00000008.png
/tmp/qrc-out/out00000009.png
/tmp/qrc-out/out00000010.png
```

Once the video frames are extracted, use zxing-cpp to find the QR codes embedded in the images and decode them
into the original base64 content.

```
$ cd decoder
$ ./zxing-cpp/build/example/ZXingReader /tmp/qrc-out/out*.png | ./qrc-decode-single.pl | base64 --decode > /tmp/qrc-out.decoded
MIME type: data:image/jpeg;base64
```

The [example](example/) directory contains a sample JPEG file (borrowed from [@bigendiansmalls](https://twitter.com/bigendiansmalls),
who initially posted [here](https://twitter.com/bigendiansmalls/status/1374783712714485763) looking for stupid data exfiltration
tricks.  That file was encoded with the encoder, and the video was captured with a cellphone camera.  The corresponding ZXing output
generated from that video file (via ffmpeg) can also be found in the example directory.

```
$ cd example/
$ md5sum test.jpg
1f5ab5f204f3086dc1994af718ccdbd3  test.jpg
$ gzip -cd ./test.zxing.output.gz | ../decoder/qrc-decode-single.pl | base64 --decode | md5sum
MIME type: data:image/jpeg;base64
1f5ab5f204f3086dc1994af718ccdbd3  -
```

## Notes
Throughput of the encoder can be modified with `frameSize` and `frameInterval` parameters at the
top of [qrc-encoder.html](encoder/qrc-encoder.html).  The overall throughput can be calculated by the formula:

```
throughput (bytes/sec) = 750 * frameSize / frameInterval
```

The default settings (`frameSize = 256` and `frameInterval = 100`) are quite conservative and result in a modest
1.9kB/s transfer rate to maximize reliability.  Using a handheld 1080p cellphone camera recording at 30 fps,
zxing detects 3-5 copies of each QR frame in the output.  This implies that a with a fast display and a 4K camera
recording at 60 fps, an 8x increase in throughput (`frameSize = 1024` and `frameInterval = 50`) could be achieved
with no loss of robustness at 15kB/s.

Depending on display responsiveness, camera resolution, framerate, and image stability, you may find even more
aggressive settings (higher `frameSize`, lower `frameInterval`) that still work reliably with the devices
in your situation.

repository: spectrophagus/qrc-exfil

repo_name: spectrophagus/qrc-exfil


text:
# Yast - Yet another survey tool

Evaluation, playground project to try implementing a one page application able survey. The reference frontend is implemented using BackboneJS, the trivial reference backend is implemented using a NodeJS server utilizing ExpressJs 4.

# Idea

- REST API for feedback and surveys
- Survey template as JSON datastructure
- Survey structure and text separated for easy internationalisation
- Simple Javascript library for frontends

# "Features"

- Multiple input element types (see below)
- Texts and survey structure separated
- Steps can depend on other answers values
- Humble responsiveness
- Dumb ExpressJs backend to serve and receive the survey

# Technology

## BackboneJs

- The template structure is fed into / as the view's config
- The `Step` view, extended from a `Group` maps the template `type` to the view class
- The survey values are stored into a model; the template's `id` will be the model's key.
- The pagination is controlled using a model: `navModel`

## Template

The template is based on JSON and consisting of a tree structure modeling the GUI elements and a list of translations.

A GUI element at least has this structure:
```
{type: "<TYPE>", content: <CONTENT>}
```

- `TYPE` can be `step`, `group`, `text`, `multiplechoice`, `range` or `freetext`
- `CONTENT` depends on the type and is an object for every type except `text`, which just contains the I18N reference
- `group` and `step` are similar, they only contain other elements
- `group`s may contain other groups
- All elements may have an `id` attribute specifying the key to store the value to

For an example template see `/data/form.json.example` and the corresponding `texts.json.example`.

### Types

#### Step

- `content` (Array) Contains other GUI template objects
- `depends` (String) Simple comparsion expression to match the value of another ID to a hardcoded value. This can be used to make a step dependent on another input element's choice/value. Currently only one comparsion level (`<IDENTIFYER> <COMPARATOR> <VALUE>`) is possible.

#### Group

- `content` (Array) contains other GUI template objects

#### Text

- `content` (String) I18N reference

#### Multiplechoice

- `id` (ID)
- `exclusive` (boolean) - If true only one option can be active at the time
- `layout` (String) - Control the layout of the buttons. Valid: `row`, `column`
- `choices` (Array) - Objects containing ...
-- `id` (ID)
-- `text` (String) I18N reference and optionally
-- `free-text` (boolean)

#### Range

- `id` (ID)
- `steps` (int) Number of options
- `lower` (String) I18N reference
- `upper` (String) I18N reference

#### Freetext

- `id` (ID)

# Try out

## Prepare the template

Copy the form and text JSON example files into a subdirectory with a numeric foldername which represents the ID.

```
$ mkdir /data/47
$ cp /data/form.json.example /data/47/form.json.example
$ cp /data/texts.json.example /data/47/texts.json.example
```

## Start the server

```
$ node server/runme.js
```

## Use it

Surf to on of the example pages, e.g.: http://localhost:7072/index.html#in-overlay,47

(The format of the hash part is `#{in-overlay|standalone},<ID>`.)

Send some surveys and take a look into the folder `/received/47`. You'll find some files with a Unix timestamp as name containing the result data in JSON format.

## See the results

The accumulated results can be examined under http://localhost:7072/results/47 too.

# Status

In early development. Unstable. Probably never done. Not tested. But working.

# License

This code is MIT licensed for you.

repository: tholewebgods/yast

repo_name: tholewebgods/yast


text:
---
layout: default
---

# 1996-02-21 - Re: Chaotic physical systems as random number sources

## Header Data

From<EMAIL_ADDRESS>(Timothy C. May)

To<EMAIL_ADDRESS>Message Hash: b3fbcb1c52e17d1e457eead2949e89853905d28d36dd19a0aec5865ce704dcfa

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-02-21 05:39:48 UTC

Raw Date: Wed, 21 Feb 1996 13:39:48 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Timothy C. May)
Date: Wed, 21 Feb 1996 13:39:48 +0800
To<EMAIL_ADDRESS>Subject: Re: Chaotic physical systems as random number sources
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

At 6:46 PM 2/20/96, E. ALLEN SMITH wrote:
>        I'm curious if anyone knows of any attempts to use a chaotic physical
>system (such as the famous double pendulum) as a source of random numbers. I
>did an Alta Vista check on the problem, and all I turned up was a paper (in
>postscript, so I couldn't read it) on all mathematical pseudorandom number
>generators being logical chaotic systems. (It's at
>http://csl.ncsa.uiuc.edu/~herring/publications/rand.ps).
>        One problem that I can see is that of strange attractors. While the
>path through each time would be different, they're still _close_ to each other,
>and a practical mechanical system might not be sensitive enough to pick up the
>differences.

This has come up several times. As I recall, some guys at a Navy research
lab (San Diego?) were claiming to have a "chaotic encryption" system.

As to using chaotic systems for PRNGs or RNGs, the "turbulent flow over
disk drive platters causes speed variations" idea, described recently, is
of course an example of nominally using a chaotic/turbulent system to
defeat predictability.

I have at least a couple of paragraphs on chaos and crypto in my Cyphernomicon.

--Tim

Boycott espionage-enabled software!
We got computers, we're tapping phone lines, we know that that ain't allowed.
---------:---------:---------:---------:---------:---------:---------:----
Timothy C. May              | Crypto Anarchy: encryption, digital money,
<EMAIL_ADDRESS>408-728-0152 | anonymous networks, digital pseudonyms, zero
W.A.S.T.E.: Corralitos, CA  | knowledge, reputations, information markets,
Higher Power: 2^756839 - 1  | black markets, collapse of governments.
"National borders aren't even speed bumps on the information superhighway."

{% endraw %}
```

## Thread

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

+ Return to<EMAIL_ADDRESS>(Timothy C. May)](/authors/tcmay_at_got_net_timothy_c_may_)"

+ 1996-02-21 (Wed, 21 Feb 1996 13:39:48 +0800) - Re: Chaotic physical systems as random number sources -<EMAIL_ADDRESS>(Timothy C. May)_