text:
# `.xcode-version`

## Introduction

This is a proposal for a new standard for the iOS community: a text-based file that defines the Xcode version to use to compile and package a given iOS project.

This will be used by this gem, however it's designed in a way that any tool in the future can pick it up, no matter if it's Ruby based, Swift, JavaScript, etc.

Similar to the [.ruby-version file](https://en.wikipedia.org/wiki/Ruby_Version_Manager), the `.xcode-version` file allows any CI system or IDE to automatically install and switch to the Xcode version needed for a given project to successfully compile your project.

## Filename

The filename must always be `.xcode-version`.

## File location

The file must be located in the same directory as your Xcode project/workspace, and you should add it to your versioning system (e.g. git).

## File content

The file content must be a simple string in a text file. The file may or may not end with an empty new line, this gem is responsible for stripping out the trailing `\n` (if used).

### Sample files

To define an official Xcode release

```
9.3
```

```
7.2.1
```

You can also use pre-releases

```
11.5 GM Seed
```

```
12 beta 6
```

Always following the same version naming listed by `xcversion list`.

**Note**: Be aware that pre-releases might be eventually taken down from Apple's servers, meaning that it won't allow you to have fully reproducible builds as you won't be able to download the Xcode release once it's gone.

It is recommended to only use non-beta releases in an `.xcode-version` file to have fully reproducible builds that you'll be able to run in a few years also.

repository: xcpretty/xcode-install

gha_language: Ruby

repo_name: xcpretty/xcode-install


text:
# Groupin-Backend
## Starting App

**Without Migrations**

```
npm install
npm start
```

**With Migrations**

```
npm install
npm run migrate
npm start
```

This will start the application and (optionally) migrate the MySQL tables if the database exists.

Note that the database must be configured with the details provided in `config/config.js`, otherwise change `config.js` according to your existing configuration.

if the database doesn't exist yet, run this before starting the app:
```
npm run createdb
```

The backend will then be available at [http://localhost:6000](http://localhost:6000).

## Creating a new migration
Improved the DB's schemas by changing the data models? want to clarify that your version is superior in every way and should be used in every DB instance from now on? good! you need to create a new migration file.

In order to do so, simply run
```
npm run makemigration <migration_name>
```
you can then test your migration by running the `npm run migrate` command.

## Seeding the Database
If you wish to have some inital values in your DB's tables, run the following command just before starting the app:
```
npm run seed
```

repository: groupin-il/groupin-backend

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

license_type: permissive

repo_name: groupin-il/groupin-backend


text:
## Blocitoff

Blocitoff is a demonstration of Frontend web development knowledge. It showcases a working task manager for a computer web browser or mobile device.

## Tools

HTML

CSS

JavaScript

Angular

Firebase

## Try It

Blocitoff on Netlify

repository: timschmidtdev/blocitoff

repo_name: timschmidtdev/blocitoff


text:
# framework
C++ framework for Android and iOS development.

Dependencies
============

    http://github.com/Sometrik/httpclient
    http://github.com/Sometrik/canvas
    glm
    OpenGL ES 2.0

Credits
=======

* Mikael Rekola
* Mikko Suni (for Android support)
* Sami Rämö (for preliminary iOS support)

license: MIT

repository: Sometrik/framework

repo_name: Sometrik/framework


text:
[中文文档](README.zh-CN.md)

# Gen2 Frames Sync

This example demonstrates how to synchronize incoming frames using their sequence numbers.
This allows displaying frames taken in exact same moment

## Demo

![demo](./demo.png)

## Pre-requisites

1. Purchase a DepthAI model (see [shop.luxonis.com](https://shop.luxonis.com/))
2. Install requirements
   ```
   python3 -m pip install -r requirements.txt
   ```

## Usage

```
python3 main.py
```

## TODO

- Add color camera stream (waiting for sequence numbers sync between RGB and Mono cameras)

repository: mzemlyanikin/depthai-experiments

gha_license_id: MIT

repo_name: mzemlyanikin/depthai-experiments


text:
# 1.0.0

- Initial release.

# 1.0.1

- Require mongo >= 1.8 for method consistency.

# 1.1.0

- Query count and Query time are now threadsafe.

# 1.2.0

- Use `Module#prepend` over `alias_method_chain` - #4 @NJ-Scioly

repository: peek/peek-mongo

repo_name: peek/peek-mongo


text:
# Emotion Notes

Emotion is a library designed for writing css styles with JavaScript. It provides powerful and predictable style composition in addition to a great developer experience with features such as source maps, labels, and testing utilities. Both string and object styles are supported.

There are two primary methods of using Emotion. The first is framework agnostic and the second is for use with React.

**Framework Agnostic**

```sh
npm i @emotion/css
```

See [@emotion/css](https://emotion.sh/docs/@emotion/css) for more info.

**React**

```sh
npm i @emotion/react
```

See [@emotion/react](https://emotion.sh/docs/@emotion/react) for more info.

repository: dhurlburtusa/shortcuts

repo_name: dhurlburtusa/shortcuts


text:
`ltags` produces tag files compatible with extended [tags format](http://ctags.sourceforge.net/FORMAT)
used by Vim and [many other editors](http://en.wikipedia.org/wiki/Ctags#Editors_that_support_ctags)
This adds very useful semantic hints for symbols, such as basic type, global or file scope, belonging to what
struct, etc.

Although [Exuberant ctags](http://ctags.sourceforge.net/) is the most commonly used implementation, supporting
41 programming languages, it does not do Lua very well.  It only does functions, and always collects the module
and the function together (e.g 'tablex.imap') as the 'tag'.  No extended type information is provided, and no
indication of file scope.

Invocation is easy - this script only needs Lua (5.1 or 5.2) and is to be passed the filenames to be processed.
On Windows, wildcard arguments will also be expanded.

As with `ctags`, a single file 'tags' is generated in the directory where `ltags` is invoked.

The `-nv` option switches off module-level local variable tagging.
The common practice of declaring imported functions as locals up front can complicate
the simple business of going to the original definition.  So if we had `local imap = tablex.imap` up
top then there would be two items with name 'imap' visible in that module - the local alias
and the actual function.  Not a problem if your editor is comfortable with multiple tag values.

repository: idbrii/ltags

repo_name: idbrii/ltags


text:
# People demo page

This section of our demo was originally made by [phaux](https://github.com/phaux) in the [web-app-boilerplate](https://github.com/phaux/web-app-boilerplate) repo. It has been slightly modified from it's original to better work inside of our demo app

repository: preactjs/preact

branch_name: refs/heads/main

repo_name: preactjs/preact


text:
Project dans le cadre de ma formation chez O'clock
# jGame
🚩 Jeu de carte, retourner deux cartes identique et ceux avec toutes les cartes pour finir la partie.
🚀🚀🚀🚀🚀🚀
## Installation

This is a [Node.js](https://nodejs.org/) module available through the
[npm registry](https://www.npmjs.com/). It can be installed using the
[`npm`](https://docs.npmjs.com/getting-started/installing-npm-packages-locally)
or
[`yarn`](https://yarnpkg.com/en/)
command line tools.

```sh
npm install
```

## Tests

```sh
npm install
npm test
```

## Dev Dependencies

- [@babel/core](https://ghub.io/@babel/core): Babel compiler core.
- [@babel/eslint-parser](https://ghub.io/@babel/eslint-parser): ESLint parser that allows for linting of experimental syntax transformed by Babel
- [@babel/plugin-proposal-class-properties](https://ghub.io/@babel/plugin-proposal-class-properties): This plugin transforms static class properties as well as properties declared with the property initializer syntax
- [@babel/plugin-proposal-private-methods](https://ghub.io/@babel/plugin-proposal-private-methods): This plugin transforms private class methods
- [@babel/plugin-transform-spread](https://ghub.io/@babel/plugin-transform-spread): Compile ES2015 spread to ES5
- [@babel/preset-env](https://ghub.io/@babel/preset-env): A Babel preset for each environment.
- [@babel/register](https://ghub.io/@babel/register): babel require hook
- [autoprefixer](https://ghub.io/autoprefixer): Parse CSS and add vendor prefixes to CSS rules using values from the Can I Use website
- [babel-loader](https://ghub.io/babel-loader): babel module loader for webpack
- [babel-plugin-module-resolver](https://ghub.io/babel-plugin-module-resolver): Module resolver plugin for Babel
- [babel-register](https://ghub.io/babel-register): babel require hook
- [core-js](https://ghub.io/core-js): Standard library
- [css-loader](https://ghub.io/css-loader): css loader module for webpack
- [eslint](https://ghub.io/eslint): An AST-based pattern checker for JavaScript.
- [eslint-config-google](https://ghub.io/eslint-config-google): ESLint shareable config for the Google style
- [eslint-plugin-import](https://ghub.io/eslint-plugin-import): Import with sanity.
- [eslint-plugin-jsx-a11y](https://ghub.io/eslint-plugin-jsx-a11y): Static AST checker for accessibility rules on JSX elements.
- [eslint-plugin-react](https://ghub.io/eslint-plugin-react): React specific linting rules for ESLint
- [eslint-plugin-react-hooks](https://ghub.io/eslint-plugin-react-hooks): ESLint rules for React Hooks
- [extract-loader](https://ghub.io/extract-loader): webpack loader to extract HTML and CSS from the bundle
- [file-loader](https://ghub.io/file-loader): A file loader module for webpack
- [jest](https://ghub.io/jest): Delightful JavaScript Testing.
- [postcss-loader](https://ghub.io/postcss-loader): PostCSS loader for webpack
- [sass](https://ghub.io/sass): A pure JavaScript implementation of Sass.
- [sass-loader](https://ghub.io/sass-loader): Sass loader for webpack
- [style-loader](https://ghub.io/style-loader): style loader module for webpack
- [webpack](https://ghub.io/webpack): Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.
- [webpack-cli](https://ghub.io/webpack-cli): CLI for webpack & friends
- [eslint-plugin-jest](https://ghub.io/eslint-plugin-jest): Eslint rules for Jest

## License

ISC

repository: Yecodeo/Jgame

repo_name: Yecodeo/Jgame


text:
# Go Lang Material

[![Udhay's GitHub activity graph](https://img.shields.io/github/commit-activity/m/udhayprakash/GoLangMaterial?label=Commit%20Activity&logo=github&style=flat-square)](https://github.com/udhayprakash/GoLangMaterial)

- General Purpose Compiled Programing language
- created by Ken Thompson (B, C, Unix, UTF-8), Rob Pike(Unix, UTF-8),
    Robert Griesemer(Hotspot, JVM) and few google engineers.
- first release was on March 2012.
- No pre-requisites need. Can be learned as first programming language.
- C language is the most direct influence on Go.
- Platform-independent.
    - Create executable build based on the platform.
    - Means, source code is translated into language that the system understands.
- comes with its own compiler
- statically typed programming language
- Concurrency
    - allows multiple processes running simultaneously and effectively.
- garbage collector - automatic memory management
- Execution flow - top to botton and left to right order
- Official website: https://www.golang.org
- Go programs are two types
    - Executables
    - Libraries
        - Libraries are collections of code that we package together so that we can use them in other programs.
- Go doesn't care about white-spaces and indentation
- Two type of comments are supported:
    - line comment //
    - multi-line comment /* */
- Functions are building blocks of a Go Program
- All versions are backward compatible (promised).
- Go has replaced the traditional features of class inheritance with the help of
its two features, i.e., type embedding and interfaces.
- Other features
    - Fast compilation process
    - Default concurrency support
    - Simple and easy to use
- Designed to achieve concurrency using the multi-core CPUs available these days
- compiles, combining all dependency libraries and module into a single binary file based
    on OS type and architecture
- Popular features of other languages, which are not present in Golang are
        - no implicit numeric conversions
        - no constructors or destructors
        - no operator overloading
        - no default parameter values
        - no inheritance
        - no generics
        - no exceptions
        - no macros
        - no function annotations
        - no thread-local storage
-  It is meant to replace C++ and Java in terms of Google's needs.
    Go was meant to alleviate some of the slowness and clumsiness of development
    of very large software systems.
- To be a little more specific, Go helps solve …
        - slow compilation and slow execution
        - programmers that collaborate using different subsets of languages
        - readability and documentation
        - language consistency
        - versioning issues
        - multi-language builds
        - dependencies being hard to maintain
- Compilers
    - There are two Go compiler implementations, gc, and gccgo.
        Gc uses a different calling convention and linker and because of this,
        can only be linked with C programs following the same convention.
        Gccgo is a GCC frontend that can be linked with GCC-compiled C or C++ programs.
        Gccgo is slower to compile than the default gc, but supports more powerful
        optimizations so many programs compiled with it will run faster.
        This takes great care and even more patience.

    - The cgo program provides the mechanism for a foreign function interface to
        allow safe calling of C libraries from Go code. SWIG extends this capability
        to C++ libraries.
- Limitations of Go
    - No Generics, no .map, .reduce, .filter
    - No exceptions or assertions, as mentioned earlier (but I feel that this could go either way)
    - No Ternary operations. Use the good ole 'if else' statements.
    - Absolutely no tolerance for unused variables or imports (but is that really a bad thing?)
    - Your virus protection might think your compiled binaries are infected because it doesn't understand the structure of a Go Binary 😅
    - No pointer arithmetic (but thats for safety, and simplifies implementation of the garbage collector)
    - And honestly, dealing with GOPATH is kinda messy and annoying. You are forced to do all of your go projects within your GOPATH, but IDE's like VSCode and GoLand allow you to set the GoPath for your project without affecting your system's actual GOPATH.
-Philosophy
    - Do not communicate by sharing memory; instead, share memory by communicating
        The number 1 feature of GoLang is the exact opposite definition of what OOP stands for.
    - Keep It Simple Stupid (KISS)
        - Only one way of doing things
            No more spaces vs tabs, functions vs objects, for vs while …
            Developers write the same code, compiler can optimize it better.
- OOP
    - There are no classes in Go, but some features of Object Oriented programming are supported:
        - Encapsulation (possible on package level in Go)
        - Composition (possible through embedding in Go)
        - Polymorphism (possible through Interface satisfaction in Go)
        - Inheritance (Not possble - overloading makes code harder to debug)

# Why Golang
----------
- Go is natively compiled
    - No VM needed.
    - Directly compiled to machine code like c, c++.
- Static Typing
- Scalable to large Systems
- General Purpose Programming Language
    - Mainly targeted at System/ Server-side programming like C, C++, Rust, ..
- Clean Syntax
- Excellent Support for concurrency and networking
- Automatic Garbage Collection
- Rich Standard library
- Go Compiler is available on Linux, OS X, Windows, various BSD & Unix versions
- Go is open Source

# Who Uses Go
-----------
- Many Google web properties and systems including youtube, Kubernetes containers and download server dl.google.com
- Docker, a set of tools for deploying Linux containers
- Dropbox, migrated some of their critical components from Python to Go
- SoundCloud, for many of their systems
- CloudFoundry, aplatform as a service(PaaS)
- Couchbase, Query and indexing services within the couchbase server
- MongoDB, tools for administering MongoDB instances
- ThoughtWorks, some tools and applications around continous delivery and instant messages
- SendGrid, a transactional email delivery and management service
- BBC, in some games and internal projects
- Novartis, for an internal inventory system

# What's not PRESENT in Go
-----------------
- Class
- Class based Inheritance
- Generics
- Traits/ Mixins
- Pointer Arithmetic
- Implicit type conversions
- Method/Function Overloading

# Go Tools
- To check the go version,
        go version
- To know all the options,
        go help
- To get help about a package,
        godoc fmt Println

## DataTypes
    - statically typed programming language
    - Data Types
        - Integers
            - unsigned - uint8, uint16, uint32, uint64
            - signed - int8, int16, int32, int64
            - aliases:
                - rune is alias for int32
                - byte is alias for uint8
                    1 byte = 8 bits
                    1024 bytes = 1 kilobyte
                    1024 kilobytes = 1 Megabyte ...
            - Also, there are three machine dependent integer types
                - Machine dependent because their size depends on type of system architecture.
                - uint, int, uintptr
            - Generally, we can use int

        - Floating-point numbers
            - float32 - referred, also, as single precision
            - float64 - referred, also, as double precision
            - Larger sized floating-point number increases its precision
            - Generally, we can use float
        - NaN (not a number)
            - To represent 0/0
        - +∞ and −∞ (positive and negative infinity)
        - Complex
            - complex64
            - complex128

        - Strings
            - Go Strings are made up of individual bytes, usually one for each character
            - non-english characters are represented by more than 1 byte
            - created using
                - double quotes("Hello world")
                    - single-line strings
                    - Allow special sequences
                - back ticks (`Hello world`)
        - bool (true, false)

Identifier Naming Convention
    - first character - A-Z, a-z
    - remaining chars - A-Z, a-z, 0-9, _
    - pascalCase or CamelCase is recommended.

## Important Links:
    - tour.golang.org
    - lean.go.dev
    - gophercises.com
    - gobyexample.com
    - golangprograms.com
    - for jobs, golang.cafe
    - https://www.golang-book.com/
    - https://www.gopl.io/
    - https://www.goinggo.net/

    - https://github.com/GoesToEleven/svcc-19

    - Bill Kennedy
        - https://www.ardanlabs.com/blog/

    - https://www.twitter.com/joncalhoun?lang=en
    - https://www.gophercises.com/

    https://www.udemy.com/user/toddmcleod/
    https://www.greatercommons.com/

    https://www.changelog.com/gotime
    https://golangbyexample.com/

    https://golang.org/
    golang spec
    effective golang
    https://go.libhunt.com/
    forum.golangbridge.org

    https://programming.guide/go/
    godoc.org
        standard library and 3rd party packages

This source code is tested in go 1.13.5

## TODO:

- https://www.sohamkamani.com/blog/golang/2018-06-20-golang-factory-patterns/
- https://go101.org/article/channel.html
- https://exercism.io/tracks/go/learning

## Articles
    [Go CodeReview Comments guidelines](https://github.com/golang/go/wiki/CodeReviewComments)
    https://medium.com/@kevalpatel2106/why-should-you-learn-go-f607681fad65
    [Farewell Node.js](https://medium.com/code-adventures/farewell-node-js-4ba9e7f3e52b?)

## Quotes

    “Go will be the server language of the future.” — Tobias Lütke, Shopify
    “With constant pressure to add features and options and configurations, and to
     ship code quickly, it’s easy to neglect simplicity, even though in the long
     run simplicity is the key to good software” — Rob Pike, One of Golang creators

## Packages

1. GoReleaser, http://github.com/goreleaser
2. Cobra( for creating CLIs), https://github.com/spf13/cobra
3. github.com/dgrijalva/jwt-go 				- generate and sign json web tokens
4. github.com/doug-martin/goqu 				- SQL query builder. Don't like ORMs in general, didn't like GORM. The API is a bit verbose but it does the job and supports tons of SQL features including database specific ones.
5. github.com/gin-gonic/gin 					- My goto framework for writing microservices
6. github.com/go-chi/chi 						- when net/http is not enough this is the router I use. gorilla/mux is slow, didn't bother trying anything else after chi.
7. github.com/go-gorm/gorm 					- database "orm"
8. github.com/golang-migrate/migrate/v4 		- database schema migration
9. github.com/golang/mock 						- Auto generate mocks from interfaces for unit testing
10. github.com/gonum/gonum 						- Contains almost everything one needs for numerical analysis. The guys over there are porting LAPACK to pure Go with explicit tests.
11. github.com/hashicorp/go-hclog 				- structured logging
12. github.com/jackc/pgx 						- excellent library for Postgre. Especially if you need PSQL specific features
13. github.com/kyleconroy/sqlc 					- generate funcs, structs and interfaces by providing a sql schema and queries
14. github.com/labstack/echo 					- web framework
15. github.com/nhooyr/websocket 				- websocket implementation. Recently migrated to it from gorilla/websocket. Nicer API and faster but nothing really wrong with gorilla. Just wanted to try something new.
16. github.com/pkg/errors 						- don't like how wrapping is done in standard library. This is better. Been using this library forever and it's even compatible with recent standard library changes.
17. github.com/rs/zerolog 						- structural logging library, fluent interface
18. github.com/satori/go.uuid  					- great for generating uuid's
19. github.com/shopspring/decimal  				- super useful when dealing with currency
20. github.com/sirupsen/logrus 					- go-to logger when i need something more than just pushing to stdout
21. github.com/stretchr/testify 				- very useful for tests
22. github.com/stretchr/testify#suite-package 	- I primarily use the suite package for a clear separation of setup and teardown during tests and the Require() to fail fast the test at the point of error
23. github.com/stretchr/testify/require 		- abort a test if some requirement is not met in one line
24. go.uber.org/automaxprocs 					- must-have for kubernetes deployments
25. pkg.go.dev/golang.org/x/sync/errgroup 		- Managing goroutines which can return error in the idomatic go way

# Upgrading dependencies
- To upgrade a specific package,
    go get -u <package-name>

- To upgrade all (direct and indirect) packages in go.mod file,
    go get -u ./...

     This is the command you want to use.
    go get -t -u ./... walks all packages in your project and also downloads tests files of these dependencies. Probably you don’t need that.
    go get -u updates in the current directory only. Useful for small single-package projects, just use the first version.
    go get -u specific.com/package updates just one (or more separated by space) packages (and dependencies).
    go get -u specific.com/package@version the same but to a specific version.
    go get -u all updates modules from the build list from go.mod. This is useful for listing (go list -m -u all) but not too useful for updates.

repository: udhayprakash/GoLangMaterial

gha_language: Go

repo_name: udhayprakash/GoLangMaterial


text:
# Frontend developer test

Please push your code to your Github and send the link to<EMAIL_ADDRESS>
## 1. Start from [this file](https://github.com/GetLinks/Tech-Guide/blob/master/frontend/getLinks-frontend-developer-test.html), use Bootstrap to make a web page like picture below
![](images/frontend-test.png?raw=true)
- You can use Lorem text and placeholder images anywhere you want
- You can modify the design if you have a better idea
- (Optional) Make React reusable components from the web page

---

repository: GetLinks/Tech-Guide

repo_name: GetLinks/Tech-Guide


text:
# process-drift-detection
After detecting the drift from the event log, analyze the differences between the variants based on the drift point.
## Python packages required
- lxml (http://lxml.de/)
- numpy (http://www.numpy.org/)
## How to use
Please run the detector.py file directly.The parameters can be modified by yourself.


text:
# fixed-map
[![Build Status](https://travis-ci.org/udoprog/fixed-map.svg?branch=master)](https://travis-ci.org/udoprog/fixed-map)

**Note:** this crate is still in heavy development. Please be careful!

This crate provides a map implementation that can make use of a fixed-size backing storage.

For more information on how to use `fixed-map`, see the [documentation].

[documentation]: https://docs.rs/fixed-map

## The `Key` derive

The `Key` derive is provided to construct optimized storage for a given Key.

For example:

```rust
use fixed_map::{Key, Map};

#[derive(Clone, Copy, Key)]
enum Part {
    One,
    Two,
}

#[derive(Clone, Copy, Key)]
enum Key {
    Simple,
    Composite(Part),
    String(&'static str),
    Number(u32),
    Singleton(()),
}

let mut map = Map::new();

map.insert(Key::Simple, 1);
map.insert(Key::Composite(Part::One), 2);
map.insert(Key::String("foo"), 3);
map.insert(Key::Number(1), 4);
map.insert(Key::Singleton(()), 5);

assert_eq!(map.get(Key::Simple), Some(&1));
assert_eq!(map.get(Key::Composite(Part::One)), Some(&2));
assert_eq!(map.get(Key::Composite(Part::Two)), None);
assert_eq!(map.get(Key::String("foo")), Some(&3));
assert_eq!(map.get(Key::String("bar")), None);
assert_eq!(map.get(Key::Number(1)), Some(&4));
assert_eq!(map.get(Key::Number(2)), None);
assert_eq!(map.get(Key::Singleton(())), Some(&5));
```

## Missing APIs

The API of this project is incomplete since it is experimental.
You can help by adding more!

## Why does this crate exist?

There are many cases where you want associate a value with a small, fixed number of elements
identified by an enum.

For example, let's say you have a game where each room has something in for directions:

```rust
#[derive(Key)]
pub enum Dir {
    North,
    East,
    South,
    West,
}
```

Now we can use this map to associate an item with each direction.

```rust
let mut map = fixed_map::Map::new();
map.insert(Dir::North, Item::Bow);
```

## Performance

The goal is for the performance of fixed-map to be identical to storing the data linearly in memory
like when using `[Option<Key>; N]`.

In the following benchmarks, fixed-map is compared to:

* `fixed` - A `fixed_map::Map` with a derived `Key` with `N` variants.
* [`hashbrown`] - A high performance hash map. This is only included for reference.
  - Note: Maps are created with `HashMap::with_capacity(N)`.
* `array` - A simple `[Option<Key>; N]` array.

To do this, run:

```
RUSTFLAGS="--emit asm" cargo build --release --example <example>
```

You should be able to find the assembler generated in the target folder:

```
ls target/release/examples/
```

## LICENSE

This project is distributed under the terms of both the MIT license and the Apache License (Version
2.0).

This project contains code derived from [HashMap] (Rust stdlib).

[HashMap]: https://github.com/rust-lang/rust/blob/2c1a715cbda1d6eba39625aca08f1f2ac7c0dcc8/src/libstd/collections/hash/map.rs

repository: haraldmaida/fixed-map

repo_name: haraldmaida/fixed-map


text:
drumminhands-mtg-life-counter
=============================

An arduino controlled life counter for MtG: Magic the Gathering
Created by<EMAIL_ADDRESS>
Press the plus button (button A) to increment the life counter by one. Hold to move faster.
Press the minus button (button B) to decrease the life counter by one. Hold to move faster.
Hold the reset button (button C) to reset to 20 life when starting a new game.
Hold longer to reset to 40 life for an EDH game.

Uses a four digit display from Adafruit https://learn.adafruit.com/adafruit-led-backpack/0-54-alphanumeric


text:
Sometimes you may only want to display part of your template if a property
exists.

You can use the `{{#if}}` helper to conditionally render a block:

```handlebars
{{#if person}}
  Welcome back, <b>{{person.firstName}} {{person.lastName}}</b>!
{{/if}}
```

Handlebars will not render the block if the argument passed evaluates to
`false`, `undefined`, `null` or `[]` (i.e., any "falsy" value).

If the expression evaluates to falsy, we can also display an alternate template
using `{{else}}`:

```handlebars
{{#if person}}
  Welcome back, <b>{{person.firstName}} {{person.lastName}}</b>!
{{else}}
  Please log in.
{{/if}}
```

To only render a block if a value is falsy, use `{{#unless}}`:

```handlebars
{{#unless hasPaid}}
  You owe: ${{total}}
{{/unless}}
```

`{{#if}}` and `{{#unless}}` are examples of block expressions. These allow you
to invoke a helper with a portion of your template. Block expressions look like
normal expressions except that they contain a hash (#) before the helper name,
and require a closing expression.

## Inline-if syntax

You can also use the inline-if to keep code terse:

```handlebars
This message is {{if isImportant 'important' 'unimportant'}}.
```

You can even use this inline-if syntax to bind values to attributes:

```handlebars
<div class="message {{if isImportant 'important' 'unimportant'}}"></div>
```

The inline-if syntax also support the inverse syntax using an inline-unless:

```handlebars
This message is {{unless isImportant 'unimportant' 'important'}}.
```

<!-- eof - needed for pages that end in a code block  -->

repository: ember-learn/guides-source

gha_language: HTML

repo_name: ember-learn/guides-source


text:
# Yahoo Auction Http library

### Description
This library will help you to work with Yahoo auction. It makes requests to Yahoo auction like a normal browser. To use this library you must specify your username and password from Yahoo to login. In order not to make a login every time, after the first login, save your cookies so that the following requests will be in the same session. You can view your won lots and bidding lots. To get information about the lot or bid on the lot, you will need an application key.

### Requirements
- php >= 5.4
- php-curl
- php-mbstring
- php-xml

### Installation
```
composer require notfoundsam/yahoo-auction
```

### Examples
Specify your credentials and create a new instance of Browser object.
```
require __DIR__ . '/../vendor/autoload.php';

use Yahooauc\Browser as Browser;

$userName = "your_yahoo_user";
$userPass = "your_yahoo_pass";

/* Get saved cookie */
$cookie = file_get_contents('cookie.cache');
$cookieJar = $cookie !== false ? unserialize($cookie) : [];

$browser = new Browser($userName, $userPass, null, $cookieJar);
```
If you don't have cookies yet try to login into Yahoo.
It throws `LoginException` or `CaptchaException` if something wrong.
```
/* Try to login into Yahoo */
var_dump($browser->login());
```
If you already have cookies try to check it.
```
/* Check is logged in */
var_dump($browser->checkLogin());
```
Use the next methods to get information about your auctions or bid on the lot.
```
/* Get information about the lot */
var_dump($browser->getAuctionInfoAsXml("auction_lot_id"));

/* Get list of lots from the first bidding page */
var_dump($browser->getBiddingLots(1));

/* Get array of auction id from the first won page */
var_dump($browser->getWonIds(1));

/* Bid on the lot. The second argument is price in yen */
var_dump($browser->bid("auction_lot_id", 100));
```
In the end save your browser cookies to use it next time.
```
$cookieJar = $browser->getCookie();
$cookie = serialize($cookieJar);
file_put_contents('cookie.cache', $cookie);
```

### Debug
Since v1.1.0 you can use the debugging mode to test your application locally. Export `YAHOO_AUC_ENV` to your environment. Set it to `production` to use on production or other to use the debugging mode.
```
export YAHOO_AUC_ENV=local
```
You can also enable or disable the debugging mode with the following method.
Pass the second argument with the path to the folder with your test files.
```
$browser->debug($debug = true);
$browser->debug($debug = true, $testPath = 'your_folder_with_test_pages');
```
### How to use the debugging mode
Replace `test_user` with something else to throw `LoginException`. It means the login failed.
```
$userName = "not_test_user";
$userPass = "secret_password";

$browser = new Browser($userName, $userPass, null, []);
$browser->debug($debug = true);
```
Pass the following id `n000000000` to throw `PageNotfoundException`. It means the auction not found.
```
$userName = "test_user";
$userPass = "secret_password";

$browser = new Browser($userName, $userPass, null, []);
$browser->debug($debug = true);
$browser->getAuctionInfoAsXml("n000000000");
```
Get an array of fake data from the first bidding page.
```
$userName = "test_user";
$userPass = "secret_password";

$browser = new Browser($userName, $userPass, null, []);
$browser->debug($debug = true);
$browser->getBiddingLots(1);
```
Get an array of fake IDs from the first won page.
```
$userName = "test_user";
$userPass = "secret_password";

$browser = new Browser($userName, $userPass, null, []);
$browser->debug($debug = true);
$browser->getWonIds(1);
```
Bid on the following lot `e000000000` to throw `AuctionEndedException`. This auction has already ended.
Bid on the following lot `x000000000` with price under `220` to throw `BrowserException`. It means your price is lower than the current price.
Bid on the following lot `x000000000` with price between `220` and `999` to throw `RebidException`. It means the price of the lot has rose, and the bid failed.
Bid on the following lot `x000000000` with price more than `999` for a successful bid.
```
$userName = "test_user";
$userPass = "secret_password";

$browser = new Browser($userName, $userPass, null, []);
$browser->debug($debug = true);
$browser->bid("e000000000", 1000); // Has already ended
$browser->bid("x000000000", 100);  // Not enough
$browser->bid("x000000000", 500);  // Rebid page, bid failed
$browser->bid("x000000000", 1000); // Success
```

## About v1.3.x

### Features
- Added xdebug to the docker container.

### Updates
- Yahoo auction API was removed because Yahoo fully closed their API.
- If the page or lot not found it will throw `PageNotfoundException`.
- Check login with new request (Sometimes after login Yahoo shows different page).
- Remove unnecessary request options in `Browser` constructor.

### Fixes
- The method `getAuctionImgsUrl` returned empty array.

### Notes
- Field `$appId` don't need anymore, pass null instead to the `Browser` constructor.
- Method `$browser->getAuctionInfoAsXml("...")` returns shorted version of API result. Currently, available fields: `AuctionID`, `AuctionItemUrl`, `Title`, `Seller->Id`, `Img`, `Price`, `TaxinPrice`, `StartTime`, `EndTime`, `Status`.

### Migration from v1.2.x
- Check available fields for `$browser->getAuctionInfoAsXml("...")` in Notes.

repository: notfoundsam/yahoo-auction

repo_name: notfoundsam/yahoo-auction


text:
---
layout: default
---

# 1994-05-01 - Re:  Cypherpunks as lobbying/propagandizing group

## Header Data

From<EMAIL_ADDRESS>(Curtis D Frye)

To<EMAIL_ADDRESS>Message Hash: 527113581c7bf155232b608d153be31d8c69aeda5607e4c4bdeb4b996dbff413

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-05-01 03:49:08 UTC

Raw Date: Sat, 30 Apr 94 20:49:08 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Curtis D Frye)
Date: Sat, 30 Apr 94 20:49:08 PDT
To<EMAIL_ADDRESS>Subject: Re:  Cypherpunks as lobbying/propagandizing group
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Eric Hughes says:  "It's a fine idea, except there's no way such a group can
claim to represent cypherpunks at large."

True enough -- my idea would be to say that our group is composed of folks who
happen to be Cypherpunks subscribers.  I agree that claiming to represent an
anarchy is illogical and, well, an outright untruth.

Curt

{% endraw %}
```

## Thread

+ Return to [May 1994](/archive/1994/05)

+ Return to<EMAIL_ADDRESS>(Curtis D Frye)](/authors/cfrye_at_mason1_gmu_edu_curtis_d_frye_)"
+ Return to "["Jim Sewell" <jims@Central.KeyWest.MPGN.COM>](/authors/jim_sewell_jims_at_central_keywest_mpgn_com_)"
+ Return to "[Julietta <albright@scf.usc.edu>](/authors/julietta_albright_at_scf_usc_edu_)"
+ Return to<EMAIL_ADDRESS>(Timothy C. May)](/authors/tcmay_at_netcom_com_timothy_c_may_)"

+ 1994-05-01 (Sat, 30 Apr 94 20:49:08 PDT) - Re:  Cypherpunks as lobbying/propagandizing group -<EMAIL_ADDRESS>(Curtis D Frye)_
  + 1994-05-01 (Sun, 1 May 94 01:20:44 PDT) - [Re: Cypherpunks as lobbying/propagandizing group](/archive/1994/05/0d39ca7fa387245bd5febd452389e450ff3e60c41f33056b3dcc1a8427685b4a) - _Julietta<EMAIL_ADDRESS>    + 1994-05-02 (Sun, 1 May 94 17:37:44 PDT) - [Re: Cypherpunks as lobbying/propagandizing group](/archive/1994/05/2ec8706833678028e738d36dae72ef385f0fb210025181424583636f11cfd01f) -<EMAIL_ADDRESS>(Timothy C. May)_
  + 1994-05-01 (Sun, 1 May 94 08:48:26 PDT) - [Re: Cypherpunks as lobbying/propagandizing group](/archive/1994/05/38f51f6b5702b2f51d41884c2e207f0dce3f12b83a43c1af6c0078b04954b460) - _"Jim Sewell"<EMAIL_ADDRESS>


text:
# Jekyll Faces

Jekyll is a great blogging platform, but to make it really shine, you need to make some tweaks. We've made those tweaks, and we've done so in such a way as to avoid using plugins, so your site can easily be hosted for free on [GitHub Pages](https://pages.github.com/).

Check us out at [JekyllFaces.com](http://jekyllfaces.com/)!

> **NOTE:** This project isn't quite ready for primetime. It's getting there, though. ETA is first part of July, 2017.

[![Build Status](https://travis-ci.org/groundh0g/jekyllfaces.svg?branch=gh-pages)](https://travis-ci.org/groundh0g/jekyllfaces)

## Project Landing Page

![Project Page Example](docs/images/project.png)

## Contributors Page

![Contributors Page Example](docs/images/contributors.png)

## Book Progress Page

![Book Progress Page Example](docs/images/books-summary.png)

## 12 Built-In 404 Pages

![Project Page Example](docs/images/old-404/404-sticky.png)

## Search

Coming soon...

branch_name: refs/heads/gh-pages

gha_language: Liquid


text:
---
layout: post
title: 'Announcing Window 2.0: Weight Tracking and more!'
post-id: announcing-window-2-0
thumbnail: thumbnail.png
photoswipe: true
tags:
  - Apps

weight-tracking:
  - src: weight-tracking-1.png
    maxres: 931 × 1656
  - src: weight-tracking-2.png
    maxres: 931 × 1656
  - src: weight-tracking-3.png
    maxres: 931 × 1656

window-notes:
  - src: window-notes-1.png
    maxres: 931 × 1656
  - src: window-notes-2.png
    maxres: 931 × 1656

fasting-duration:
  - src: fasting-duration-1.png
    maxres: 931 × 1656
  - src: fasting-duration-2.png
    maxres: 931 × 1656

ipad:
  - src: ipad-1.png
    maxres: 1536 × 2048
  - src: ipad-2.png
    maxres: 1536 × 2048

shortcuts:
  - src: shortcuts.jpg
    maxres: 585 × 736

---

Since Window was published back in May 2016, I've gotten a lot of great requests for new features from people who use the app every day. After a few months of hard work, I'm very excited to announce that Window 2.0 has been published on the App Store and is now available for download! It includes tons of great new features:

Weight Tracking

{% include photoswipe.html images=page.weight-tracking class='shadow' %}

Weight tracking was probably the single most-requested feature I've gotten over the past year, and a lot of thought went in to how to make it as useful as possible. Now you can view and log your weight right in Window! You can see a graph of your weight over time, including a seven-day moving average. You also have the option to show your window history as a line on the graph so you can understand how your use of Window is impacting your overall weight.

Window uses Apple Health to access and store your weights, so you can rest easy knowing your data is in safe hands. This also means that your weight data is shared with any other app that works with Apple Health. If you log your weight in another app or with a smart scale device, it will still appear in Window.

Window Notes

{% include photoswipe.html images=page.window-notes class='shadow' %}

You can now add notes to your windows (while they're open or even after they're closed). You have space to write about day, mention how you feel, or mark down what you ate for dinner. You can also attach pictures, which is the perfect way to document your eating habits. Window will save these notes with your windows forever so you can come back and reference them later.

View your Fasting Duration

{% include photoswipe.html images=page.fasting-duration class='shadow' %}

The second most common request I've gotten has been to add more functionality for people who prefer to view their "fast" instead of their "eating window". In the Window History screen, you now have the option to view your fasting duration. Window will automatically calculate the length of your daily fast by finding the time between the end of one eating window and the start of the next. You still track your daily eating window, but now you have the ability to see it from a different perspective.

iPad Support

{% include photoswipe.html images=page.ipad class='shadow' %}

Window also supports the iPad now, so you can finally use it on all of your devices! Every screen has been optimized for the larger screen, and it fits right in. None of the other major fast tracking apps support iPad at the time of writing, so it's exciting to open up the app to an entire new group of users for the first time! The iPad version doesn't support weight tracking for now, because Apple Health is unavailable on iPad devices. I may put out an update that works around this limitation in the future.

Home Screen 3D Touch Shortcuts

{% include photoswipe.html images=page.shortcuts class='shadow' max-height=300 %}

One last quick addition is support for Home Screen 3D Touch Shortcuts. Home screen shortcuts are a quick way to get to important parts of an app, and you can open them by force-touching on any app icon. Window now supports this feature, and includes four useful new shortcuts.

Feature Requests

All of these new features were requests from real users! If you have any more ideas or suggestions, you can [email me](/contact.html) and let me know!

Downloading Window

If you haven't downloaded Window, you can get it on the [App Store](https://itunes.apple.com/us/app/window-intermittent-fasting-tracker/id1112765909?mt=8) for iPhone or Pad.

{% include appstore.html link='https://itunes.apple.com/us/app/window-intermittent-fasting-tracker/id1112765909?mt=8' %}


text:
# Carbon Aware SDK

You can reduce the carbon footprint of your application by just running things
at different times and in different locations. That is because not all
electricity is produced in the same way. Most is produced through burning fossil
fuels, some is produced using cleaner sources like wind and solar.

When software does more when the electricity is clean and do less when the
electricity is dirty, or runs in a location where the energy is cleaner, we call
this **carbon aware software**.

The Carbon Aware SDK helps you build the carbon aware software solutions with
the intelligence to use the greenest energy sources. Run them at the greenest
time, or in the greenest locations, or both! Capture consistent telemetry and
report on your emissions reduction and make informed decisions.

With the Carbon Aware SDK you can build software that chooses to run when the
wind is blowing, enable systems to follow the sun, moving around the world to
where energy is the greenest, and create tools that give insights and help
software innovators to make greener software decisions. All of this helps reduce
carbon emissions.

# Getting Started Overview

Head on over to the [Getting Started Overview Guide](./docs/overview.md) to get up and running.

Get started on creating sustainable software innovation for a greener future
today!

## What is the Carbon Aware SDK?

At its core the Carbon Aware SDK is a WebApi and Command Line Interface (CLI) to
assist in building carbon aware software. The functionality across the CLI and
WebApi is identical by design.

### The WebApi

The WebApi is the preferred deployment within large organisations to centralise
management and increase control and auditability, especially in regulated
environments. It can be deployed as a container for easy management, and can be
deployed alongside an application within a cluster or separately.

![WebApi Screenshot](./images/screenshot_web_api.png)

### The CLI

The CLI tends to be handy for legacy integration and non-cloud deployments,
where a command-line can be used. This tends to be common with legacy DevOps
pipelines to drive deployment for integration testing where you can test your
deployment in the greenest location.

![WebApi Screenshot](./images/screenshot_cli.png)

## Who Is Using the Carbon Aware SDK?

The Carbon Aware SDK is being used by large and small companies around the
world. Some of the world’s biggest enterprises and software companies, through
to start-ups.

Machine Learning (ML) workloads are a great example of long running compute
intensive workloads, that often are also not time critical. By moving these
workloads to a different time, the carbon emissions from the ML training can be
reduced by up to 15%, and by moving the location of the training this can be
reduced even further, at times by up to 50% or more.

## What does the SDK/API provide that 3rd party data providers such as WattTime or ElectricityMaps do not?

Many of the benefits tend to relate to removing the tight coupling of an
application from the 3rd party data source it is using, and allow the
application to focus on the sustainability impact it is looking to drive. This
abstraction allows for changing of data providers, data provider aggregation,
centralised management, auditability and traceability, and more.

### Collaborative Effort

The Carbon Aware SDK is a collaborative effort between companies around the
world, with the intention of providing a platform that everyone can use. This
means the API will be striving towards what solves the highest impact issues
with diverse perspectives from these organisation and contributors.

### Standardization

Something we are driving with the Carbon Aware SDK is towards standardisation of
the interface into these data providers. This ultimately will help to drive SCI
calculations in the future, and also helps to drive innovation. The 3rd party
API’s do differ, and the results can vary in units, from lbCO2/kWh to gCO2/Wh.
The Carbon Aware SDK will take care of all conversions to a standardised
gCO2/kWh, which becomes increasingly valuable with aggregated data sources.

Standardisation also helps drive innovation. For example, if a 3rd party
develops tools to scale Kubernetes clusters based on emissions, they can build
against the Carbon Aware SDK. If you want to use this 3rd party tool, the SDK
allows the tool to plug in _your_ choice of data providers, not _their_ choice
of data provider. In this way the standardisation drives innovation and
flexibility of choice.

The intention is to have other compatible tooling and software that leverages
the Carbon Aware SDK to obtain emissions data, while being agnostic to the data
provider.

### Centralised secret and key management

The ability to manage keys to 3rd party API’s can be centralised with the Carbon
Aware API. This means that any changes to keys or rotation can be done in a
centralised and controlled manner without exposing the keys to application
development teams.

It also can be upgraded across all applications within an organisation when
centralised, with new data sources being added without consuming applications to
make any changes.

In addition, the need for the Carbon Aware SDK is something that has been
identified by some of the largest enterprises when looking to drive innovation
within their own organisations by centralising the capability within their
business, creating green software engineering practices and providing the API
internally across their organisation.

### Auditability

Due to the API being centralised, this gives you the ability to audit a
controlled environment for when decisions are made. With increasing regulatory
need, the ability to prove sustainability actions and impact will need to be
from highly trusted sources, and having centralised management provides this
capability.

### Aggregated Sources

A feature we have in the roadmap is the ability aggregate data sources across
multiple providers. Different data providers have different levels of
granularity depending on region, and it may be that data provider A is preferred
in Japan, while data provider B is preferred in US regions.

Similarly, you may have your own data for your data centres that you would
prefer to use for on premises workloads, which you can combine in aggregate with
3rd party data providers.

## Is it possible to retrieve energy mix information from the SDK?

Energy mix (the percentages that are from different energy soruces i.e. coal,
nuclear, wind, gas, solar, tidal, hydro etc) is not provided in the API to date.
This may be a feature we will consider in the future. The SDK provides emissions
percentage information only at the moment.

## Contributing

The Carbon Aware SDK is open for contribution! Want to contribute? Check out the
[contribution guide](./CONTRIBUTING.md).

## Green Software Foundation Project Summary

The Carbon Aware SDK is a project as part of the
[Green Software Foundation](https://greensoftware.foundation/) (GSF) and the GSF
Open Source Working Group.

### Appointments

- Chair/Project lead - Vaughan Knight (Microsoft)
- Vice Chair - Szymon Duchniewicz (Avanade)

### GSF Project Scope

For developers to build carbon aware software, there is a need for a unified
baseline to be implemented. The Carbon Aware Core SDK is a project to build a
common core, that is flexible, agnostic, and open, allowing software and systems
to build around carbon aware capabilities, and provide the information so those
systems themselves become carbon aware.

The Carbon Aware Core API will look to standardise and simplify carbon awareness
for developers through a unified API, command line interface, and modular
carbon-aware-logic plugin architecture.

branch_name: refs/heads/dev

gha_language: C#


text:
# elk-with-filebeat-by-docker-compose
![GitHub](https://img.shields.io/github/license/gnokoheat/elk-with-filebeat-by-docker-compose) ![GitHub last commit](https://img.shields.io/github/last-commit/gnokoheat/elk-with-filebeat-by-docker-compose)

ELK with Filebeat by Docker-compose - Simple & Easy way to file logging

## Work flow
- mylog -> filebeat -> logstash -> elasticsearch <- kibana

## Usage

### Make ELK with Filebeat
1. Docker & Docker-compose install (Ubuntu)
```
# Docker install
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $(whoami)
```
```
# Docker-compose install
sudo apt-get install docker-compose
```

2. Git clone this repository
```
git clone https://github.com/gnokoheat/elk-with-filebeat-by-docker-compose
cd elk-with-filebeat-by-docker-compose/
```

3. Set to making your log file into 'mylog' folder and change log index template.
- Filebeat can auto-detect to *.log file was made, updated and push it to logstash.
- Change your log index file of "logstash.template.json".

4. Docker-compose up command
```
docker-compose up -d
```

### Customize Config
- logstash.template.json : Change it to your log index
```
# Make your own log index
{
    ...
    "mappings": {
        "properties": {
            "name": {
                "type": "keyword"
            },
            "class": {
                "type": "keyword"
            },
            "state": {
                "type": "integer"
            },
            "@timestamp": {
                "type": "date"
            }
        }
    }
}
```
- logstash.conf
```
# Change 'timestamp' to your log custom timestamp key
filter {
  ...
  date{
    match => ["timestamp", "UNIX_MS"]
    target => "@timestamp"
  }
}
```
```
# Change 'time.localtime' to your location time
filter {
  ...
  ruby {
    code => "event.set('indexDay', event.get('[@timestamp]').time.localtime('+09:00').strftime('%Y%m%d'))"
  }
}
```


text:
![badmath](https://img.shields.io/badge/License-MIT-blue)

# E-commerce-Back-End

## Description
A back end only for shopping using dotenv, express, mysql2, and sequelize.

## Instructions
- Download the code
- install npm packages dotenv, express, mysql2, and sequelize.
- to seed type in "npm run seed"
- to run the program type in "node server" in the command line

link to demo video
https://drive.google.com/file/d/1awqlSfgVv72unxeHyl-CU0m5VxlLWrCd/view

repository: Menkoi/E-commerce-Back-End

repo_name: Menkoi/E-commerce-Back-End


text:
# Ranging, Monitoring and Scanning

<!-- TOC depthFrom:2 depthTo:3 withLinks:1 updateOnSave:1 orderedList:0 -->

- [Overview](#overview)
- [Monitoring and ranging](#monitoring-and-ranging)
	- [1. Define beacon regions](#1-define-beacon-regions)
	- [2. Create a Beacon Manager object](#2-create-a-beacon-manager-object)
	- [3. Connect to the beacon scanning service](#3-connect-to-the-beacon-scanning-service)
	- [4. Set monitoring and ranging listeners](#4-set-monitoring-and-ranging-listeners)
	- [5. Set scan periods](#5-set-scan-periods)
	- [6. Start monitoring/ranging](#6-start-monitoringranging)
- [Scanning](#scanning)
	- [Eddystone](#eddystone)
	- [Nearable](#nearable)
	- [Estimote Telemetry](#estimote-telemetry)
	- [Estimote Location](#estimote-location)

<!-- /TOC -->

## Overview

Estimote beacons and stickers are able to broadcast multiple packets: [iBeacon](http://developer.estimote.com/ibeacon/), [Eddystone](http://developer.estimote.com/eddystone/), [Nearable](http://developer.estimote.com/nearables/), Estimote Telemetry, and Estimote Location. Android SDK supports interacting with them in the following ways:

- **monitoring** and **ranging** for [iBeacon](http://developer.estimote.com/ibeacon/) packets advertised by beacons.
- **scanning** for [Eddystone](http://developer.estimote.com/eddystone/), Estimote Telemetry and Estimote Location packets advertised by beacons, and [Nearable](http://developer.estimote.com/nearables/) packets advertised by stickers.

## Monitoring and ranging

[Monitoring](http://developer.estimote.com/ibeacon/tutorial/part-2-background-monitoring/) can be thought of as a geofence: a virtual barrier, here defined by the range of beacon or a group of beacons. Going in and out of this range triggers events that application can react to.

[Ranging](http://developer.estimote.com/ibeacon/tutorial/part-3-ranging-beacons/) enables receiving more comprehensive beacon data: identifiers and proximity estimates of the beacons in range.

To use monitoring and ranging, follow these steps:

  1. Define beacon regions.
  2. Create a Beacon Manager object.
  3. Connect the Beacon Manager to the beacon scanning service maintained by the Estimote SDK.
  4. Set monitoring and ranging listeners.
  5. Set scan periods.
  6. Start monitoring/ranging for the regions defined earlier.

### 1. Define beacon regions

Beacon regions can be used to specify beacons or groups of beacons that should trigger a monitoring event or be included in the list of ranged devices. You can defined a region using beacon identifiers:

- **UUID** - most commonly represented as a String, e.g.: `"B9407F30-F5F8-466E-AFF9-25556B57FE6D"`
- **Major** - an unsigned short integer, (1–65535)
- **Minor** - an unsigned short integer, (1–65535)

You can find UUIDs, majors, and minors of your beacons in [Estimote Cloud](https://cloud.estimote.com).

Define a Region object like this:

```java
Region mintBeaconRegion = new Region("Mint beacon",
        UUID.fromString("B9407F30-F5F8-466E-AFF9-25556B57FE6D"), 24515, 28667);
```

You don't have to pass all three values—e.g., your region can be based on UUID only (skip other values by passing null):

```java
Region allBeaconsRegion = new Region("Beacons with default Estimote UUID",
        UUID.fromString("B9407F30-F5F8-466E-AFF9-25556B57FE6D"), null, null);
```

The available combinations are: UUID + major + minor, UUID + major, UUID alone, or none of it.

### 2. Create a Beacon Manager object

As you might need to reuse the Beacon Manager in many activities or fragments, it's a good practice to store an instance of it in your Application's subclass:

```java
public class MyApplication extends Application {

    private BeaconManager beaconManager;

    @Override
    public void onCreate() {
        super.onCreate();
        beaconManager = new BeaconManager(getApplicationContext());
    }
}
```

Make sure that you add your `Application` subclass to `AndroidManifest.xml`:

```xml
<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:supportsRtl="true"
    android:theme="@style/AppTheme"
    android:name=".MyApplication"> <!-- <=== here -->
```

### 3. Connect to the beacon scanning service

Once you create the Beacon Manager object, you need to connect it to the **beacon service** that is responsible for performing BLE scanning operations. You can simply do it by invoking the `connect` method. Pass a `ServiceReadyCallback` to receive information when mentioned service is ready to use.

```java
@Override
public void onCreate() {
    super.onCreate();
    beaconManager = new BeaconManager(getApplicationContext());
    beaconManager.connect(new BeaconManager.ServiceReadyCallback() {
        @Override
        public void onServiceReady() {
            // Ready to start scanning!
        }
    });
}
```

Make sure that the `beaconManager`'s connection scope is strictly related to the lifecycle of its encompassing application (or activity, or fragment).

### 4. Set monitoring and ranging listeners

Beacon Manager offers a variety of listeners that facilitate detecting beacons.

#### Monitoring listener

Monitoring listener enables you to subscribe to monitoring events, such as entering and exiting the range of beacons in a Region.

```java
beaconManager.setMonitoringListener(new BeaconManager.MonitoringListener() {
    @Override
    public void onEnteredRegion(Region region, List<Beacon> list) {
        // ...
    }

    @Override
    public void onExitedRegion(Region region) {
        // ...
    }
});
```

#### Ranging listener

Ranging listener enables you to subscribe to a continuous (by default: every second) stream of ranging events, which provides a detailed list of beacons detected in range, their full identifiers, and relative proximity to them. If a beacon goes out of range, it will disappear from the list.

```java
beaconManager.setRangingListener(new BeaconManager.RangingListener() {
    @Override
    public void onBeaconsDiscovered(Region region, List<Beacon> beacons) {
        if (beacons.size() != 0) {
            Beacon beacon = beacons.get(0);
            // ...
        }
    }
});
```

### 5. Set scan periods

To conserve the host device's battery, Estimote SDK doesn't continuously scan for beacons. Instead, it cycles between periods of scanning and waiting. You can adjust the duration of these two periods with two methods listed below. Bear in mind that these values are only a hint—the internal Bluetooth stack of the device might shorten or extend the scan period.

- **monitoring**: `setBackgroundScanPeriod(long scanPeriodMillis, long waitTimeMillis)`
- **ranging**: `setForegroundScanPeriod(long scanPeriodMillis, long waitTimeMillis)`

For example, to increase responsiveness of monitoring events, you may set the `scanPeriod` to 5 seconds and the `waitTime` to 10 seconds.

```java
beaconManager.setBackgroundScanPeriod(5000, 10000);
```

Just keep in mind that shortening the cycle can increase the battery drain.

If not sure what to do, leave these two methods out. The default values were picked carefully to provide a good balance between responsiveness and battery usage.

### 6. Start monitoring/ranging

Once you set monitoring and ranging listeners you can start monitoring and ranging using the regions you defined earlier.

```java
@Override
public void onCreate() {
    super.onCreate();
    beaconManager = new BeaconManager(getApplicationContext());
    beaconManager.setMonitoringListener(/* ... */);
    beaconManager.setRangingListener(/* ... */);
    // beaconManager.setBackgroundScanPeriod(5000, 10000);
    beaconManager.connect(new BeaconManager.ServiceReadyCallback() {
        @Override
        public void onServiceReady() {
            // Ready to start scanning!
            beaconManager.startMonitoring(allBeaconsRegion);
            // beaconManager.startRanging(defaultUUIDRegion);
        }
    });
}
```

#### Hint: ranging only when in range of beacons

Since ranging is much more energy-intensive than monitoring, it's a good practice to only do it when you know (thanks to monitoring) that you're in range of some beacons:

```java
private void setMonitoringListener() {
    beaconManager.setMonitoringListener(new BeaconManager.MonitoringListener() {
        @Override
        public void onEnteredRegion(Region region, List<Beacon> list) {
            beaconManager.startRanging(region);
        }

        @Override
        public void onExitedRegion(Region region) {
            beaconManager.stopRanging(region);
        }
    });
}
```

####  Dealing with many onExit/onEnter events

Accuracy of monitoring mostly depends on device's hardware and low level bluetooth stack implementation. Because of that, monitoring sometimes calls many onExit/onEnter events millis apart. There is no golden rule which applies to every Android device, so you need to tweak this by yourself - but don't worry, our SDK provides you with tools for doing that.
First of all, you need to know, that beacon advertising interval is also affecting user experience. Setting your beacon to `200ms-300ms` interval is the best practice. Greater values might cause user phone to be less effective while scanning.
On SDK side, you can tweak your background scan interval and wait period. The shorter they are, the more accurate scaning will be. Keep in mind, that short interval increases battery drain.
Our internal engine tracks each beacon occurance, applies smoothing algorithms and does a lot of job to provide you with the best result possible. Unfortunately, we are not responsible for scan results returned by low-level bluetooth stack. We tested that on many devices, and some returns proper scan values, and some returns scans with large delay. To deal with that, we encourage you to play with public method `setRegionExitExpiration(long period)` in BeaconManager class. In that way, once visible beacon must not be seen for more then `long period` time. Bear in mind, that this will affect accuracy of onExit region event. For your information, our SDK default value for region expiration is set to `20s`.

## Scanning

Android SDK supports scanning for devices that broadcast [Eddystone](http://developer.estimote.com/eddystone/), Estimote Telemetry, Estimote Location, and [Nearable](http://developer.estimote.com/nearables/) packets.

Since scanning is similar in nature to ranging, it uses the `setForegroundScanPeriod` settings.

### Eddystone

[Eddystone](http://developer.estimote.com/eddystone/) is an open Bluetooth 4.0 protocol from Google that is designed to support multiple data packet types such as **Eddystone-UID** or **Eddystone-URL**. Estimote Beacons are fully compatible with Eddystone.

To start scanning for [Eddystone](http://developer.estimote.com/eddystone/) packets:

-   Set an `EddystoneListener`:

    ```java
    beaconManager.setEddystoneListener(new BeaconManager.EddystoneListener() {
        @Override
        public void onEddystonesFound(List<Eddystone> eddystones) {
            // ...
        }
    });
    ```

-   Start scanning for Eddystone devices. Make sure that you store the `scanId` value—you will need it later to stop scanning:

    ```java
    public class MyActivity extends Activity {

        private BeaconManager beaconManager;
        private String scanId;

        @Override
        protected void onCreate() {
            super.onCreate();
            beaconManager = new BeaconManager(this);
            beaconManager.setEddystoneListener(/* ... */);
        }

        @Override
        protected void onStart() {
            super.onStart();
            beaconManager.connect(new BeaconManager.ServiceReadyCallback() {
                @Override
                public void onServiceReady() {
                    scanId = beaconManager.startEddystoneScanning();
                }
            });
        }

        @Override
        protected void onStop() {
            super.onStop();
            beaconManager.stopEddystoneScanning(scanId);
        }
    }
    ```

### Nearable

[Nearable](http://developer.estimote.com/nearables/) is the main advertising packet of Estimote Stickers. Apart from the sticker's 16-byte identifier, it includes sensor data (motion, temperature) and sticker's health data (battery voltage, firmware version).

To start scanning for [Nearables](http://developer.estimote.com/nearables/):

-   Set a `NearableListener`:

    ```java
    beaconManager.setNearableListener(new BeaconManager.NearableListener() {
        @Override
        public void onNearablesDiscovered(List<Nearable> nearables) {
            // ...
        }
    });
    ```

-   Start scanning for Nearable devices. Make sure that you store the `scanId` value—you will need it later to stop scanning:

    ```java
    public class MyActivity extends Activity {

        private BeaconManager beaconManager;
        private String scanId;

        @Override
        protected void onCreate() {
            super.onCreate();
            beaconManager = new BeaconManager(this);
            beaconManager.setNearableListener(/* ... */);
        }

        @Override
        protected void onStart() {
            super.onStart();
            beaconManager.connect(new BeaconManager.ServiceReadyCallback() {
                @Override
                public void onServiceReady() {
                    scanId = beaconManager.startNearableDiscovery();
                }
            });
        }

        @Override
        protected void onStop() {
            super.onStop();
            beaconManager.stopNearableDiscovery(scanId);
        }
    }
    ```

### Estimote Telemetry

To start scanning for Estimote Telemetry packets:

-   Set a `TelemetryListener`:

    ```java
    beaconManager.setTelemetryListener(new BeaconManager.TelemetryListener() {
        @Override
        public void onTelemetriesFound(List<EstimoteTelemetry> telemetries) {
            // ...
        }
    });
    ```

-   Start scanning for Estimote Telemetry packets. Make sure that you store the `scanId` value—you will need it later to stop scanning:

```java
public class MyActivity extends Activity {

    private BeaconManager beaconManager;
    private String scanId;

    @Override
    protected void onCreate() {
        super.onCreate();
        beaconManager = new BeaconManager(this);
        beaconManager.setTelemetryListener(/* ... */);
    }

    @Override
    protected void onStart() {
        super.onStart();
        beaconManager.connect(new BeaconManager.ServiceReadyCallback() {
            @Override
            public void onServiceReady() {
                scanId = beaconManager.startTelemetryDiscovery();
            }
        });
    }

    @Override
    protected void onStop() {
        super.onStop();
        beaconManager.stopTelemetryDiscovery(scanId);
    }
}
```

### Estimote Location

To start scanning for Estimote Location packets:

-   Set a `LocationListener`:

    ```java
    beaconManager.setLocationListener(new BeaconManager.LocationListener() {
        @Override
        public void onLocationsFound(List<EstimoteLocation> locations) {
            // ...
        }
    });
    ```

-   Start scanning for Estimote Location packets. Make sure that you store the `scanId` value—you will need it later to stop scanning:

    ```java
    public class MyActivity extends Activity {

        private BeaconManager beaconManager;
        private String scanId;

        @Override
        protected void onCreate() {
            super.onCreate();
            beaconManager = new BeaconManager(this);
            beaconManager.setLocationListener(/* ... */);
        }

        @Override
        protected void onStart() {
            super.onStart();
            beaconManager.connect(new BeaconManager.ServiceReadyCallback() {
                @Override
                public void onServiceReady() {
                    scanId = beaconManager.startLocationDiscovery();
                }
            });
        }

        @Override
        protected void onStop() {
            super.onStop();
            beaconManager.stopLocationDiscovery(scanId);
        }
    }
    ```

repository: DanielRooks/AdrenaLan

repo_name: DanielRooks/AdrenaLan


text:
---
layout: "unit"
title: "Guide Entry 00.05.09"
path: "/curriculum/guides/2000/5/00.05.09.x.html"
unitTitle: "Sounding Off About Trig"
unitAuthor: "Andrea Sorrells"
keywords: ""
recommendedFor: "Recommended for Algebra II, Trigonometry, and Physics, grades 9-12."
---

Guide Entry to 00.05.09:

The unit, "Sounding Off About Trig," takes the overarching theme of sound and applies it to various aspects of algebra and trigonometry.  While the unit is designed to supplement a Pre-Calculus textbook, there are parts that may be adaptable to an Algebra II/Trigonometry class.  I have created short activities that can be applied in different places of the curriculum.  This enables teachers to either use individual activities of this project to enrich a concept or they can use all the activities as a cohesive unit.

Because most students learn best when they can put their hands around what they are learning, the activities are very "hands-on." In one activity students are asked to create a musical octave using bottles.  All the activities ask students to use technology or musical instruments. The activities deal with concepts of sine waves including phase shift, amplitude, period, and addition of ordinates.  In addition, sound concepts such as frequency, wavelength, and Helmhotlz resonators will also be addressed.  In any given activity, both sound and math objectives will be addressed.  Thus, "Sounding Off About Trig" asks students to integrate their knowledge of mathematical skills with their understanding of sound.

(Recommended for Algebra II, Trigonometry, and Physics, grades 9-12.)


text:
# Beancount DKB Importer

[![image](https://github.com/siddhantgoel/beancount-dkb/workflows/beancount-dkb/badge.svg)](https://github.com/siddhantgoel/beancount-dkb/workflows/beancount-dkb/badge.svg)

[![image](https://img.shields.io/pypi/v/beancount-dkb.svg)](https://pypi.python.org/pypi/beancount-dkb)

[![image](https://img.shields.io/pypi/pyversions/beancount-dkb.svg)](https://pypi.python.org/pypi/beancount-dkb)

[![image](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

`beancount-dkb` provides an Importer for converting CSV exports of [DKB]
(Deutsche Kreditbank) account summaries to the [Beancount] format.

## Installation

```sh
$ pip install beancount-dkb
```

In case you prefer installing from the Github repository, please note that
`main` is the development branch so `stable` is what you should be installing
from.

## Usage

If you're not familiar with how to import external data into Beancount, please
read [this guide] first.

Adjust your [config file] to include `ECImporter` and `CreditImporter`
(depending on what account you're trying to import).

A sample configuration might look like the following:

```python
from beancount_dkb import ECImporter, CreditImporter

IBAN_NUMBER = 'DE99 9999 9999 9999 9999 99' # your real IBAN number

CARD_NUMBER = '9999 9999 9999 9999'         # your real Credit Card number

CONFIG = [
    ECImporter(
        IBAN_NUMBER,
        'Assets:DKB:EC',
        currency='EUR',
        file_encoding='utf-8',
    ),

    CreditImporter(
        CARD_NUMBER,
        'Assets:DKB:Credit',
        currency='EUR',
        file_encoding='utf-8',
    )
]
```

Once this is in place, you should be able to run `bean-extract` on the command
line to extract the transactions and pipe all of them into your Beancount file.

```sh
$ bean-extract /path/to/config.py transaction.csv >> you.beancount
```

### Transaction Codes as Meta Tags

By default, the ECImporter prepends the transaction code ("Buchungstext") to the
transaction description. To achieve shorter descriptions and use meta tags to
query for certain transaction codes, the importer may be configured to store the
transaction code in a user provided meta tag.

The following configuration instructs the importer to use a meta tag `code` to
store transaction codes:

```python
...
CONFIG = [
    ECImporter(
        IBAN_NUMBER,
        'Assets:DKB:EC',
        currency='EUR',
        meta_code='code',
    ),
...

```

This is how an example transaction looks without the option:

```beancount
2021-03-01 * "Kartenzahlung" "XY Supermarket"
    Assets:DKB:EC                        -133.72 EUR
```

And this is the resulting transaction using `meta_code='code'`

```beancount
2021-03-01 * "XY Supermarket"
    code: Kartenzahlung
    Assets:DKB:EC                        -133.72 EUR
```

### Pattern-matching Transactions

It's possible to give the importer classes hints if you'd like them to include a
second posting based on specific characteristics of the original transaction.

For instance, if the payee or the description in a transaction always matches a
certain value, it's possible to tell the `ECImporter` or `CreditImporter` to
automatically place a second posting in the returned lits of transactions.

#### `ECImporter`

`ECImporter` accepts a `payee_patterns` argument, which should be a list of
`(pattern, account)` tuples.

```python
CONFIG = [
    ECImporter(
        IBAN_NUMBER,
        'Assets:DKB:EC',
        currency='EUR',
        file_encoding='utf-8',
        payee_patterns=[
            ('REWE Filialen', 'Expenses:Supermarket:REWE'),
            ('NETFLIX', 'Expenses:Online:Netflix'),
        ],
    ),
```

#### `CreditImporter`

`CreditImporter` accepts a `description_patterns` argument, which should be a
list of `(pattern, account)` tuples.

```python
CONFIG = [
    CreditImporter(
        CARD_NUMBER,
        'Assets:DKB:Credit',
        currency='EUR',
        file_encoding='utf-8',
        description_patterns=[
            ('REWE sagt Danke', 'Expenses:Supermarket:REWE'),
            ('NETFLIX', 'Expenses:Online:Netflix'),
        ],
    )
```

## FAQ

```sh
ERROR:root:Importer beancount_dkb.ec.ECImporter.identify() raised an unexpected error: 'utf-8' codec can't decode byte 0xf6 in position 17: invalid start byte
```

Change the `file_encoding` parameter. It seems like the CSV
exports are `ISO-8859-1` encoded, but `utf-8`
seems like a useful default.

## Contributing

Contributions are most welcome!

Please make sure you have Python 3.6+ and [Poetry] installed.

1. Clone the repository: `git clone https://github.com/siddhantgoel/beancount-dkb`
2. Install the packages required for development: `poetry install`
3. That's basically it. You should now be able to run the test suite: `poetry run py.test`.

[Beancount]: http://furius.ca/beancount/
[config file]: https://beancount.github.io/docs/importing_external_data.html#configuration
[DKB]: https://www.dkb.de
[Poetry]: https://python-poetry.org/
[this guide]: https://beancount.github.io/docs/importing_external_data.html

repository: siddhantgoel/beancount-dkb

gha_language: Python

repo_name: siddhantgoel/beancount-dkb


text:
---
layout: default
---

# 1996-01-16 - Re: Respect for privacy != Re: exposure=deterence?

## Header Data

From: jim bell<EMAIL_ADDRESS>To: Rich Graves<EMAIL_ADDRESS>Message Hash: fd9faec6a3896644a8e0c51398af0573f46b751d574889ee892bd4c4983bfb9e

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-01-16 08:52:09 UTC

Raw Date: Tue, 16 Jan 1996 16:52:09 +0800

## Raw message

```
{% raw  %}From: jim bell<EMAIL_ADDRESS>Date: Tue, 16 Jan 1996 16:52:09 +0800
To: Rich Graves<EMAIL_ADDRESS>Subject: Re: Respect for privacy != Re: exposure=deterence?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

At 12:27 AM 1/15/96 -0800, Rich Graves wrote:
>On Sun, 14 Jan 1996, jim bell wrote:
Richard Graves wrote:

>However, you won't consider looking at a dissenting FAQ.

Aha! Now you identify it as a "dissenting FAQ"!  Let's play a little game.
Let's say, for purposes of the argument, that there are people who are
"pro-libertarian," "neutral", and "anti-libertarian."  I know plenty of
people who hardly even know what libertarianism is about, but in fact are
more-or-less libertarian in philosophy.  Let's call these people "neutral."

Somehow, I think I've got you pegged correctly.

>> "Proposition 187"?  Isn't that from CALIFORNIA, not Pennsylvania?  Your
>> commentary is very confusing.
>
>Sorry, an old irrelevant battle.

Then don't confuse people with things like that!

>There was quite a row between Californian "libertarians" and
>non-Californian "libertarians" about Prop 187, with those in California
>saying that the illegal people were STEALING MONEY, and those outside the
>state, including Reason Magazine, saying it was hypocritical at best to
>use government force to deny freedom of movement, especially when neutral
>studies showed that the illegal people were a net plus for society. In
>effect, Reason Magazine was calling them selfish.

You miss the point.  (this is probably congenital.)

There is a generic problem with "asking a libertarian his position on an
issue."  See, the question assumes how much of an opinion you want, and what
assumptions you're making.

I'll try to formulate a relevant analogy:  Suppose  you're building a new
house, you have your plans, I'm your friend, and you ask me over for an
opinion on how it ought to be done.  On the one hand, my advice might simply
be to "change the color of the paint."   Or, I could say something more
detailed, like, "you should add another floor."  Or, finally, I could say,
"I don't think you should be building a house THERE, in that low area
subject to flooding, you should build it 10 feet higher, 100 yards away."
Finally, I could say, "No, I don't think you should build that house AT ALL."

Each of these is a form of advice.  The difference is the scope of the
advice.  __YOU__ may only have wanted me to advise you on the color of the
paint.  My advice was to change EVERYTHING.  Both may be quite valid and
correct opinions.

A third party, observing the discussion, would think that there was some
sort of contradiction going on, when in reality (remember reality?!?) it is
simply a matter of scope being determined.

Now, proposition 187, as I _vaguely_ recall, deals with immigrants,
primarily illegal immigrants, and the services a community provides them.
So if you ask a libertarian, "what should we do," there are a number of
separate and distinct types of advise he could give you, depending on the
scope of the question.

On the one hand, the natural response of an unrestrained libertarian is to
say, "There should be no borders, no governments, no taxes, and no welfare,
as well as no public schools, etc."   And that would be correct, as far as
it went.

If you responded to that libertarian, "Uh, sorry, we're not interested in
changing EVERYTHING; we're just asking you to decide whether or not we
should get public services (paid for by tax dollars stolen from citizens by
government) to people who got into the country in violation of the law,"
then he might provide a more limited form of advice based on this
restrictive set of parameters.

The important thing to remember, however, is that exactly which kind of
advice he gives may be entirely dependent on how restrictive the set of
parameters you've insisted that he follow.  An intelligent libertarian could
give a good and valid piece of advise, with the proviso that since he's
being restricted in the scope of his advice, it will not necessarily be a
"completely libertarian" position.  This should be ASSUMED.

Which means that you could ask essentially the same question of two
different libertarians, and by subtle manipulation of the parameters, get
what might otherwise appear to be two contradictory opinions, depending on
how much latitude each is given in his advice.

>Obviously, I was on the right side.

Obviously, you always THINK you are on the right side.

>
>> >Where, exactly, do you get off disparaging my political philosophy, with
>> >which you are completely unfamiliar?
>> >
>> >> >See the non-libertarian
>> >> >FAQ, at http://world.std.com/~mhuben/libindex.html
>> >>
>> >> Sounds like it would be extraordinarily un-interesting.
>> >
>> >Good to see you're as open-minded as I thought.
>>
>> Well, you called it, and I quote, a "non-libertarian FAQ."   Well, I know
>> what a "libertarian FAQ" would generally contain, information to teach the
>> uninformed about libertarianism. These FAQs are generally prepared by
>> libertarians, and are often (usually?) intended to convince people to
>> support the libertarian cause.
>>
>> But what, pray tell, is a "non-libertarian FAQ"?
>
>Information to teach the uninformed about libertarianism.

Then you should have called it a "FAQ _for_ pre-libertarians."   Or a "FAQ
for those not yet informed about libertarianism."

But in fact, since above you called it a "dissenting FAQ," more likely, "a
FAQ intended to dissuade people from being (or thinking) in a libertarian
manner."  Far more informative.  Which is why I said that I would consider
it to be extraordinarily UN-interesting.

>> And thus, as I said, I think that would be extraordinarily un-interesting.
>> I've heard PLENTY of idiots try to debunk libertarian philosophy, the vast
>> majority of which know so little about it as to make their attempt not only
>> totally ineffective, but also counter-productive to their intention.
>
>How many is plenty?

In 4 years on FIDOnet?  Dozens.

>> >I see no sequitur here. Where have I excused anyone's actions? I was
>> >talking about ethics, justifiable force,
>>
>> Libertarians have a principle called "Non-initiation of Force/Fraud." (or
>> "Non-Agression principle.")  Anyone who collects taxes has AUTOMATICALLY
>> initated agression.  Violence against him is not a violation of any
>> libertarian principle.
>
>Libertarians have a practice of USING CAPITAL LETTERS and RIDICULOUS JESSE
>JACKSON-ESQUE RHETORIC to define anything they DISAGREE WITH as VIOLENCE
>AND FRAUD, a non-falsifiable approach that leads to ludicrous conclusions.

 If you have
>> >probable cause that Watergate or Whitewater has occurred, then further
>> >investigation is justified. If you don't, then the customary financial
>> >disclosure statements should do.
>>
>> You're hiding behind the rules of the GOVERNMENT.  Rules written for the
>> benefit of GOVERNMENT people.  Violations of law by GOVERNMENT people are
>> hardly ever prosecuted; Rodney King's assaulters were prosecuted only
>> because somebody JUST HAPPENED to have a camcorder on at "just the right
>> time."
>
>> >Eternal vigilance is the price of liberty, but that doesn't mean you need
>> >to spy on everybody.
>>
>> When my system is in place, we won't have to worry about that ever again.
>...
>> >No matter what rhetoric you use, it is not nice to respond to a tax
>> ----------------------------------------^^^^^^^^
>>
>> >collector COMING TO STEAL YOUR MONEY by invading his privacy.
>>
>> Huh?  You're crazier than I thought!  You would deny even the principle of
>> self-defense!    No wonder you had so many questions
>> above!   "Nice" has NOTHING to do with it!
>
>A restaurant denying you a free lunch is the initiation of violence.

Do you really believe this, or were you merely trying to misuse this as a
contrary (though extremely weak) example?

> If
>you try to skip a debt

What kind of "debt"?

Your misunderstanding of libertarianism exceeds only your misunderstanding
of simple logic.

>Measured response and justifiable force. Contracts and justice. When your
>kid misbehaves, you spank them. When someone cuts you off on the freeway,
>you flip them off. When you disagree with someone, you are supposed to
>construct a logical counterargument.   The IRS is enforcing a contract.

I've signed no such "contract."  I agreed to no such contract.  I'm AWARE of
no such contract.  The "contract" or "social contract" argument is debunked
repeatedly in the various libertarian-oriented political echoes.  Actually,
it's debunked in non- (not to be confused with "anti-") libertarian echoes
too, because even if you ignore all the people who don't yet claim
themselves to be libertarians, the rest of the public can't agree on exactly
what this "contract" really says.

The "social contract" of a liberal contradicts the "social contract" of the
conservative.  The "social contract" of a Republican contradicts the "social
contract" of a Democrat.

Even if you take a generous position and say that we owe taxes, it has been
repeatedly demonstrated by media/reporter types (by visiting a number of IRS
offices, presenting them with the same identical numbers, and asking them
how much taxes are owed, and each office gives a DIFFERENT amount.  In other
words, even if we ASSUME the existence of some sort of "contract," nobody
seems to be able to agree on what the terms of that "contract" are.

Now, I'm not a lawyer, and I don't even play one on TV, but one thing that I
do know about law is that for there to be a "contract" there is necessary to
be a "meeting of the minds" about what that contract is actually for.  Both
(all?) parties to the contract must have the same UNDERSTANDING of the terms
of the contract in order for it to be valid.  Clearly that is not the case
about the "social contract" statist lunatics speak of.

Furthermore, in order for there to be a valid "contract" there must be
CONSENT.  One party cannot threaten or extort from the other, getting the
other party to agree to terms that are coercive. Both parties must have the
option of NOT entering into that "contract."  Yet, practically the whole
reason for the existence of governments is "coercion," meaning that absent
some clear evidence of arms-length negotiation, it is impossible to come to
a valid "contract" with the government.

     I'm working on a similar system.  You'll
>> eventually hear of it.
>
>You're building a giant robot? Oh my. I thought this was starting to read
>like bad science fiction.

Just wait.

I've decided to post this to Cypherpunks.  Forgive me, it's only marginally
on-topic, but I think it's vital for the public to know how Richard Graves
thinks.

{% endraw %}
```

## Thread

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

+ Return to "[jim bell <jimbell@pacifier.com>](/authors/jim_bell_jimbell_at_pacifier_com_)"
+ Return to "[Rich Graves <llurch@networking.stanford.edu>](/authors/rich_graves_llurch_at_networking_stanford_edu_)"

+ 1996-01-16 (Tue, 16 Jan 1996 16:52:09 +0800) - Re: Respect for privacy != Re: exposure=deterence? - _jim bell<EMAIL_ADDRESS>  + 1996-01-16 (Tue, 16 Jan 1996 17:01:50 +0800) - [[NOISE] Re: Respect for privacy != Re: exposure=deterence?](/archive/1996/01/4361e63470746818834696e248db4d3fb00e070a3a38d841afab350acb6ec6bf) - _Rich Graves<EMAIL_ADDRESS>


text:
MediaScape BBC Radio Discovery Extensions
===

This Chrome Extension looks for "Now Playing" links on BBC Radio sites and replace with mediascape attributes, allowing you to pay the streams on a mediascape device.

For detailed installation of all components see [discovery-audio-stream-controller](https://github.com/mediascape/discovery-audio-stream-controller/blob/master/INSTALL.md).

Web page authors can indicate that they have playable streams by adding the `mediascape-playable-stream` attribute to a DOM element within their pages. When clicked, that DOM element will display a list of available devices on the local network. Selecting a device from the list will start the stream playing on the remote device.

repository: mediascape/discovery-bbc-radio

repo_name: mediascape/discovery-bbc-radio


text:
# simplebuild-moduledoc

Autogenerate README files for simplebuild modules.

[Simplebuild](https://github.com/jamesshore/simplebuild) is a specification for universal JavaScript task automation. This module has tasks to help you generate README files and (eventually) other documentation. It takes advantage of standard Simplebuild descriptors so you don't have to repeat yourself.

This README is an example of the output of this tool. It was generated from the descriptors in [messages.js](./src/messages.js).

## Installation

This is a Node.js library. Install Node, then:

`npm install simplebuild-moduledoc` (add `--save` or `--save-dev` if you want)

## Usage

This library exports this API:

* `createReadme`: Create a README file for a Simplebuild module.

### `createReadme(options, success, failure)`

Create a README file for a Simplebuild module. The text of the README is generated from the module's task descriptors.

* `options`: an object containing the following properties:
    * `output`: Name of file to write README to. Defaults to `./README.md`.
    * `module`: The module to document. Must be a simplebuild module with task descriptors.
    * `descriptors`: Module descriptors: name, summary, description, and copyright. `name` is the npm name of the module. `summary` is a one-sentence description of the module. `description` is a paragraph describing the module that picks up where `summary` leaves off. `copyright` is the copyright; e.g., 'Copyright (c) 2014 James Shore.'

* `success()`: called if `createReadme` finishes successfully.

* `failure(message)`: called if `createReadme` doesn't finish successfully. Detailed error messages (if any) are written to stdout and a summary error message is provided in the `message` parameter.

## About Simplebuild

This library is a simplebuild module. In addition to being used as a standalone library (as described above), it can also be used with simplebuild extensions and mappers. For more information about simplebuild, see [the Simplebuild GitHub page](https://github.com/jamesshore/simplebuild).

## License

The MIT License (MIT)

Copyright (c) 2014 James Shore

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

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

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

repository: jamesshore/simplebuild-moduledoc

repo_name: jamesshore/simplebuild-moduledoc


text:
# SquareConnect.LoyaltyAccountMapping

### Description
**Note: This model is in beta.**

Associates a loyalty account with the buyer's phone number. For more information, see  [Loyalty Overview](/docs/loyalty/overview).

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**id** | **String** | The Square-assigned ID of the mapping. | [optional]
**type** | **String** | The type of mapping. See [LoyaltyAccountMappingType](#type-loyaltyaccountmappingtype) for possible values |
**value** | **String** | The phone number, in E.164 format. For example, \"+14155551111\". |
**created_at** | **String** | The timestamp when the mapping was created, in RFC 3339 format. | [optional]

repository: square/connect-nodejs-sdk

repo_name: square/connect-nodejs-sdk


text:
# Create scalable react apps without configuration ⚙

# Instalation 👷♀

    npm install scalable-react -g

# Usage 👨🚀

## Create a new page 📕

At the moment you need to create 2 files with same name to create a new page:

- .html in public folder
- .js in scr/react/pages folder

## Scripts 🧰

**You have 3 scripts, one for initial configuration one for production and other for development:**

**Init**

Execute

    scalable-react init

**Develop** 🤖

You need the filename in **src/react/pages**

    npm run dev nameOfFile

**Build** 🔨

    npm run build

### This command doesn't need configuration, just execute.

repository: Ulisessg/scalable-react

repo_name: Ulisessg/scalable-react


text:
# Simulation code description
Simulations codes for IEEE Transactions on Cybernetics paper ID CYB-E-2020-09-2426

These scripts should be implemented in Matlab 2018b or later

If you want to reproduce the results in the manuscript, please run
1) case_one_with_different_control_schemes.m for case I
2) case_two_with_different_settling_time_T.m for case II
3) case_three_different_accuracy.m for case III.

If you have any problem on the implementatin of these codes, please feel free to contact me at<EMAIL_ADDRESS>

repository: xiaogaogaoxiao/Euler-Lagrange

repo_name: xiaogaogaoxiao/Euler-Lagrange


text:
# K3D

## Prerequisites

## Setup

When the cluster is just created:
- applications can be installed right away
- it can take 10 mins before you can access them through the browser while the nginx ingress and cert manager come up.

## Stopping the cluster

```
PROVIDER=k3d make stop
```

## Starting the cluster

```
PROVIDER=k3d make start
```


text:
Migrating
=========

Use this document to help you transition away from deprecated code.

## Switching from AbstractCommand to CommandInterface

Version 2.0.0 simplifies the `CommandInterface` and adds an `OptionsInterface`.
Combined, these two interfaces represent the fundamental requirements of a
command system that is flexible and can be used in modern and legacy environments.

### Creating an Options Value Object

All options must implement `OptionsInterface`.

Options must validate the values passed during construction. If you are using an
array to hydrate the options, the `OptionsRequiredTrait` will help you validate
requirements. Type checking should also be done when suitable.

```php
use Equip\Command\OptionsInterface;
use Equip\Command\OptionsRequiredTrait;

class LoginOptions implements OptionsInterface
{
    use OptionsRequiredTrait;

    private $email;
    private $password;

    public function __construct(array $options)
    {
        $this->checkRequired($options, [
            'email',
            'password',
        ]);

        $this->email = $options['email'];
        $this->password = $options['password'];
    }

    public function email()
    {
        return $this->email;
    }

    public function password()
    {
        return $this->password;
    }
}
```

### Creating a Command

All commands must implement the `CommandInterface` instead of `AbstractCommand`.

Commands should be immutable and return a copy when `withOptions()` is called.
The `CommandImmutableOptionsTrait` can provide this functionality.

```php
use Equip\Command\CommandInterface;
use Equip\Command\CommandImmutableOptionsTrait;

class LoginCommand implements CommandInterface
{
    use CommandImmutableOptionsTrait;

    /**
     * @var LoginOptions
     */
    private $options;

    public function withOptions(LoginOptions $options)
    {
        return $this->copyWithOptions($options);
    }

    /**
     * @return object
     */
    public function execute()
    {
        $user = $this->getUser($this->options->email());

        $this->checkCredentials($user, $this->options->password());

        return $user;
    }
}
```

### Executing a Command

```php
$options = new LoginOptions([
    'email' =><EMAIL_ADDRESS>    'password' => 'very secret',
]);

$command = new LoginCommand();
$command = $command->withOptions($options);

$user = $command->execute();
```

repository: equip/command

gha_language: PHP

repo_name: equip/command


text:
# NFC_F91W
This is a mod for the Casio F91-W to include a 125kHz NFC chip, specifically the rewritable [ATA5577](https://ww1.microchip.com/downloads/en/DeviceDoc/ATA5577C-Read-Write-LF-RFID-IDIC-100-to-150-kHz-Data-Sheet-DS70005357B.pdf). The goal of this was to create a working tag that would fit in the watch with no modification to the outer case and water resistance.

## Specifications:
* 125kHz Frequency NFC using the [ATA5577](https://ww1.microchip.com/downloads/en/DeviceDoc/ATA5577C-Read-Write-LF-RFID-IDIC-100-to-150-kHz-Data-Sheet-DS70005357B.pdf)
* PCB Dimensions:
  *  15mm width
  *  3.1mm length
  *  0.3mm height
* Assembled Height: ~3.5mm
* Read range: ~25mm (Rough Estimate)

## BOM:
* [ATA5577](https://www.digikey.com/en/products/detail/microchip-technology/ATA5577M233SC-DBQ/4966011)
* [4308RV](https://www.coilcraft.com/en-us/products/rf/rfid-transponders/x-y-axis-transponder-coil/4308rv/4308rv-495/)

## Build Details:
In order to make an antenna for this frequency the major issue I faced was that a planar antenna in a PCB would not fit in the casing for the required inductance of 4.9125 millihenrys. To rememdy this a [4308RV](https://www.coilcraft.com/getmedia/7bd70c9a-8fab-45b6-b44a-96b8e1c407c6/4308rv.pdf) transponder coil was used. The PCB was designed to fit in the watch module above the LCD display on the two upper pegs that hold the LCD PCB in. In order to make space for the antenna a rectangular hole must be filed into the module housing. This mod will not be visible on the outside and the antenna sits flush with the housing so there should be no issues with the reading angle of the watch face changing.

The PCB was designed in [KiCad](https://gitlab.com/kicad/code/kicad) and calculations for the required inductance were made using the following [reference](https://ww1.microchip.com/downloads/en/AppNotes/00710c.pdf) (This can be generalized to other frequencies).

The PCB is difficult to manufacture and solder. Soldering these will require a stencil and hot air station for the small traces of the ATA5577. My success rate, soldering with a hot air station and stencil, is 75% having only soldered four tags.