text:
# Intermediate Representation (IR) Classes {#irdefs}

The IR classes are automatically generated by tools/ir-generator
from \*.def files.  The .def files contain class definitions with
boilerplate removed, which the ir-generator generates.

##### ir.h
  Top level include file that just includes everything else.  Code outside this
  folder generally just includes this file.

##### ir-inline.h ir-tree-macros.h ir-util.h
  IR support stuff.  `ir-inline.h` has inline methods for things in header
  files that can't be defined until after other header files are included.
  `ir-tree-macros.h` has macros for generating code referring to all IR
  classes, used by the visitors.

##### node.h node.cpp
  `IR::Node` base class.

##### id.h
  Defines the `ID` struct, which is not a standalone IR class, but is used
  in many places in IR classes, representing an identifier with associated
  source location (for error reporting).

##### ir.def ir.cpp
   Miscelaneous front-end IR classes.

##### v1.def, v1.cpp
   IR classes only needed to process P4 v1.0 / v1.1 programs

##### expression.def expression.cpp
  IR classes related to expressions.  The `Expression` abstract class is
  base for all expressions, and contains a `type` field.  Abstract subclasses
  include `Operation`, `Unary`, `Binary`, and `Trinary`, with concrete
  subclasses:

        Expression
        +-- Operation
        |   +-- Operation_Unary
        |   |   +-- Neg, Cmpl, LNot, UPlus
        |   |   \-- Member, Cast
        |   +-- Operation_Binary
        |   |   +-- Mul, Div, Mode, Add, Sub, Shl, Shr
        |   |   +-- Operation_Relation
        |   |   |   \-- Equ, New, Lss, Leq, Grt, Geq
        |   |   +-- BAnd, BOr, BXor, LAnd, LOr
        |   |   \-- Concat, ArrayIndex, Range, Mask
        |   +-- Operation_Trinary
        |   |   \-- Slice, Mux
        |   \-- Primitive
        \-- Constant, ...

##### typedecl.def type.cpp
  IR subclasses related to types and declarations.

##### namemap.h
  IR subclass template `NameMap`, which holds a set of named IR objects and
  supports lookups by name.  `NameMap` supports transforms that return null or
  additional `NameMap` objects for IR objects in the `NameMap` to modify the
  `NameMap`.

##### vector.h
  IR subclass template `Vector`, which holds a vector of IR objects.
  This is largely equivalent to a `vector`, except that it is a subclass
  of `IR::Node` so it can be included in an IR tree as a first-class
  member, with its own traversal code (visitor subclass preorder and
  postorder functions).  Automatically flattens any sub-`Vector` objects
  and removes null when transforms on elements of the vector return them.

###### indexed_vector.h
  IndexedVector: contains a Vector and also an index mapping cstrings
  to IDeclarations for all objects in the vector that are IDeclarations.

##### dbprint.h dbprint.cpp dbprint-expression.cpp dbprint-p4.cpp
  Debug printing routines.  Most IR classes declared a `dbprint` method,
  which are defined here.  The header contains flags and support that
  dbprint methods use to communicate formatting information (indentation,
  precendence, and format mode).

##### std.h
  using directives for a bunch of `std::` classes that are heavily used in
  the code.  `std::vector` is instead wrapped (as `vector`) with a version
  that automatically uses bounds-checking for *all* indexed accesses.

##### visitor.h visitor.cpp
  `Visitor` base class, and `Inspector`, `Modifier`, and `Transform` subclass
  definitions, along with `ControlFlowVisitor`, `Backtrack` and `P4WriteContext`
  mixin interfaces.

##### pass\_manager.h pass\_manager.cpp
  `PassManager` subclass (of `Visitor`) which manages an arbitrary sequence of
  `Visitor`s, and handles backtracking between passes.


text:
# Pattern Matching

Julia supports regular expressions or regexes for string matching. The expressions must be compliant with the
[Perl Compatible Regular Expressions](http://www.pcre.org/) library.

A regular expression in Julia is denoted by a leading `r`. For example, a regular to match comments will look like:
```julia
r"^\s*(?:#|$)"
```

The `ismatch`, `match` and `replace` functions accept regular expressions.

## Matching Letters

To check if a string consists of only alphabetic characters:

```julia
julia> ismatch(r"^[A-Za-z]*$", "asdf")
true

julia> ismatch(r"^[A-Za-z]*$", "asdf123")
false
```

## Matching Words

Use the `\b` character to match at word boundaries.

```julia
julia> match(r"\bthe\b", "read the thesaurus").offset
6
```

## Finding the nth match

The `matchall` function can be used to return all occurrences of a pattern in a string. To nth match
can then be retrieved using an indexing. For example, to find the third integer in a string:

```julia
julia> matchall(r"[0-9]+", "12 apples plus 1 make 13")[3]
"13"
```

However, for larger strings, it may take a while to generate all matches. For such cases:

```julia
function nth_occurance(pattern::Regex, n::Int, str::String)
   count = 1
   idx = 1
   while idx <= length(str)
      m = match(pattern, str, idx)
      if m == nothing
         return
      elseif(count == n)
         return m.match
      else
         count += 1
         idx = m.offset + length(m.match) + 1
      end
   end

   return
end

julia> nth_occurance(r"[0-9]+", 3, "12 plus 1 make 13")
"13"
```

license: MIT

repository: pranavtbhat/JuliaCookbook

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: pranavtbhat/JuliaCookbook


text:
# XMPP_Parking
## Consists of Openfire Server and Smack Clients.

The openfire server stores the map for parking lot and has the information of all the empty and occupied parking positions in the parking area. Parking Model consists of sensor attached to every parking slot. These sensors run Smack-tcp client to send their status to the server. Also every new car arriving runs a smack client as well and makes a request to openfire server to get and reserve a empty parking slot. All the connections and request goes over TCP with TLS authentication using XMPP Protocol. Multiple client tries to connect to server in separate threads over same socket. The service time of each client is noted to study the queuing delay r waiting time for customers to get their request served.Traffic coming to the server follows the poisson arrival.

## Code Changes:-
### Server side handling:-
* ClientStanzaHandler.java
* AdminConsolePlugin.java

File Location:-
* openfire_src/src/java/org/jivesoftware/openfire/net/ClientStanzaHandler.java
* openfire_src/src/java/org/jivesoftware/openfire/container/AdminConsolePlugin

### Client side changes:-
Created new folder client in smack-tcp. Clients thread are running and service time for each client is noted to evaluate prformance. Clients are arriving according to Poisson Distribution.

Folder Location:- smack-tcp/src/main/java/org/jivesoftware/smack/tcp/client

Files added:-
* XMPPOpenfireConnection.java
* abstractClientWrapper.java
* clientsThread.java
* putClient.java
* getClient.java
* deleteClient.java

## Installation and run:-
### Pre requisites
* Install ant to build openfire server and gradle to build smack client.
* Install eclipse and import smack-core, smack-java7, smack-resolver-javax, smack-sasl-javax and smack-tcp projects.
* Add smack-java7 as build dependency in smack-tcp.
* Add math3 jars present at Smack-master/Jars as external jar to resolve errors
* From terminal go inside each folder in the above sequence and run $ gradle eclipse build

### Openfire build and start server
Inside folder openfire_src/build run following command

$ ant

Now after successful build go to folder openfire_src/target/openfire/bin and run

$ ./openfire.sh

Follow the steps in http://www.2daygeek.com/install-openfire-instant-messaging-server-on-ubuntu-centos-debian-fedora-mint-rhel-opensuse/# to "Configure openfile server" on the listening address displayed on terminal.
Activate required plugins to allow client interaction by going to plugin tabs and see list of Available Plugins.

### Running Smack Client
Inside Smack-master/smack-tcp/src/main/java/org/jivesoftware/smack/tcp/client run XMPPOpenfireConnection.java


text:
## Requires

- node
- npm

## Instructions

Ports 3000 and 400 need to be available.

```sh
npm install
```

```sh
npm start
```

repository: Sandalf/react-dashboard

repo_name: Sandalf/react-dashboard


text:
---
slug: covid-19--athletic-facilities-and-swimming-pool-closed
title: "COVID-19 | Athletic facilities and Swimming pool: Closed"
date: January 01 2020
---

  This message was sent to all students, faculty, and staff on Friday, March
    13 ,2020.

  To address health and safety concerns, we are closing the
  Otter Sports Center, including the gymnasium, locker rooms, weight training area, and cardio
  fitness areas, until further notice.

  The
  Aquatic Center
  facilities, including open swim hours, are also closed until
  further notice.

  Thank you for your understanding, and we apologize for the inconvenience this
  may cause.

  Stay up to date on all COVID-19 related changes on the
  CSUMB COVID-19 webpage.

repository: csumb-archives/news-gatsby

gha_language: JavaScript

gha_license_id: MIT

repo_name: csumb-archives/news-gatsby


text:
# The Dependencies package

This package allows you to declare dependencies irrespective of how they will be
later installed. This way you can be dependency manager agnostic.

## Usage

You can inject the `dependencies` object and call `addDependency(type, id, options)`
on it.

- `type` is a string telling what kind of dependency it is. Currently recognised types are `client-js`, `node-js`, `client-js-dev` and `node-js-dev`. The `dev` suffix indicates a developemnt depedency.
- `id` is the name/url of the dependency. This will end up being passed to dependency manager.
- `options` is an object that specifies other properties of the dependency. A comonly recognised option is `version`.

## Implementing a dependency manager

You can call the `dependencies(type)` method on the `dependencies` object. This
will give you an array of dependencies of that particular type.

repository: gampleman/praxis-client-generator

repo_name: gampleman/praxis-client-generator


text:
# Authentication

You can pick `localStorage` or `cookies`.

If you want have universal shared auth `cookies` are useful to share cookie values while `localstorage` is not.

e.g: if you want to create shared auth or language for both `cleo.one`, `app.cleo.one` and `blog.cleo.one` use [cookieManager.js](https://github.com/cleo-one/front-end-docs/blob/master/snippets/cookie/cookieManager.js)

repository: CLEO-one/front-end-docs

repo_name: CLEO-one/front-end-docs


text:
iop
===

Static analysis tools, sample exploits, and bugdoor discussed in my paper *Interrupt-oriented
Programming in Microcontrollers: Codeless and Dataless Attacks and Backdoors*

By Samuel J. Tan<EMAIL_ADDRESS>
Repo organization
------------------
- **asm/**:		MSP430 assembly source code for synthetic IOP exploits
- **bugdoor/**:   	Patch for TinyOS 2.0 to implant IOP bugdoor
- **idapython/**: 	IDAPython static analysis scripts
- **mspdebug/**:  	Patch for mspdebug-0.22 to implement static analysis tools
- **schematics/**: 	Schematics for GoodFET42-JTAG
- **LICENSE**:    	License for using the contents of this repo
- **README.md**:  	This file

repository: Trietptm-on-Coding-Algorithms/iop

repo_name: Trietptm-on-Coding-Algorithms/iop


text:
## Tools for verifying Kubernetes packages

The tests in this folder run periodically and their status is available here:
https://k8s-testgrid.appspot.com/sig-cluster-lifecycle-all

### Package publishing

The `verify_packages_published.sh` script verifies that the necessary DEB/RPM packages are published to official repositories.

Running locally:
```
docker run -it -v $(pwd):/test debian:stretch /test/tests/e2e/packages/verify_packages_published.sh
```

### Package installation

The `verify_packages_install_deb.sh` verifies that the DEB packages from our release repositories and CI build
can be installed and uninstalled successfully.

Running locally:
```
docker run -it -v $(pwd):/test debian:stretch /test/tests/e2e/packages/verify_packages_install_deb.sh
```

repository: android-coco/kubeadm

gha_language: Python

repo_name: android-coco/kubeadm


text:
# mp-esp8266
Using the esp8266 with micropython

## board
I'm using the esp8266 board from Olimex : [MOD-WIFI-ESP8266-DEV](https://www.olimex.com/Products/IoT/MOD-WIFI-ESP8266-DEV/open-source-hardware)

[Here](docs/mp-mod-wifi-esp8266-dev.md) is some documentation about using this board with micropython.

For easier testing, I'm using the [ESP8266-EVB-BAT](https://www.olimex.com/Products/IoT/ESP8266-EVB-BAT/open-source-hardware
), from Olimex too
It's shipped with an MOD-WIFI-ESP8266-DEV that can be removed, so the ESP8266-EVB-BAT is more an addon for the esp8266 board

[Here](docs/mp-esp8266-evb-bat.md) is some documentation about using this addon board with micropython


text:
ToFactory :wrench:
=========

[![Maintainability](https://api.codeclimate.com/v1/badges/34f4377c5b911bcb4433/maintainability)](https://codeclimate.com/github/markburns/to_factory/maintainability)
[![Test Coverage](https://api.codeclimate.com/v1/badges/34f4377c5b911bcb4433/test_coverage)](https://codeclimate.com/github/markburns/to_factory/test_coverage)
[![Gem Version](http://img.shields.io/gem/v/to_factory.svg)](https://rubygems.org/gems/to_factory)
[![License](http://img.shields.io/:license-mit-blue.svg)](http://markburns.mit-license.org)

Easily add factories with valid data for an existing project.

If you find yourself retro-fitting tests this gem will save you some of the legwork.

* auto-generate all factories
* adhoc generate from existing records
* unintrusively update factory files in place
* display factory definition for a record
* parse and write `FactoryBot` syntax

Tested against Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0,  2.1.x, 2.2.x

## Warning :warning:
`ToFactory` writes into the `spec/factories` folder. Whilst it
is tested and avoids overwriting existing factories,
it is recommended that you execute after committing or when in a known
safe state.

## Installation :file_folder:

```ruby

#Gemfile
#add to whichever environments you want to generate data from
group :test, :development do
  gem 'to_factory'
end
```

```bash
git add spec/factories
git commit -m "I know what I am doing"
rails c
>ToFactory()
```
## Example :computer:

```ruby
#Generate all factories
ToFactory()
#outputs the first record of each ActiveRecord::Base subclass in the models folder
#to spec/factories

#Choose input/output directories
ToFactory.models    = "models/this/subfolder/only" #default "./app/models"
ToFactory.factories = "spec/support/factories"     #default "./spec/factories"
ToFactory()

#Exclude classes
ToFactory(exclude: [User, Project])

#Use Adhoc instances from the console
ToFactory User.last

#writes to spec/factories/user.rb
FactoryBot.define
  factory(:user) do |u|
    email<EMAIL_ADDRESS>    name "Mike"
  end
end

#List defined factory names
ToFactory.definitions
#=> [:user, :admin, :project]

#Display definition from record
ToFactory.definition_for @user

#Display existing definition from name
ToFactory.definition_for :admin

#doesn't overwrite existing factories
ToFactory User.last
#Exception =>
#ToFactory::AlreadyExists: an item for each of the following keys :user already exists

#Choose specific name
ToFactory :admin => User.last
#appends to spec/factories/user.rb

```

### Other useful projects

If you are adding specs to an existing project you may want to look at:

* [rspec-kickstarter](https://github.com/seratch/rspec-kickstarter) (auto generate specs)
* [rspec-kickstarter-vintage](https://github.com/ifad/rspec-kickstarter-vintage) (for Ruby 1.8/Rspec 1.x)
* [hash_syntax](https://github.com/michaeledgar/hash_syntax) (convert 1.8 syntax to 1.9 and vice-versa)
* [transpec](https://github.com/yujinakayama/transpec) (convert old rspec syntax to new expect syntax)

branch_name: refs/heads/main

gha_language: Ruby


text:
# Getting started with webpack and ES6 modules – the demo

- This demo project is complimentary to the article, "[Getting started with webpack and ES6 modules](https://medium.com/@svinkle/getting-started-with-webpack-and-es6-modules-c465d053d988)"
- [See this demo in action](https://svinkle.github.io/getting-started-with-webpack-and-es6-modules-the-demo/)!
- Made with 💖 by [@svinkle](https://twitter.com/svinkle)

## License

This project and its source code is licensed under the [MIT](LICENSE.txt) license.

repository: Inkernel/recupera

repo_name: Inkernel/recupera


text:
HonBot-Client [![devDependency Status](https://david-dm.org/scttcper/honbot-client/dev-status.svg)](https://david-dm.org/scttcper/honbot-client#info=devDependencies)
=============
HonBot is a [Heroes of Newerth (HoN)](http://www.heroesofnewerth.com/) statistics website for the [HoN API](http://api.heroesofnewerth.com/).

This repo contains the frontend for honbot.com

##Installation
```bash
npm install gulp -g
npm install bower -g
npm install
bower install
gulp serve
```

##Scripts
#### large_hero
Run this to download all large image cutouts for the homepage. Will output a txt file with paths to images. Place this in largeHero.js.
Also downloads hero icons and creates and object of hero names.
```
python large_hero
```

#### item_setup
downloads icon images and creates json object in items.txt. Place in itemlist.js
```
python item_setup
```

repository: hassanbazzi/honbot-client

repo_name: hassanbazzi/honbot-client


text:
---
---
# Login Page

The login page allows a user to gain access to an application by entering their username and password or by authenticating using a social media login. For additional login methods, see:
- [Single Sign-On](https://www.patternfly.org/pattern-library/application-framework/single-sign-on/#)
- [Identity First Login](https://www.patternfly.org/pattern-library/application-framework/identity-first/#)

Usage scenarios related to the login page include:

* A user navigates to an application and is presented with a login page as a way to gain access to the application. There are two possible results:
  * Authentication is successful and the user is directed to the application landing page.
  * Authentication fails and the user remains on the login page. If authentication fails, the screen should show an informational or error message about the failure.
* A user is automatically logged out due to inactivity. In this event, they will be returned to the login page, which will display an informational message explaining what happened. Once the user logs in again, they should be taken back to the page they were previously on before being timed out. Thirty minutes is the suggested duration before a session timeout, but this is subject to change based on your product’s security requirements.
* A user has forgotten their username and/or password. A link is available to begin the process to reset this information. Once the user clicks on one of these links, the contents of the login page is replaced with fields specific to recovering their username and/or password. There are a number of different ways the user could recover their password. This pattern does not dictate which methods an application should follow. Some options include:
  * The user could provide their e-mail and be sent a temporary password or a link to reset their password.
  * The user could answer a security question.
  * The user could get a message explaining that they have to contact a specific person.

## Basic Login Page
This is a general layout of a common login screen. A user can input the username and the password together to log in.

![Image of basic login page](img/basic-login-screen.png)

## Social Login
Social login will allow a user to sign in with their social networks or IdPs accounts.

Please refer to branding guidelines when using logos for social login page. The following are examples of some of the more frequently used but you may use others as your needs require.

- [Facebook brand guidelines](https://en.facebookbrand.com/guidelines/brand)
- [Twitter brand guidelines](https://about.twitter.com/en_us/company/brand-resources.html)
- [Github brand guidelines](https://github.com/logos)
- [Stack Exchange brand guidelines](https://stackexchange.com/legal/trademark-guidance)
- [Google brand guidelines](https://developers.google.com/identity/branding-guidelines)
- [LinkedIn brand guidelines](https://brand.linkedin.com)
- [OpenID brand guidelines](http://openid.net/add-openid/logos/)
- [Instagram brand guidelines](https://en.instagram-brand.com)

![Image of social login](img/social-account.png)

repository: jsdelivrbot/pf-dev

repo_name: jsdelivrbot/pf-dev


text:
## 1990s again! Play mechanical HDD sounds in Linux linked to real disk activity.

REQUIREMENTS
------------
* libpulse-dev
* In Ubuntu just:
`sudo apt install libpulse-dev`

BUILD
-----
`make`

USAGE
-----
* Find your partition which HDD activities shall be soundified: `mount | grep "\ /\ "` to see which is your root (/) partition
* `ls /sys/block/`

* start the executable as a daemon, e.g.:
`./hdd_sound sda & # to soundify partition sda and start this as background task`


text:
# Color Tools Plugin

The **Color Tools** Plugin is an extension for [Grav CMS](http://github.com/getgrav/grav) that provides useful Twig and PHP tools for working with CSS colors. When a color object is created, it provides the ability to call a variety of methods to manipulate the color and returns the results.

## Methods Available

* `complementary()`
* `darken()`
* `getCssGradient()`
* `getHex()`
* `getHsl()`
* `getRgb()`
* `hexToHsl()`
* `hexToRgb()`
* `hslToHex()`
* `isDark()`
* `isLight()`
* `lighten()`
* `makeGradient()`
* `mix()`
* `rgbToHex()`
* `rgbToString()`

## Installation

Installing the Color Tools plugin can be done in one of three ways: The GPM (Grav Package Manager) installation method lets you quickly install the plugin with a simple terminal command, the manual method lets you do so via a zip file, and the admin method lets you do so via the Admin Plugin.

### GPM Installation

To install the plugin via the [GPM](http://learn.getgrav.org/advanced/grav-gpm), through your system's terminal (also called the command line), navigate to the root of your Grav-installation, and enter:

    bin/gpm install color-tools

This will install the Color Tools plugin into your `/user/plugins`-directory within Grav. Its files can be found under `/your/site/grav/user/plugins/color-tools`.

### Admin Plugin

If you use the Admin Plugin, you can install the plugin directly by browsing the `Plugins`-menu and clicking on the `Add` button.

## Twig Usage

This plugin returns a color object with the twig filter `|color_object`. For example:

```twig
{% set orange_color = '#FFCC00'|color_object %}
{{ orange_color.darken(20) }}
```

or

```twig
{% set button_color = page.header.hero_button.color|color_object %}
{% set button_css_class = button_color.isLight() ? 'text-dark' : 'text-light' %}
```

## PHP Usage

To use this class in PHP is also quite simple, an example that mimic above can be seen below:

```php
use Grav\Plugin\ColorTools\Color;

$orange_color = new Color('#FFCC00');
$darker_orange = $orange_color->darken(20);

$button_color = new Color($page_header['hero_button']['color']);
$button_css_class = $button_color->isLight() ? 'text-dark' : 'text-light';
```

## Credits

The PHP class used was originally developed by Arlo Carreon <http://arlocarreon.com>, then modified by Trilby Media.


text:
# `burro`: A Shiny Data Explorer for Teaching Exploratory Data Analysis

# <img src="man/figures/burro3.png" align="right" />

## Why `burro`(w) into your data?

Exploratory Data Analysis (EDA) is highly visual and can be a motivating entry point into data science and analysis. `burro` attempts to make EDA accessible to a larger audience by exposing datasets as a simple Shiny App that can be [shared via `shinyapps.io` or other Shiny hosts](https://laderast.github.io/burro/articles/making_a_burro_app.html). You can see an example here: https://tladeras.shinyapps.io/nhanes_explore/

We use `burro` as an introductory tool for EDA by using it in "[data scavenger hunts](https://laderast.github.io/burro/articles/data_scavenger_hunt.html)", where groups of students are given specific questions to answer about the data, and then have to show their fellow students the answer and how the discovered it. Looking at the data together is vital to building understanding of the data together.

By concentrating on the data visualization first, `burro` apps let us have conversations about the data, and hopefully motivate students to learn more tools of EDA such as `ggplot`, `visdat`, and `skimr`.

## Installing `burro`

`burro` is currently only on github and not on CRAN yet. To install it, run the following.

```{r}
install.packages("remotes")
remotes::install_github("laderast/burro")
```

## Dataset requirements

`burro` expects a dataset as a `data.frame` or `data.table`. It attempts to automatically figure out which variables to use in specific visualizations.

If the variable is categorical, then the variable should be cast as `factor()` or `ordered()`. For example:

```
data(mtcars)
mtcars$cyl <- factor(mtcars$cyl)
mtcars$gear <- factor(mtcars$gear)
explore_data(mtcars)
```

`burro` can utilize an *outcome variable*, which should be categorical/factor.

It's on my list of things to do to make `burro` adaptive to the data passed into it, but it currently is pretty inflexible about these two things.

An optional (though helpful) requirement is to have a data dictionary which has a column called `variableNames` that defines each variable in the dataset.

## Running `burro` on `NHANES` Data

![burro app for NHANES](man/figures/categorical.gif)

Here we make a `burro` app using the `explore_data` option for the NHANES (National Health and Nutrition Examination Survey) data. We specify our covariates, and our outcome of interest (`Depressed`, the number of depressive episodes).

You can see the `burro` app for the `NHANES` data here: https://tladeras.shinyapps.io/nhanes_explore/

```
library(burro)
#make sure that NHANES package is installed
library(NHANES)
data(NHANES)

data_dict <- readr::read_csv(system.file("nhanes/data_dictionary.csv", package="burro"))

##specify outcome variable here
outcome <- c("Depressed")

explore_data(dataset=NHANES, data_dictionary=data_dict, outcome_var=outcome)
```

## Running `burro` on `biopics` data from `fivethirtyeight`

![burro app for biopics](man/figures/biopics.png)

We can examine the `biopics` dataset using `burro`. We specify our `outcome_var` to be `subject_sex`, so we can examine everything through the facet of gender.

```{r}
library(burro)
library(fivethirtyeight)
data(biopics)
explore_data(biopics, outcome_var = "subject_sex")

```

## Run `burro` on `diamonds`

```{r}
library(ggplot2)
data(diamonds)
burro::explore_data(diamonds, outcome_var="cut")
```

## Acknowledgements

`burro` uses many wonderful packages developed by Nicholas Tierney and rOpenSci: [`visdat`](http://visdat.njtierney.com/), [`naniar`](http://naniar.njtierney.com/), and [`skimr`](https://github.com/ropensci/skimr).

`burro` was partially developed with funding from Big Data to Knowledge (BD2K) and a National Library of Medicine T15 Training Grant supplement for the development of data science curricula.

The `burro` hex sticker uses clipart [designed by Freepik](https://www.freepik.com/free-vector/donkey-head_763369.htm).

## Related Packages

The `esquisse` package (https://github.com/dreamRs/esquisse) is a wonderful start to making a drag and drop visualization tool in R. Check it out!

## License

`burro` is released under a MIT license. Please let us know if you are using `burro` in your work!

## Contributing

We want you to contribute! See the [contributing link above](https://laderast.github.io/burro/CONTRIBUTING) for more info.

repository: giminformatics/burro

repo_name: giminformatics/burro


text:
---
layout: post
comments: false
title: "Introducing the new CLion Conan Plugin compatible with 2.X"
meta_title: "Unveiling the new Conan CLion Plugin for seamless C++ package management - Conan Blog"
description: "Discover how the new Conan CLion plugin 2.X enhances C++ development, with a practical example using libcurl for loading images from the internet."
permalink: /introducing-new-conan-clion-plugin/
---

In this post, we are thrilled to announce the launch of the new version of the Conan CLion
Plugin, now compatible with the 2.X versions of Conan. The new plugin is designed to bring
more ease and control to developers using CLion (with version higher than 2022.3) and
Conan for C++ projects. We will walk you through the process of using this plugin with a
practical example that uses [libcurl](https://curl.se/libcurl/) and
[stb](https://github.com/nothings/stb) to download an image from the Internet, load it,
and print it as ASCII art in the console.

## How the plugin works

Before explaining how to install, configure, and use the plugin, let's briefly discuss how
it integrates Conan with CMake to create a seamless experience. This plugin utilizes
[cmake-conan](https://github.com/conan-io/cmake-conan/tree/develop2), a [CMake dependency
provider](https://cmake.org/cmake/help/latest/guide/using-dependencies/index.html#dependency-providers)
for the Conan C and C++ package manager. It injects ``conan_provider.cmake`` using the
``CMAKE_PROJECT_TOP_LEVEL_INCLUDES`` definition. This dependency provider will translate
the CMake configuration to Conan. For instance, if you select a *Debug* profile in CLion,
Conan will install and use the packages for *Debug*.

Bear in mind that *cmake-conan* activates the Conan integration every time CMake calls to
``find_package()``, meaning that no library will be installed until the CMake configure
step runs. At that point, Conan will try to install the required libraries and build them
if needed.

Also, note that as dependency providers are a relatively new feature in CMake, you will
need CMake version >= 3.24 and Conan >= 2.0.5.

## Installing the plugin

To install the new Conan CLion plugin, navigate to the JetBrains marketplace. Open CLion,
go to *Settings > Plugins*, then select the *Marketplace* tab. Search for the Conan plugin
and click on the Install button. After restarting CLion, a new “Conan” tool tab will
appear at the bottom of the IDE.

## Creating a new CMake project

First, create a new CMake project in CLion, as usual.

Then select the project location and the language standard you want to use, and click on
"Create".

## Configuring the plugin

Go to the “Conan” tool tab at the bottom of the IDE. You will see that the only enabled
action in the toolbar of the plugin is the one with the ⚙ (wheel) symbol, click on it.

The first thing you should do there is configuring the Conan client executable that's
going to be used. You can point to one specifically installed in an arbitrary location on
your system or you can select *"Use Conan installed in the system"* to use the one
installed at the system level.

You will find there some options marked as default. Let's go through all of them.

- First, you will see checkboxes to mark in which configurations Conan should manage the
  dependencies. In our case, as we only have the Debug configuration, it's the only one
  checked. Also, below that "Automatically add Conan support for all configurations" is
  marked by default. That means that you don't have to worry about adding Conan support to
  new build configurations because the plugin will automatically add Conan support by
  default.

- You can also see that there's a checkbox to let Conan change the default CLion settings
  and run CMake sequentially instead of running it in parallel. This is needed as the
  Conan cache is not yet concurrent up to Conan 2.0.9 version.

Normally, if you are using the Conan plugin, you wouldn't want to unmark them. So leave
them and let's create our project and add the libraries to it. So, click on the OK button
and the plugin should be ready to use.

**Note:** At this point, CLion will run the configure step for CMake automatically. Since
the plugin sets up the *conan.cmake* dependency provider, a warning will appear in the
CMake output indicating that we have not added a `find_package()` to our *CMakeLists.txt*
yet. This warning will disappear after we add the necessary `find_package()` calls to the
*CMakeLists.txt* file.

After doing the initial configuration, you will notice that the list of libraries is now
enabled and that the 🔄 (update) and 👁 (inspect) symbols are also enabled. We will
explain them later in detail.

## Using the plugin

Now that we have our plugin configured and ready, let's explore its usage with an example.
For this, we will use [libcurl](https://curl.se/libcurl/) to download an image from the
Internet, then [stb](https://github.com/nothings/stb) to load it, and some basic code to
print it in the console as ASCII characters.

We will not delve into the specific details of the code, as it is beyond the scope of this
tutorial. However, all the source code for this example is available in the [Conan 2.0
examples repo](https://github.com/conan-io/examples2/tree/main/examples/libraries/libcurl/download_image):

### Adding the code

First, open the *main.cpp* file that CLion generated and replace the example code with the code below (you can also copy it from the
[repository](https://github.com/conan-io/examples2/tree/main/examples/libraries/libcurl/download_image/main.cpp)):

```cpp
#include <iostream>
#include <curl/curl.h>
#include <vector>
#include <string>

#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>

// Size of ASCII art
static const int new_width = 100;

// Ascii gradient
static const std::string ASCII_CHARS = " .:-=+#%@@"; // Inverted colors

// Function to scale the luminance into an ASCII character
char map_luminance_to_ascii(float luminance) {
    size_t position = luminance * (ASCII_CHARS.size() - 1);
    return ASCII_CHARS[position];
}

// Function to download image
static size_t write_data(void* ptr, size_t size, size_t nmemb, void* stream) {
    ((std::string*)stream)->append((char*)ptr, size * nmemb);
    return size * nmemb;
}

std::string download_image(const std::string& url) {
    CURL* curl = curl_easy_init();
    std::string response_string;

    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response_string);
    curl_easy_perform(curl);
    curl_easy_cleanup(curl);

    return response_string;
}

// Function to convert image to ASCII
std::string image_to_ascii(const std::string& image_data) {
    int width, height, channels;
    unsigned char* data = stbi_load_from_memory(
            reinterpret_cast<const stbi_uc*>(image_data.data()),
            image_data.size(),
            &width,
            &height,
            &channels,
            0
    );

    int new_height = static_cast<int>(static_cast<double>(height) / width * new_width * 0.45);

    std::string ascii_image;
    for (int i = 0; i < new_height; ++i) {
        for (int j = 0; j < new_width; ++j) {
            int old_i = i * height / new_height;
            int old_j = j * width / new_width;

            float r = data[(old_i * width + old_j) * channels + 0] / 255.0f;
            float g = data[(old_i * width + old_j) * channels + 1] / 255.0f;
            float b = data[(old_i * width + old_j) * channels + 2] / 255.0f;
            float luminance = (0.2126f * r + 0.7152f * g + 0.0722f * b); // Subtract the luminance from 1 to invert

            ascii_image += map_luminance_to_ascii(luminance);
        }
        ascii_image += '\n';
    }

    stbi_image_free(data);
    return ascii_image;
}

int main(int argc, char** argv) {
    // Picture by Katarzyna Modrzejewska from pexels.com
    std::string url = "https://images.pexels.com/photos/1314550/pexels-photo-1314550.jpeg";

    if (argc > 1) {
        url = argv[1];
    }

    std::string image_data = download_image(url);
    std::cout << image_to_ascii(image_data);
}
```

Essentially, this application accepts an image URL as an argument (or defaults to a
specific one if not provided), and downloads it using *libcurl* with the
``download_image()`` function. Subsequently, it reads the RGB values with *stb* and
converts the luminance values to ASCII characters using the ``image_to_ascii()`` function.

Currently, attempting to build this code will result in an error because we don't have the
required libraries yet. Navigate to the library list and search for *libcurl*. Some
information on how to add it to CMake will be displayed, along with a "Use in project"
button. Select the version you want to use and click the button.

Perform the same operation for *stb*.

Now, if you click on the 👁 (inspect) icon mentioned earlier, you will see all the
libraries we added to the project. This includes basic target information for CMake and
the necessary code snippets to add to CMake to use them.

Conan stores information about the used packages in a *conandata.yml* file located in your
project folder. This file is read by a *conanfile.py*, also created during this process.
These files can be customized for advanced usage of the plugin, but please read the
information in the corresponding files on how to do this properly.

Modify your *CMakeLists.txt* according to the instructions, which should result in something
like this:

```cmake
cmake_minimum_required(VERSION 3.25)
project(ascii_image)

set(CMAKE_CXX_STANDARD 17)

find_package(CURL)
find_package(stb)

add_executable(ascii_image main.cpp)

target_link_libraries(ascii_image CURL::libcurl stb::stb)
```

After reloading the CMake project, you should see Conan installing the libraries in the
CMake output tab. Once the configuration process is complete, you can build and run the
project:

## Conclusions

The new Conan CLion plugin, compatible with 2.X versions, is designed to provide seamless
integration between the Conan package manager and the CLion IDE. The plugin offers a more
intuitive interface, making it easier to manage your dependencies directly within CLion.
We hope this tool enhances your development experience, and we eagerly await to see what
you will build with it!

extension: markdown

gha_language: HTML


text:
---
layout: post
title: "Event Reminder: TW12 Jazz Festival and Jam Session - 2 to 3 August 2014"
permalink: /archives/2014/07/event_reminder_tw12_jazz_festival_and_jam_session.html
commentfile: 2014-07-23-event_reminder_tw12_jazz_festival_and_jam_session
category: around_town
date: 2014-07-23 21:50:40
image: "/assets/images/2014/Jam-Flyer_thumb.jpg"
excerpt: |
    #### TW12 Pre-Jazz Festival Jazz Jam Session - 2 August 2014

    To get into the festival spirit before the main event at Hampton Hill Playhouse on Sunday 3rd August the festival organisers are putting on a free jazz jam at the lovely Bell Inn Riverside Pub/Restaurant on Saturday evening 2nd from 6 o'clock. This features an excellent house trio led by pianist Terence Collie and the evening will be hosted by vocalist Janet McCunn. If the weather is fine the music will take place in the garden and good food will be served. Everyone is welcome to come along though festival ticket holders will be given priority for performing.

---

#### TW12 Pre-Jazz Festival Jazz Jam Session - 2 August 2014

To get into the festival spirit before the main event at Hampton Hill Playhouse on [Sunday 3rd August](/event/concert/200705144559) the festival organisers are putting on a free jazz jam at the lovely Bell Inn Riverside Pub/Restaurant on Saturday evening 2nd from 6 o'clock. This features an excellent house trio led by pianist Terence Collie and the evening will be hosted by vocalist Janet McCunn. If the weather is fine the music will take place in the garden and good food will be served. Everyone is welcome to come along though festival ticket holders will be given priority for performing.

#### More Information

-   [Full details](http://www.tw12jazzfestival.co.uk/jam_session)

#### TW12 Jazz Festival at Hampton Hill Playhouse - 3 August 2014

The second year of the [TW12 Jazz Festival](/event/concert/200705144558) features one day of fantastic varied musicians and artists. Top rate award winning musicians along with local performers and the Richmond Jazz Youth Band in the lovely Hampton Hill Playhouse. Headliners include the Gwilym Simcock Trio with Yuri Goloubev and Asaf Sirkis; Andrew McCormack and Jason Yarde duo and guitar virtuoso John Etheridge doing a solo set.

#### More Information

-   Daytime session from midday to 6 pm.
-   Evening session from 7pm to 10.30pm.
-   Tickets £20 half day and £30 full event in advance only through the [website](http://www.tw12jazzfestival.co.uk).

repository: pmahnke/stmgrts

repo_name: pmahnke/stmgrts


text:
---
name: Bug report
about: Create a report if something seems off
title: "[Bug]: "
labels: bug
assignees: ''

---

**Describe the bug**
A clear and concise description of what the bug is.

**Desktop (please complete the following information):**
 - OS: [e.g. iOS]
 - Browser [e.g. chrome, safari]

**Smartphone (please complete the following information):**
 - Device: [e.g. iPhone6]
 - Browser [e.g. chrome, safari]

**Additional context**
Add any other context about the problem here, if applicable.

**Dev**
What does the developer need to use in order to accomplish a resolution? Eg. Frontend/backend.

branch_name: refs/heads/production

gha_language: PHP


text:
# InvCLR: Improving Transformation Invariance in Contrastive Representation Learning
This is a [PyTorch](https://github.com/pytorch/pytorch) implementation of the ICLR paper [Improving Transformation Invariance in Contrastive Representation Learning (InvCLR)](https://arxiv.org/abs/2010.09515):
```
@article{foster2020improving,
  title={Improving Transformation Invariance in Contrastive Representation Learning},
  author={Foster, Adam and Pukdee, Rattana and Rainforth, Tom},
  journal={arXiv preprint arXiv:2010.09515},
  year={2020}
}
```

## Installation and datasets
Install PyTorch following the instructions [here](https://pytorch.org/). Download the the [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html) and [CIFAR-100](https://www.cs.toronto.edu/~kriz/cifar.html) datasets.
The Spirograph dataset is included in this code base.
To use the Spirograph dataset on its own, see this [standalone repo](https://github.com/rattaoup/spirograph).
To install the requisite packages for this project, use `pip install -r requirements.txt`.
Note: to install `torchlars` it is necessary to set the environment variable `CUDA_HOME`.

### Dataset locations

The dataset file locations should be specified in a JSON file of the following form
```
dataset-paths.json
{
    "cifar10": "/data/cifar10/",
    "cifar100": "/data/cifar100/",
    "stl10": "/data/stl10/",
    "imagenet": "/data/imagenet/2012/"
}
```

## Training an encoder
We support multi-GPU `DataParallel` training.
Use the following command to train an encoder from scratch on CIFAR-10. We ran this using 8 GPUs.
```bash
$ python3 invclr.py \
  --num-epochs 1000 \
  --cosine-anneal \
  --arch resnet50 \
  --dataset cifar10 \
  --lambda-gp 1e-1 \
  --filename cifar10_run
```
Set `--dataset cifar100` to train on CIFAR-100.
To train an encoder on the Spirograph dataset, use
```bash
$ python3 invclr.py \
  --num-epochs 50 \
  --cosine-anneal \
  --test-freq 0 \
  --save-freq 10 \
  --arch resnet18 \
  --dataset spirograph \
  --lambda-gp 1e-2 \
  --filename spirograph_run \
  --gp-upper-limit 1000
```
You can set `--lambda-gp 0` to train an encoder with no gradient penalty.

## Evaluating an encoder
Use the following command to evaluate the trained CIFAR-10 encoder on untransformed inputs with 50% of
the training labels used for supervized training
```bash
$ python3 eval.py \
  --load-from cifar10_run_epoch999.pth \
  --untransformed \
  --proportion 0.5
```
for Spirograph, we used
```bash
$ python3 eval.py \
  --load-from spirograph_run_epoch049.pth \
  --reg-weight 1e-8 \
  --proportion 0.5
```
On Spirograph, you can view regression results for each of the separate tasks by adding `--componentwise`, otherwise
the presented loss is the mean over all tasks.

### Feature averaging
Use the following command to evaluate classification performance of feature averaging using an average of 100 samples
```bash
$ python3 eval.py \
  --load-from cifar10_run_epoch999.pth \
  --num-passes 100
```
for  Spirograph, run the following code
```bash
$ python3 eval.py \
  --load-from spirograph_run_epoch049.pth \
  --num-passes 30 \
  --reg-weight 1e-8
```
We obtained the following (best of 3 runs)

| Dataset    | Loss | Accuracy |
|------------|------|----------|
| CIFAR-10   | 0.154 |  94.9%   |
| CIFAR-100  | 1.008 |  75.1%   |
| Spirograph | 0.000983 |  n/a     |

repository: ae-foster/invclr

branch_name: refs/heads/invclr-main

repo_name: ae-foster/invclr


text:
# MyResponder

An opensource PHP project to help dispatch local **guards** in gated
communities by SMS to a **home owner**'s address.

There are three parties involved in this system:

1. Guard (also known as "first responder")
2. Home owner
3. Management

Management's task is to approve by "arming" who can raise alerts and who can receive them.

Other features:

- Every alert or incident recorded in a JSON file. Logging incidents gives you the metrics to improve!
- Optional ability to time track guards, providing the "clock out"

## Setup

`envfile` needs:

    HOST=myresponder.local
    M_USER=duroa
    M_PASS=SECRET
<EMAIL_ADDRESS>    TZ=Asia/Singapore
    # M_EMAIL must be verfied!
    AWS_ACCESS_KEY_ID=AKIAJPZG5CILK47K132
    AWS_SECRET_ACCESS_KEY=SECRET
    REGION=us-west-2 # for AWS SES

To simulate new .local addresses, you need to do something like:

    $ avahi-publish -a -R myresponder.local <IP_ADDRESS>
    Established under name 'myresponder.local'
    $ avahi-publish -a -R m.myresponder.local <IP_ADDRESS>
    Established under name 'm.myresponder.local'

## Series of videos explaining the development & demonstrating its use

- [Documentation](docs/index.md)
- <https://natalian.org/2015/11/29/Neighbourhood_watch_on_the_Web/>
- [MyResponder Youtube playlist](https://www.youtube.com/playlist?list=PLiKgVPlhUNuyKRfZayi0LLcq7i9l3yOtE)

repository: kaihendry/myresponder

repo_name: kaihendry/myresponder


text:
![bassmaster Logo](https://raw.github.com/spumko/bassmaster/master/images/bassmaster.png)

The batch endpoint makes it easy to combine requests into a single one.  It also supports pipelining so you are able to take the result of one of the endpoints in the batch request and use it in a subsequent endpoint.  The batch endpoint only responds to POST requests.

## Getting Started
Install **bassmaster** by either running `npm install bassmaster` in your sites working directory or add 'bassmaster' to the dependencies section of the 'package.json' file and run `npm install`.

### Required permissions
**bassmaster** requires the following permissions to be granted on the server for the plugin to work correctly:
- route

### Available options
At this time the options object supports the following configuration:
- `batchEndpoint` - the path where batch requests will be served from.  Default is '/batch'.

As an example to help explain the use of the endpoint, assume that the server has a route at '/currentuser' and '/users/{id}/profile/'.
You can make a POST request to the batch endpoint with the following body and it will return an array with the current user and their profile.

```json
{ "requests": [
    {"method": "get", "path": "/currentuser"},
    {"method": "get", "path": "/users/$0.id/profile"}
] }
```

The response body to the batch endpoint is an ordered array of the response to each request.  Therefore, if you make a request to the batch endpoint that looks like

```json
{ "requests": [
    {"method": "get", "path": "/users/1"},
    {"method": "get", "path": "/users/2"}
] }
```

The response will look like the following, where the first item in the response array is the result of the request from the first item in the request array.

```json
[{"userId": "1", "username": "bob"}, {"userId": "2", "username": "billy" }]
```

When making a POST request as part of the batch assign the _'payload'_ property with the contents of the payload to send.

If an error occurs as a result of one the requests to an endpoint it will be included in the response in the same location in the array as the request causing the issue.  The error object will include an error property that you can interrogate.  At this time the response is a 200 even when a request in the batch returns a different code.

repository: nearform/gammaray

gha_language: Go

repo_name: nearform/gammaray


text:
### File-upload

This component is used when a container of type `AQ_File_Upload` is used.
This will be displayed as a button

### Parameters on container 'AQ_File_Upload'

When setting `FileExtension` these also will be displayed below the upload button
When setting `MaxFileSize` these also will be displayed below the upload button
When setting `Mode` to single, only one file can be selected in the pop-up dialog
When setting `Mode` to multi, multiple files can be selected in the pop-up dialog
When setting `MaxFileAmount` to 1, only one file can be selected in the pop-up dialog
When setting `MaxFileAmount` to -1, multiple files can be selected in the pop-up dialog
When setting `MaxFileAmount` higher than 1, the number of files can be uploaded.
When setting `Required` the container will contain a field with error messages that should be displayed.

repository: blueriq/blueriq-material

gha_language: TypeScript

gha_license_id: NOASSERTION

repo_name: blueriq/blueriq-material


text:
---
layout: default
---

# 1994-02-16 - Re: Pynchon as roadkill on the digital superhighway

## Header Data

From: Cyrus Shaoul<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 2b117f21e998b0656c03e51fa2bd9d70e4cb4f88f3f7cb058136729ebd803646

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-02-16 08:50:06 UTC

Raw Date: Wed, 16 Feb 94 00:50:06 PST

## Raw message

```
{% raw  %}From: Cyrus Shaoul<EMAIL_ADDRESS>Date: Wed, 16 Feb 94 00:50:06 PST
To<EMAIL_ADDRESS>Subject: Re: Pynchon as roadkill on the digital superhighway
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

 Michael C. Berch writes:

>> And as cool an author as Pynchon is, I suspect he is an amateur at the
>> privacy business; anyone who would put their true residence address on
>> their driver's license is obviously not paranoid enough to be serious
>> about not being found.

 Has anyone gone to check up on Mr.
Vineland lately? Perhaps the address in the DMV computer is that of a
fried chicken franchise in Lost Hills, CA! Just cause you have some data
doesn't mean it's useful.

[Gratuitous Blues Brothers reference to Wrigley Field inserted automagically.]

-----------------------------------------------------------------
Cyrus Shaoul<EMAIL_ADDRESS>NTT Human Interface Labs / Yokosuka        TEL +81(0)468-59-4672
Visual Media Laboratory  / Japan           FAX +81(0)468-59-2829
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Finger<EMAIL_ADDRESS>for PGP public key, or use the server.
Or get it all from my WWW Page: http://iikk.inter.net/
________________________________________________________________

{% endraw %}
```

## Thread

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

+ Return to "[Cyrus Shaoul <cyrus@ntthcs.ntt.jp>](/authors/cyrus_shaoul_cyrus_at_ntthcs_ntt_jp_)"

+ 1994-02-16 (Wed, 16 Feb 94 00:50:06 PST) - Re: Pynchon as roadkill on the digital superhighway - _Cyrus Shaoul<EMAIL_ADDRESS>


text:
---
title: i3wm - Enable Autostart
---

Today we want to enable our Autostart Scripts by starting i3wm.

## Find i3 Config File
Fist we need to find our [i3 Config File](https://i3wm.org/docs/userguide.html#configuring)
register a Script, witch runs when we start i3.
It is most likely located at `~/.config/i3/config`

## Run Script on Start of i3
Now we just tell i3 to run a Bash Script `autostart.sh` located at `~/.config/i3/` on start.
We add this line to our `~/.config/i3/config` File:

    exec --no-startup-id bash ~/.config/i3/autostart.sh

## Setup the Bash Script
Last but not least we create the Bash Script `autostart.sh` located at `~/.config/i3/` containing:

    #!/bin/bash
    grep -rh Exec ~/.config/autostart | while read -r line ; do
       ${line:5} &
    done

This will look in our Directory `~/.config/autostart` for executable Script Paths and run them.

## _(optional)_ /etc/xdg/autostart
We can also add our `/etc/xdg/autostart` to our Bash Script `autostart.sh`, if we wish to execute it as well.
We add to our Bash Script `autostart.sh`:

    grep -rh Exec /etc/xdg/autostart | while read -r line ; do
       ${line:5} &
    done


text:
interstitial
=============

Tool to detect interstitial errors in digitization workflows

Introduction
------------

interstitial is designed to detect dropped samples in audio digitization processes.  These are caused by fleeting interruptions in the hardware/software pipeline on a digital audio workstation, causing a small number of samples to be dropped from the transfer.

More information on interstitial errors can be found in [this FADGI report](http://www.digitizationguidelines.gov/audio-visual/documents/Interstitial_Error_Report_2013-04-08.pdf)

Usage
-----

This tool requires two sets of audio files: one generated as normal on a DAW, and one generated on a reference device.  Typically, a device such as a standalone recorder is used as the reference device.  This device should receive the same digital output that the DAW receives and record it to disk.

Once the two sets are generated, interstitial-errors can be pointed at the reference and DAW directories and run.  It will automatically match WAV files between the directories, find errors in the DAW-generated files, and report results.

Sample audio files can be found here:

[DAW](http://www.avpreserve.com/interstitialerrorsamples/201206081082_DAW.wav)

[Ref](http://www.avpreserve.com/interstitialerrorsamples/201206081082_DDR.wav)

Note that, due to the nature of the tests performed by the tool, it may also highlight other issues in a digitization chain (e.g. timing problems).

Requires
--------

* audiolab
* numpy
* PyQt4 (GUI only)

Precompiled Binaries
--------------------

* [Windows](http://www.avpreserve.com/wp-content/uploads/2013/07/interstitial-win.zip)
* [OSX](http://www.avpreserve.com/wp-content/uploads/2013/07/interstitial-osx.zip)

repository: clacinak/interstitial

repo_name: clacinak/interstitial


text:
# exemplar

*Markup Language Expressions for LFE: creating HTML with s-expressions on the Erlang VM.*

## Introduction

### Supported Tags

Right now, only HTML5 is supported. Feel free to submit pull requests to support
older/different tags/elements.

The list of tags was obtained from
Mozilla's
HTML 5 documentation

Note that XML namespacing hasn't been explored yet, but *should* be possible.

### Current Status

As you can see in the example usage below, you can use exemplar to build HTML
strings using LFE S-expressions. However, do note that the project has *just*
started and there are lots of unexplored HTML edge-cases that simply won't work
right now.

If you come across anything, feel free to submit a bug in the github issue
tracker, or even send us a pull request :-)

### About the Name

Naming and cache invalidation, right?

The first thought was to name the project ML-expr: ML for HTML, replacing the
"s" of "s-expression". MLEXPR isn't all that pronouncable, so another "e" and
an "a" were added for "exemplar". That's all there is to it.

Also: "Do you know who I *am*?!"

## Dependencies

This project assumes that you have [rebar](https://github.com/rebar/rebar)
installed somwhere in your ``$PATH``.

This project depends upon the following, which installed to the ``deps``
directory of this project when you run ``make deps``:

* [LFE](https://github.com/rvirding/lfe) (Lisp Flavored Erlang; needed only
  to compile)
* [lfeunit](https://github.com/lfe/lfeunit) (needed only to run the unit tests)

## Installation

Just add it to your ``rebar.config`` deps:

```erlang
    {deps, [
        ...
        {exemplar, ".*", {git, "git@github.com:lfe/exemplar.git", "master"}}
      ]}.
```

And then do the usual:

```bash

    $ rebar get-deps
    $ rebar compile
```

## Usage

### Interactive Use from the REPL

#### HTML

Start the REPL:

```bash
    $ make shell
```

Then, from a clone of exemplar:

```lisp
    > (slurp '"src/exemplar-html.lfe")
    #(ok exemplar-html)
    > (html (body (div (p '"Here is somem content")))))
```

Or, from your own project with exemplar as a dep:

```lisp
    > (slurp '"deps/exemplar/src/exemplar-html.lfe")
    #(ok exemplar-html)
    > (html (body (div (p '"Here is somem content")))))
```

Which will give the following output

```html
    "<html><body><div><p>Here is somem content</p></div></body></html>"
```

#### Custom Elements

You can create your own elements, too. In your project that has exemplar set
up as a dependency, create a module and ``include-lib`` the macros file:

```cl
(defmodule my-project
  (export all))

(include-lib "deps/exemplar/include/macros.lfe")

(defelem custom-elem)
```

Then, you can ``make shell``, ``slurp`` that file, and use your new element:

```cl
    > (slurp '"src/my-project.lfe")
    #(ok my-project)
    > (custom-elem (custom-elem '"much wow"))
```

Which will give the following output

```html
    "<custom-elem><custom-elem>much wow</custom-elem></custom-elem>"
```

#### Current Limitations

Right now, the ``defelem`` macro which generates all the HTML functions only
generates functions with three different arities. For instance,
``include/html-macros.lfe`` defines the ``div`` element:

```cl
(defelem div)
```

The ``defelem`` macro in ``include/macros.lfe`` generates three functions with
this definition:

* ``div/0``
* ``div/1``
* ``div/2``

We can see these three aritiies in action by slurping ``src/exemplar-html.lfe``
and calling these functions:

```cl
    > (slurp '"src/exemplar-html.lfe")
    #(ok exemplar-html)
    > (div)
    "<div />"
    > (div '"some content")
    "<div>some content</div>"
    > (div '(class "some-css") '"some content")
    "<div class=\"some-css\">some content</div>"
```

What this means is that (for now) you cannot do something like this:

```cl
    > (div (p '"paragraph 1") (p '"paragraph 2") (p '"paragraph 3"))
    exception error: #(unbound_func #(div 3))
```

Since there is no ``#'div/3``. Instead, you will have to do this:

```cl
    > (div (list (p '"paragraph 1") (p '"paragraph 2") (p '"paragraph 3")))
    "<div><p>paragraph 1</p><p>paragraph 2</p><p>paragraph 3</p></div>"
```

Another common use case:

```cl
    > (ul (list (li '"a") (li '"b") (li '"c")))
    "<ul><li>a</li><li>b</li><li>c</li></ul>"
```

Note that the 1-arity generated functions have some smarts: in addition to being
able to handle lists of elements, they can also handle lists of attributes and
string content. You've seen the string content and list arguments above; here's
``#'div/1`` with attributes:

```cl
    > (div '(id "div-1" class "big"))
    "<div id=\"div-1\" class=\"big\" />"
```

Here's an example using a variable:

```cl
    > (set class '"bigger")
    "bigger"
    > (div `(id "div-1" class ,class))
    "<div id=\"div-1\" class=\"bigger\" />"
    > (div (list 'id '"div-1" 'class class))
    "<div id=\"div-1\" class=\"bigger\" />"
```

### Using Exemplar with YAWS

If you are running a YAWS-based project, you can easily include exemplar in it.
Any function that is returning content to YAWS can simply use the exemplar HTML
macros.

For instance, let's say you had a YAWS project that was configured like so:

```apache
      logdir = logs
      ebin_dir = deps/yaws/var/yaws/ebin
      ebin_dir = ebin
      log_resolve_hostname = false
      fail_on_bind_err = true

      <server localhost>
              port = 5099
              listen = <IP_ADDRESS>
              appmods = </, my-project>
              docroot = www
      </server>
```

Then the ``my-project.lfe`` file might look something like this:
```cl
(defmodule my-project
  (export all))

(include-lib "deps/exemplar/include/html-macros.lfe")

(defun out (arg-data)
  "This function is executed by YAWS. It is the YAWS entry point for our app."
  (let ((path-info (: string tokens
                      (parse-path arg-data)
                      '"/")))
    (routes path-info arg-data)))

(defun routes
  "Routes for our app."
  ;; /content/:id
  (((list '"content" item-id) arg-data)
   (content-api item-id arg-data))
  ;; potentially many other routes
  ...
  ;; When nothing matches, do this
  ((path method arg)
    (: io format
      '"Unmatched route!~n Path-info: ~p~n arg-data: ~p~n~n"
      (list path arg))
    (make-error-response '"Unmatched route.")))

(defun make-html-response (html)
  (tuple 'content
         '"text/html"
         html))

(defun content-api (id request-data)
  ;; pull content from a data store
  (let ((fetched-title '"Queried Title")
        (fetched-content '"Some super-great queried lorem ipsum."))
    (: {{PROJECT}}-util make-200-result
      (html
        (list
            (head
              (title fetched-title))
            (body
              (main
                (div '(class "dynamic content")
                  (list
                    (h1 fetched-title)
                    (h2 (++ '"Item " item-id))
                    (div (p fetched-content)))))))))))
```

Note that, due to the current limitation of the generated HTML element function
arities, we have to wrap sibling calls (e.g., ``(head ...) (body ...)`` in a
``list``.

Needless to say, one could also create custom templates via functions that
generate partial HTML and have parameters/variables for addition HTML to be
passed.

If you'd like to see this example running, download
lfetool, install it, and then
execute these commands:
```bash
  $ lfetool new yaws my-web-proj
  $ cd my-web-proj
  $ make dev
```

Then point your browser at http://localhost:5099/.

For more information on using LFE with YAWS, be sure to check out the
LFE REST example app.

repository: oubiwann/exemplar

gha_language: Erlang

repo_name: oubiwann/exemplar


text:
---
layout: post
title:  "2017 goals"
date:   2017-01-02 15:00:00
categories: [goals,new Year's resolutions]
comments: true
---

![Goals]({{ "/img/goals.jpg" | absolute_url }})

Yesterday, first of January, I read the [Bonilista's newsletter](http://www.bonillaware.com/objetivos-para-2017) ] how every Sunday, for more than 6 months, and it made me think thant I should also make a list with my goals for the new year, and at the same time analyze how gone 2016 because I need to know how the year has gone to know if I'm on the right track or if I've lost my way.

Here we go with my summary of 2016

At the professional level it has been a very good year due to my great progression in my company. I have learned a lot, I have programmed everything I have wanted and more, I have introduced new technologies in the company, I have introduced new concepts needed in a software factory and most importantly I have been happy. On the contrary, I have suffered a lot of stress due to high workload and not knowing how to disconnect from work.

On a personal level, the truth is that I have no achieved milestones, mainly for being very focused on my professional life.

* I have not managed to obtain a certification in English, that is, I have to learn English seriously.
* I have not managed to lead a healthier life.
* I forgot a bit my family and couple.
* I have not published anything in this Blog.

In relation to my needs, these are my goals for 2017.

1. **Work from home one day a week.** This objective I think is important because I like to work with my timing, with my schedule and 100% focused on work, therefore, I am happy. I think it can be achieved because the company is facilitating this possibility and therefore it is something that I should take advantage of.
2. **Learn to disconnect from work.** A great burden that haunts me since I started working. If there is not something I can do, that helps me lose time, that helps me read and write, that I like it more, that it does not disconnect me more irascible
3. **Lead a healthier life.** Due to the high level of stress suffered in 2016, food and health has not been a priority for me in the wake of states of anxiety and to carry out a feeding sometimes harmful. This can not happen in 2017 and I must put many means into it.
4. **Learn English seriously.** Nowadays I can not afford the luxury of not speak English at a high level. There are no excuses and we must remedy it. No more If I achieve this goal I will get an official certification, so get to work.
5. **Attend conferences, talks and events related to the software.** Last year I followed from Twitter, with much envy, many events related to the software community, like tarugoconf, codemotion, sevilla-jam, agile spain, etc ... If I want to continue learning and growing in this community I must learn from better and it is clear that the best are in those events.

Honestly, they come to my head 5 or 6 more goals but I think I have to be realistic and focus on what is most important in order to achieve all the objectives.

Let's do it that I've been a day late 🙂


text:
#⃣ Slack invites will be sent via email to everyone, please register [here](https://docs.google.com/forms/d/e/1FAIpQLSefYuPFtqgVetZwNLtDzB7yi8NTeSrSSm9Luk4JehV8mPfM1Q/viewform)

👉 [Check out this YouTube video for a walkthrough](https://youtu.be/GHVl0YPveoQ)

👉 [Original LinkedIn post](https://www.linkedin.com/posts/gregvannoni_summer-2020-internship-survey-activity-6658239700710633472-EU_T)

👉 [This is the end-goal](https://padlet.com/gregvannoni/c9gopoit4i1aku59): tie everything together in opportunityhack.io

# Read this first
If you decide to help support non-profits by working on Opportunity Hack this summer, you need to be made aware of a few things.

0.   We'll be making time to help you this summer.
1. This is the first time we're doing this.
2. We're doing this to provide experience and education over the summer for students who may have had difficulty in finding internships, either because they couldn't find one or because it was [cancelled](https://github.com/gcreddy42/hiring2020).
3. There is no guarantee that you'll receive a job from the work you do with this internship.
4. All of the work you do will be publicly available (i.e. Slack, GitHub, demos will be recorded and published on YouTube) for any employer and for you to put in your portfolio.  Ideally the effort you put in is equal to your chances for success in the future.
5. We cannot offer official letters of employment (if you are on a visa) as we are a group of people who volunteer our technology-focused minds to help non-profits.  You'd be joining us in our guild.  Hopefully by the same time next year we'll have an official non-profit and we can help with letters of employment.  This is not an unpaid internship, this is you volunteering your time over the summer.

# Table of contents
1. [Outcomes](#outcomes)
2. [Projects](#projects)
   1. [Digitize paper forms](#1-digitize-paper-forms)
   1. [Simple EHR](#2-simple-electronic-healthcare-records-ehr)
   1. [Client Relationship Manager](#3-client-relationship-manager-crm)
   1. [Risk scoring](#4-risk-scoring)
   1. [Volunteer registration and tracking](#5-volunteer-registration-and-tracking)
   1. [Intelligent donation platform](#6-intelligent-donation-platform)
   1. [Inventory management system](#7-inventory-management-system)
   1. [Notification system](#8-notification-system)
   1. [Data analysis](#9-data-analysis)
   1. [Best website platform](#10-recommend-the-best-website-platform-for-non-profits-to-use)
   1. [Build opportunityhack.io](#11-create-the-new-opportunityhackio)
3. [Schedule](#schedule)
   1. [Full schedule](#full-schedule)
   1. [Getting started](#getting-started)
   1. [Standups](#standups)
   1. [Demo meetings](#demo-meetings)
   1. [Mentor "office hours"](#mentor-office-hours)

# Outcomes
## Your benefit
By working on an Opportunity Hack project over the summer, you'll not only be helping your community, but you'll learn these skills:
1. Learn GitHub
2. Agile - sprints, demos, planning
3. Write code
4. Work with a team

Some other things:
1. Public proof of your work for your portfolio
2. A document that describes the work you put in this summer
3. A recommendation for above-and-beyond effort

## Our benefit
1. We'd love to prove that a virtual summer project can work
2. Continued work on meaningful projects we have identified for non-profits
3. Making connections with you

# Projects
These projects come from our years of experience working with non-profits, we sought to generalize the problems we see in order to impact many non-profits, so although you'll see a few called out, we intend for these solutions to be used at scale, globally, at a relatively inexpensive price point.

## 1. Digitize Paper Forms
Slack Channel: `#2020-vol-intern-digitize-paper-forms`

Non-profits are using paper forms.  The cost to digitize these forms to an HTML form in order to integrate it into their existing systems is difficult.  Google Forms is great, yes, but it still requires some effort and knowledge without allowing integration with existing software applications.  We have been working with ASU on two senior capstones around this problem that we can leverage as a head start.

### Requirements
1. You'll be given an [YOLOv3](https://pjreddie.com/darknet/yolo/) ML model (from our work with ASU)
2. You'll be given two images of paper forms
3. Given the bounding boxes output from the ML model, the solution shall create an HTML-based form for each image
4. The solution shall handle additional images in the future
5. The solution shall store the data submitted in the form
6. The solution shall be deployable via 1-button click with a service like [Heroku](https://www.heroku.com/)
### References
- 2018 Proposal for ASU Tempe [Digitize Paper Forms with Machine Learning Part 1](https://docs.google.com/document/d/1xZSuvGs2s-AP4staL0lyeUUDJCBc_DggPglEpLoMZI8/edit?usp=sharing)
- 2019 Proposal for ASU Tempe [Digitize Paper Forms with Machine Learning Part 2](https://docs.google.com/document/d/1nXNlYUaABAfAKbmi1ZnU79VgFa7B5NLPTkdw4dxIRVU/edit?usp=sharing)
- [Mi Benefial Legal](https://github.com/opportunity-hack/Arizona/issues/46) problem statement history from Opportunity Hack
- [National Kidney Foundation](https://github.com/opportunity-hack/Arizona/issues/24) problem statement history from Opportunity Hack
- This [DevPost submission](https://devpost.com/software/a-2d-2-all-about-dat-data) from 2018 Opportunity Hack
- [2019-2020 ASU Capstone Github Repo](https://github.com/MrPanda1/YOLO-FormDataset)
- [2018-2019 ASU Capstone GitHub Repo](https://github.com/opportunity-hack/digitize-paper-forms)

## 2. Simple Electronic Healthcare Records (EHR)
Slack Channel: `#2020-vol-intern-simple-ehr`

Some non-profits have "clients" that require demographics and treatment to be tracked easily.  This usually requires some scheduling component as well as a historical record of visits with services provided, then reports follow.  There are open-source EHR solutions on the internet, but none are simple enough for non-profits to use without dedicated training.
### Requirements
1. The solution shall allow for clients to register for the system, using Google Single Sign-on or system-based account creation
2. The solution shall record "treatments": medicine provided, music session, painting
3. The solution shall allow for role-based access:
4. The solution shall log an audit record of activity
5. The solution shall be secure: (1) no security violations for packages, (2) strong authentication
6. The solution shall use an existing framework (e.g. [Django](https://hackernoon.com/configure-role-based-access-control-in-django-74fa94a54aff)) that offers authentication and role-based access.
7. The solution shall allow for data to be import via CSV including patient records and schedule
8. The solution shall be deployable via 1-button click with a service like [Heroku](https://www.heroku.com/)
### References
- [Chandler CARE Center](https://github.com/opportunity-hack/Arizona/issues/44) problem statement history from Opportunity Hack
- [Neurologic Music Therapy Services of Arizona (NMTSA)](https://github.com/opportunity-hack/Arizona/issues/31) problem statement history from Opportunity Hack
- [Sunshine Acres](https://github.com/opportunity-hack/Arizona/issues/23) problem statement from Opportunity Hack 2017
- Both [Will2Walk](https://github.com/opportunity-hack/Arizona/issues/38) and [ICM Food and Clothing Bank](https://github.com/opportunity-hack/Arizona/issues/37) submitted a shared "progress tracking" problem statement at Opportunity Hack 2018
- [2nd Place Opportunity Hack 2019 project](https://devpost.com/software/chandler-care-center-data-intake) for Chandler CARE Center
- [Opportunity Hack 2017 project for NMTSA](https://devpost.com/software/team-3-nmtsa)
- [Opportunity Hack 2019 project for NMTSA](https://devpost.com/software/nmtsa-scheduleapp)

## 3. Client Relationship Manager (CRM)
_Still working on these details_

This is the sister to the Lightweight EHR project above.  Instead of tracking health and progress of clients, non-profits typically do this with Excel or Google Forms and also manually integrate into DonorPerfect and other non-profit platforms.  SalesForce is the obvious leading solution here, [but still charges non-profits for use](https://www.salesforce.org/nonprofit_product/nonprofit-editions-pricing/).  Platforms like [SpiceCRM](https://www.spicecrm.io/) and [various open-source platforms](https://blog.capterra.com/free-and-open-source-crm/) are available, but non-profits don't have IT support right next to them, they need something simple and cost-effective.

## 4. Risk Scoring
Slack Channel: `#2020-vol-intern-risk-scoring`

Non-profits need a way to vet the standing of people, specifically for pets, as they want to be sure they are going to a nice home.  Given a social media profile (and potentially their network) that someone has granted access to, analyze the content of their posts to create a risk score to understand if there are any red flags for pet adoption.
### Requirements
1. The solution shall collect posts and bio information from Facebook or Twitter
2. The solution shall provide a high risk score for accounts that use terms that indicate violence, hate, animal cruelty, and malice -  this likely means that you will be looking for accounts that already exhibit this, or you can create mock accounts to validate and test the scoring methodology
3. The solution shall be deployable via 1-button click with a service like [Heroku](https://www.heroku.com/)
4. The solution shall provide a URL that a non-profit can send to a potential animal adopter.  This potential animal adopter will use this URL to sign into either Facebook and Twitter to allow this application to collect data as stated above in order to collect data that may not be publically available per privacy settings the user has provided
5. The solution shall not store data from the person's Facebook or Twitter account that is not private
6. The solution shall store the risk score along with the URL that was provided to the potential animal adopter
### References
- [Saving One Life Animal Rescue and Sanctuary](https://github.com/opportunity-hack/Arizona/issues/43) problem statement history from Opportunity Hack
- [My First Machine Learning Project: Designing a Hate Speech Detecting Algorithm](https://towardsdatascience.com/my-first-machine-learning-project-designing-a-hate-speech-detecting-algorithm-56ab32f10833)
- [Hate Speech Detection Using Natural
Language Processing Techniques](https://science.vu.nl/en/Images/werkstuk-biere_tcm296-893877.pdf)

## 5. Volunteer registration and tracking
There are a ton of non-profits that want to allow volunteers to register on their website,
_Still working on these details_

Slack Channel: `#2020-vol-intern-volunteer-registration-and-tracking`

Perform market research to recommend a system for all non-profts to use.
### Requirements
1. Be able to list times available for volunteers along with location and duration of request
2. Be able to specify skill that is needed (e.g. painting, drywall, electrical, math tutor, etc.)
3. Increase communication between NPO and volunteers to increase engagement
4. Be able to find volunteer opportunities in a region
5. Be able to find opportunities that are good for families
6. Recommend volunteer opportunities based on previous experience
## References
- SignupGenius

## 6. Intelligent Donation Platform
_Still working on these details_

Increase recurring donations or volume of donations
### Requirements
1. Recommend other items to donate: if someone donates a TV, ask if they also have shoes to donate
2. Cluster similar donors together to determine alternative marketing methods that may be more effective within the cohort

## 7. Inventory management system
A large set of non-profits that would benefit from a solution here are food pantries (note the difference between [a food bank and a food pantry](https://www.feedingamerica.org/hunger-blog/what-difference-between-food-bank-and-food-pantry)).  There are large food pantries who likely have all of the software they need (including an integration with [Link2Feed](https://www.link2feed.com/)), but most of the smaller food pantries won't have everything they need, but still need to provide food for their client base.  An effective, free, solution here will benefit many food pantries.

### Requirements
_Still working on these details_

### References
- [Matthew's Crossing Food Bank](https://github.com/opportunity-hack/Arizona/issues/9) received many Opportunity Hack solutions over the years to the point where they likely don't have any more problems to solve.  Unfortunately, these custom solutions cannot be generally applied to other food pantries.
- [Child Crisis AZ](https://github.com/opportunity-hack/Arizona/issues/15) problem statement form 2016 Opportunity Hack using QR codes to track inventory
- [Joshua Tree](https://github.com/opportunity-hack/Arizona/issues/28) also hoped to use barcodes to track inventory from 2017 Opportunity Hack

## 8. Notification system
_Still working on these details_

## 9. Data Analysis
_Still working on these details_

Slack Channel: `#2020-vol-intern-data-analysis`

### 9.1 Analyze trends to recommend areas of focus
- https://github.com/opportunity-hack/Arizona/issues/36

### 9.2 Allow non-profits to print forms, collect responses, scan them and easily analyze the data
- Productionalize [Survey Stack](https://devpost.com/software/survey-stack) from Opportunity Hack 2018 for [Animals and Humans in Disaster Inc.](https://github.com/opportunity-hack/Arizona/issues/35), [RealTimeSTEAM](https://github.com/opportunity-hack/Arizona/issues/36), and [NMTSA](https://github.com/opportunity-hack/Arizona/issues/31).

## 10. Recommend the best website platform for non-profits to use
This project only requires significant research in this space, you'lll need to create (free/trial) accounts, Google your heart out, and document your analysis of the various options available for non-profits to use.  Instead of surgically repairing various websites, we would instead like to recommend a platform that non-profits can use.  We'd then use Opportunity Hack to work with them to move their content to this platform that you recommend.
### Requirements
1. A proper solution shall cost less than $20/month
2. A solution shall allow for SEO to be configured and updated easily (ideally with no user input)
3. A solution shall allow for non-profits to easily link to their social media accounts
4. A solution shall allow for their social media accounts to easily link to specific posts on their website (e.g. you press "share" on the website and are able to make a Facebook/Twitter/LinkedIn post)
5. A solution shall allow non-profits to change content easily
6. A solution shall allow non-profits to easily configure donations
7. A solution shall allow for proper security (e.g. using Google SSO or Facebook SSO for ease of use and increased security instead of maintaining security within the website)
8. A solution shall provide significant documentation and various platforms and a cost/benefit analysis and comparison between products.  It may be useful to develop a scoring system in various categories so that you can clearly show the winner in this manner.
9. Uncached page load times shall be less than or equal to 3 seconds - [ref](https://www.criticalcase.com/blog/what-is-page-load-time-and-why-it-is-important.html)
10. You should research at least 8 different alternative platforms, but no more than 20.
### References
- [Cece's Hope Center](https://github.com/opportunity-hack/Arizona/issues/40), [Impact One Breast Cancer Foundation](https://github.com/opportunity-hack/Arizona/issues/41), and [Newtown CDC](https://github.com/opportunity-hack/Arizona/issues/42) all were looking for help in this area at the 2018 Opportunity Hack
- [Animals and Humans in Disaster Inc](https://github.com/opportunity-hack/Arizona/issues/35) also needs help in this space

## 11. Create the new OpportunityHack.io
We use [opportunity-hack.org](http://opportunity-hack.org/) to discuss our annual, global hackathons.  As we continue to create solutions that all non-profits can use, we want to build out the NPOaaS (Non-proft as a service) platform on opportunityhack.io.  This website will allow any non-profit to:
1. Find all relevant solutions we've created for them
2. Find recommendations for other solutions currently available along with our seal of approval recommending that they use them (because we've already tried them out)
One key thing that limits productivity of non-profits are separate systems that are not connected to one another.  While an existing solution may work for them initially, over time they will likely save cost and time by moving to an opportunityhack.io solution that combines many solutions into one platform.
### Requirements
0. [Be sure to read this padlet](https://padlet.com/gregvannoni/c9gopoit4i1aku59) that illustrates the end-goal of all of these projects: opportunityhack.io.
1. This solution shall use [Gatsby](https://www.gatsbyjs.org/) and [Netlify (free tier)](https://www.netlify.com/).  We normally don't lock solutions down to specifics, but in this case, we'd like this to be the technology for our solution.
2. This solution will give you autonomy and artistic license to create this website as you see fit.  Please check out our previous images [on Facebook](https://www.facebook.com/opportunityhack) and [opportunity-hack.org](http://opportunity-hack.org) to get a feel for what we already have as a good foundation for your creation.
3. This solution shall have its code stored in GitHub (just like all of the rest of the projects, but extremely important for us so that we can move what you've built over to opportunityhack.io).
4. opportunityhack.io shall have various sections as outlined in the above projects (for instance, "Digitize Paper Forms"). As background for you, these solutions will be provided as open-source, and also should be deployed with one-click using Heroku.  We will provide documentation, GitHub links, Heroku links, and a video walkthrough for each solution.  In the future, non-profits will be able to combine solutions together (e.g. CRM + notifications or Inventory Management + additional data analysis).
5. This solution may have mocked out Heroku and user screens that show how a non-profit would interact with this website.  Although we don't yet have this platform built, we would still love to have some help laying the foundation for what we think opportunityhack.io could be.
### References
- This [article on technologyadvice.com](https://technologyadvice.com/nonprofit/) discusses the various software platforms available to non-profits.  You can see the struggle that non-profits have with various CRM, donor management, email marketing, and accounting platforms.
- This [Medium article](https://medium.com/verticalchangehq/saas-for-nonprofit-3a5a70099824) also discusses the challenges that many non-profits face.

# Schedule
## Full Schedule
We're starting on May 8th and we're calling August 7th our end.

## Getting started
1. Join the Slack channel for the topic you want to work on
2. Based on the availability of everyone, you may already have people who want to work on this project, if you want to work with a team, say "hi" and join a team.  It may be awkward, but you'll be fine.
3. Once you have formed a team, [create a public Opportunity Hack Slack channel](https://www.google.com/search?q=creating+a+slack+channel&oq=creating+a+slack+channel) and invite your team, then an Issue ticket [here in this GitHub project](https://github.com/opportunity-hack/2020-summer-volunteer-internship/issues/new/choose).  Click on "Get started" and fill out the template - one per team.
4. This ticket is where all of your documentation for the summer will live. For demos, you can either upload a video or link to YouTube, all designs and general discussions will live here.
5. All of your code will go into https://github.com/2020-opportunityhack-voln-internship
   - You will need to Slack us in `#help-github` to ask for a project be created along with the GitHub username or email address we should assign as the owner to this repo.
   - Once added, you'll receive an email *that you must accept* then you'll be able to add the rest of your team.
6. You should now start researching previous Opportunity Hack DevPost and GitHub submissions (and even Slack history), planning with your team how you'll attack your problem, and get off to the races!

## Agile meetings
### Standups
Every Monday and Wednesday (via Slack).  You'll be messaged by Dixi App every Monday and Wednesday to ask for status.  That status will then be shared in your team's Slack channel for everyone to see once everyone has provided their standup details.

Here's an example of what this will look like
![standup](dixi_standup.png)

### Demo meetings
Every 2 weeks on Friday - recorded and published to YouTube.  You'll get a reminder in Slack, and by the end of the day you should have a 4-minute or less video describing your contributions to the project for those 2 weeks.  Each person will create their own demo video.

### Planning meetings
Every 2 weeks on Wednesday.  You should meet with your teams via Google Meet, Zoom, Slack call, or Slack chat to take stock of where you are at now and what needs to be done.  In order to track this work, we'd recommend you use a [Trello board like this](https://trello.com/templates/engineering/agile-sprint-board-ZqN99gGN), but this is completely up to you and your team.

## Mentor "office hours"
- Every week to start for the first 2 weeks
- Switch to 2-week meetings after first 2 weeks
- We'll be using Google Meet and the link will be provided in our `#2020-vol-intern-general` Slack chat


text:
---
index: 1300
category: flux-state
path: /reference/state-preview
title: preview
---

An [app state](/manual/flux-architecture) of Markdown preview pane.
To get the `preview` state:

```js
const { preview } = inkdrop.store.getState()
```

Or, to connect with your React component:

```js
import { useSelector } from 'react-redux'

const selector = ({ preview }) => preview

const MyComponent = props => {
  const preview = useSelector(selector)
  // render
}
```

## Data Structure

### dom: `?Object`

A React DOM that was generated by Markdown renderer.

### lastError: `?Error`

The last error that was occurred while rendering a note

repository: inkdropapp/docs

repo_name: inkdropapp/docs