text:
# jQuery Easter Egg [![Build Status](https://img.shields.io/travis/unindented/jquery-easteregg.svg)](http://travis-ci.org/unindented/jquery-easteregg) ![Abandoned](https://img.shields.io/badge/status-abandoned-red.svg)

Do you remember those cheats and easter eggs that you used to trigger on your NES and GameBoy games by pressing a certain sequence of buttons? Now you can add them to your pages with this tiny jQuery plugin!

## Demo

Go to <https://unindented.github.com/jquery-easteregg/> and try pressing the following sequence of keys:

↑↑↓↓←→←→BA

## Usage

If you already have jQuery on your site, then it's just a matter of downloading this plugin and loading it into your page. Then just call the `easteregg` method on any element you want, providing a callback (`callback` property) and the sequence of keys that will trigger it (`sequence` property):

```html
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title>jQuery Easter Egg</title>
  </head>
  <body>
    <script src="jquery.min.js"></script>
    <script src="jquery.easteregg.min.js"></script>
    <script>
      $(function () {
        $(document).easteregg({
          sequence : [38, 38, 40, 40, 37, 39, 37, 39, 66, 65]
        , callback : function () {
            alert('Pizza time!');
          }
        });
      });
    </script>
  </body>
</html>
```

If no `sequence` is provided, the [Konami Code](http://en.wikipedia.org/wiki/Konami_Code) sequence will be used (↑↑↓↓←→←→BA).

## Meta

* Code: `git clone git://github.com/unindented/jquery-easteregg.git`
* Home: <https://unindented.github.com/jquery-easteregg/>

## Contributors

* Daniel Perez Alvarez ([unindented@gmail.com](mailto:unindented@gmail.com))

## License

Copyright (c) 2012 Daniel Perez Alvarez ([unindented.org](https://unindented.org/)). This is free software, and may be redistributed under the terms specified in the LICENSE file.

repository: unindented/jquery-easteregg

repo_name: unindented/jquery-easteregg


text:
# Quiz: Modifying Data With SQL: Updating Data in a Database Review (5 Questions)
## Python Techdegree
## Created by Dulio Denis on 4/14/19.

### Quiz Question 1 of 5
![](../img/games.png?raw=true)
Finish the following statement to replace NULL values with the value of "Cross-Platform".

```UPDATE games SET platform = "Cross-Plaform" WHERE id ____ (1,4); ```

> tried = but that was wrong

### Quiz Question 2 of 5
![](../img/games2.png?raw=true)

After issuing the following statement, what would you expect the contents of the table to be?

```UPDATE games SET platform="Cross-Platform"; ```

![](../img/cross-platform.png?raw=true)

### Quiz Question 3 of 5

Please fill in the correct answer in each blank provided below.

```UPDATE shows SET title _____ "Friends";```

What's the missing operator?
> =

### Quiz Question 4 of 5

Please fill in the correct answer in each blank provided below.
CRUD stands for ___, ___, ___, ___.

> Create, Read, Update, Delete.

### Quiz Question 5 of 5

Please fill in the correct answer in each blank provided below.

Fill in the missing keywords for the following UPDATE statement.

```____ cars ____ model = "Ford" ___ id = 1;```
> UPDATE SET WHERE

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Incremental Compilation

The `incremental` package contains logic related to incremental compilation in ngtsc. Its goal is to
ensure that the compiler's incremental performance is largely O(number of files changed in that
iteration) instead of O(size of the program as a whole), by allowing the compiler to optimize away
as much work as possible without sacrificing the correctness of its output.

An incremental compilation receives information about the prior compilation, including
its `ts.Program` and the result of ngtsc's analyses of each class in that program. Depending on the
nature of any changes made to files in the program between its prior and current versions, and on
the semantic effect of those changes, ngtsc may perform 3 different optimizations as it processes
the new build:

* It can reuse analysis work performed in the previous program

ngtsc receives the analyses of all decorated classes performed as part of the previous compilation,
and can reuse that work for a class if it can prove that the results are not stale.

* It can skip emitting a file

Emitting a file is a very expensive operation in TypeScript, involving the execution of many
internal TS transforms (downleveling, module system, etc) as well as the synthesis of a large text
buffer for the final JS output. Skipping emit of a file is the most effective optimizations ngtsc
can do. It's also one of the most challenging. Even if ngtsc's _analysis_ of a specific file is not
stale, that file may still need to be re-emitted if other changes in the program impact its
semantics. For example, a change to a component selector affects other components which use that
selector in their templates, even though no direct dependency exists between them.

* It can reuse template type-checking code

Template type-checking code is generated using semantic information extracted from the user's
program. This generation can be expensive, and ngtsc attempts to reuse previous results as much as
possible. This optimization can be thought of as a special case of the above re-emit optimization,
since template type-checking code is a particular flavor of "emit" for a component.

Due to the way that template type-checking works (creation of a second `ts.Program`
with `.ngtypecheck` files containing template type-checking blocks, or TCBs), reuse of template
type-checking code is critical for good performance. Not only is generation of these TCBs expensive,
but forcing TypeScript to re-parse and re-analyze every `.ngtypecheck` file on each incremental
change would be costly as well.

The `incremental` package is dedicated to allowing ngtsc to make these important optimizations
safely.

During an incremental compilation, the compiler begins with a process called "reconciliation",
focused on understanding the differences between the incoming, new `ts.Program` and the
last `ts.Program`. In TypeScript, an unchanged file will have its `ts.SourceFile` AST completely
reused. Reconciliation therefore examines the `ts.SourceFile`s of both the old and new programs, and
identifies files which have been added, removed, or changed. This information feeds in to the rest
of the incremental compilation process.

## Reuse of analysis results

Angular's process of understanding an individual component, directive, or other decorated class is
known as "analysis". Analysis is always performed on a class-by-class basis, so the analysis of a
component only takes into consideration information present in the `@Component` decorator, and not
for example in the `@NgModule` which declares the component.

However, analysis _can_ depend on information outside of the decorated class's file. This can happen
in two ways:

* External resources, such as templates or stylesheets, are covered by analysis.
* The partial evaluation of expressions within a class's metadata may descend into symbols imported
  from other files.

For example, a directive's selector may be determined via an imported constant:

```typescript=
import {Directive} from '@angular/core';
import {DIR_SELECTOR} from './selectors';

@Directive({
  selector: DIR_SELECTOR,
})
export class Dir {}
```

The analysis of this directive _depends on_ the value of `DIR_SELECTOR` from `selectors.ts`.
Consequently, if `selectors.ts` changes, `Dir` needs to be re-analyzed, even if `dir.ts` has not
changed.

The `incremental` system provides a mechanism which tracks such dependencies at the file level. The
partial evaluation system records dependencies for any given evaluation operation when an import
boundary is crossed, building up a file-to-file dependency graph. This graph is then transmitted to
the next incremental compilation, where it can be used to determine, based on the set of files
physically changed on disk, which files have _logically_ changed and need to be re-analyzed.

## Reuse of emit results

In plain TypeScript programs, the compiled JavaScript code for any given input file (e.g. `foo.ts`)
depends only on the code within that input file. That is, only the contents of `foo.ts` can affect
the generated contents written to `foo.js`. The TypeScript compiler can therefore perform a very
simple optimization, and avoid generating and emitting code for any input files which do not change.
This is important for good incremental build performance, as emitting a file is a very expensive
operation.

(in practice, the TypeScript feature of `const enum` declarations breaks this overly simple model)

In Angular applications, however, this optimization is not nearly so simple. The emit of a `.js`
file in Angular is affected in four main ways:

* Just as in plain TS, it depends on the contents of the input `.ts` file.
* It can be affected by expressions that were statically evaluated during analysis of any decorated
  classes in the input, and these expressions can depend on other files.

For example, the directive with its selector specified via the imported `DIR_SELECTOR` constant
above has compilation output which depends on the value of `DIR_SELECTOR`. Therefore, the `dir.js`
file needs to be emitted whenever the value of the selector constant in `selectors.ts` changes, even
if `dir.ts` itself is unchanged. The compiler therefore will re-emit `dir.js` if the `dir.ts` file
is determined to have _logically_ changed, using the same dependency graph that powers analysis
reuse.

* Components can have external templates and CSS stylesheets which influence their compilation.

These are incorporated into a component's analysis dependencies.

* Components (and NgModules) are influenced by the NgModule graph, which controls which directives
  and pipes are "in scope" for each component's template.

This last relationship is the most difficult, as there is no import relationship between a component
and the directives and pipes it uses in its template. That means that a component file can be
logically unchanged, but still require re-emit if one of its dependencies has been updated in a way
that influences the compilation of the component.

### Example

For example, the output of a compiled component includes an array called `directiveDefs`, listing
all of the directives and components actually used within the component's template. This array is
built by combining the template (from analysis) with the "scope" of the component - the set of
directives and pipes which are available for use in its template. This scope is synthesized from the
analysis of not just the component's NgModule, but other NgModules which might be imported, and the
components/directives that those NgModules export, and their analysis data as well.

These dependencies of a component on the directives/pipes it consumes, and the NgModule structures
that made them visible, are not captured in the file-level dependency graph. This is due to the
peculiar nature of NgModule and component relationships: NgModules import components, so there is
never a reference from a component to its NgModule, or any of its directive or pipe dependencies.

In code, this looks like:

```typescript=
// dir.ts
@Directive({selector: '[dir]'})
export class Dir {}

// cmp.ts
@Component({
  selector: 'cmp',
  template: '<div dir></div>', // Matches the `[dir]` selector
})
export class Cmp {}

// mod.ts
import {Dir} from './dir';
import {Cmp} from './cmp';

@NgModule({declarations: [Dir, Cmp]})
export class Mod {}
```

Here, `Cmp` never directly imports or refers to `Dir`, but it _does_ consume the directive in its
template. During emit, `Cmp` would receive a `directiveDefs` array:

```typescript=
// cmp.js
import * as i1 from './dir';

export class Cmp {
  static cmp = defineComponent({
    ...
    directiveDefs: [i1.Dir],
  });
}
```

If `Dir`'s selector were to change to `[other]` in an incremental step, it might no longer
match `Cmp`'s template, in which case `cmp.js` would need to be re-emitted.

### SemanticSymbols

For each decorated class being processed, the compiler creates a `SemanticSymbol` representing the
data regarding that class that's involved in these "indirect" relationships. During the
compiler's `resolve` phase, these `SemanticSymbol`s are connected together to form a "semantic
dependency graph". Two classes of data are recorded:

* Information about the public shape API of the class.

For example, directives have a public API which includes their selector, any inputs or outputs, and
their `exportAs` name if any.

* Information about the emit shape of the class, including any dependencies on
  other `SemanticSymbol`s.

This information allows the compiler to determine which classes have been semantically affected by
other changes in the program (and therefore need to be re-emitted) according to a simple algorithm:

1. Determine the set of `SemanticSymbol`s which have had their public API changed.
2. For each `SemanticSymbol`, determine if its emit shape was affected by any of the public API
   changes (that is, if it depends on a symbol with public API changes).

### Determination of public API changes

The first step of this algorithm is to determine, for each `SemanticSymbol`, if its public API has
been affected. Doing this requires knowing which `SemanticSymbol` in the previous program
corresponds to the current version of the symbol. There are two ways that symbols can be "matched":

* The old and new symbols share the same `ts.ClassDeclaration`.

This is true whenever the `ts.SourceFile` declaring the class has not changed between the old and
new programs. The public API of the symbol may still have changed (such as when a directive's
selector is determined by a constant imported from another file, like in one of the examples above).
But if the declaration file itself has not changed, then the previous symbol can be directly found
this way.

* By its unique path and name.

If the file _has_ changed, then symbols can be located by their declaration path plus their name, if
they have a name that's guaranteed to be unique. Currently, this means that the classes are declared
at the top level of the source file, so their names are in the module's scope. If this is the case,
then a symbol can be matched to its ancestor even if the declaration itself has changed in the
meantime. Note that there is no guarantee the symbol will be of the same type - an incremental step
may change a directive into a component, or even into a pipe or injectable.

Once a previous symbol is located, its public API can be compared against the current version of the
symbol. Symbols without a valid ancestor are assumed to have changed in their public API.

The compiler processes all `SemanticSymbol`s and determines the `Set` of them which have experienced
public API changes. In the example above, this `Set` would include the `DirectiveSymbol` for `Dir`,
since its selector would have changed.

### Determination of emit requirements

For each potential output file, the compiler then looks at all declared `SemanticSymbol`s and uses
their ancestor symbol (if present) as well as the `Set` of public API changes to make a
determination if that file needs be emitted.

In the case of a `ComponentSymbol`, for example, the symbol tracks the dependencies of the component
which will go into the `directiveDefs` array. If that array is different, the component needs to be
re-emitted. Even if the same directives are referenced, if one of those directives has changed in
its public API, the emitted output (especially when generating prelink library code) may be
affected, and the component needs to be re-emitted.

### `SemanticReference`s

`ComponentSymbol`s track their dependencies via an intermediate type, a `SemanticReference`. Such
references track not only the `SemanticSymbol` of the dependency, but also the name by which it was
imported previously. Even if a dependency's identity and public API remain the same, changes in how
it was exported can affect the import which needs to be emitted within the component consuming it,
and thus would require a re-emit.

## Reuse of template type-checking results

Since type-checking block (TCB) generation for template type-checking is a form of
emit, `SemanticSymbol`s also track the type-checking shape of decorated classes. This includes any
data which is not public API, but upon which the TCB generation for components might depend. Such
data includes:

* Type-checking API shape from any base classes, since TCB generation uses information from the full
  inheritance chain of a directive/pipe.
* The generic signature shape of the class.
* Private field names for `@Input`s and `@Output`s.

Using a similar algorithm to the `emit` optimization, the compiler can determine which files need
their type-checking code regenerated, and which can continue to use TCB code from the previous
program, even if some dependencies have unrelated changes.

## Unsuccessful compilation attempts

Often, incremental compilations will fail. The user's input program may contain incomplete changes,
typos, semantic errors, or other problems which prevent the compiler from fully analyzing or
emitting it. Such errors create problems for incremental build correctness, as the compiler relies
on information extracted from the previous program to correctly optimize the next compilation. If
the previous compilation failed, such information may be unreliable.

In theory, the compiler could simply not perform incremental compilation on top of a broken build,
and assume that it must redo all analysis and re-emit all files, but this would result in
devastatingly poor performance for common developer workflows that rely on automatically running
builds and/or tests on every change. The compiler must deal with such scenarios more gracefully.

ngtsc solves this problem by always performing its incremental steps from a "last known good"
compilation. Thus, if compilation A succeeds, and a subsequent compilation B fails, compilation C
will begin using the state of compilation A as a starting point. This requires tracking of two
important pieces of state:

* Reusable information, such as analysis results, from the last known good compilation.
* The accumulated set of files which have physically changed since the last known good compilation.

Using this information, ngtsc is able to "forget" about the intermediate failed attempts and begin
each new compilation as if it were a single step from the last successful build. It can then ensure
complete correctness of its reuse optimization, since it has reliable data extracted from the "
previous" successful build.

repository: angular/angular

branch_name: refs/heads/main

gha_language: TypeScript

gha_license_id: MIT

repo_name: angular/angular


text:
---
title: 'Number  of  people  requiring  interventions  against  neglected  tropical  diseases'
permalink: /3-3-5/
sdg_goal: 3
layout: indicator
indicator: 3.3.5
indicator_variable: null
graph: null
graph_title: null
graph_type_description: 'CDC  program  does  not  have  these  data.'
graph_status_notes: unk
variable_description: null
variable_notes: null
un_designated_tier: '1'
un_custodial_agency: WHO
target_id: '3.3'
has_metadata: false
rationale_interpretation:
goal_meta_link: 'http://unstats.un.org/sdgs/files/metadata-compilation/Metadata-Goal-3.pdf'
goal_meta_link_page: 11
indicator_name: 'Number  of  people  requiring  interventions  against  neglected  tropical  diseases'
target: 'By  2030,  end  the  epidemics  of  AIDS,  tuberculosis,  malaria  and  neglected  tropical  diseases  and  combat  hepatitis,  water-borne  diseases  and  other  communicable  diseases.'
indicator_definition:
actual_indicator_available: null
actual_indicator_available_description: null
method_of_computation: ''
comments_and_limitations: null
periodicity: null
time_period: null
unit_of_measure: null
disaggregation_categories: null
disaggregation_geography: null
date_of_national_source_publication: null
date_metadata_updated: null
scheduled_update_by_national_source: null
scheduled_update_by_SDG_team: null
source_agency_staff_name: null
source_agency_staff_email: null
source_agency_survey_dataset: null
source_title: null
source_url: null
source_notes: null
international_and_national_references: null

---


text:
---
id: 259-The-Ideas-of-March
author: matthew
title: 'The Ideas of March'
draft: false
public: true
created: '2011-03-15T14:41:28-04:00'
updated: '2011-03-16T03:16:42-04:00'
tags:
    - php
---
[Chris Shiflett has asked the question](http://shiflett.org/blog/2011/mar/ideas-of-march),
why don't people blog anymore? In this age of real-time streams and dead-simple
status updates, blogs often feel like the uncared-for step-child or a website;
indeed, many folks are trading their blogs for pages that simply track their
various lifestreams (tweets, facebook status, flickr images, and more).

While this sort of thing is trendy and interesting, it also sucks:

<!--- EXTENDED -->

- It's a snapshot of simply what your most recent activity was, and rarely provides the ability to mine the streams to get a more full picture.
- There's no good way to converse. Sure, you can do @mentions, or Facebook comments, but it's not the same. These forms are often space-limited, or lose context rapidly (ever try to re-create a twitter conversation thread?).
- What happens when your thoughts are bigger than a tweet?

I was recently reminded of this in a twitter exchange I had with [Jon Whitcraft](http://h2ik.co). He asked for some advice with [Git](http://git-scm.org), and I replied with some fairly cryptic advice — which he simply didn't understand. We then moved the discussion to email, where I was able to give a full example, with command snippets, project context, etc.

In the time I took to write it, I could have written a blog post from which many folks could have benefitted, and on which they could have commented. (Heck, a post **I** could go to later when I get stuck with the same issue, as I almost surely will. Jon was kind enough to [post the conversation on his blog](http://h2ik.co/2011/03/having-fun-with-git-subtree/).)

The point is that Twitter is great for the ephemeral, but a terrible medium for having a record of ideas.

The interesting thing for me about Chris' post is that, in looking back on the past year, I've already been blogging more. [My employers](http://www.zend.com) like having a post of mine to link to in the monthly newsletter, and having that (minimal) pressure has forced me to take time each to think about what I've been working on, what trends I've been observing, or what questions I've been seeing pop up over and over again… and write.

Writing is an interesting process. It forces one to take those scattered thoughts and provide some order and structure around them. When done well, it often helps reveal facets of the subject matter you'd not considered previously, opening new questions to consider. I find that taking the time to write helps me fully explore an issue in a way I'd never do normally. As such, my blog has, believe it or not, been primarily for my own consumption; it's a tool to help me learn and explore ideas.

So, I've tossed my hat in the ring — now it's your turn: blog it!

gha_language: PHP


text:
# Kafka Broker Metrics

Here is the list of metrics based on MBeans exposed by Kafka broker.

Broker metrics:

| Metric Name                        | Type          | Attributes | Description                                                          |
| ---------------------------------- | ------------- | ---------- | -------------------------------------------------------------------- |
| kafka.message.count                | Counter       |            | The number of messages received by the broker                        |
| kafka.request.count                | Counter       | type       | The number of requests received by the broker                        |
| kafka.request.failed               | Counter       | type       | The number of requests to the broker resulting in a failure          |
| kafka.request.time.total           | Counter       | type       | The total time the broker has taken to service requests              |
| kafka.request.time.50p             | Gauge         | type       | The 50th percentile time the broker has taken to service requests    |
| kafka.request.time.99p             | Gauge         | type       | The 99th percentile time the broker has taken to service requests    |
| kafka.request.queue                | UpDownCounter |            | Size of the request queue                                            |
| kafka.network.io                   | Counter       | direction  | The bytes received or sent by the broker                             |
| kafka.purgatory.size               | UpDownCounter | type       | The number of requests waiting in purgatory                          |
| kafka.partition.count              | UpDownCounter |            | The number of partitions on the broker                               |
| kafka.partition.offline            | UpDownCounter |            | The number of partitions offline                                     |
| kafka.partition.underReplicated    | UpDownCounter |            | The number of under replicated partitions                            |
| kafka.isr.operation.count          | UpDownCounter | operation  | The number of in-sync replica shrink and expand operations           |
| kafka.lag.max                      | Gauge         |            | The max lag in messages between follower and leader replicas         |
| kafka.controller.active.count      | UpDownCounter |            | The number of controllers active on the broker                       |
| kafka.leaderElection.count         | Counter       |            | The leader election count                                            |
| kafka.leaderElection.unclean.count | Counter       |            | Unclean leader election count - increasing indicates broker failures |

Log metrics:

| Metric Name               | Type    | Attributes | Description                      |
| ------------------------- | ------- | ---------- | -------------------------------- |
| kafka.logs.flush.count    | Counter |            | Log flush count                  |
| kafka.logs.flush.time.50p | Gauge   |            | Log flush time - 50th percentile |
| kafka.logs.flush.time.99p | Gauge   |            | Log flush time - 99th percentile |

gha_language: Java


text:
# Elm Hot Loader [![Version](https://img.shields.io/npm/v/elm-hot-loader.svg)](https://www.npmjs.com/package/elm-hot-loader)

Hot swapping for [Elm](http://elm-lang.org/) module.

This loader injects [HMR](https://webpack.github.io/docs/hot-module-replacement.html) support code to the Elm module generated by [elm-webpack-loader](https://github.com/rtfeldman/elm-webpack-loader). **Since v0.1.4, It also re-subscribe all ports after swap.**

## Installation

```sh
$ npm install --save elm-webpack-loader elm-hot-loader
```

## Usage

[Documentation: Using loaders](http://webpack.github.io/docs/using-loaders.html)

In your `webpack.config.js` file:

```js
module.exports = {
  module: {
    loaders: [{
      test: /\.elm$/,
      exclude: [/elm-stuff/, /node_modules/],
      loader: 'elm-hot!elm-webpack'
    }]
  }
};
```

You should also add the `--hot` flag when starting webpack.

## Notes

### swap port and Empty action

After hot swapping, elm-hot-load will call 'swap' port to trigger a re-render.
So in your elm main module, you should define something like:

```elm
type Action
  = Empty -- this action does not modify model, just to trigger a re-render
  | CounterAction Counter.Action

-- for elm-hot-loader to trigger a re-render
port swap : Signal Bool

-- map swap to Empty action
swapsignal : Signal Action
swapsignal =
  Signal.map (\_ -> Empty) swap

app : StartApp.App Model
app =
  StartApp.start
    { init = init
    , update = update
    , view = view
    , inputs = [ swapsignal ] -- add swap signal as an input
    }
```

`swap` also needs to be initialized at the point where your app is embedded:

```javscript
var app = Elm.embed(Elm.Main, mountNode, { swap: true });
```

### Dependency

This loader relies on elm-webpack-loader to compile ELM to JS.

### Example

You can find an example in the `example` folder.
To run:

```
cd example
npm install
npm run dev
```

Open http://localhost:3000

![Screenshot](https://raw.githubusercontent.com/fluxxu/elm-hot-loader/master/example/example.gif)

repository: rtfeldman/elm-hot-loader

repo_name: rtfeldman/elm-hot-loader


text:
# withings-stream <sup>[![Version Badge](http://vb.teelaun.ch/tellnes/withings-stream.svg)](https://npmjs.org/package/withings-stream)</sup>

[![Dependency Status](https://david-dm.org/tellnes/withings-stream.png)](https://david-dm.org/tellnes/withings-stream)
[![devDependency Status](https://david-dm.org/tellnes/withings-stream/dev-status.png)](https://david-dm.org/tellnes/withings-stream#info=devDependencies)
[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/tellnes/withings-stream/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

[![NPM](https://nodei.co/npm/withings-stream.png)](https://nodei.co/npm/withings-stream/)

Streams Withings Measures. (`measure / getmeas`)

Getting the token and token secret is outside the scope of this lib. You can use
[passport-withings](https://github.com/mowens/passport-withings)
to do that.

## Usage

```js
var options =
  { consumerKey: '...'
  , consumerSecret: '...'
  , token: '...'
  , tokenSecret: '...'
  , userid: '...'
  , startdate:<PHONE_NUMBER>
  , enddate:<PHONE_NUMBER>
  }
var WithingStream = require('withings-stream')

var stream = WithingsStream(options)

stream.on('data', function (measuregrp) {
  // Do something with measuregrp
})
```

## Install

    $ npm install withings-stream

## License

MIT

repository: tellnes/withings-stream

repo_name: tellnes/withings-stream


text:
# Ethereum ENS tutorial and playground with Python & web3.py

For educational purposes. Made for https://energyweb.atlassian.net/wiki/spaces/EWF/pages/555745281/Using+ENS+on+Tobalaba.

Used with [Parity client](https://github.com/paritytech/parity-ethereum) version 1.11.6 Beta and [web3.py](https://github.com/ethereum/web3.py) version 4.5.0.

### Dependencies

- Connection to Tobalaba. For a tutorial on how to set up a local [Parity client](https://github.com/paritytech/parity-ethereum) and connect to the network, check [here](https://energyweb.atlassian.net/wiki/spaces/EWF/pages/72974337/Install+the+Energy-Web+Client).
- [Parity UI](https://github.com/parity-js/shell) (Helps a lot).
- An account with some test Ethers in it. You can use the Parity UI for this purpose, then navigate to the [faucet](http://tobalaba.slock.it/faucet/) to get some ethers.
- Python 3.6, pip, Jupyter notebook

### Setup

You need a [Jupyter notebook](http://jupyter.org/install):
```
pip install jupyter
(or pip3 install jupyter)
```
Then
```
git clone https://github.com/ngyam/tutorial-ens-py.git
cd tutorial-ens-py
pip install -r requirements.txt
(or pip3 install -r requirements.txt)
```

### How to use

 1. Make sure your parity client is running and configured to connect to Tobalaba
 2. Open the Jupyter notebook file and play around.

```
cd tutorial-ens-py
jupyter notebook
```

### Resources

[Energy Web Foundation](http://www.energyweb.org/)

[Parity client](https://github.com/paritytech/parity-ethereum)

[ENS official documentation](https://docs.ens.domains/en/latest/)

[ENS Github Repo](https://github.com/ensdomains/ens)

[web3.py documentation](https://web3py.readthedocs.io/en/stable/)

repository: ngyam/tutorial-ens-py

repo_name: ngyam/tutorial-ens-py


text:
FRC Team 604: 2011 ["Barracuda"](http://604robotics.com/Quixilver/Robots/)
===================

This is [FIRST Team 604](http://604robotics.com/)'s 2011 robot code, rewritten from LabVIEW into C++ with the WPILib framework.

### "Special" Features

 - **Dual-mode arm control**, with manual and single-button PID-controlled preset modes, and a button to hold in the current position.
 - **Gyro-based driving**, with one button to face the robot forward, one to face it in the opposite direction, and one to reset the position that is considered "forward".

### Other Features
 - Example of a custom PID Source and Output.
 - Example of basic drive code.
 - Example of compressor/pneumatics code.
 - Example of solenoid-based shifter code.
 - Control code for a single-jointed arm with a pneumatic gripper and rollers.
 - Control code for a pneumatics-driven minibot deployment system.

### License

Licensed under the [MIT License](https://en.wikipedia.org/wiki/MIT_License).


text:
# Non exhaustive pattern in function noThirds

## Question

So, my Problem is, that I have to write a program that filters all 3 * x (3,6,9...) elements from a list. My program looks like:

    length'  :: [a] -> Int
    length' = foldr (\_ -> (+1)) 0

    help_ :: [a] -> [a] -> [a]
    help_ (x:xs) [] = help_ (xs) [x]
    help_ [] (x) = (x)
    help_ (x:xs) (y)
        |((length' [xs]) ==0) = (y)
        |((length' [y]) `mod` 2 ==0) = help_ (xs) (y)
        |otherwise = help_ (xs) (y++[x])

    noThirds :: [a] -> [a]
    noThirds [x] = help_ [x] []

The compiler accepts this but gives the error "Non exhaustive pattern in function noThirds" when I enter "noThirds \[1,2,3,4,5,6,7,8\]" . I guess it's cause im missing a variety of "help_ .." but I don't get it. Im grateful for every help! Btw predefined list and arithmetic functions are not allowed.

## Answer

It's because `noThirds` only has one pattern, `[x]` which only matches against a single element list. `[x]` is exactly equivalent to `(x : [])`. What I think you meant was

    noThirds :: [a] -> [a]
    noThirda xs = help_ xs []

repository: stackflow-io/stackflow

repo_name: stackflow-io/stackflow


text:
# K_PITCHES
## By Kerry Kogei

## Description
Are you looking for a Picth of the week to brighten up your day and your week? Here you can find a list of positive quotes to help you get through a tough week!

## User Story

1. As a user, I would like to see the pitches other people have posted.
2. As a user, I would like to vote on the pitch they liked and give it a downvote or upvote.
3. As a user, I would like to be signed in for me to leave a comment
4. As a user, I would like to receive a welcoming email once I sign up.
5. As a user, I would like to view the pitches I have created in my profile page.
6. As a user, I would like to comment on the different pitches and leave feedback.
7. As a user, I would like to submit a pitch in any category.
8. As a user, I would like to view the different categories.

## Setup Installation
* Clone the repository
 ```https://github.com/Kerrykogei24/K-Pitches```

* cd k-pitches

* To test the application
 ```python3.6 manage.py test```

* To run the application, in your terminal:

        $ chmod +x start.sh
        $ ./start.sh

## Behaviour Driven Development
| Behavior            | Input                         | Output                        |
| ------------------- | ----------------------------- | ----------------------------- |
| View Product Pitches | Click on any category | Taken to the clicked category | Click on `Click    submit To Post A Pitch` | Redirected to the login page | Signs In/ Signs Up |
| Click on `Click create a new To Post A Pitch` | If logged in, display form to add a pitch | Redirected to the home page |
| Click upvote/ downvote button | Redirects to home page | Upvote/ downvote count changes | Click add comment button | Redirects to the comment page | Displays a comment form | Click on Sign Out | Redirects to the home page | Signs user out |
| Click on profile | Redirects to the profile page | User adds bio and profile picture |

## Technology used

* Python3.6
* Flask
* Heroku

## Contact Information

If you have any question or contributions, please email me at<EMAIL_ADDRESS>
### License
  [MIT] Copyright (c) 2020 Kerry Kogei


text:
---
date: 2019-08-10T08:03:18-07:00
slug: learn-go
title: Learning Go
summary: Some resources I've found incredibly useful in learning Go, aka Golang.
collection_swe_toolbox: true
---

## Ready to learn Go?

Above all, I'd recommend the
[The Go Programming Language](https://www.amazon.com/dp/B0184N7WWS/) book.
It was published in 2015, but thanks to the stability of the Go language,
this is still the best book for picking up Go.

## Watch

- [The Why of Go](https://www.youtube.com/watch?v=bmZNaUcwBt4)
- [Simplicity Is Complicated, Rob Pike](https://www.youtube.com/watch?v=rFejpH_tAHM)
- [Concurrency Is Not Parallelism, Rob Pike](https://vimeo.com/49718712)
- [A Tour of Go, Russ Cox](https://research.swtch.com/gotour)
- [Go: building on the shoulders of giants and stepping on a few toes](https://www.youtube.com/watch?v=sX8r6zATHGU)

## Read and do

- [**The Go Programming Language**](https://www.amazon.com/dp/B0184N7WWS/) ⭑
- [**Learn Go with Tests**](https://github.com/quii/learn-go-with-tests) ⭑
- [A Tour of Go](https://tour.golang.org/welcome/1)
- [Effective Go](https://golang.org/doc/effective_go.html)
- [Package Docs](https://golang.org/pkg/)
- [Language Specification](https://golang.org/ref/spec)
- [Many links on golang.org Documentation](https://golang.org/doc/). Especially the **codewalks**.

## Golang news and updates

- [Official blog](https://blog.golang.org)
- [The Go Gazette](http://www.go-gazette.com/)
- [Golang Weekly](https://www.golangweekly.com/)
- [r/golang](https://www.reddit.com/r/golang/) on Reddit
- My [Twitter list of Golang folks](https://twitter.com/BrianSigafoos/lists/golang)

## Cheatsheets

- [Learn Go in Y Minutes](https://learnxinyminutes.com/docs/go/)
- [a8m/go-lang-cheat-sheet](https://github.com/a8m/go-lang-cheat-sheet)
- [devhints.io/go](https://devhints.io/go)

## Practice

- [Gophercieses](https://gophercises.com)

## Podcasts and video series

- [Go Time](https://changelog.com/gotime)
- [Just for Func](https://www.youtube.com/c/justforfunc)

## Linting

- [golangci-lint](https://github.com/golangci/golangci-lint)
  - Configurable meta linter

## Development

```shell
export GOPATH=~/go
export PATH="$GOPATH/bin:$PATH"
eval "$(gimme 1.12.7)"
```

- Versions of Go
  - Use gimme for easy version switching: `brew install gimme; eval "$(gimme 1.12.7)"`
  - Add the code above to your shell init script: ~/.bash_profile, ~/.profile, etc
- Use Go modules ([read this wiki](https://github.com/golang/go/wiki/Modules))
  - You can either:
    - A: git clone the code outside your GOPATH (ie, next to your other code) to use go modules automatically (recommended)
    - B: set `GO111MODULE=on` and keep your Go code in your GOPATH

## IDE Tools

- VS Code
  - [Go modules in VS Code](https://github.com/Microsoft/vscode-go/wiki/Go-modules-support-in-Visual-Studio-Code)

## And finally... the Go Gopher!

- [Learn about Go's adorable mascot, the Go Gopher, created by Renee French](https://blog.golang.org/gopher).

![Gophers](https://blog.golang.org/store/gophers.jpg)

![5 years](https://golang.org/doc/gopher/fiveyears.jpg)

![Go Gopher](https://golang.org/doc/gopher/modelsheet.jpg)

gha_language: HTML


text:
# Tree Network in Network (TreeNiN) for Jet Physics

### **Sebastian Macaluso and Kyle Cranmer**

Note that this is an early development version.

[![DOI](https://zenodo.org/badge/160135404.svg)](https://zenodo.org/badge/latestdoi/160135404) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![docker: pull](https://img.shields.io/badge/docker-pull-green.svg)](https://hub.docker.com/r/smacaluso/treenin)

## Introduction

In this method, a tree neural network (TreeNN) is trained on jet trees. The TreeNN provides a *jet embedding*, which maps a set of 4-momenta into a vector of fixed size and can be trained together with a successive network used for classification or regression  (see [Louppe et al. 2017, "QCD-Aware Recursive Neural Networks for Jet Physics"](https://arxiv.org/abs/1702.00748) for more details). Jet constituents are reclustered to form binary trees, and the topology is determined by the clustering algorithm (e.g. kt, anti-kt or Cambridge/Aachen). We chose the kt clustering algorithm, and 7 features for the nodes: |p|, eta, phi, E, E/Ejet, pT and theta. We scaled each feature with the scikit-learn preprocessing method RobustScaler (this scaling is robust to outliers).

To speed up the training, a special batching was implemented in [Louppe et al. 2017](https://arxiv.org/abs/1702.00748). Jets are reorganized by levels (e.g. the root node of each tree in the batch is added at level zero, their children at level one, etc). Each level is restructured so that all internal nodes come first, followed by outer nodes (leaves), and zero padding is applied when necessary. We developed a PyTorch implementation to provide GPU acceleration.

We introduced a Network in Network generalization of the simple TreeNN architecture proposed in [Louppe et al. 2017](https://arxiv.org/abs/1702.00748), where we add fully connected layers at each node of the binary tree before moving forward to the next level. We refer to this model as TreeNiN. In particular, we add 2 NiN layers with ReLU activations. Also, we split weights between internal nodes and leaves, both for the NiN layers and for the initial embedding of the 7 input features of each node. Finally, we introduce two sets of independent weights for the NiN layers of the left and right children of the root node. Our model has 33,901 trainable parameters. Training is performed over 40 epochs with a minibatch of 128 and a learning rate of 0.002 (decayed by a factor of 0.9 after every epoch), using the cross entropy loss function and Adam as the optimizer.

-------------------------------------------------------------------------
## Implementing the TreeNiN on the *Top Tagging Reference Dataset*

This repository includes all the code needed to implement the TreeNiN on the *Top Tagging Reference Dataset*. A description and link to the Top Tagging Reference Dataset (provided by Gregor Kasieczka, Michael Russel and Tilman Plehn) can be found [here](https://docs.google.com/document/d/1Hcuc6LBxZNX16zjEGeq16DAzspkDC4nDTyjMp1bWHRo/edit)
with the link to download it [here](https://desycloud.desy.de/index.php/s/llbX3zpLhazgPJ6). This dataset contains about 1.2M training events, 400k validation events, 400k test events with equal numbers of top quark and qcd jets. Only 4 momentum vectors of the jet constituents.

-------------------------------------------------------------------------
## Running with Docker (Recommended)

### Dependencies:

Install [docker](https://docs.docker.com/install/)

### Docker Image

1. If building the Docker Image, from the root directory of this repository, run: `docker build --tag=treenin:1.0.0 .`

2. Alternatively, it is easier to download the pre-built image from Docker Hub [here](https://hub.docker.com/r/smacaluso/treenin). In this case run: `docker pull smacaluso/treenin:1.0.0`

**Relevant Structure**:

- [`Dockerfile`](Dockerfile)
- [`scripts`](scripts): dir with the scripts to install specific dependencies when building the image.
- [`code`](code): working directory for the docker container.
    - [`top_reference_dataset`](code/top_reference_dataset)
        - [`outProb`](code/top_reference_dataset/outProb): dir with the output probabilities.
        - [`in_data`](code/top_reference_dataset/in_data): dir where the initial test dataset will be downloaded.
    - [`dataWorkflow.py`](code): script with the data workflow.
    - [`MLWorkflow.py`](code): script with the machine learning workflow.
    - [`saveProb.py`](code): script that saves the output probabilities in [`outProb/[filename.pkl]`](code/top_reference_dataset/outProb).
    - [`recnn`](code/recnn): dir with the code for the TreeNiN.
    - [`data`](code/data): dir with the jet trees (before and after preprocessing).

### Running the treenin container:

Run the container:
`docker run [options] -i -t smacaluso/treenin:1.0.0 /bin/bash`

If loading external files, we should mount the host file inside the docker container at running time. This will import a copy of the file to the chosen location (it also creates the path inside the container if necessary), e.g. for macOS:
`docker run -v [path/to/external/file]:[full/path/to/file/inside/the/container] [options] -i -t smacaluso/treenin:1.0.0 /bin/bash`

Check `docker run --help` for all the options. Some useful `[options]`:
- `--rm`: Remove the container when we exit.
- `--shm-size [RAM size]G`: shared memory with the container.

#### Evaluation mode

The container is ready to run the code on evaluation mode (to run on training mode, follow the instructions on *Training mode* below) . From the [working directory](/code/):

1. Run the data workflow. Choose one of the two options below:

    a. Automatically download the [test dataset](https://desycloud.desy.de/index.php/s/llbX3zpLhazgPJ6) from the website:
`python dataWorkflow.py 0`

    b. Load the [test dataset](https://desycloud.desy.de/index.php/s/llbX3zpLhazgPJ6) as an external file (first mount the host file inside the docker container at running time):
                `python dataWorkflow.py 0 [full/path/to/file/inside/the/container]`

    If running with `0` as an input argument, the whole dataset will be used (this value determines the starting jet position to load from the dataset). This could be changed for testing purposes, e.g. to use only 1% of the dataset, set this argument to `400000`. This script returns the preprocessed dataset ready to be used as input for the TreeNiN:

    -  Loads and reclusters the jet constituents.
    - Creates binary trees with the clustering history of the jets and outputs a dictionary for each jet that contains the root_id, tree, content (constituents 4-momentum vectors), mass, pT, energy, eta and phi values.
    - Preprocessing is applied. The initial 7 features are: p, eta, phi, E, E/JetE, pT, theta.

    The final preprocessed test dataset is saved here: [test_top_tag_reference_dataset_kt_1200000_Njets_.pkl](/code/data/preprocessed_trees/test_top_tag_reference_dataset_kt_1200000_Njets_.pkl)

2. Run the TreeNiN workflow (loading previously trained weights):
    `python MLWorkflow.py 0 9`

    where we are testing over all the models between `0` and `9`.

3. Read and save the output probabilities for all the models:
    `python3 saveProb.py`

    This saves the probabilities here: [TreeNiN_hd50.pkl](code/top_reference_dataset/outProb/TreeNiN_hd50.pkl)

   (Note that the `TreeNiN_hd50.pkl` file uploaded to this repository is only for testing purposes and contains 1% of the dataset. This file will be overwritten when running the pipeline. The output probabilities for the full top tagging reference test dataset are here: [TreeNiN_hd50_full.pkl](code/top_reference_dataset/outProb/TreeNiN_hd50_full.pkl))

#### Training mode:

##### **Data pipeline**
To run on training mode we need to preprocess the train and val datasets as well. Follow the instructions below and rerun for each dataset (train, val, test).

1. Modify the last two lines of [ReadData.py](code/top_reference_dataset/ReadData.py)  to load the validation (train) dataset. (You would first need to download the validation and training datasets from [here](https://desycloud.desy.de/index.php/s/llbX3zpLhazgPJ6) )
2. `cd `[`TreeNiN_code/top_reference_dataset/`](code/top_reference_dataset/)
3. `python3 ReadData.py 0`
4. `python2.7 toptag_reference_dataset_Tree.py jet_image_trim_pt800-900_card.dat test out_data/ ../data/inputTrees/top_tag_reference_dataset/`
(The output file with the dictionary for each jet will be saved in [data/inputTrees/top_tag_reference_dataset/](code/data/inputTrees/top_tag_reference_dataset/). Also, change `test` for `val` or `train` to run the data pipeline over the validation and train sets.)
5. Set the flag *test_train_val_datasets=True* in [preprocess_main.py](code/recnn/preprocess_main.py).
6. `cd `[`TreeNiN_code/recnn/`](code/recnn/)
7. `python3 `[`run_preprocess.py`](code/recnn/run_preprocess.py)

##### **TreeNiN**

1. Set the flag *TRAIN_and_EVALUATE=True* and *EVALUATE=False* in  [search_hyperparams.py](code/recnn/search_hyperparams.py) (This will run [train.py](code/recnn/train.py) and [evaluate.py](code/recnn/evaluate.py)).
2. Specify the *multi_scan* function arguments as explained below.
3. Run: `python3 search_hyperparams.py --gpu=0`. Results will be saved in `experiments/[dir_name]`.

-------------------------------------------------------------------------
## Running directly

### Dependencies

Make sure the following tools are installed and running:

- Python 2.7, Python 3.6, packages included in [Anaconda](https://www.anaconda.com/) (Numpy, Scipy, scikit-learn, Pandas),  [FastJet](http://fastjet.fr/), [PyTorch](https://pytorch.org/).

-------------------------------------------------------------------------
## Data processing structure

The data dir is [`top_reference_dataset`](code/top_reference_dataset):

-[`ReadData.py`](code/top_reference_dataset/ReadData.py): Load the datasets in h5 format, get the labels and non-zero values for the jet constituents and save pickle files in [`out_data`](code/top_reference_dataset/out_data).

-[`toptag_reference_dataset_Tree.py`](code/top_reference_dataset/toptag_reference_dataset_Tree.py): Load and recluster the jet constituents. Create binary trees with the clustering history of the jets and output a dictionary for each jet that contains the root_id, tree, content (constituents 4-momentum vectors), mass, pT, energy, eta and phi values (also charge, muon ID, etc depending on the information contained in the dataset). Auxiliary scripts that are called:

- [`analysis_functions.py`](code/top_reference_dataset/analysis_functions.py): auxiliary functions.
- [`preprocess_functions.py`](code/top_reference_dataset/preprocess_functions.py): auxiliary functions.
- [`tree_cluster_hist.py`](code/top_reference_dataset/tree_cluster_hist.py): Create binary trees. If the dataset has more information besides the jet constituents 4-vectors (e.g. charge, muon ID, etc), this script runs a recursive function that traverses the tree down to the leaves and then goes back to the root generating the inner nodes values by adding the children values for the extra information.
- [`jet_image_trim_pt800-900_card.dat`](code/top_reference_dataset/jet_image_trim_pt800-900_card.dat): parameters card with kinematic variables values, clustering algorithm choice, etc. Currently not used.

-------------------------------------------------------------------------
## TreeNiN structure

The TreeNiN code dir is [`recnn`](code/recnn):

- [`search_hyperparams.py`](code/recnn/search_hyperparams.py): main script that calls preprocess_main.py, train.py and evaluate.py; and runs hyperparameters searches.
    - Parameters to specify before running:
        - *multi_scan* function arguments. Determine the hyperparameter values (for a scan input a list of values), *dir_name* and *number of runs=Nrun_finish-Nrun_start*.
        ```
        multi_scan(learning_rates=[5e-4],
        decays=[0.92],
        batch_sizes=[64],
        num_epochs=[40],
        hidden_dims=[40],
        jet_numbers=[1200000],
        Nfeatures=7,
        dir_name='top_tag_reference_dataset',
        name=architecture+'_kt_2L4WleavesInnerNiNuk',
        info='',
        sample_name=args.sample_name,
        Nrun_start=0,
        Nrun_finish=9)
        ```
        - Flags: *PREPROCESS*, *TRAIN_and_EVALUATE*, *EVALUATE*

    - To run:
        `python3 search_hyperparams.py --gpu=0`

- [`run_preprocess.py`](code/recnn/run_preprocess.py): same as search_hyperparams.py but hard-coded to do the preprocessing only.

- [`preprocess_main.py`](code/recnn/preprocess_main.py): Preprocess the jet dictionaries and go from the jet constituents 4-momentum vectors to the 7 features for the nodes (|p|, eta, phi, E, E/Ejet, pT and theta). Before running, define *toptag_reference_train*, *toptag_reference_val* and *toptag_reference_test* with the  name of the input trees saved in [`data/inputTrees/top_tag_reference_dataset/`](code/data/inputTrees/top_tag_reference_dataset/) (e.g. `toptag_reference_train=dir_jets_subjets+'/tree_train_jets.pkl'`)

- [`train.py`](code/recnn/train.py): Train the model. This file calls `model/recNet.py`, `model/data_loader.py`, `model/preprocess.py`, `model/dataset.py` and `utils.py`

- [`evaluate.py`](code/recnn/evaluate.py): loads the weights that give the best val accuracy (this could be changed to lowest val loss function value) and gets the accuracy, tpr, fpr, and ROC auc over the test set.

- [`model`](code/recnn/model/):

    - [`recNet.py`](code/recnn/model/recNet.py): model architecture for batch training and accuracy function.

    - [`data_loader.py`](code/recnn/model/data_loader.py): load the raw data and create the batches:

        - Load the jet events and make the trees.
        - Shuffle the signal and background sets independently. Split the sample into train, validation and test with equal number of sg and bg events. Then shuffle each set.
        - Load the jet trees, reorganize the tree by levels, create a batch of N jets by appending the nodes of each jet to each level and add zero padding so that all the levels have the same size
        - Generator function that loads the batches, shifts numpy arrays to torch tensors and feeds the training/validation pipeline

    - [`preprocess.py`](code/recnn/model/preprocess.py): rewrite and reorganize the jet contents (e.g. add features for each node such as energy, pT, eta, phi, charge, muon ID, etc)

    - [`dataset.py`](code/recnn/model/dataset.py): This script defines:
        - A new subclass of torch.utils.data.Dataset that overrides the *__len__*  and *__getitem__* methods. This allows to call torch.utils.data.DataLoader to generate the batches in parallel with num_workers>1 and speed up the code.
        - A customized *collate* function to load the batches with torch.utils.data.DataLoader.

- [`experiments`](code/recnn/experiments):

    - [`template_params.json`](code/recnn/experiments/template_params.json):  Template file that contains all the architecture parameters and training hyperparameters for a specific run. “search_hyperparams.py” modifies these parameters for each scan

    - [`experiments/[dir_name]`](code/recnn/experiments): dir with all the hyperparameter scan results (weights, log files, results) for each sample/architecture. For each run, a new directory will be created with files saving the output probabilities on the test set, metrics history after each epoch, best and last weights, etc.

- [`jet_study.ipynb`](code/recnn/jet_study.ipynb): Load results from `experiments/[dir_name]`, and get results (accuracy, AUC, background rejection, etc) for single and/or multiple runs.

- [`utils.py`](code/recnn/utils.py): auxiliary functions for training, logging, loading hyperparameters from json file, etc.

-------------------------------------------------------------------------

## Acknowledgements

SM gratefully acknowledges the support of NVIDIA Corporation with the donation of a Titan V GPU used for this research.

-------------------------------------------------------------------------
## References

If you use this package, please cite this code as

```
@misc{TreeNiN,
author       = "Macaluso, Sebastian and Cranmer, Kyle",
title        = "{Tree Network in Network (TreeNiN) for jet physics}",
note         = "{DOI: 10.5281/zenodo.2582216}",
year         = {2019},
url          = {https://github.com/SebastianMacaluso/TreeNiN}
}
```

repository: SebastianMacaluso/TreeNiN

repo_name: SebastianMacaluso/TreeNiN


text:
## ap-fffit/runs

The directory naming scheme is ``uc-lattice-iter[iternum]`` where
``iternum`` is the iteration number.

Each directory contains the files necessary to run the molecular
simulations associated with the given iteration. The ``init.py``
defines the ``signac`` workspace and the ``project.py`` defines
the flow operations (i.e., performs the system setup, creates the
molecular simulation inputs, performs the simulations, and performs
any analysis).

repository: helpscott/ap-fffit

repo_name: helpscott/ap-fffit


text:
# Android Media Picker

[![Android](https://img.shields.io/badge/Android-19-brightgreen.svg)](https://www.android.com/)
[![Release](https://jitpack.io/v/pankajdoni19/AndroidMedia.svg)](https://jitpack.io/#pankajsoni19/AndroidMedia)

* AndroidX support
* Supports picking multiple media files from gallery and camera
* Support square, rectangle camera
* Supports media/video effect filters
* No ffmpeg

![Snapshot](image/snapshot.png)

## About

This fork is a collection of forks from the original creator.

We have been using ffmpeg from java-cpp in android for recording square videos. It is excellent library, however we faced issues related to threads, ffmpeg loading, using realm and webrtc alongside it, and a very bloated apk.
Though we have sorted all those issues out, we would like a simpler approach natively supported by android.

We will try to maintain the repository as best we can. All pull requests are welcome.
Though bugs will only be solved that we face in our projects.

The intention is to sort out the edge cases and make it available as a library project.

### Using in your project

1. Include jitpack.io maven repo ( app build.gradle)

```
    repositories {
        maven { url "https://jitpack.io" }
    }

```

2. Add dependency to project ( app build.gradle)

```
    dependencies {
        implementation 'com.github.pankajsoni19:AndroidMedia:1.1.1'
    }

```

### Usage

##### To Pick Image

```
    private void startPicker() {
             new MediaPickerOpts.Builder()
                            .setMediaType(MediaType.IMAGE)
                            .canChangeScaleType(Boolean.valueOf("true"))
                            .withGallery(Boolean.valueOf("true"))
                            .withCameraType(ScaleType.SCALE_SQUARE)
                            .withFlash(Boolean.valueOf("true"))
                            .withMaxSelection(Integer.parseInt("1"))
                            .withFilters(Boolean.valueOf("true"))
                            .withCropEnabled(Boolean.valueOf("true"))
                            .build()
                            .startActivity(this);
        }
    }

```

##### To Pick Profile Image

```
    private void startPicker() {
             new MediaPickerOpts.Builder()
                            .setMediaType(MediaType.IMAGE)
                            .canChangeScaleType(Boolean.valueOf("true"))
                            .withGallery(Boolean.valueOf("true"))
                            .withCameraType(ScaleType.SCALE_SQUARE)
                            .withFlash(Boolean.valueOf("true"))
                            .withMaxSelection(Integer.parseInt("1"))
                            .withFilters(Boolean.valueOf("true"))
                            .withCropEnabled(Boolean.valueOf("true"))
                            .withImgSize(Integer.valueOf("96"))
                            .build()
                            .startActivity(this);
        }
    }

```

##### To Pick Video

```
    new MediaPickerOpts.Builder()
                    .setMediaType(MediaType.VIDEO)
                    .canChangeScaleType(Boolean.valueOf("true"))
                    .withGallery(Boolean.valueOf("true"))
                    .withCameraType(ScaleType.SCALE_SQUARE)
                    .withFlash(Boolean.valueOf("true"))
                    .withMaxSelection(Integer.parseInt("2"))
                    .withFilters(Boolean.valueOf("true"))
                    .build()
                    .startActivity(this);

```

##### Handle Result

```

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        Result result = MediaPickerOpts.onActivityResult(requestCode, resultCode, data);
        if (result != null) {
            for (String file: result.files) {
                Log.d(TAG, "file: picked: " + file);
            }
        }
    }

```


text:
# Markdown for 5 different users
I have to create a application that is like a website where users have 20 images total. The user starts off by only clicking on a list of three items. Secondly The list then changes not showing the one previous to the user.
Thirdly, the user is given only 25 attempts at selecting items.
Fourthly, there is a counter of clicks near the end where a tally is held.

(users1) User Clicking/shopper
-this person -
A interface must be created so that they can click on various images; he/she is only listed with three images to start off with. Make a selection.

(users2) Inventory Guy
-the Inventory Manager-
This person keeps the Inventory of the images that is clicked, thus far its only 20 items.

(users3) Sales Guy
-Seller-
This is the guy that sells stuff he is responsible for selling items and probably wants to know what is the most clicked item pushed.

(users4) This is me the person that develops the app
-the developer-
I want to start off by loading all the images into containers,
I then want to make a random kicker, then I want to make a random thing
that lets people pick.

(users5) This is the guy who hired me
-the Owners-
He wants overall total control to add select, change and manipulate what is in the Mall buss

repository: Playingtygre/BusMall

gha_language: JavaScript

repo_name: Playingtygre/BusMall


text:
## TypeExtensions

Property and method metadata can be obtained for a `Type` using various reflection methods. It can be difficult, however, to easily extract that information when you need to filter down to specific requirements. `AllOverIt` includes several methods to simplify the process.

The following class is used in the examples below:

```csharp
public class PersonBase
{
  protected int Id { get; set; }
}

public class Person : PersonBase
{
  public string FirstName { get; set; }
  public string Surname { get; set; }
}
```

### GetPropertyInfo()

```csharp
public static PropertyInfo GetPropertyInfo(this Type type, string propertyName);

public static IEnumerable<PropertyInfo> GetPropertyInfo(this Type type,
  BindingOptions binding = BindingOptions.Default, bool declaredOnly = false);
```

Getting `PropertyInfo` for public or protected properties, by name, is as simple as:

```csharp
var firstNameInfo = typeof(Person).GetPropertyInfo("FirstName");
var surnameInfo = typeof(Person).GetPropertyInfo("Surname");

// assuming 'subject' is of type 'Person'
var firstName = firstNameInfo.GetValue(subject);
var surname = surnameInfo.GetValue(subject);
```

To get the `PropertyInfo` of select properties, use any of the following:

```csharp
// all public and protected properties
var allInfo = typeof(Person).GetPropertyInfo();

// all properties, including internal and private
var allInfo = typeof(Person).GetPropertyInfo(BindingOptions.All);

// all properties, including internal and private, of the declared class only
// (will not return Id)
var allInfo = typeof(Person).GetPropertyInfo(BindingOptions.All, true);
```

### GetMethodInfo()

```csharp
public static MethodInfo GetMethodInfo(this Type type, string name);

public static MethodInfo GetMethodInfo(this Type type, string name, Type[] types);

public static IEnumerable<MethodInfo> GetMethodInfo(this Type type,
  BindingOptions binding = BindingOptions.Default,
  bool declaredOnly = false);
```

Getting `MethodInfo` for any static, instance, public, or non-public method can be obtained by name and, where required, by a list of argument types.

```csharp
// get MethodInfo for StringBuilder.Clear()
var methodInfo = typeof(StringBuilder).GetMethodInfo("Clear");

// get MethodInfo for the StringBuilder.AppendFormat() overload:
// public StringBuilder AppendFormat(string format, params object[] args);
var methodInfo = typeof(StringBuilder).GetMethodInfo(
  "AppendFormat",
  new[] {typeof(string), typeof(object[])});
```

The same functionality is also available in the `ReflectionHelper` namespace.  Refer to [Obtain Method Information](../reflection.md#obtain-method-information) for more information.

repository: mjfreelancing/AllOverIt

gha_language: C#

repo_name: mjfreelancing/AllOverIt


text:
# Test Policy {#TestPolicy}

[TOC]

# Overview

Document authors: A. Zschutschke

This document is created as template for teaching purposes, please adapt to
your own project needs. Usually, your organisation should supply a Test Policy
document, which acts as basis for the organisation's \ref TestStrategy as well.

Please refer to the [definitions page](\ref Definitions) for details of
specific key words and phrases and explanation for abbreviations.

## Introduction

*ISO 29119* sets up this document as the top level (and most generic) test document in your
organisation, setting the north star for all test activities regarding their:

* motivation and objectives
* overall test process
* test organisation structure
* tester training and ethics
* standards
* measuring / assessment the value of testing
* asset archiving and reusing
* process improvement

From this, the test strategy for (parts of) the organisation can be forged, setting more
concrete guidelines for the actual test process in the organisation and how to implement
the target level of test quality. See *ISO 29119 part 2* for more details on the Test
Policy document, while the above bullet list should assemble a usable outline.


text:
SFDC QueryBuilder
=================

This is a Query Builder application, which is built using Google App Script (GAS) which connects to Salesforce. This provides UI which helps you to select
different objects from drop down and builds dynamic query which performs series of CRUD operations.

Set Up
---------

1. Goto http://script.google.com
2. create new project, add a new file code.gs (if it does not exits)
3. replace the content of code.gs with sfdcconnector.gs as shown below

```
function myFunction(){

}
```

```
var USERNAME_PROPERTY_NAME = "username";

function onInstall() {
    onOpen();
}
/* create menu and menu items here */
function onOpen() {
   ............
    }];
}

function saveConfiguration(e) {
 	...........
}
.... so on complete script
```

4. Save your project and give a name to it.
5. Goto Publish --> Deploy as web app.
6. Save it as a new version. You`ll get a confirmation message saying "This project is deployed as a web app"
7. Once done, goto http://docs.google.com and create a new spread sheet.
8. You can see "SFDC Connector" as a menu item and a modal dialog "Salesforce Configuration" will be displayed.
9. Fill in your credentials and security token (SFDC security token) and click "Login".
10. If you avoid step 9 and try to "Create" or "Run" any query, you will not be allowed to do that, you`ll be shown "Authorization Required" (the general app authorization dialog from google side).
11. Accept the "Permission" and continue.
12. Refresh the page and try to login with "Configuration" dialog. Once done. You`ll be able to pull data and build your custom query.

License
-------

    Copyright 2014 Naveen Kumar Aechan Vinod

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.


text:
# Darwin - helps to evolve your database schema

Darwin is one of our oldest libraries, which we still use extensively - its origins date back to 2007. It allows easy
evolution of the data model for your application. Darwin runs migration SQL scripts in a specific dialect according
to clearly defined rules. It probably originated much earlier than the open-source variants of
[Liquibase](https://www.liquibase.org/) or [FlywayDB](https://flywaydb.org/). It is also much simpler, but it represents
a reliable "[Kalashnikov](https://en.wikipedia.org/wiki/AK-47)" for us, which is universal and reliable in its
simplicity.

***Disclaimer:** we took original source code that works for more than 13 years in production and updated it to JDK 8 version
and up-to-date Java classes and Spring framework. Architecture, design and tests are mostly originates several years ago.*

The library allows you to maintain SQL scripts on classpath, allowing you to create the tables that your application
needs, not only for one specific database, but for different ones at once (ie in parallel you can maintain
both MySQL and Oracle schema for your universal libraries). Darwin decides which one to apply after starting
the application and finding out the database type from the [DataSource](https://docs.oracle.com/javase/7/docs/api/javax/sql/DataSource.html)
object.

As you further develop your application, you will soon find that the existing table structure does not suit you and
needs to be expanded or changed. To do this, all you have to do is to save the so-called patch files in the Darwin folder,
containing in your name the version number of the application for which this structure is needed. The next time you
start the application, Darwin will compare the current version of your application (ie the one you just started) with
the version it last applied to the database schema. If the application version is newer, it finds all patches between
the two versions and applies them to the schema one by one.

At the same time, Darwin pays close attention to the "transactionality" of changes, and even if the database does not
support transaction for schema changes (ie it cannot properly roll back DDL SQL statements), it remembers which SQL
statements it actually executed as part of the patch and which did not. Thanks to this, it can start its activity even
in the middle of a half-applied patch. This is especially handy in the development phase.

The library allows for a modular approach, so it can be instantiated in the application, for example, 20 times
for different shared libraries.

Darwin also pays great attention to the traceability of everything he has done with your database. All statements he
executed at your instruction are logged in its tables with all necessary information such as the date the patch was
discovered in the application, the date the patch was applied to the db, the duration of individual SQL statements,
any exception that fell out of the database when much more.

Darwin also includes a [Locker](src/main/java/one/edee/darwin/locker/Locker.java) tool that allows you to synchronize
tasks within a cluster if a shared database exists. Darwin uses this [Locker](src/main/java/one/edee/darwin/locker/Locker.java)
class to apply SQL patches to only one of the nodes when running the same application on multiple
nodes in a cluster at the same time, and the other instances of Darwin obediently wait for the migration to complete.
However, you can use the tool for other purposes. For example, we use it relatively actively to control the execution
of asynchronous tasks not only within the cluster, but also on one instance of the JVM.

For more information see section [How to use](#how-to-use)

## Prerequisites

- JDK 1.8+
- Commons Logging (1.2.0+)
- Spring framework (5.3.0+), works also on 4.3.X older version although not compilable due to JUnit tests

## Supported databases

- MySQL
- Oracle
- H2

Do you missing one? Fill a pull request!

## How to compile

Use standard Maven 3 command:

```
mvn clean install
```

## How to run tests

Start databases:

```
docker-compose -f docker/docker-compose.yml up
```

Run your tests in IDE or run:

```
mvn clean test
```

Help us maintain at least 80% code coverage!

## How to use

See separate chapters for details:

- [How to integrate to your project](src/main/resources/META-INF/darwin/docs/how-to-integrate-to-your-project.md)
- [How to create migration scripts](src/main/resources/META-INF/darwin/docs/how-to-create-migration-scripts.md)
- [How to switch to Darwin with existing database](src/main/resources/META-INF/darwin/docs/how-to-introduce-darwin-to-existing-db.md)
- [How to make programmable scripts](src/main/resources/META-INF/darwin/docs/how-to-make-programmable-scripts.md)
- [How to user locker for intra-cluster synchronization](src/main/resources/META-INF/darwin/docs/how-to-use-locker-synchronization.md)

## Implementation notes:

- [Versioning rules](src/main/resources/META-INF/darwin/docs/versioning.md)
- [Patch content rules and escaping](src/main/resources/META-INF/darwin/docs/content-rules.md)
- [Infrastructural tables](src/main/resources/META-INF/darwin/docs/infrastructural-tables.md)

repository: FgForrest/Darwin

repo_name: FgForrest/Darwin


text:
# Ignite-Curie

Ignite-Curie is an Ansible playbook meant to provision a personal server
running Arch Linux. It is intended to run locally on a fresh Arch install (ie,
taking the place of any post-installation), but due to Ansible's idempotent
nature it may also be run on top of an already configured machine.

Ignite-Curie will mount a fileserver and setup a plex server.
This behaviour may be changed by skipping the `media-server` tag.

## Running

First, sync mirrors and install Ansible:

    $ pacman -Syy python2-passlib ansible

Second, install and update the submodules:

    $ git submodule init && git submodule update

Run the playbook as root.

    $ ansible-playbook -i localhost playbook.yml

You can also use the `install.sh` script to automate these steps.

When run, Ansible will prompt for the user password. This only needs to be
provided on the first run when the user is being created. On later runs,
providing any password -- whether the current user password or a new one -- will
have no effect.

repository: rhwilr/ignite-curie

repo_name: rhwilr/ignite-curie


text:
# Setup

## Raspberry Pi

### Raspbian
- Go to https://www.raspberrypi.org/downloads/raspbian/ and download the raspbian image either with or without desktop.

- Go to https://etcher.io/ and download the etcher tool.

- Insert the micro SD card to the PC and intall the downloaded image via etcher.

### Boot Raspberry Pi

- Insert the MicroSD memory card into the Raspberry Pi
- Connect the USB keyboard
- Connect the HDMI cable
- Connect the Ethernet cable
- Connect the Power cable to boot the raspberry pi

### Setup SSH

- logon via user (pi) and pwd (raspberry)
- go to the raspberry config via
```bash
pi@raspberrypi:~ $ sudo raspi-config
```
- change user password via menu
- go to interface setting and enable SSH
- get and remember the ip address via
```bash
pi@raspberrypi:~ $ sudo ifconfig
```
- reboot the pi with
```bash
pi@raspberrypi:~ $ sudo reboot now
```

- switch to your "normal" pc
- get putty from https://www.putty.org/
- run putty and connect via ip address and port 22 connection type SSH
- you should now be connected to the pi via SSH

see also: https://www.w3schools.com/nodejs/nodejs_raspberrypi.asp

### Node.js Setup

- update & upgrade
```
$ sudo apt-get update
$ sudo apt-get dist-upgrade
```
- get nodejs
```
$ curl -sL https://deb.nodesource.com/setup_10.x | sudo -E bash -
$ sudo apt-get install -y nodejs
```
- install typescript
```
$ sudo npm install -g typescript
```

## Local development

### Setup

- create a project folder (PiBox) and init a project via:
```
$ npm init
```
- adapt the package json with the start script:
```json
"start": "tsc && node dist/index.js"
```

- add the typescript config file
```json
{
  "compilerOptions": {
    "module": "commonjs",
    "declaration": false,
    "noImplicitAny": false,
    "removeComments": true,
    "noLib": false,
    "allowSyntheticDefaultImports": true,
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "target": "es6",
    "sourceMap": true,
    "allowJs": true,
    "outDir": "./dist",
    "baseUrl": "./src"
  },
  "include": [
    "src/**/*"
  ],
  "exclude": [
    "node_modules",
    "**/*.spec.ts"
  ]
}
```
- install GPIO module for the pi (onoff)
```
$ npm install onoff -save
```

- create a folder src
- create a file index.ts in src

repository: princeV/pi-box

repo_name: princeV/pi-box


text:
# Connector PCB

This PCB was designed to plug into a [SparkFun ESP8266
Thing](https://www.sparkfun.com/products/13231).

It was designed in the [free version of Autodesk's Eagle
CAD](https://www.autodesk.com/products/eagle/free-download).

I had this manufactured by basicpcb.com which was very cheap and fast: it cost
about $15 since I paid an extra $8 for quick shipping and I received the board
in 8 calendar days.

Included is the original [stairwell.brd](./stairwell.brd) file, but I've also
included the [gerber zip file](./stairwell_2021-02-15.zip) that can be directly
uploaded to basicpcb.

The board dimensions are 1.5" x 1.05".

Here's the file to layer mapping:

file                   | layer
-----------------------|-------------------
copper_bottom.gbr      | Bottom Copper
copper_top.gbr         | Top Copper
drill_1_16.xln         | NC Drill
gerber_job.gbrjob      | Drawing/Other
profile.gbr            | Drawing/Other
silkscreen_bottom.gbr  | Bottom Silkscreen
silkscreen_top.gbr     | Top Silkscreen
soldermask_bottom.gbr  | Bottom Soldermask
soldermask_top.gbr     | Top Soldermask
solderpaste_bottom.gbr | Bottom Solderpaste
solderpaste_top.gbr    | Top Solderpaste

repository: augustoroman/stairwell-lights

repo_name: augustoroman/stairwell-lights


text:
# Tinkoff SDK for PHP

[![PHP Version](https://img.shields.io/badge/php-7.0%2B-blue.svg?style=flat-square)](https://packagist.org/packages/personnage/tinkoff-sdk)
[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE.md)
[![Build Status](https://travis-ci.org/personnage/tinkoff-sdk.svg?branch=master)](https://travis-ci.org/personnage/tinkoff-sdk)
[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/personnage/tinkoff-sdk/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/personnage/tinkoff-sdk/?branch=master)
[![StyleCI](https://styleci.io/repos/105796556/shield?branch=master)](https://styleci.io/repos/105796556)

---

## Installation :rocket:

```bash
$ composer require personnage/tinkoff-sdk
```

## Usage

```php
<?php

```

## Using Events

```php
<?php

```

## Change log

Please see [CHANGELOG](CHANGELOG.md) for more information on what has changed recently.

## Testing

```bash
$ composer test                            # run all unit tests
$ composer testOnly TestClass              # run specific unit test class
$ composer testOnly TestClass::testMethod  # run specific unit test method
```

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

repository: andreybolonin/tinkoff-sdk

repo_name: andreybolonin/tinkoff-sdk


text:
# activerules-run-parallel

### Run an array of functions in parallel

[![NPM version](https://img.shields.io/npm/v/activerules-run-parallel.svg)](https://www.npmjs.com/package/activerules-run-parallel)
[![Build Status](https://travis-ci.org/bwinkers/activerules-run-parallel.svg?branch=master)](https://travis-ci.org/bwinkers/activerules-run-parallel)
[![Code Climate](https://codeclimate.com/github/bwinkers/activerules-run-parallel/badges/gpa.svg)](https://codeclimate.com/github/bwinkers/activerules-run-parallel)
[![Coverage Status](https://img.shields.io/coveralls/bwinkers/activerules-run-parallel.svg)](https://coveralls.io/github/bwinkers/activerules-run-parallel)
[![Dependency Status](https://img.shields.io/david/bwinkers/activerules-run-parallel.svg?label=deps)](https://david-dm.org/bwinkers/activerules-run-parallel)
[![devDependency Status](https://img.shields.io/david/dev/bwinkers/activerules-run-parallel.svg?label=devDeps)](https://david-dm.org/bwinkers/activerules-run-parallel#info=devDependencies)
[![Known Vulnerabilities](https://snyk.io/test/github/bwinkers/activerules-run-parallel/badge.svg)](https://snyk.io/test/github/bwinkers/activerules-run-parallel)

### install

```
npm install activerules-run-parallel
```

### usage

#### parallel(tasks, [callback])

Run the `tasks` array of functions in parallel, without waiting until the previous
function has completed. If any of the functions pass an error to its callback, the main
`callback` is immediately called with the value of the error. Once the `tasks` have
completed, the results are passed to the final `callback` as an array.

It is also possible to use an object instead of an array. Each property will be run as a
function and the results will be passed to the final `callback` as an object instead of
an array. This can be a more readable way of handling the results.

##### arguments

- `tasks` - An array or object containing functions to run. Each function is passed a
`callback(err, result)` which it must call on completion with an error `err` (which can
be `null`) and an optional `result` value.
- `callback(err, results)` - An optional callback to run once all the functions have
completed. This function gets a results array (or object) containing all the result
arguments passed to the task callbacks.

##### example

```js
var parallel = require('activerules-run-parallel')

parallel([
  function (callback) {
    setTimeout(function () {
      callback(null, 'one')
    }, 200)
  },
  function (callback) {
    setTimeout(function () {
      callback(null, 'two')
    }, 100)
  }
],
// optional callback
function (err, results) {
  // the results array will equal ['one','two'] even though
  // the second function had a shorter timeout.
})
```

This module is basically equavalent to
[`async.parallel`](https://github.com/caolan/async#paralleltasks-callback), but it's
handy to just have the one function you need instead of the kitchen sink. Modularity!
Especially handy if you're serving to the browser and need to reduce your javascript
bundle size.

The difference is we swallow errors.

### license

MIT. Copyright (c) [Brian Winkers]

Checkout [ActiveRules Phalcon](https://github.com/bwinkers/docker-php7-phalcon)

repository: bwinkers/activerules-run-parallel

repo_name: bwinkers/activerules-run-parallel


text:
_Master branch (Jekyll) is deprecated.  Please see the gh-pages branch._

FYI: hcc.colorado.edu points to http://hcc.colorado.edu.s3-website-us-east-1.amazonaws.com/, contact OIT to change this for any reason...

---

CU Human Centered Computing Website
=====================================
_Built on Jekyll Bootstrap, this site finds a balance between a static and dynamic website._

This site pulls data from Flickr, Google Scholar, and Google Drive.

The database, therefore, is a series of google spreadsheet, offering a familiar UI for any user to update.

The majority of the images are hosted on flickr and organized by tags.  Values in the description of the image inside of square brackets ```[]``` are merged with existing flickr tags to organize images.

The site is built and maintained using the [Static-Bliss](http://github.com/jenningsanderson/Static-Bliss) gem. This gem requires ```_config.yml``` to be properly defined (See [Configuration](#configuration))

## Publishing
The site should function when hosted on Github, provided the YAML files are up-to-date thorugh the bliss update functions.

The site is designed to be published to an amazon s3 bucket:
[HCC-Colorado on S3](http://hcc.colorado.edu.s3-website-us-east-1.amazonaws.com/)

If you would like ability to publish the site, just email Jennings and he'll provide access to the S3 bucket.

The gh-pages branch here is for development and production is then pushed out to the s3 bucket: http://hcc.colorado.edu.s3-website-us-east-1.amazonaws.com/ (which is where hcc.colorado.edu points).

## Configuration

### _config.yml

````
sheets :
  courses :
    key     : 0AhQ6tqeOTfwBdDdyY1U4UlBnTk5rc1BIRDhnckhoQ1E
    object  : Course
    types   : ['Undergraduate', 'Graduate']

  people  :
    key     : 0AhQ6tqeOTfwBdFhrTmxXM0oxYkx2Vl9ucXJpd0hQRHc
    object  : Person
    types   : ['Faculty', 'Students', 'Alumni', 'Researchers']

flickr:
  hcc_photos :
    set : '72157646414725101'

data_directory : './_data'

credentials: _secret_config.yml
````

### _secret_config.yml

````

#Amazon S3 hcc_colorado account credentials
s3_id: *************
s3_secret: *************
production_bucket: hcc.colorado.edu

flickr_api_key : ***************
````

## Bootstrap License
[MIT](http://opensource.org/licenses/MIT)

repository: Project-EPIC/hcc-colorado

repo_name: Project-EPIC/hcc-colorado


text:
---
id: 75
title: 'PHP Coders  - Please Think More Carefully About Code Layout'
date: 2010-05-14T08:30:12+00:00

layout: single

guid: http://gregwoods.co.uk/?p=75
permalink: /2010/05/php-coders-please-think-more-carefully-about-code-layout/
categories:
  - Programming
---
I've only recently started to use PHP again, but have coded a lot of classic ASP over the last few years, and both platforms share the same potential annoyances in code layout. Both languages were designed for the easy intermingling of server side code and html. Whilst I like this ease, it can result in spagetti code. My top tip is to make a decision. Your page is either:

  1. Almost entirely server side code with some html. In his case, replace most of your inline php tags with print commands. More code, but easier to read
  2. An html template with a scattering of simple, server-side placeholder variables. In this case, don't put any logic in the inline php, move it elsewhere

My second gripe is around indenting, and placement of php tags.  Here's a php code fragment from the WordPress Codex:

```php
<?php $my_query = new WP_Query('category_name=featured&posts_per_page=1');
while ($my_query->have_posts()) : $my_query->the_post();
    $do_not_duplicate = $post->ID; ?>
Html block here
<?php endwhile; ?>
```

I find the above pretty nasty. The sample below is my preferred formatting. I have:

  1. Given priority to the server-side code for indenting. Everything between the while and endwhile is indented one tab, even the code outside of the php tags
  2. Made it clear when we switch between server-side and client-side code. By putting the opening and closing php tags on their own line. It will be easier to read context switches between server-side and html code.

```php
<?php
$my_query = new WP_Query('category_name=featured&posts_per_page=1');
while ($my_query->have_posts()) :
    $my_query->the_post();
    $do_not_duplicate = $post->ID;
    ?>
    Html block here
    <?php
endwhile;
?>
```

My formatting may be more lines of code, but it is easier to see what is going on.

gha_language: SCSS


text:
Day 2: Operators

Objective

In this challenge, you'll work with arithmetic operators. Check out the Tutorial tab for learning materials and an instructional video!

Task

Given the meal price (base cost of a meal), tip percent (the percentage of the meal price being added as tip), and tax percent (the percentage of the meal price being added as tax) for a meal, find and print the meal's total cost.

Note: Be sure to use precise values for your calculations, or you may end up with an incorrectly rounded result!

Input Format

There are 3 lines of numeric input:

The first line has a double, mealCost (the cost of the meal before tax and tip).

The second line has an integer, tipPercent (the percentage of mealCost being added as tip).

The third line has an integer, taxPercent (the percentage of mealCost being added as tax).

Output Format

Print The total meal cost is totalCost dollars., where totalCost is the rounded integer result of the entire bill (mealCost with added tax and tip).

Sample Input

12.00

20

8

Sample Output

The total meal cost is 15 dollars.

Explanation

Given:

mealCost = 12, tipPercent = 20, taxPercent = 8

Calculations:

tip = 12 x (20 / 100) = 2.4

tax = 12 x (8 / 100) = 0.96

totalCost = mealCost + tip + tax = 12 + 2.4 + 0.96 = 15.36

round(totalCost) = 15

We round totalCost to the nearest dollar (integer) and then print our result:

The total meal cost is 15 dollars.

url: https://raw.githubusercontent.com/mannut2014/HackerRank-solutions-1/a58d5c909a2ad29c9d5a638a3f0571b50fe7322a/30 Days of code/Problem statement/Day 2/Readme.md


text:
---
layout: default
---

# 1995-09-16 - Re: CYPHERPUNK considered harmful.

## Header Data

From: Black Unicorn<EMAIL_ADDRESS>To: Peter Trei<EMAIL_ADDRESS>Message Hash: 9b695b75b85e9134f070e52900ab7c592645c0dadea4afef4d02517e9660c219

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1995-09-16 16:31:09 UTC

Raw Date: Sat, 16 Sep 95 09:31:09 PDT

## Raw message

```
{% raw  %}From: Black Unicorn<EMAIL_ADDRESS>Date: Sat, 16 Sep 95 09:31:09 PDT
To: Peter Trei<EMAIL_ADDRESS>Subject: Re: CYPHERPUNK considered harmful.
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

On Fri, 15 Sep 1995, Peter Trei wrote:

> -----BEGIN PGP SIGNED MESSAGE-----
>
>      Think about it. Which future would you rather see:
>
> 1. Lots of people demanding strong unescrowed crypto for what you
>    consider rather peripheral and politically unaware reasons, which
>    you have educated them in.
>
> 2. Unescrowed crypto banned, with those who promote considered
>    aiders and abeters of the four horsemen, (but boy are they
>    ideologically pure!).

3. Unescrowed crypto banned, with advanced stego, panic passwords,
stealth PGP, incorporated remailers all across international borders
making offenders impossible to identify or catch.

Given the degree to which I believe 1. unlikely in the numbers required
to avoid the unescrowed encryption ban, I believe the goal is to
propogate crypto far enough to at least have a salient "underground"
participants.

Some months ago I called for advanced stego and stealth PGP as well as
larger keys in the event we all had to go "into the crypto closet" for a
time.

I call for them again.

>
> Peter Trei
>
> I probably won't see any responses till Monday. I'm going for a
> weekend at a resort on Lake Winnipesaukee. If you need me, I'll be
> in the hot tub. :-)
>
>
>
>
>
>
>
> -----BEGIN PGP SIGNATURE-----
> Version: 2.6.2
>
> iQCVAwUBMFmmK1QxhKXe9s8VAQE+tgP+NcKdGvBeJpa8AHGr/RhKCHudZP2qmRNP
> J699UCCvN006ywIjurjuis48VPj26uxBkcRbeuzNxGlKmZqXIkS0vEcFjrrZhBsK
> V9dLFFGTZ6JG3nK++mleW1wQB/F0azXXvXKJWa6R+Tnj1oo2ADUxGNQMs9IVmgR3
> zsyK3fej+IQ=
> =YqDH
> -----END PGP SIGNATURE-----
>
> Peter Trei
> Senior Software Engineer
> Purveyor Development Team
> Process Software Corporation
> http://www.process.com
><EMAIL_ADDRESS>>

{% endraw %}
```

## Thread

+ Return to [September 1995](/archive/1995/09)

+ Return to "[Black Unicorn <unicorn@polaris.mindport.net>](/authors/black_unicorn_unicorn_at_polaris_mindport_net_)"
+ Return to "["Peter Trei" <trei@process.com>](/authors/peter_trei_trei_at_process_com_)"

+ 1995-09-15 (Fri, 15 Sep 95 12:15:22 PDT) - [Re: CYPHERPUNK considered harmful.](/archive/1995/09/ba11a67bb709d2a18650d30db5cd22d175dabc59b9bd8a1b1d13a0192a694f73) - _"Peter Trei"<EMAIL_ADDRESS>  + 1995-09-16 (Sat, 16 Sep 95 09:31:09 PDT) - Re: CYPHERPUNK considered harmful. - _Black Unicorn<EMAIL_ADDRESS>


text:
---
layout: page
title: Contributing to The Toolsmiths Codex
permalink: /contributing_to_the_toolsmiths_codex/
---
{% include JB/setup %}

The Toolsmiths Codex is ever growing knowledge base about Game Tools  Development. It needs your help and expertise to be the best that it can be and stay up to date on the latest and greatest. There are a couple of ways you can help and contribute.

1. The easiest way to contribute is to join our [Discord server](https://discord.gg/k4PuzbZ){:target="_blank"} and share your experience, ideas, links to excellent articles and videos.
2. Another way to contribute is to create a Pull Request on [our Github page](https://github.com/TheToolsmiths/TheToolsmiths.github.io). The process would look something like this:
* find a page you want to improve
* click on the ["Improve this page"](https://github.com/TheToolsmiths/TheToolsmiths.github.io/edit/wiki/{{ page.path }}) link
* make a fork of [TheToolsmiths.github.io](https://github.com/TheToolsmiths/TheToolsmiths.github.io)
* make your changes and submit the pull request
3. For ideas and feedback regarding the [website](thetoolsmiths.org), [blog](http://thetoolsmiths.org/blog) or [codex](http://thetoolsmiths.org/codex) join our **#meta** channel in our [Discord server](https://discord.gg/k4PuzbZ){:target="_blank"}. We will be happy to hear from you!

If you have any questions, don't hesitate to ask! Join our [Discord server](https://discord.gg/k4PuzbZ){:target="_blank"}
and ask away!


text:
---
id: version-2.2-schema-organization
title: Schema organization
original_id: schema-organization
---

As you add more and more types to your schema, it can grow quite large.
Learn how to split your schema across multiple files and organize your types.

## Schema Imports

Suppose you created your schema files likes this:

```
graphql/
|-- schema.graphql
|-- user.graphql
```

Lighthouse reads your schema from a single entrypoint, in this case `schema.graphql`.
You can import other schema files from there to split up your schema into multiple files.

```graphql
type Query {
  user: User
}

#import user.graphql
```

Imports always begin on a seperate line with `#import `, followed by the relative path
to the imported file. The contents of `user.graphql` are new pasted in the final schema.

```graphql
type Query {
  user: User
}

type User {
    name: String!
}
```

The import statements are followed recursively, so it is easy to organize even the most complex of schemas.

## Type Extensions

Suppose you want to add a new type `Post` to your schema. First step, you create a new file `post.graphql`
to contain the schema for that type.

```graphql
type Post {
  title: String
  author: User @belongsTo
}
```

Then you add an import to your main schema file.

    #import post.graphql

Now you want to add a few queries to actually fetch posts. You could add them to the main `Query` type
in your main file, but that spreads the definition apart and could also grow quite large over time.
Another way would be to extend the `Query` type and colocate the type definition with its Queries in `post.graphql`.

```graphql
type Post {
  title: String
  author: User @belongsTo
}

extend type Query {
  posts: [Post] @paginate
}
```

repository: nuwave/lighthouse-docs

gha_language: CSS

repo_name: nuwave/lighthouse-docs


text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [0.3.1] - 2022-02-01

### Fixed

- Fixed default container bindings not being registered correctly if package config has not been published (fixes #5)

## [0.3.0] - 2022-01-30

### Added

- Added support for Laravel 9

## [0.2.1] - 2022-01-04

### Fixed

- Update incorrect namespace in spider stub (#4). Credits @RyanPriceDotCa

## [0.2.0] - 2021-12-28

### Changed

- Bump `roach-php/core` dependency to `^0.2.0` which includes a middleware to execute
  Javascript on a page.

## [0.1.0] - 2021-12-27

### Added

- Initial release

[0.3.1]: https://github.com/roach-php/laravel/compare/0.3.0...0.3.1
[0.3.0]: https://github.com/roach-php/laravel/compare/0.2.1...0.3.0
[0.2.1]: https://github.com/roach-php/laravel/compare/0.2.0...0.2.1
[0.2.0]: https://github.com/roach-php/laravel/compare/0.1.0...0.2.0

repository: isaacongoma/laravel

repo_name: isaacongoma/laravel


text:
---
title: "Appendix: Go Data Types and Templates"
description: "A quick overview on variables in templates."
weight: 16
---

The Helm template language is implemented in the strongly typed Go programming
language. For that reason, variables in templates are _typed_. For the most
part, variables will be exposed as one of the following types:

- string: A string of text
- bool: a `true` or `false`
- int: An integer value (there are also 8, 16, 32, and 64 bit signed and
  unsigned variants of this)
- float64: a 64-bit floating point value (there are also 8, 16, and 32 bit
  varieties of this)
- a byte slice (`[]byte`), often used to hold (potentially) binary data
- struct: an object with properties and methods
- a slice (indexed list) of one of the previous types
- a string-keyed map (`map[string]interface{}`) where the value is one of the
  previous types

There are many other types in Go, and sometimes you will have to convert between
them in your templates. The easiest way to debug an object's type is to pass it
through `printf "%t"` in a template, which will print the type. Also see the
`typeOf` and `kindOf` functions.

repository: helm/helm-www

repo_name: helm/helm-www


text:
# Ochlandra scriptoria (Dennst.) C.E.C.Fisch. SPECIES

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
J. S. Gamble et al. , Fl. Madras 3(10):1863. 1934 (Bull. Misc. Inform. 1935:149, in observ. 1935)

#### Original name
null

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone