text:
# =====Fortnite AES Grabber: NuGet=====

[![Nuget](https://img.shields.io/nuget/v/Fortnite.AES?style=flat-square)](https://www.nuget.org/packages/Fortnite.AES)

Grabs AES keys for Fortnite (The Video Game).

# Use

AESGrabber.GetKeys() -Grabs the latest AES keys.

AESGrabber.WriteKeysToFile(string path) -Grabs the latest AES keys and writes them to a path of your choice.

AESGrabber.GetMainKey() -Attempts to get the latest main AES key.

AESGrabber.GetKey(string FileName) -Gets an AES key for a specified Fortnite Pak file.

AESHistory.GetOldKeys(string version) -Grabs AES keys for a specified version of Fortnite.

AESHistory.WriteOldKeysToFile(string version, string path) -Grabs AES keys for a specified version of Fortnite and writes them to a path of your choice.

AESHistory.GetOldMainKey(string version) -Attempts to get the main AES key for a specified version of Fortnite.

AESHistory.GetOldKey(string version, string FileName) -Gets an AES key for a specified Pak file of a chosen Fortnite version.

# Notice

Fortnite is a trademark and is a copyrighted work of Epic Games, Inc. All rights reserved by Epic Games, Inc. This material is not official and is not
endorsed by Epic Games, Inc.

This tool uses https://benbot.app/api/v1/aes

Thanks!

repository: pirica/Fortnite-AES

repo_name: pirica/Fortnite-AES


text:
# Ramaria capitata var. ochraceosalmonicolor (Cleland) A.M. Young & N.A. Fechner, 2007 VARIETY

#### Status
ACCEPTED

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

#### Published in
Australas. Mycol. 26(1): 47 (2007)

#### Original name
Clavaria ochraceosalmonicolor Cleland, 1931

### Remarks
null

repository: mdoering/backbone

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: mdoering/backbone


text:
Title: Book Review: The Pragmatic Programmer
Date: 2020-08-14
Author: Jack McKew
Category: Software, Book Reviews
Tags: software, bookreview

The Pragmatic Programmer is heiled as one of the must-reads for all developers and is extremely well known. It is comparable to a hand book full of tips and tricks to develop more robust software, and also introduces lots of concepts throughout that can be used to improve the development workflow as it evolves for projects. Thus here are my key takeaways, I strongly believe that this is a book you read once, learn a stack from and when you revisit it with more experience down the line, you'll learn even more.

> This review is based on the 20th anniversary edition of the book.

Most of the points below relate to specific chapters/sections.

## Soft Skills

While software development is a technical role, soft skills are still one of the most paramount traits in effective developers and working with others in any scenario.

Skills for being an effective communicator include:

- Active Listening
- Collaboration
- Presentation of Ideas
- Teamwork
- Adaptability
- Conflict Resolution

## No Broken Windows

The broken window theory is a criminological theory in that visible signs of damage create an environment that encourages further damage. If a street has a broken window, what's the big deal if another broken window happens, rinse and repeat until chaos. By ensuring that no broken windows are left in your designs, this encourages further quality contributions.

## Boiled Frogs

If a team works without communication, it may be difficult to see that the entire project may be boiling over. By constant communication, responsibility and transparency throughout the team, this can be minimized. Each member should feel comfortable in raising possible issues with others, and likewise in receiving feedback.

## Know When to Stop

*Great software today is often preferable to perfect software tomorrow.*

When building software, it is often tempting to think *gee this feature would be better if I just added this*, then chasing that feature down a rabbit hole and suddenly the day is over. By doing this, it is potentially delaying the software from potentially being used by the end user.

## DRY Principle

*Don't repeat yourself.*

There are many ways information can be duplicated throughout a project, this presents a problem when you need to change that piece of information. By having a single, unambiguous representation means changes can be much more easily handled, and as we all know change is inevitable.

There are multiple types of duplication:

- **Imposed duplication** - Developers feel they have no choice—the environment seems to require duplication.
- **Inadvertent duplication** - Developers don't realize that they are duplicating information.
- **Impatient duplication** - Developers get lazy and duplicate because it seems easier.
- **Interdeveloper duplication** - Multiple people on a team (or on different teams) duplicate a piece of information.

## Orthogonality

Two or more things are orthogonal if changes in one don't affect the others. By writing orthogonal code & developing orthogonal systems, the benefits ripple throughout the entire project.

Some of the benefits include:

- Changes are now localised
- Promotes reuse of existing code
- Allows for more combinations of existing modules
- Bugs are now contained & isolated
- Functionality can be divided for working with multiple teams
- Easier to test

## Tracer Design

Whenever a project begins, knowing what it'll need to do and the requirements by the end of the project is extremely difficult to know; with change also being evitable the first thoughts for requirements may not be the same by the end. The name tracer design comes from tracer bullets, which are bullets used that light up so that the shooter can readjust their aim until they're on target; the same concept can be applied to design. This also brings the end-users into the design process by giving them early access to a working product.

Some of the benefits include:

- Users get to see/use something early on
- Bugs and requirements can be captured earlier
- Developers get a structure to build upon
- Feel better for seeing progress

Tracer design is different to prototyping, with prototyping a developer is exploring aspects on what may be in the final product. Tracer designs aims to have the code that is being develop be apart of the final product, essentially verifying that the product hangs together and runs as intended.

## Risk in Prototypes being Deployed

When a prototype is presented to the end-user, there is potential for the user to believe it is almost finished or worse finished. Managing the expectations of your users or stakeholders comes back to [Soft Skills](#soft-skills), in that developers need to be effective communicators on informing that this is incomplete and there is much left to go!

## Crash Early

By crashing early, it means the program does a lot less damage than a crippled program. This concept can be implemented by checking for the inverse of the requirement and erroring. By doing this, it means the code is more readable in finding the requirements that it must meet. It captures more potential issues before they cause damage versus checking all the ducks are lined up.

For demonstrating this, we will use the example of a square root function. As we know, square root wants to have a positive number given to it (unless using complex numbers).

``` python
def sqrt(value):
    if value < 0:
        raise ValueError("Value must be positive to get the square root")

    return value ** 0.5
```

By doing this, we enable the function to potentially raise an error, multiply by -1 or even append an *i* for complex numbers. Another example of this is, before querying a database check if there isn't a connection to the database and raise an error rather than checking if the connection is established (thus making for quite the nested beast sometimes).

## Design by Contract

A correct program does no more and no less then what it claims to do. Ensure conditions (both pre & post) are met before anything begins, and promise as little as possible in return. This also helps enforcing [Crash Early](#crash-early), by verifying conditions have been satisfied, enables developers to crash the program if anything is unsatisfactory.

## Build End to End

There are many ways when it comes how something is built. More commonly things are viewed upon as being top-down or bottom-up. Top down is when we define the problem statement and break it down into smaller actionable chunks until it's pieced together. Bottom up is when we build more amd more of the smaller actionable pieces and plan to join them all together to meet the requirements in the future (very helpful when the problem isn't well defined).

Rather than either of these, if we look through the perspective of building things end-to-end this can be a more holistic methodology. Which can also be adopted with either of the prior methodologies mentioned beforehand ensuring to build complete pipelines which can be combined or amended later on in development when the problem is further understood.

## Debugging

Don't assume how a bug occurred, prove it. This is also a fantastic practice to tie in with testing, by discovering a bug, determine how it was created and then prove that's how the bug occurred. This brings the workflow into:

- Bug occurs
- Find out why/how the bug occurred
- Prove that's how it occurred
- Add it to the test suite to ensure the bug never occurs again (or is captured appropriately)

## Rename ASAP & Rename Well

As a project changes, the intention behind the name of a variable/function may also change. It is important to ensure that naming conventions ensure that the intention behind the name matches the functionality. No one wants to have to explain to a new user why `getData()` actually writes data.

## Define Requirements with User Stories

Rather than defining concrete technical requirements on how an application should behave and what outcomes are to be expected, developers can make the most of user stories to define the requirements. This puts the power in the hands of the developers to thoroughly understand and ask questions about how a story is to be completed. Typically written informally and from the perspective of the end user.

Some examples include:

- As a user, I want to see other users progress, so I can understand where I'm at
- As a manager, I want to see the overall number of outstanding tasks, so I can allocate resources appropriately

## Project Glossary

Along with naming things appropriately, chaos can ensue when meaning behind words are not the same across different people. Ensure to keep a project glossary around project specific words and their meaning to ensure that everyone in the project is on the same page.

![Bookcover]({static img/bookcover.jpg})

license: MIT

branch_name: refs/heads/main

gha_language: JavaScript

gha_license_id: MIT


text:
# docker\_awscli

_... for systems such as RancherOS or coreos -_
_use this container to emulate the aws cli binary to run aws commands_

## building

**master branch built at shippable.com**

[![Run Status](https://api.shippable.com/projects/589464f0efe9200f00fd7cd2/badge?branch=master)](https://app.shippable.com/projects/589464f0efe9200f00fd7cd2)

```bash
git clone https://github.com/opsgang/docker_awscli.git
cd docker_awscli
git clone https://github.com/opsgang/alpine_build_scripts
./build.sh # adds custom labels to image
```

## installing

```bash
# ... replace /in/my/PATH below with somewhere in your $PATH
docker pull opsgang/awscli:stable # or use x.y.z version as required.
wget https://github.com/opsgang/docker_awscli/raw/master/.examples/aws -O /in/my/PATH/aws
chmod a+x /in/my/PATH/aws
```

## running

```bash
# ... run like aws cli
aws --region us-east-1 ec2 describe-images # ... or whatever else you need to do.
```

Note that the aws cmd is running within a container, so there are caveats when it comes to
making AWS\_\* env vars or the local file-system available to the container

See [README in .examples dir](https://github.com/opsgang/docker_awscli/tree/master/.examples)
for how to use $DOCKER\_OPTS to get around those caveats.


text:
Field Oriented Control
======================

So, now that we have working swerve code, lets use it for some fun, shall we?

The idea is that instead of having "forward" mean "the front of the robot", "forward" means towards the other end of the field.

For us, we want forward to mean "top of the screen." While that may sound scary, it's actually not very much math compared
to what we've already done. You just need to rotate the joystick vector 'into the frame' of the robot. Draw some pictures.

All you will need that you haven't used before is `RobotInterface.getHeading()`, which returns the direction that the robot is currently facing.
Note that it returns the heading in radians, positive counterclockwise, with `0` facing up.
Also, it will count full rotations in both directions, not just values between `0` and `2*pi`.

repository: Bobobalink/Swerve-Simulator

path: /tasks/6. Field Oriented Control.md

filename: 6. Field Oriented Control.md

repo_name: Bobobalink/Swerve-Simulator


text:
---
hrs_structure:
  division: '1'
  volume: '5'
  title: '18'
  chapter: 302A
  section: 302A-1137
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0302A-1137
    parent: HRS0302A
    name: 302A-1137 Attendance records; availability to authorized
weight: 64990
title: Attendance records; availability to authorized
full_title: 302A-1137 Attendance records; availability to authorized
---
**[§302A-1137]** **Attendance records; availability to authorized police officers.** Dates of attendance of a student shall be made available to authorized police officers upon request. [L 1996, c 89, pt of §2]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# Algorithm Details

## Overview

![](../pictures/algorithm.png)

## Coincidence Lattices

Coincidence lattices are determined with the algorithm outlined by Schwalbe-Koda ([1]).

[1]: https://doi.org/10.1021/acs.jpcc.6b01496 ". Phys. Chem. C 2016, 120, 20, 10895-10908"

Two 2D lattice bases (lattice vectors are given as column vectors) are given by:

```math
\mathbf{A} = \begin{pmatrix} a_{11} & a_{21} \\ a_{12} & a_{22} \end{pmatrix} ~~~~
\mathbf{B} = \begin{pmatrix} b_{11} & b_{21} \\ b_{12} & b_{22} \end{pmatrix}
```

Such that each point in the 2D plane is given by the coefficients:

```math
P(m_1, m_2) = m_1 \vec{a}_1 + m_2 \vec{a}_2 ~~~~
P(n_1, n_2) = n_1 \vec{b}_1 + n_2 \vec{b}_2
```

Additionally, the two bases can be rotated with respect to each other:

```math
\mathbf{R}(\theta) = \begin{pmatrix} \cos(\theta) & -\sin(\theta) \\ \sin(\theta) & \cos(\theta) \end{pmatrix}
```

Two lattice points of the two bases coincide under the following condition:

```math
\begin{pmatrix} \vec{a}_1 & \vec{a}_2 \end{pmatrix} \begin{pmatrix} m_1 \\ m_2 \end{pmatrix}
= \mathbf{R}(\theta) \begin{pmatrix} \vec{b}_1 & \vec{b}_2 \end{pmatrix}
\begin{pmatrix} n_1 \\ n_2 \end{pmatrix} \\
```
```math
\mathbf{A} \vec{m} = \mathbf{R}(\theta) \mathbf{B} \vec{n}
```

As a tolerance criterion, coincidence is accepted if the distance between the coinciding lattice points is smaller than a threshold:

```math
| \mathbf{A} \vec{m} - \mathbf{R}(\theta) \mathbf{B} \vec{n} | \leq tolerance
```

Solving this system of linear equations yields a set of associated vectors for each angle:

```math
S(\theta) = \{ (\vec{m_1}, \vec{n_1}), (\vec{m_2}, \vec{n_2}), ..., (\vec{m_s}, \vec{n_s}), ..., (\vec{m_k}, \vec{n_k}) \} \\
```

From any pair of these associated vectors that is linearly independent, one can construct supercell matrices from the row vectors:

```math
\mathbf{M} = \begin{pmatrix} m_{s1} & m_{s2} \\ m_{k1} & m_{k2} \end{pmatrix}~~~~
\mathbf{N} = \begin{pmatrix} n_{s1} & n_{s2} \\ n_{k1} & n_{k2} \end{pmatrix}
```

This represents a very large set of possible supercell matrices. For practical purposes, this one is reduced by multiple criteria.

First, all unit cell multiples are removed:

```math
\text{gcd}(m_{s1}, m_{s2}, m_{k1}, m_{k2}, n_{s1}, n_{s2}, n_{k1}, n_{k2}) = 1
```

Second, positive entries are preferred over negative ones:
```math
\text{sum}(m_{s1}, m_{s2}, m_{k1}, m_{k2}, n_{s1}, n_{s2}, n_{k1}, n_{k2})~\forall~\mathbf{M},\mathbf{N}~\text{where det}(\mathbf{M})~\text{is equal} \rightarrow \text{max}
```

Third, symmetric matrices are preferred over unsymmetric ones:
```math
m_{k1} = m_{s2}~\text{and}~n_{s1} = n_{k2}~\forall~\mathbf{M}, \mathbf{N}~\text{where det}(\mathbf{M})~\text{is equal}
```

Lastly, for each twist angle, only the ones that minimize the area are kept:
```math
\forall~\mathbf{M}, \mathbf{N} ~ \in ~ S(\theta)~\text{keep}~\text{min}(\text{det}(\mathbf{M}))
```

Then, the coincidence unit cells for both lattices are constructed by:

```math
\mathbf{MA} \approx \mathbf{N} \mathbf{R}(\theta) \mathbf{B}
```

The new unit cell of the resuling heterostructure can be chosen as a linear combination of the two:

```math
\mathbf{C} = \mathbf{MA} + w \cdot (  \mathbf{N} \mathbf{R}(\theta) \mathbf{B} - \mathbf{MA} )
```

Where the weight factor ranges from 0 to 1.

## Stress definitions and geometric matching

As a measure of stress, one can define the target transformation matrices:

```math
\mathbf{T_A} \mathbf{MA} = \mathbf{C} ~~~~ \mathbf{T_B}  \mathbf{N} \mathbf{R}(\theta) \mathbf{B} = \mathbf{C}
```

These are two-dimensional and can be polarly decomposed:

```math
\mathbf{T} = \mathbf{U}(\phi)\mathbf{P}
```

From which one can define a stress matrix:

```math
\mathbf{\varepsilon} = \mathbf{P} - \mathbb{I}
```

And a stress measure:

```math
\bar{\varepsilon} = \sqrt{\frac{\varepsilon_{xx}^2 + \varepsilon_{yy}^2 +\varepsilon_{xy}^2 + \varepsilon_{xx} \cdot \varepsilon_{yy}}{4}}
```

And a total stress on both unit cells:
```math
\varepsilon_{tot} = \bar{\varepsilon}_A + \bar{\varepsilon}_B
```

This total stress can be minimized with respect to the individual rotation of the unit cells while taking the weight factor from the definition of the target unit cell above into account.


text:
# Visit-counter for a Facilities Manager

Scenario: Report visitor trends during a week of operation

  Given Data of visitors in a week
  When a large number of visitors do not have meals in hospital canteen
  Then Reduce the number of meals prepared in canteen in the next week

Scenario: Alert when seating capacity is full

  Given Total number of seats and visitor count
  When A new visitor enters and visitor count equals number of seats
  Then Alert the staff for alternate arrangement


text:
# kotlin-beginner (Functional Programing:)
## Kotline Introduction
Kotlin is Programing langauge developed by JetBrains. It runs on Java Vartual Machine.

### Why Kotlin?
 #### Statically Typed :
  This means that the type of every variable and expression is known at compile time.it doesn’t require you to explicitly specify the type  of every variable you declare
 #### Concise
It drastically reduces the amount of boilerplate code that you have been writing all the time in other OOP languages like Java.,Using Kotlin allows you to cut off the lines of code by approximately 40% (compared to Java).
 #### Open Source
Kotlin is distributed under Apache License, Version 2.0. The Kompiler (Kotlin compiler), IntelliJ IDEA plugin, enhancements to basic Java libraries and build tools all are open source
 #### Safe
Kotlin is safe. It avoids the most dangers of null references from the code  and annoying NullPointerExceptions by supporting nullability as part of its type system.
 #### Functional and Object Oriented Capabilities
 - Functional Programing (FP) is style of structuring your program where the focus is to transforming data with expression which should not have side affect.
- FP is a style of building the structure and elements of programs—that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data
- Kotlin is perfect blend of Object-Orianted and functional programing paradigms. It brings both worlds closer together
---------------------------
## Kotlin Basic
### Kotlin Variables and Data Types
#### Var
- The var is a mutable variable, which is, a variable that can be changed to another value by reassigning it.initialized later:
```
val name = "kotlin"
name = "Kotlin1.3"

```
- In addition, the var can be
```
 var name: String
 name = "kotlin"
```
#### Val
 - The keyword val is used to declare a read-only variable. This is equivalent to declaring a final variable in Java.
 - A val must be initialized when it is created
 ```
        val name = "kotlin"
        val anotherName : String // Compile error as val must be initialized when it is created
 ```

#### Type inference (Statically Typed)
Did you notice in the above section that the type of the variable was not included when it was initialized? This is different to Java where the type of the variable must always accompany its declaration

-----------
#### Basic types
##### Numbers
The built-in number types are as follows:
Type   Width
Long    64
Int     32
Short   16
Byte    8
Double  64
Float   32
##### Booleans
There are usual negation, conjunction, and disjunction operations.
##### Chars
Chars represent a single character. Character literals use single quotes
##### Strings
Just as in Java, strings are immutable, String literals can be created using double quotes
##### Arrays
- In Kotlin, we can create an array by using the library function arrayOf():
```` val array = arrayOf(1, 2, 3) ````
- Alternatively, we can create an Array from an initial size and a function
```        val perfectSquares = Array(10, { k -> k * k }) ```
##### String templates
- String templates are a simple and effective way of embedding values, variables, or even expressions inside a string without the need for pattern replacement or string concatenation
val name = "Developer"
val str = "hello $name"
- Arbitrary expressions can be embedded by prefixing with a dollar ($) and wrapping in braces {}:
```
val name = "Sam"
val str = "hello $name. Your name has ${name.length} characters"
```
- Some example of String templates are [here](src/test/kotlin/com/stringtemplate/StringTemplateDemoTest.kt)

##### Ranges
- A range is defined as an interval that has a start value and an end value. Any types which are comparable can be used to create a range, which is done using the .. operator:
```
       val aToZ = "a".."z"
       val oneToNine = 1..9
```
- Once a range is created, the in operator can be used to test whether a given value is included in the range
- Kotlin Ranges could be found in below  forms.
  1. m..n
  2. n downTo m
  3. m until n
  4. 1 rangeTo n
- Some example of Kotlin range are [here](https://github.com/AnerayeVijay/kotlin-beginner/blob/master/src/test/kotlin/com/range/RangeDemoTest.kt)
------------------
### Visibility modifiers
Usually not all functions or classes are designed to be part of your public API. Therefore, it is desirable to mark some parts of your code as internal and not accessible outside of the class or package
#### public
This means they are fully visible to any code that wishes to use them.If no modifier is given, then the default is used, which is public

#### Private
Inside a class, interface, or object, any private function or property is only visible to other members of the same class, interface, or object:
```
class Person {
         private fun age(): Int = 21
}
```
Here, the function age() would only be invokable by other functions in the Person class.
#### Protected
Any functions or properties declared as protected inside a class or interface are visible only to members of that class or interface, as well as subclasses.
#### Internal
Any code that is marked as internal is visible from other classes and functions inside the same module
A module is defined as a Maven or Gradle module or an IntelliJ module
Effectively, internal acts as public to a module, rather than public to the universe:

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

## Java vs Kotlin

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

## Developers: Getting Started

```sh
# Install Homebrew (see https://brew.sh).
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

# Install Java 8.
brew tap caskroom/versions
brew cask install java8

# Checkout the monorepo:
git clone https://github.com/AnerayeVijay/kotlin-beginner.git
```
### Running the Applications

- Go inside `kotlin-beginner`
- Open the project in IntelliJ IDEA
  1. Tell it to overwrite `.idea`, then revert all changes IntelliJ made to that directory
  2. You can run the test cases through IntelliJ or
   run ```gradle build``` from terminal or commandprompt

repository: AnerayeVijay/kotlin-beginner

repo_name: AnerayeVijay/kotlin-beginner


text:
*Cliff/Julian, re: industry:*
1. In as few words as possible, how would you describe
    - climbing?
    - what you do?

`Cliff:`
- climbing is a lifestyle
    - sport, for sure
    - very all encompassing

- routesetting as main contribution
    - contributing a space for the climbing lifestyle
    - more than just a business

`Julian:`
- Owner's of GP
- extension of search for happiness
- challenge body & mind

2. thesis synopsis + some brief findings, re: industry
    - what do you think?
    - anything glaring missing?

`Cliff:`
- more people just as strong
- maturing sport
- it'll be a while before it goes up 6 grades

3. How would you describe the growth of the climbing industry?
4. How/Why do you think this growth contributes to stronger climbing?

`Cliff:`
- more people
- more maturiy
- more efficiency
- more motivators

`Julian:`
- become main stream. doesn't really like it
    - mega facilities
    - corporate
    - not focused on experience and ethos of climbing, and community building
- loss of main core values of what climbing really is
- becoming larger has increased access to various communities, which helps find "strength" in differnt places
- increased audience

5. Apart from climbing types (lead vs boulder), are there types of gyms?
    - eg think planet fitness vs gold's gym

`Cliff:`
- yeah there are differences
    - think GP
    change focus of why we're here

6. Some obvious trends include gender and racial gaps (until now, predominantly white male sport)
    - are there trends that you know of?

`Cliff:`
- trending in positive direction
- oudoor industry as a whole is getting better

- Do you think addressing negative trends helps contribute to the growth of the sport?

`Julian:`
- has seen change toward diversity and communitis
    - outdoors, etc
- can be better, canbe faster
- industry is very reactionnary, not proactive
    - if 2020 hadn't happened, would the change be different

- worried about more traffic = more population
    - people who are actually part of community are getting overwhelmed
    - can be a detriment

- indsutry can be focused on just money
    - not on building/growing the outdoor climber manners

7. climbing has taken aspects from other sports to improve (chalk, strength training, etc)
    - are there other areas that you think climbing borrows from?
    - do you think climbing gives as much as it receives?

`Cliff:`
- cultural crossovers w/ other sports (eg skating, surfing)
- reverse gymnastics to cliff

`Julian:`
- climbing has adapted more than its given back
    - training for climbing relatively new
    - still a young sport

- alpinism/mountaineering were the original
    - has evolved and been split into more specific things eg: sport/bouldering

- has taken mental coaching/visualizing
    - training mental athleter
    - developing strategy etc
- eg integrating heart rate monitors
    - managing pump

8. what aspects of the industry do you think contributes most to climbing strength and why?
    - eg gyms/comps, trainers/research, hold makers, shoes/chalk, etc

`Cliff:`
- gyms
    - access to the gym

`Julian:`
- looks at it with 2 components
- people & tools
- people - main elements
    - the climber
    - eg 2 hr marathon breaking
    - "to be a good rock climber, you have to climb outside"
    - "not just pulling hard, crimping - its everything; nutrition, getting tired on the hike in, mats, safety"


text:
---
title: Blog Migration (again!)
layout: post
---
Recently a bunch of stuff came out, or got noticed, for students. That is, free stuff.

[Here](https://education.github.com/pack) Github Education put together a collection of software and resources that's now free for a period of time if you're a student. One of the offers is $100 at DigitalOcean, a company that provide servers which you can install whatever you'd like on it.

Since I've recently started using things like Markdown and LaTeX, I thought I'd give [Ghost](https://ghost.org/) a try: so far I'm pretty impressed, stuff just works and the editor is much more simple than wordpress. Things like commenting and media aren't well supported, but overall me likey.

gha_language: CSS

gha_license_id: NOASSERTION


text:
---
title: "An Intermediate Guide To RSA"
author: 'dusty.phillips.codes'
date: '2018-09-13'
slug: an-intermediate-guide-to-rsa
link: https://dusty.phillips.codes/2018/09/13/an-intermediate-guide-to-rsa/
categories:
- bloglink
tags:
  - dustyphillipscodes
---

The venerable RSA public key encryption algorithm is very elegant. It requires a basic understanding of modular arithmetic, which may sound scary if you haven't studied it. It reduces to taking the remainder after integer long division. The RSA Wikipedia article describes five simple steps to generate the keys[... <i class="fas fa-external-link-alt"></i>](https://dusty.phillips.codes/2018/09/13/an-intermediate-guide-to-rsa/)

repository: mkearney/data-scribers

repo_name: mkearney/data-scribers


text:
# @lynx-json/lynx-docs

[![Build Status](https://travis-ci.org/lynx-json/lynx-docs.svg?branch=master)](https://travis-ci.org/lynx-json/lynx-docs)

## Installation

`npm install @lynx-json/lynx-docs --save-dev`

## Starting the server

`npx lynx-docs start --root ./templates`

Use `npx lynx-docs --help` to get help or review [command line parameters reference](https://github.com/lynx-json/lynx-docs/wiki/Command-Line-Parameters)

## Origin

lynx-docs is an [NPM package](https://www.npmjs.com/package/@lynx-json/lynx-docs) we made to help us with the following:

* Writing templates for [Lynx documents](http://lynx-json.org/specification/) (or any JSON document) using a [specific YAML syntax](https://github.com/lynx-json/lynx-docs/wiki/dynamic-content).
* Exporting those templates to another template format via the [`export` command](https://github.com/lynx-json/lynx-docs/wiki/Command-Line-Parameters#export-command-parameters) (currently we only support exporting the YAML templates to Handlebars).
* Viewing those templates in a web browser via the [`start` command](https://github.com/lynx-json/lynx-docs/wiki/Command-Line-Parameters#start-command-parameters).

## Benefits

* a better templating language for JSON templates - we didn't find a templating language that worked well with JSON, so we made our own on top of YAML.
* a pre-built web server - verify your static files, templates, forms, and links before you begin to write your real web app.

## Docs and Community

- lynx-docs [wiki](https://github.com/lynx-json/lynx-docs/wiki)
- application/lynx+json [media type specification](http://lynx-json.org/specification/)

## Quick start

Coming soon

repository: lynx-json/lynx-docs

repo_name: lynx-json/lynx-docs


text:
# ADS-WS1 / Ultimeter Weather Station Serial Parser API
This script takes serial data from Argent Data System's ADS-WS1 and Peet Bros ULTIMETER Series and generates a JSON, XML and Prometheus API hosted on a flask webserver.

Its currently in its early stages and is working but please plan on future updates. I will try to keep this README.md file updated.

Talked about in my blogpost: https://evan.kj7bre.com/blog/weather-station/

# Data Output Sources
- JSON
- Prometheus

repository: EvanVS/WXparser

repo_name: EvanVS/WXparser


text:
---
layout: page
title: Projects
---

I love programming and solving challenging problems. Mainly I work with Python. Recently I have started learning Django and web development.

Some of my projects are:

* __Ansible Django__

  * A set of playbooks to automate deployment of a Django project on a remote server.
  * Tested on multiple debian based servers.
  * Github Repo - [https://github.com/pattu777/Ansible-Django](https://github.com/pattu777/Ansible-Django)

* __Lucy__

  * A CLI tool to generate software licenses.
  * Built with Python and uses Github v3 API.
  * Github Repo - [https://github.com/pattu777/Lucy](https://github.com/pattu777/Lucy)

* __Algorithms and Data Structures__

    * Implementation of various data structures with unit tests.
    * Written in Python and Java.
    * Github Repo - [https://github.com/pattu777/Algorithms-and-Data-structures](https://github.com/pattu777/Algorithms-and-Data-structures)


text:
# Nashville's Mentor Night Site

This is the source code for our group's upcoming public Web site. Development mostly happens in the `/src` folder, while the build files are in the `/docs` folder. Old, archived progress for this project is located [at this repository](https://github.com/nashvillefcc/nashvillefcc2020website). Since we moved to Gatsby, all progress has been logged on this repository.

## Built With

This project was bootstrapped with the Gatsby starter [gatsby-starter-tailwind](https://www.gatsbyjs.org/starters/taylorbryant/gatsby-starter-tailwind/).

- [Gatsby](https://www.gatsbyjs.org/)
- [React](https://reactjs.org/)
- [Tailwind CSS](https://tailwindcss.com/)
- [Prettier](https://prettier.io/)

> "Gatsby is a free and open source framework based on React that helps developers build blazing fast websites and apps." -[Gatsby](https://www.gatsbyjs.org/)

> "Tailwind CSS is a utility-first CSS framework for rapidly building custom user interfaces." –[Tailwind CSS](https://tailwindcss.com)

## Getting Started

From the command line, you can run:

- `npm install` - Installs dependencies for this project.
- `npm run develop` - Runs the site in development mode, allows for live editing.
- `npm run build` - Builds the site for deployment in `public` folder, which we ignore with git.
- `npm run analyze` - See what ESLint and Prettier can fix.
- `npm run fix` - Run Prettier and ESLint with the `--fix` option.
- `npm run test` - TODO: https://gatsby.dev/unit-testing\

If you are using VS Code, we have recommended extensions listed in the `mentor-night-site.code-workspace` file. VS Code will automatically detect that list and prompt you to install.

## Contributing

When contributing to this repository, please notify us first before assigning yourself to the ticket. We can be contacted via Discord or GitHub. See the [task board](https://github.com/nashvillefcc/mentor-night-site/projects/1) for a list of features and bugs we're working on.

See the [CONTRIBUTING](https://github.com/nashvillefcc/mentor-night-site/blob/master/CONTRIBUTING.md) page for more details.

## Contact

Please refer to the author details in /package.json.

repository: nashvillefcc/mentor-night-site

repo_name: nashvillefcc/mentor-night-site


text:
# Theta Hardhat Demo

This repository contains a sample project that you can use as the starting point for your Theta DApp project development with the [Hardhat suite](https://hardhat.org/getting-started/).

# Deployment and Testing against Theta Local Privatenet

## Setup the Hardhat demo project

The first things you need to do are cloning this repository and installing its dependencies:

```sh
git clone https://github.com/thetatoken/theta-hardhat-demo
cd theta-hardhat-demo
npm install
```

## Setup Theta local privatenet

Once installed, let's setup the Theta local privatenet with the Theta/Ethereum RPC Adaptor [following this guide](https://docs.thetatoken.org/docs/setup-local-theta-ethereum-rpc-adaptor). The ETH RPC adaptor running at `http://localhost:18888/rpc` interacts with the Web3.js library by translating the Theta RPC interface into the ETH RPC interface.

## Fund the test accounts with some TFuel

Execute the two commands below to fun the test accounts with some TFuel:

```sh
export SEQ=`thetacli query account --address=0x2E833968E5bB786Ae419c4d13189fB081Cc43bab | grep sequence | grep -o '[[:digit:]]\+'`

thetacli tx send --chain="privatenet" --from=0x2E833968E5bB786Ae419c4d13189fB081Cc43bab --to=0x19E7E376E7C213B7E7e7e46cc70A5dD086DAff2A --tfuel=1000 --password=qwertyuiop --seq=$(($SEQ+1))

thetacli tx send --chain="privatenet" --from=0x2E833968E5bB786Ae419c4d13189fB081Cc43bab --to=0x1563915e194D8CfBA1943570603F7606A3115508 --tfuel=1000 --password=qwertyuiop --seq=$(($SEQ+2))
```

## Deploy the contract to the local privatenet

Then, on a new terminal, go to the repository's root folder and run this to deploy your contract:

```sh
npx hardhat run scripts/deploy.js --network theta_privatenet
```

## Run the unit tests against the local privatenet

```sh
npx hardhat test --network theta_privatenet
```

## Run the frontend

Finally, we can run the frontend with:

```sh
cd frontend
npm install
npm start
```

# Deploy to the Theta Mainnet

First, edit the `hardhat.config.js` file, replace `"11...1"` with the actual private key of the deployer wallet (should delete the key after use, do NOT commit the private key to GitHub):

```javascript
    ...
    theta_mainnet: {
      url: `https://eth-rpc-api.thetatoken.org/rpc`,
      accounts: ["1111111111111111111111111111111111111111111111111111111111111111"],
      chainId: 361,
      gasPrice:<PHONE_NUMBER>000
    },
    ...
```

Next, go to the repository's root folder and run this to deploy your contract:

```sh
npx hardhat run scripts/deploy.js --network theta_mainnet
```

# Special Notes on Testing with the Ethers.js+Waffle framework

Currently the RPC Adaptor does NOT support [non-standard methods](https://cnpmjs.org/package/ganache-core/v/2.3.3) like `evm_snapshot`, `evm_revert`, and `evm_mine`. Thus, test cases using [Fixtures](https://ethereum-waffle.readthedocs.io/en/latest/fixtures.html) (e.g. `waffle.loadFixture()`) are expected to fail when running against the Theta blockchain.

repository: rodrigoieh/theta-hardhat-demo

repo_name: rodrigoieh/theta-hardhat-demo


text:
# Academic Kickstart: The Template for [Academic Website Builder](https://sourcethemes.com/academic/)

## add publication
### Manually

Alternatively, publications can be manually created using the command:

```
hugo new --kind publication publication/<my-publication>
```

where <my-publication> is the name of your publication, using hyphens (-) instead of spaces.

Then edit the parameters in content/publication/<my-publication>/index.md to include the details of your publication. The main parameters include:

title: the title of your publication
date: the date that your publication was first published (must be in a valid TOML date format)
publication_types: use the following legend to specify the type of your publication, e.g. "1" for conference proceedings:
0 = Uncategorized
1 = Conference paper
2 = Journal article
3 = Preprint / Working Paper
4 = Report
5 = Book
6 = Book section
7 = Thesis (v4.2+ required)
8 = Patent (v4.2+ required)
publication: where your title was published - Markdown formatting is enabled here for italic etc.
abstract: the summary of your publication
Further details on your publication can be written in the body of the document (after the YAML/TOML front matter) using Markdown for formatting. This text will be displayed on the publication’s page.

To enable visitors to read your work, either paste a link to your PDF in url_pdf or **add a PDF file with the same name as your publication’s own folder to your publication’s folder and a PDF link will be automatically generated.** For example, if your publication is located at publication/photons/index.md, place a PDF at publication/photons/photons.pdf.

To enable visitors to easily cite your work, export a BibTeX citation file named cite.bib from your reference management tool to your publication’s own folder and a citation link will be automatically generated.

### Linking other resources

The url_ links can either point to local or web content. Associated local publication content, may be copied to the publication’s folder and referenced like url_code = "code.zip".

## deployment

To create the `academic-kickstart` repository, [**fork**](https://github.com/sourcethemes/academic-kickstart#fork-destination-box) the *Academic Kickstart* repository and clone your fork with Git (download it to your computer) by replacing `` in the following command with your Github username:

```
git clone https://github.com/<USERNAME>/academic-kickstart.git My_Website
cd My_Website
git submodule update --init --recursive
```

In your `config.toml` file, set `baseurl = "https://.github.io/"`, where `` is your Github username. Stop Hugo if it’s running and delete the `public`directory if it exists (by typing `rm -r public/`).

Add your *.github.io* repository into a submodule in a folder named *public*, replacing with your Github username:

```
git submodule add -f -b master https://github.com/<USERNAME>/<USERNAME>.github.io.git public
```

Add everything to your local git repository and push it up to your remote repository on GitHub:

```
git add .
git commit -m "Initial commit"
git push -u origin master
```

Whilst running the above commands you may be prompted for your Github username and password.

Next, **regenerate** your website’s HTML code by running Hugo and uploading the *public* submodule to GitHub:

```
hugo
cd public
git add .
git commit -m "Build website"
git push origin master
cd ..
```

Once Git has finished uploading your site to Github, you can open your new `https://.github.io` website in your browser, substituting with your Github username.

[**Academic**](https://github.com/gcushen/hugo-academic) makes it easy to create a beautiful website for free using Markdown, Jupyter, or RStudio. Customize anything on your site with widgets, themes, and language packs. [Check out the latest demo](https://academic-demo.netlify.com/) of what you'll get in less than 10 minutes, or [view the showcase](https://sourcethemes.com/academic/#expo).

**Academic Kickstart** provides a minimal template to kickstart your new website.

- 👉 [**Get Started**](#install)
- 📚 [View the **documentation**](https://sourcethemes.com/academic/docs/)
- 💬 [Chat with the **Academic community**](https://spectrum.chat/academic) or [**Hugo community**](https://discourse.gohugo.io)
- 🐦 Twitter: [@source_themes](https://twitter.com/source_themes) [@GeorgeCushen](https://twitter.com/GeorgeCushen) [#MadeWithAcademic](https://twitter.com/search?q=%23MadeWithAcademic&src=typd)
- 💡 [Request a **feature** or report a **bug**](https://github.com/gcushen/hugo-academic/issues)
- ⬆ **Updating?** View the [Update Guide](https://sourcethemes.com/academic/docs/update/) and [Release Notes](https://sourcethemes.com/academic/updates/)
- :heart: **Support development** of Academic:
  - ☕ [**Donate a coffee**](https://paypal.me/cushen)
  - 💵 [Become a backer on **Patreon**](https://www.patreon.com/cushen)
  - 🖼 [Decorate your laptop or journal with an Academic **sticker**](https://www.redbubble.com/people/neutreno/works/34387919-academic)
  - 👕 [Wear the **T-shirt**](https://academic.threadless.com/)
  - :woman_technologist: [**Contribute**](https://sourcethemes.com/academic/docs/contribute/)

[![Screenshot](https://raw.githubusercontent.com/gcushen/hugo-academic/master/academic.png)](https://github.com/gcushen/hugo-academic/)

## Install

You can choose from one of the following four methods to install:

* [**one-click install using your web browser (recommended)**](https://sourcethemes.com/academic/docs/install/#install-with-web-browser)
* [install on your computer using **Git** with the Command Prompt/Terminal app](https://sourcethemes.com/academic/docs/install/#install-with-git)
* [install on your computer by downloading the **ZIP files**](https://sourcethemes.com/academic/docs/install/#install-with-zip)
* [install on your computer with **RStudio**](https://sourcethemes.com/academic/docs/install/#install-with-rstudio)

Then [personalize your new site](https://sourcethemes.com/academic/docs/get-started/).

## Ecosystem

* **[Academic Admin](https://github.com/sourcethemes/academic-admin):** An admin tool to import publications from BibTeX or import assets for an offline site
* **[Academic Scripts](https://github.com/sourcethemes/academic-scripts):** Scripts to help migrate content to new versions of Academic

## License

Copyright 2017-present [George Cushen](https://georgecushen.com).

Released under the [MIT](https://github.com/sourcethemes/academic-kickstart/blob/master/LICENSE.md) license.

[![Analytics](https://ga-beacon.appspot.com/UA-78646709-2/academic-kickstart/readme?pixel)](https://github.com/igrigorik/ga-beacon)


text:
# Telescope MSK

Hello, Sam!

Telescope library for interacting with an MSK/Kafka cluster.

## Requirements

* [Python 3.8+](https://www.python.org/downloads/release)
* [Poetry](https://python-poetry.org/)
* [librdkafka](https://github.com/edenhill/librdkafka)

## Quick start

Install dependencies using Poetry:

```sh
poetry install
```

All available interactions with the MSK cluster are packaged as individual Python scripts in `bin/`.
Run each script as `poetry run bin/<script.py>` prefixed with the desired AWS profile.
Example:

```sh
aws-profile -p telemetry-mdtp-staging-RoleTelemetryEngineer \
  poetry run bin/consumer-groups.py --help
```

## Local development

To run locally the plaintext bootstrap cluster host names must be added to local host IP address:
```
<IP_ADDRESS>       localhost       b-1.msk-cluster.mmfn29.c4.kafka.eu-west-2.amazonaws.com:9092,b-2.msk-cluster.mmfn29.c
4.kafka.eu-west-2.amazonaws.com:9092,b-3.msk-cluster.mmfn29.c4.kafka.eu-west-2.amazonaws.com:9092
```
Fetch the ip from ecs node on aws console,
Then an SSH tunnel must be set up using an the ip to forward the port to localhost:
```sh
ssh -L 9092:localhost:9092 <IP_ADDRESS>
```
Once a port is open you can run the standard scripts as above:
```sh
aws-profile -p telemetry-mdtp-staging-RoleTelemetryEngineer \
  poetry run bin/consumer-groups.py --help
```

### Sync and run in ECS
### ECS is currently unavailable as of TEL-2300, permissions to run telemetry ecs must be added to the labs security group if wanting to run

```sh
export ECS_INSTANCE_IP_ADDRESS=<IP_ADDRESS>
ssh $ECS_INSTANCE_IP_ADDRESS
curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python -
./poetry/bin/poetry install
export AWS_DEFAULT_REGION=eu-west-2
python3 .poetry/bin/poetry run python3 bin/consumer-groups.py
```

## License

This code is open source software licensed under the [Apache 2.0 License]("http://www.apache.org/licenses/LICENSE-2.0.html").


text:
#### 0.1.0 September 15 2017 ####
**Initial Release of .Net Core 2.0 port of [Jenetics GA](http://jenetics.io)**

This port should be seen as proof of concept, if it proofs useful to community it may be mentained further

- Based on Jenetics 3.9.0
- Main GA data structures, examples & tests ported
- Missing XML serialization
- Missing documentation


text:
---
layout: post
title: A.B.L — Always Be Learning
date: 2016-08-20 18:56
author: mpsturm
comments: true
categories: [Education, Learning, Productivity, Self Improvement, Self-awareness, Uncategorized]
---

A.B.L — Always Be Learning

But not in the ways you might think

This!

Today, I just felt the compelling need to say the following:

Always be learning — always.

Even when you feel like you’re not “getting anything done”.

Even when you feel like you’ll never really get what you’re trying to learn — especially when you feel like that.

Even when you feel like so many people know more than you. Even more so when you hear someone else say that they know more than you.

Even when it would be easier to just coast on through the day. Especially then.

Even when you think you know enough. Especially when you think you know enough. That’s when you need learning the most.

The disposition to learn is humbling, cleansing, purifying. It serves you and it serves humankind. It can and does make the world better.

Always be learning.

I’m not saying to always be reading. I’m not saying to always be taking courses online. I’m not saying to read my blog. I’m not saying to listen to this list of “enriching” podcasts. There are plenty of pieces (especially here on Medium) telling you do those things.

What I am saying is to always be learning. Learning can be done in so many other ways. Every conversation you have, or overhear. That’s a learning opportunity. Every moment of quiet introspection — observing the thoughts and feelings that arise. That’s a learning opportunity. Every floor you sweep, every dish you wash — there is ample opportunity to learn.

Whatever you are doing, it can be done better. It can be more enriching. However you are doing, you can always do better. Not just for you, but for those you serve — especially for those you serve. Learning is not so much self improvement as it is world improvement.

If you are always open to learn, you will always be agile, always be flexible, and always be getting better — at whatever it is you’re doing.

Always.

repository: mikesturm/leonids

branch_name: refs/heads/gh-pages

repo_name: mikesturm/leonids


text:
# Audiology - Team Member Breakdown of Work

We held collaboration sessions through VSCode's liveshare feature and communicated through slack to explain our work.

## Jeffrey Lau

### All Tasks

---

- Built the base structure with Python, Flask, Flask Login, WTForms, JinJa2
- Implemented express server
- Integrated Bootstrap into initial phase of styling
- Restructured files and modularized code into packages using Blueprint
- Collaborated in the design of database
- Designed logo for the group

---

Environment

Most of the work done was providing a MVP to work with. Added on the meat of the application through trial and error and redsigned the styling over a few iterations.

## John Nguy

### All Tasks

---

- Implemented AWS S3
- Implemented Musixmatch and Last.fm API's
- Wrote database queries
- Collaborated in the design of the database
- Collaborated in using WTForms, Jinja

---

#### Explanation

Most of my work was focused on implementing the API's and pulling song lyrics and albums, Amazon S3 to handle larger file uploads such as mp3 files, and database queries into the server to pull and store data from the SQLite database. Hardest part was setting up many-to-many relationships in Flask SqlAlchemy as the structure is hard to wrap your head around. Being able to implement a working many-to-many join table into the server was a multi-day endeavour.

## Emmy Wong

### All Tasks

---

- Collaborated in designing the database
- Collaborated with ensuring music uploads to an Amazon S3 bucket and could be played back on local server
- Linking resources from the database to display on the front-end
- Setting up templates using Jinja
- Styling

---

#### Explanation

I collaborated with my team members in a group effort to design the database and implementing the schema using Flask sqlalchemy. I worked mostly on the templates, using Bootstrap to style different sections of the front-end such as making sure the album covers were accurately resized on user playlists. Prior to this project I had no experience with Flask and most technologies involved, so I had to do research on how to implement certain parts and pulling data from the database as well.

gha_language: Python


text:
**Precondition:**

```
Regex input "\A([a-z]+\ ?)+(?<!\ )\Z", phrase)
A phrase always has the translation.
```

repository: oduvan/checkio-empire-bird-language

repo_name: oduvan/checkio-empire-bird-language


text:
# StateMachine
_Fun with state machines and automata_

- [**statemachine.py**](statemachine.py) - A lightweight, flexible, state machine engine; also includes tracing and the beginnings of a stack machine extension

---

- [**sled**](sled) - **S**tatemachine **L**ine **ED**itor: A [`sed`](https://en.wikipedia.org/wiki/Sed)-like front-end built on [`statemachine.py`](statemachine.py), documented in [sled.md](sled.md)

- [**SmoothSailing**](SmoothSailing) - Tiny, seemingly pointless, interactive fiction game to play with [`statemachine.py`](statemachine.py)

- [**statusparser**](statusparser) - Small example of a parser using the [`statemachine.py`](statemachine.py) engine to selectively extract and format some text; compare with [`statusparser.sled`](statusparser.sled) which instructs [`sled`](sled) to do approximately the same transformation.

---

repository: inventhouse/statemachine

repo_name: inventhouse/statemachine


text:
---
layout: article
title:  "MXNet"
excerpt: "Deploying your MXNet model to Algorithmia."
categories: model-guides
tags: [algo-model-guide]
show_related: true
author: besir_kurtulmus
permalink: /model-deployment/mxnet/
redirect_from:
  - /algorithm-development/model-guides/mxnet/
image:
    teaser: /language_logos/mxnet.png
---

Welcome to deploying your MXNet model on Algorithmia!

This guide is designed as an introduction to deploying a MXNet model and publishing an algorithm even if you’ve never used Algorithmia before.

After training your MXNet model, you'll want to save the model and weights so you can upload it to Algorithmia.

### Create a Data Collection
Host your data where you want and serve it to your model with Algorithmia's Data API.

In this guide we'll use Algorithmia's Hosted Data Collection, but you can host it in S3 or Dropbox as well. Alternatively, if your data lies in a database, [check out]({{site.baseurl}}/data/dynamodb) how we connected to a DynamoDB database.

First, you'll want to create a data collection to host your pre-trained model.

- Log into your Algorithmia account and create a data collection via the Data Collections page.

- Click on **“Add Collection”** under the “My Collections” section.

- After you create your collection you can set the read and write access on your data collection.

For more information check out: Data Collection Types.

Note, that you can also use the Data API to create data collections and upload files.

### Host Your Model File
Next, upload your model files to your newly created data collection.

- Load model by clicking box **“Drop files here to upload”**

- Note the path to your files:
    - data://username/collections_name/resnet-152-0000.params,
    - data://username/collections_name/resnet-152-symbol.json,
    - data://username/collections_name/synset.txt

## Create your Algorithm

Hopefully you've already followed along with the Getting Started Guide for algorithm development. If not, you might want to check it out in order to understand the various permission types, how to enable a GPU environment, and use the CLI.

Once you've gone through the Getting Started Guide, you'll notice that when you've created your algorithm, there is boilerplate code in the editor that returns "Hello" and whatever you input to the console.

The main thing to note about the algorithm is that it's wrapped in the `apply()` function.

The apply() function defines the input point of the algorithm. We use the apply() function in order to make different algorithms standardized. This makes them easily chained and helps authors think about designing their algorithms in a way that makes them easy to leverage and predictable for end users.

Go ahead and remove the boilerplate code below that's inside the `apply()` function on line 6, but leave the `apply()` function intact:

### Set your Dependencies
Now is the time to set your dependencies that your model relies on.

- Click on the **"Dependencies"** button at the top right of the UI and list your packages under the required ones already listed and click **"Save Dependencies"** on the bottom right corner.

Please note that you will need to use the **mxnet-cu80==0.11.0** package to be able to run an MXNet algorithm.
{: .notice-warning}

Also please add the following code snippet to the top of your python script to use the latest MXNet library:

{% highlight python %}
import sys
# Don't use anaconda2 version of MXNet, it's too old
sys.path.remove("/opt/anaconda2/lib/python2.7/site-packages/mxnet-0.9.4-py2.7-linux-x86_64.egg")
{% endhighlight %}

## Load your Model
Here is where you load and run your model which will be called by the apply() function.

When you load your model, our recommendation is to preload your model in a separate function external to the apply() function.

This is because when a model is first loaded it can take time to load depending on the file size.

Then, with all subsequent calls only the apply() function gets called which will be much faster since your model is already loaded.

If you are authoring an algorithm, avoid using the ‘.my’ pseudonym in the source code. When the algorithm is executed, ‘.my’ will be interpreted as the user name of the user who called the algorithm, rather than the author’s user name.
{: .notice-warning}

Note that you always want to create valid JSON input and output in your algorithm. For examples see the [Algorithm Development Guides]({{site.url}}{{site.baseurl}}/algorithm-development/languages/python/#io-for-your-algorithms).

Here is an example for loading your model based on the Predict with pre-trained models based on MXNet's official tutorial.

### Example Hosted Model:
{% highlight python %}
import sys
# Don't use anaconda2 version of MXNet, it's too old
sys.path.remove("/opt/anaconda2/lib/python2.7/site-packages/mxnet-0.9.4-py2.7-linux-x86_64.egg")
import Algorithmia
import mxnet as mx
import os
import cv2
import numpy as np
from collections import namedtuple
Batch = namedtuple('Batch', ['data'])

class AlgorithmError(Exception):
     def __init__(self, value):
         self.value = value
     def __str__(self):
         return repr(self.value)

client = Algorithmia.client()

def download_model_files():
    params = "data://deeplearning/mxnet_demo/resnet-152-0000.params"
    symbol = "data://deeplearning/mxnet_demo/resnet-152-symbol.json"
    synset = "data://deeplearning/mxnet_demo/synset.txt"

    params_path = "/tmp/resnet-152-0000.params"
    symbol_path = "/tmp/resnet-152-symbol.json"
    synset_path = "/tmp/synset.txt"

    params_temp_path = client.file(params).getFile().name
    symbol_temp_path = client.file(symbol).getFile().name
    synset_temp_path = client.file(synset).getFile().name

    os.rename(params_temp_path, params_path)
    os.rename(symbol_temp_path, symbol_path)
    os.rename(synset_temp_path, synset_path)

    return {"params": params_path, "symbol": symbol_path, "synset": synset_path}

def init_model(params_path, symbol_path, synset_path):
    sym, arg_params, aux_params = mx.model.load_checkpoint("/tmp/resnet-152", 0)
    mod = mx.mod.Module(symbol=sym, context=mx.cpu(), label_names=None)
    mod.bind(for_training=False, data_shapes=[("data", (1,3,224,224))],
             label_shapes=mod._label_shapes)
    mod.set_params(arg_params, aux_params, allow_missing=True)
    with open(synset_path, 'r') as f:
        labels = [l.rstrip() for l in f]

    return {"sym": sym, "arg_params": arg_params, "aux_params": aux_params, "model": mod, "labels": labels}

files = download_model_files()
model_stuff = init_model(files["params"], files["symbol"], files["synset"])

def predict(imageData):
    img = get_image(imageData, show=True)
    # compute the predict probabilities
    model_stuff["model"].forward(Batch([mx.nd.array(img)]))
    prob = model_stuff["model"].get_outputs()[0].asnumpy()
    # print the top-5
    prob = np.squeeze(prob)
    a = np.argsort(prob)[::-1]
    for i in a[0:5]:
        return {"probability": float(prob[i]), "label": str(model_stuff["labels"][i])}

def get_image(url, show=False):
    # download and show the image
    # fname = mx.test_utils.download(url)
    data_path = client.algo("util/SmartImageDownloader/0.2.16").pipe(url).result["savePath"][0]
    fname = client.file(data_path).getFile().name
    img = cv2.cvtColor(cv2.imread(fname), cv2.COLOR_BGR2RGB)
    if img is None:
         return None
    # convert into format (batch, RGB, width, height)
    img = cv2.resize(img, (224, 224))
    img = np.swapaxes(img, 0, 2)
    img = np.swapaxes(img, 1, 2)
    img = img[np.newaxis, :]
    return img

def apply(input):
    if not isinstance(input, dict):
        raise AlgorithmError("Please provide a valid input.")
    else:
        if "image" not in input:
            raise AlgorithmError("Please provide and image in input.")

    return predict(input["image"])

{% endhighlight %}

Now when you run this code, the expected input is:
{% highlight python %}
{
    "image": "https://upload.wikimedia.org/wikipedia/commons/8/82/Wood_duck_eclipse.jpg"
}
{% endhighlight %}

With the expected output:
{% highlight python %}

OUTPUT
{
  "label": "n01852142 wood duck, summer duck, wood widgeon, Aix sponsa",
  "probability": 0.27775251865386963
}
{% endhighlight %}

## Publish your Algorithm
Last is publishing your algorithm. The best part of deploying your model on Algorithmia is that users can access it via an API that takes only a few lines of code to use! Here is what you can set when publishing your algorithm:

On the upper right hand side of the algorithm page you'll see a purple button "Publish" which will bring up a modal:

In this modal, you'll see a Changes tab, a Sample I/O tab, and one called Versioning.

If you don't recall from the Getting Started Guide how to go through the process of publishing your model, check that out before you finish publishing.

If you want to have a better idea of what a finished MXNet algorithm looks like, check out: MXNet Resnet 152

For more information and detailed steps: creating and publishing your algorithm

That's it for hosting your MXNet model on Algorithmia!

repository: algorithmiaio/dev-center

branch_name: refs/heads/develop

repo_name: algorithmiaio/dev-center


text:
# React 16 Essentials - Second Edition
This is the code repository for [React 16 Essentials - Second Edition](https://www.packtpub.com/web-development/react-16-essentials-second-edition?utm_source=github&utm_medium=repository&utm_campaign=9781787126046), published by [Packt](https://www.packtpub.com/?utm_source=github). It contains all the supporting project files necessary to work through the book from start to finish.
## About the Book
React 16 Essentials, Second Edition, fully updated for React 16, takes you on a fast-paced journey through building your own maintainable React 16 applications. React experts Artemij Fedosejev and Adam Boduch give you all the essentials you need to know and start working with React 16, in this new edition of the best-selling React.js Essentials title. You'll find the latest React 16 code updates, assessment of React Fiber, new coverage of Redux, and how to work as a modern React developer.

The authors offer you their current assessment of React Fiber, and you'll soon be exploring React 16 hands on, creating your own single and multiple user interface elements with React 16. You'll then see how to create stateless and stateful components and make them reactive. You'll also learn to interact between your components and lifecycle methods, and gauge how to effectively integrate your user interface components with other JavaScript libraries. Delve deep into the core elements of the Redux architecture and learn how to manage your application and data persistence. Then go the extra mile with the Jest test framework, and run multiple tests on your applications and find solutions to scale without complexity.

Today React is used by Facebook, Instagram, Khan Academy, and Imperial College London, to name a few. Many new users recognize the benefits of React and adopt it in their own projects, forming a fast-growing community. The speed at which React has evolved promises a bright future for anyone who invests in learning it today. Let Artemij and Adam bring you a brand new look at React 16 and React Fiber, and move your web development into the future.

## Instructions and Navigation
All of the code is organized into folders. Each folder starts with a number followed by the application name. For example, Chapter02.

The code will look like the following:
```
import React from 'react';
import { render } from 'react-dom';
const reactElement = React.createElement(
'h1',
 { className: 'header' }
);
render(
 reactElement,
 document.getElementById('react-application')
);
```

First of all, you need the latest version of a modern web browser, such as Google
Chrome or Mozilla Firefox:
* Google Chrome: https://www.google.com/chrome/browser
* Mozilla Firefox: https://www.mozilla.org/en-US/firefox/new/
Second, you will need to install Git, Node.js, and npm. You will find detailed instructions on how to install and use them in Chapter 2, Installing Powerful Tools for Your Project. Finally, you will need a code editor. I recommend Sublime Text
(http://www.sublimetext.com). Alternatively, you can use Atom (https://atom.io), Brackets (http://brackets.io), Visual Studio Code (https://code.visualstudio.com), or any other editor of your choice.

## Related Products
* [ReactJS by Example - Building Modern Web Applications with React](https://www.packtpub.com/web-development/reactjs-example-building-modern-web-applications-react?utm_source=github&utm_medium=repository&utm_campaign=9781785289644)

* [React and React Native](https://www.packtpub.com/web-development/react-and-react-native?utm_source=github&utm_medium=repository&utm_campaign=9781786465658)

* [Getting Started with React VR](https://www.packtpub.com/hardware-and-creative/getting-started-react-vr?utm_source=github&utm_medium=repository&utm_campaign=9781788476607)


text:
# Guppy Environment driver

A JDBC driver that looks for system properties to delegate to a another JDBC driver.

E.g. if you set the JDBC url in your application to be jdbc:property:0 it will
look for system properties of the format:

```shell
  property.0.url
  property.0.property.1=name=value
  property.0.property.2=name2=value2
```

repository: PratesLab/piranha

repo_name: PratesLab/piranha


text:
---
layout: post
title: "The Mathematics of Marriage"
published: true
mathjax: true
---

Can you predict whether a married couple will divorce after observing them
engage in a single 15 minute conversation? This is the premise

## What are we measuring?

How do you condense all the complexity of a human being engaged in a
conversation down to a single number? The researchers created the
*Gottman-Levenson* variable, which is based on SPAFF (Specific Affect Coding
System). SPAFF is a real-time coding system where an individual's affect,
mainly based on their facial expression, is coded along five positive, ten
negative, and one neutral code. Each code is assigned a value between $$-4$$
and $$+4$$ for each second. The codes are then summed over 6 second intervals
to generate the Gottman-Levenson variable, which ranges between $$-24$$ and
$$+24$$. The SPAFF codes are mutually exclusive.

Let $$H_t$$


text:
# Changelog

## 0.5.0
* Add support for sidekiq >= 5

## 0.4.0

## 0.3.0
* stop cutting + pasting Sidekiq retry logic, which is now extracted into a method (https://github.com/mperham/sidekiq/pull/1928)
* require sidekiq 3.2.4

## 0.2.0
* simplify retry/fail logic
* fix retry: 0, which was going straight to the dead queue

## 0.1.0

* sidekiq 3 compatibility

## 0.0.1

* initial release for sidekiq 2.17.x

repository: vvalgis/sidekiq-retries

repo_name: vvalgis/sidekiq-retries


text:
# SPMacros

[![CI Status](http://img.shields.io/travis/zzxxccaa/SPMacros.svg?style=flat)](https://travis-ci.org/zzxxccaa/SPMacros)
[![Version](https://img.shields.io/cocoapods/v/SPMacros.svg?style=flat)](http://cocoapods.org/pods/SPMacros)
[![License](https://img.shields.io/cocoapods/l/SPMacros.svg?style=flat)](http://cocoapods.org/pods/SPMacros)
[![Platform](https://img.shields.io/cocoapods/p/SPMacros.svg?style=flat)](http://cocoapods.org/pods/SPMacros)

## Usage

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

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

```ruby
pod "SPMacros"
```

## Author

zzxxccaa<EMAIL_ADDRESS>
## License

SPMacros is available under the MIT license. See the LICENSE file for more info.

repository: spbreak/SPMacros

repo_name: spbreak/SPMacros


text:
# @ecocea/heroku-industrialisation
Collection of Heroku Industrialisation scripts for Node.JS

Execute a list of actions contained in plugins. Some plugins are provided, and you have the ability to create your own.

### Prerequisites
Tested on Node.js 8+
Requires ES6 compatibility
Designed for Heroku Release Phase.

### Installation
```sh
npm install @ecocea/heroku-industrialisation --save
```

### Initialisation
```javascript
//Configuration object containing a key for each plugin (configName). Use of @ecocea/config-loader is recommanded.
//During Release Phase, Heroku has access to the Config Vars.
const config = {/*...*/};

//List of custom plugins (object). Optional parameter.
const customPlugins = [/*...*/];

//Import the package
const herokuIndustrialisation = require('@ecocea/heroku-industrialisation');

//Call Logic of the package
herokuIndustrialisation(config, customPlugins);
```

### Plugin
A plugin is an object containing following fields:
- __name__: _(String)_ Name of the plugin. Should be unique, and not begin by _ (reserved for official plugins)
- __configName__: _(String)_ Name of the property of the Configuration Object passed as first argument of main function of @ecocea/heroku-industrialisation
- __dependent__: _(Array<String>) optional_ List of name of other plugins that should be executed before this one. If the plugin is not found, or disabled, he is ignored. This field can be overwritten in Configuration Object
- __process__: _(Function)_ Main Logic of the plugin, takes two parameters:
  - config: _(Object)_ Specific configuration for this plugin
  - dependenciesData: _(Array\<Object>)_ Contains the data returned by plugins, in the order they are declared

### Configuration
A global Object containing Plugin Configuration Object. Each key should be associated to a plugin configName.

The key "DEBUG" set to true allows to display debug logs displayed.

If the config of a plugin is not found, this plugin won't be executed. Adding a property "disabled" to true in Plugin Configuration Object allow to disable a plugin without deleting the configuration.

Adding a property "dependent" allow to override the dependent property of the plugin. Be careful ! Modifying dependent field may break the logic of a plugin. This function is designed to delay some plugins, allowing them to be executed after some others, but without managing response of these plugins.

repository: ecocea/heroku-industrialisation

repo_name: ecocea/heroku-industrialisation


text:
Mine
===
A project for powering your website needs.

Mine, as in "This website is *mine*"

[![Dependency Status](https://gemnasium.com/hreeder/Mine.svg)](https://gemnasium.com/hreeder/Mine) [![Join the chat at https://gitter.im/hreeder/Mine](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/hreeder/Mine?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

### Aims
Mine aims to be a central platform for serving personal websites. It is not intended to become a hosting platform.
Mine will also be based around Linked Data principles.

The philosophy behind Mine is that you are always in control of your own data.

### Requirements
* Python (Developed in 3, untested in 2)
* Flask
* Redis
* SQLAlchemy Compatible Data-Store (Developed against MySQL/MariaDB)

repository: hreeder/Mine

repo_name: hreeder/Mine


text:
# Leucocoprinus micropholis (Berk. & Broome) Locq., 1951 SPECIES

#### Status
SYNONYM

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

#### Published in
null

#### Original name
Agaricus micropholis Berk. & Broome, 1871

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Agaricales/Agaricaceae/Lepiota/Lepiota micropholis/ Syn. Leucocoprinus micropholis/README.md

repo_name: mdoering/backbone


text:
Prototype design pattern implementation allows us to solve the problem of having multiple copies of objects those are expensive and resource intensive to create.

Specifies kind of objects to created using prototypical instance and create new object by copying this object.

<kbd>![Generic class diagram](generic-class-diagram.png)</kbd>

repository: gusenov/software-design-patterns

repo_name: gusenov/software-design-patterns


text:
---
layout: default
---

# 1992-11-15 - Re: Apple including PKS?

## Header Data

From<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 992d8eb13393ccb082fb29d3ba9a809602d8bca8c116a005260cc7b8f7ca6c00

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1992-11-15 21:42:22 UTC

Raw Date: Sun, 15 Nov 92 13:42:22 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>Date: Sun, 15 Nov 92 13:42:22 PST
To<EMAIL_ADDRESS>Subject: Re: Apple including PKS?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

>Re: Apple include a PKS with their Macs
>
>Well, Apple does have a site license for RSA.  Tim Oren, who's on the
>list, knows more about this than I.  I ask him to respond.
>
>Maybe Apple could license the PGP code as a system utility?
>
>Eric

Apple does have a license from RSA, which includes both site and
redistribution rights.  The intent is to make security-enhanced features
available in something called OCE (Open Collaboration Environment) which is
to be Apple's entry in the E-mail / user directory / etc.  marketplace.
OCE is likely to be an add-on, that is, something not shipped with every
Mac, but available at extra cost.  Since I'm under NDA for the details of
OCE, I will simply quote what MacLeak says:

 According to MacWeek, Apple is using RSA software with 150-200 digit
primes for Digital Signatures. They are using "RSA's RC4 algorithm [which
will] provide
 encryption of the fly for data transmitted across an OCE (open
Collaboratioon Environment) network. Each message will be scrambled using a
unique 64-bit key.

BTW, notice that's decimal digits, not bits, in the signature length.

Apple is set up as a certifying authority, but I don't know any details of
the plans on how to certify keys.  It's a far from simple problem to work
out something that will work in the current personal computer market
structure and isn't subject to spoofing.

Re Apple licensing PGP code:  While Apple could presumably do so without
violating any laws, so long as any copyright holders in PGP granted
appropriate rights, I don't think it's very likely.  OCE is a package to be
differentiated by its user interface, and apparently MacPGP's (though I
haven't tried it myself yet) is rather crufty from the Mac point of view.
Also, Apple traditionally wants very tight control over its source code,
and is unlikely to adopt something that arrives in such a (shall we say)
'informal' fashion from outside.

Finally, as a dose of preventive medicine, I should mention that all of the
above is my best interpretation of Apple policy and probable action, with
which I don't necessarily agree personally.  Flameage ignoring this
statement will be routed appropriately.

Tim Oren

{% endraw %}
```

## Thread

+ Return to [November 1992](/archive/1992/11)

+ Return to "[oren@apple.com](/authors/oren_at_apple_com)"

+ 1992-11-15 (Sun, 15 Nov 92 13:42:22 PST) - Re: Apple including PKS? -<EMAIL_ADDRESS>


text:
---
layout: post
title: "IBM Watson Assistant: How Do I Determine Unique Users?"
date: 2019-09-12 16:00:00
categories:
comments: true
tags:
# image: /assets/article_images/2014-11-30-mediator_features/night-track.JPG
# image2: /assets/article_images/2014-11-30-mediator_features/night-track-mobile.JPG
---

IBM Watson Assistant: How Do I Determine Unique Users?

Originally posted on [Medium](https://modcarroll.medium.com/ibm-watson-assistant-how-do-i-determine-unique-users-3aef8d3a2b8e)

If you are familiar with the Watson Assistant Plus plan, then you have likely come across the same question as others: How do I determine what constitutes a "unique" user?

The Watson Assistant Plus plan comes with several super cool features, including disambiguation, intent recommendations, and user-based pricing. You can read more from the official announcement: [https://www.ibm.com/blogs/watson/2018/12/introducing-watson-assistant-plus-pricing-plan-and-new-powerful-features/](https://www.ibm.com/blogs/watson/2018/12/introducing-watson-assistant-plus-pricing-plan-and-new-powerful-features/)

The Plus (and Premium) plan bases its pricing on MAUs (Monthly Active Users). Consider this scenario: You are the owner of a floral shop specializing in yellow roses (my favorite). You would likely create a chatbot to answer common customer inquiries. These may include: what are your store hours, what types of flowers do you sell, and it can look up a customer's order information. For previous Watson Assistant pricing plans, you were charged per Message API call. If a customer asks, "What type of flowers do you specialize in?" and the bot responds with "We specialize in all types of yellow roses." then that is 1 Message API call. Each subsequent utterance is another Message API call.
With the Plus plan, you are charged a base rate for "x" number of users (tiered, starting at 10,000 users). So each user could talk to the bot 100 times per week if they wanted, but they are still only considered to be one user. Now to the original point, how do I tell Watson, who is a unique user? In your API calls, there is a parameter called `user_id` which you use to send Watson Assistant the ID for your user. [https://cloud.ibm.com/apidocs/assistant-v2#send-user-input-to-assistant](https://cloud.ibm.com/apidocs/assistant-v2#send-user-input-to-assistant)

![Watson Assistant API Documentation](/assets/article_images/user_id.png)

You should give each of your users a unique identifier (in the form of a string) as their user ID. Many companies already implement some sort of authentication for their customers, so you may choose to use their existing e-mail address or user ID from your website as their user ID. So if I log in to my floral website with the e-mail address<EMAIL_ADDRESS>then when I chat with the chatbot while logged in, my chatbot orchestration layer could grab my e-mail address, add it to the payload as the "user_id" then send my message to Watson Assistant. Here's a snippet to demonstrate:

```javascript
// assume currentUser is the current logged in user
let currentUser = {
  email<EMAIL_ADDRESS>  name: "Morgan Carroll",
  city: "Austin",
};

// get e-mail address from currentUser object
let wa_user_id = currentUser.email;

// add cookie ID to user_id parameter
const AssistantV2 = require("ibm-watson/assistant/v2");

const assistant_service = new AssistantV2({
  iam_apikey: "{apikey}",
  version: "2019-02-28",
  url: "{url}",
});

assistant_service
  .message({
    assistant_id: "{assistant_id}",
    session_id: "{session_id}",
    input: {
      message_type: "text",
      text: "Hello",
    },
    context: {
      global: {
        system: {
          user_id: wa_user_id,
        },
      },
    },
  })
  .then((res) => {
    console.log(JSON.stringify(res, null, 2));
  })
  .catch((err) => {
    console.log(err);
  });
```

There is a problem here, however. What if you have a public-facing chatbot? My bot is on the homepage of my floral website. I want any user whether they are currently logged in or not to be able to converse with my chatbot. After all, how else will they know that I specialize in yellow roses? However, if they aren't logged in, how can I assign a unique "user_id" to them? If I don't, each API call is considered a unique user. (Update: This applies to v1. v2 uses sessions instead of API calls. So in v2, each session/conversation would be considered a unique user.) The answer: cookies 🍪! When the user visits your website, a cookie is saved on their computer. Then, your website recognizes this cookie on each subsequent visit. You can determine a unique ID for each user to save in the cookie then retrieve that and pass it to Watson Assistant as the "user_id" parameter. Here's a simple example:

```javascript
// set cookie. For this user, their cookie ID is 'purplecookie1' but each user should have a unique cookie ID.
document.cookie = "cookie_id=purplecookie1";

// get cookie
let cookie_string = document.cookie.split("=");
let wa_user_id = cookie_string[0];

// add cookie ID to user_id parameter
const AssistantV2 = require("ibm-watson/assistant/v2");

const assistant_service = new AssistantV2({
  iam_apikey: "{apikey}",
  version: "2019-02-28",
  url: "{url}",
});

assistant_service
  .message({
    assistant_id: "{assistant_id}",
    session_id: "{session_id}",
    input: {
      message_type: "text",
      text: "Hello",
    },
    context: {
      global: {
        system: {
          user_id: wa_user_id,
        },
      },
    },
  })
  .then((res) => {
    console.log(JSON.stringify(res, null, 2));
  })
  .catch((err) => {
    console.log(err);
  });
```

If you are uninterested in using an authentication layer or cookies, you may try using a user's IP address. There are a few problems with this approach (dynamic IP addresses and VPNs come to mind), but it may work as a rudimentary option.

```javascript
// get user's IP address using third-party service
userIP = "";
$.getJSON("https://json.geoiplookup.io/api?callback=?", function (data) {
  console.log(JSON.stringify(data, null, 2));
  userIP = data.ip;
});

let wa_user_id = userIP;

// add cookie ID to user_id parameter
const AssistantV2 = require("ibm-watson/assistant/v2");

const assistant_service = new AssistantV2({
  iam_apikey: "{apikey}",
  version: "2019-02-28",
  url: "{url}",
});

assistant_service
  .message({
    assistant_id: "{assistant_id}",
    session_id: "{session_id}",
    input: {
      message_type: "text",
      text: "Hello",
    },
    context: {
      global: {
        system: {
          user_id: wa_user_id,
        },
      },
    },
  })
  .then((res) => {
    console.log(JSON.stringify(res, null, 2));
  })
  .catch((err) => {
    console.log(err);
  });
```

Note: These code snippets are examples ONLY and are not intended to be implemented in a production environment.

extension: markdown

gha_language: G-code


text:
---
title: CAA Unconference
revealOptions:
    transition: 'fade'
---
<style>
#fLeft {float: left; max-width: 50%;}
#fRight {float: right; max-width: 50%;}
#smallLink {font-size: 18px;}
.whitebg {background-color: #fff; margin-top: 30% !important; padding: 15px !important; border-radius: 15px;}
h1, h2, h3, h4, h5 {text-transform: capitalize !important;}
</style>

# Welcome
## Capital Area Archivists
### 2020 Spring Unconference

[archives.albany.edu/caa](https://archives.albany.edu/caa)

---

### Super low-barrier space to learn and share

* Low-budget
* Participant-Driven!
* Contributor session ideas

---

## Agenda

* Announce session ideas
* Set schedule
    * 3 sessions slots
    * 2-3 concurrent sessions
    * 15 minute breaks
    * Wrapup at the end

---

## Where things are

* Standish Room
    * here
* Conference Room
    * in special collections down the hall
* Back Room
    * behind this room

---

### Critical Images: Altering the Past
#### Sheri Sarnoff, Amanda Partridge, Miles Lawlor

---

### Capital Region Alliance for Response (CapNYAFR)
#### John Diefenderfer

---

### How do we do that? Implementing Web Systems in Archives
#### Gregory Wiedeman, Mark Wolfe

---

### I was told there would be no Public Speaking: Outreach and Archives
#### Michael Maloney

---

### Time to Write
#### Jenifer Monger

---

### Archivists & Librarians: Digital Selections in Web-Scale Discovery Tool Implementations?
#### Brenden McCarthy

---

### Collection Development and Acquisition
#### Brian Keough

---

### Schedule Setting

[archives.albany.edu/schedule](https://archives.albany.edu/schedule)

gha_language: HTML


text:
# PY3-Faster-RCNN-TF

This repo is a Python3 implementation of [Faster-RCNN_TF by smallcorgi](https://github.com/smallcorgi/Faster-RCNN_TF) which implements [Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks](http://arxiv.org/pdf/1506.01497v3.pdf) by Shaoqing Ren, Kaiming He, Ross Girshick, Jian Sun.

The full repository has been made compaitable for python3, and if you want to train a network you can follow the following instructions. In case, if you want to do the same using python2, then you can fork or download the following repo.

https://github.com/dxyang/Faster-RCNN-COCO_TF

### Requirements: software

1. Requirements for Tensorflow (see: [Tensorflow](https://www.tensorflow.org/))

2. Python packages you might not have: `pillow` `scipy` `cython`, `opencv3`, `easydict`

This repo has been tested using python3.5, tensorflow1.4, cudNN-6.

### Installation

1. Clone the PY3-Faster-RCNN-TF repository
	```bash
	# Make sure to clone with --recursive
	git clone --recursive https://github.com/surajitsaikia27/PY3-Faster-RCNN-TF
	```

2. Build the Cython modules
	```bash
	cd $PY3-Faster-RCNN-TF/lib
	make
	```

3. To run the demo:

   Download the COCO trained pretrained model from https://drive.google.com/file/d/0Bw0qMqgwZcafZlRqRDYxSnBkNFE/view

   rename VGGnet_fast_rcnn_iter_490000.ckpt.data-00000-of-00001 as VGGnet_fast_rcnn_iter_490000.ckpt

   Run the following command.
 ```bash
  python ./tools/demo.py --model "path to the VGGnet_fast_rcnn_iter_490000.ckpt"  --net VGGnet_test  --img-path path to image folder
  ```
  The results will be saved in a directory called ```detections_test```

Follow the instructions to train your own model.

1. Build pycocotools modules
	```bash
	cd $PY3-Faster-RCNN-TF/lib
	git clone https://github.com/cocodataset/cocoapi.git
	cd cocoapi/PythonAPI
	make
	cd ../..
	mv cocoapi/PythonAPI/pycocotools pycocotools
	rm -rf cocoapi
	```

2. Build the Cython modules
	```bash
	cd $PY3-Faster-RCNN-TF/lib
	make
	```

### Training Model
3. Install gsutil if you haven't already
	```bash
	curl https://sdk.cloud.google.com | bash
	```

4. Download the training, validation, test data for MS COCO
	```bash
	cd $PY3-Faster-RCNN-TF/data
	mkdir coco; cd coco
	mkdir images; cd images
	mkdir train2014
	mkdir test2014
	mkdir val2014
	gsutil -m rsync gs://images.cocodataset.org/train2014 train2014
	gsutil -m rsync gs://images.cocodataset.org/test2014 test2014
	gsutil -m rsync gs://images.cocodataset.org/val2014 val2014
	```

5. Download the annotations for MS COCO and unzip
	```bash
	cd $PY3-Faster-RCNN-TF/data
	gsutil -m rsync gs://images.cocodataset.org/annotations coco
	cd coco
	unzip annotations_trainval2014.zip
	unzip image_info_test2014.zip
	rm *.zip
	```

6. Download the annotations for the 5000 image minival subset of COCO val2014 as mentioned [here](https://github.com/rbgirshick/py-faster-rcnn/tree/master/data)
	```bash
	cd $PY3-Faster-RCNN-TF/data/coco/annotations
	wget https://dl.dropboxusercontent.com/s/o43o90bna78omob/instances_minival2014.json.zip
	wget https://dl.dropboxusercontent.com/s/s3tw5zcg7395368/instances_valminusminival2014.json.zip
	unzip instances_minival2014.json.zip; rm instances_minival2014.json.zip
	unzip instances_valminusminival2014.json.zip; rm instances_valminusminival2014.json.zip
	```

7. Download the pre-trained ImageNet model [[Google Drive]](https://drive.google.com/open?id=0ByuDEGFYmWsbNVF5eExySUtMZmM) [[Dropbox]](https://www.dropbox.com/s/po2kzdhdgl4ix55/VGG_imagenet.npy?dl=0)
	```bash
	cd $PY3-Faster-RCNN-TF
	wget https://www.dropbox.com/s/po2kzdhdgl4ix55/VGG_imagenet.npy
	mkdir data/pretrain_model
	mv VGG_imagenet.npy data/pretrain_model/VGG_imagenet.npy
	```

8. Create an output directory for log files
	```bash
	cd $PY3-Faster-RCNN-TF
	mkdir experiments/logs
	```

9. Run script to train and test model
	```bash
	cd $PY3-Faster-RCNN-TF
	./experiments/scripts/faster_rcnn_end2end.sh $DEVICE $DEVICE_ID VGG16 coco
	```
  - DEVICE is either cpu/gpu

### Testing Model
Run the following command.

```bash
python ./tools/test_net.py \
		--device gpu \
		--device_id 0 \
		--weights output/faster_rcnn_end2end/coco_2014_train/VGGnet_fast_rcnn_iter_490000.ckpt \
		--cfg experiments/cfgs/faster_rcnn_end2end.yml \
		--imdb coco_2014_minival \
		--network VGGnet_test	\
		--vis False
```

- Changing ```vis``` to ```True``` will save images with all detections above 0.8 for every image in the testing set.
- The checkpoint files folder contains the following:
	```bash
	cd output/faster_rcnn_end2end/coco_2014_train
	ls
	# VGGnet_fast_rcnn_iter_490000.ckpt.data-00000-of-00001
	# VGGnet_fast_rcnn_iter_490000.ckpt.index
	# VGGnet_fast_rcnn_iter_490000.ckpt.meta
	```


text:
Save My Tabs is a Chrome extension that stores the list of open tabs in a text file in Dropbox.

[Install](https://chrome.google.com/webstore/detail/save-my-tabs/fkbdkhmbpokikgoclndkhgldkncncmdj) it from the Chrome Web Store. You can also download a zip from [Releases](https://github.com/nikhilm/save-my-tabs/releases).

[Screencast](https://www.youtube.com/watch?v=kaiV7rrcXh4)

After installing the extension, go to the options page to sign in to Dropbox. The extension requests app permissions, so the file will be saved in the `Apps/Save My Tabs/ChromeTabs.txt` file.

# License

The extension code and resources are under the MIT License.

The [Dropbox Javascript SDK's](https://github.com/dropbox/dropbox-sdk-js) minified form is included. This is also licensed under the MIT License.

repository: nikhilm/save-my-tabs

repo_name: nikhilm/save-my-tabs


text:
# Design Guide - Community Page (Events Tab)

## Events Tab

The events tab is the 3rd tab next to the albums tab. This tab only exists in the club and lab pages, meaning this tab is where all community events of the certain club or lab reside.

### List Community Events

`GET api/community/event/community?created_under={int}`

The `{int}` is the ID of the community, used to filter only community events created under here.

### Create Community Event Button

`GET api/commununity/club/{int}`

`GET api/commununity/event/{int}`

`GET api/commununity/event/community/{int}`

`GET api/commununity/lab/{int}`

After retrieving the community data by one of these APIs, a field `own_membership_position` is expected. If is at least `1`, then render the create community event button, meaning the current user is able to create community events in the certain community.

### Create Community Event

After the user has clicked the create community event button, display the form. Within the form, call these two API to retrieve the event types and event series as the choices for the user to pick.

`GET api/category/event-type`

`GET api/category/event-series`

After the user has filled all the required information and confirmed the community event creation, call this API to create the community event.

`POST api/community/event/community`

```json
{
    "name_th": "string",
    "name_en": "string",
    "description": "string",
    "external_links": "string",
    "logo": "image",
    "banner": "image",
    "is_accepting_requests": "boolean",
    "location": "string",
    "start_date": "date",
    "end_date": "date",
    "start_time": "time",
    "end_time": "time",
    "is_cancelled": "boolean",
    "allows_outside_participator": "boolean",
    "event_type": "int",
    "event_series": "int",
    "created_under": "int"
}
```


text:
# google_sign_in_web

The web implementation of [google_sign_in](https://pub.dev/google_sign_in/google_sign_in)

## Usage

### Import the package

This package is the endorsed implementation of `google_sign_in` for the web platform since version `4.1.0`, so it gets automatically added to your dependencies by depending on `google_sign_in: ^4.1.0`.

No modifications to your pubspec.yaml should be required in a recent enough version of Flutter (`>=1.12.13+hotfix.4`):

```yaml
...
dependencies:
  ...
  google_sign_in: ^4.1.0
  ...
...
```

### Web integration

First, go through the instructions [here](https://developers.google.com/identity/sign-in/web/sign-in#before_you_begin) to create your Google Sign-In OAuth client ID.

On your `web/index.html` file, add the following `meta` tag, somewhere in the
`head` of the document:

```html
<meta name="google-signin-client_id" content="YOUR_GOOGLE_SIGN_IN_OAUTH_CLIENT_ID.apps.googleusercontent.com">
```

For this client to work correctly, the last step is to configure the **Authorized JavaScript origins**, which _identify the domains from which your application can send API requests._ When in local development, this is normally `localhost` and some port.

You can do this by:

1. Going to the [Credentials page](https://console.developers.google.com/apis/credentials).
2. Clicking "Edit" in the OAuth 2.0 Web application client that you created above.
3. Adding the URIs you want to the **Authorized JavaScript origins**.

For local development, may add a `localhost` entry, for example: `http://localhost:7357`

#### Starting flutter in http://localhost:7357

Normally `flutter run` starts in a random port. In the case where you need to deal with authentication like the above, that's not the most appropriate behavior.

You can tell `flutter run` to listen for requests in a specific host and port with the following:

```
flutter run -d chrome --web-hostname localhost --web-port 7357
```

### Other APIs

Read the rest of the instructions if you need to add extra APIs (like Google People API).

### Using the plugin
Add the following import to your Dart code:

```dart
import 'package:google_sign_in/google_sign_in.dart';
```

Initialize GoogleSignIn with the scopes you want:

```dart
GoogleSignIn _googleSignIn = GoogleSignIn(
  scopes: [
    'email',
    'https://www.googleapis.com/auth/contacts.readonly',
  ],
);
```
[Full list of available scopes](https://developers.google.com/identity/protocols/googlescopes).

You can now use the `GoogleSignIn` class to authenticate in your Dart code, e.g.

```dart
Future<void> _handleSignIn() async {
  try {
    await _googleSignIn.signIn();
  } catch (error) {
    print(error);
  }
}
```

## Example

Find the example wiring in the [Google sign-in example application](https://github.com/flutter/plugins/blob/master/packages/google_sign_in/google_sign_in/example/lib/main.dart).

## API details

See the [google_sign_in.dart](https://github.com/flutter/plugins/blob/master/packages/google_sign_in/google_sign_in/lib/google_sign_in.dart) for more API details.

## Contributions and Testing

Tests are crucial for contributions to this package. All new contributions should be reasonably tested.

**Check the [`test/README.md` file](https://github.com/flutter/plugins/blob/master/packages/google_sign_in/google_sign_in_web/test/README.md)** for more information on how to run tests on this package.

Contributions to this package are welcome. Read the [Contributing to Flutter Plugins](https://github.com/flutter/plugins/blob/master/CONTRIBUTING.md) guide to get started.

## Issues and feedback

Please file [issues](https://github.com/flutter/flutter/issues/new)
to send feedback or report a bug.

**Thank you!**

repository: buaashuai/plugins

gha_language: Dart

repo_name: buaashuai/plugins


text:
# SwitchAudio for OSX

This is an improved import of [https://code.google.com/p/switchaudio-osx](https://code.google.com/p/switchaudio-osx/)

## Enhancements

- Audio channels toggling: specify `-s` parameter twice to toggle between them
- Auto change back of previous audio channel after some pause (todo)

## Installation

- Download & install [Soundflower](http://cycling74.com/products/soundflower/)
- Extract & copy [SwitchAudioSource](https://github.com/razum2um/switchaudio-osx/releases/download/v1.0.0/SwitchAudioSource.zip) to your `$PATH` (compiled for Mavericks)

You can compile it by yourself, too (xcode command line tools needed):

    $ ./make.sh

## Usage

Bind it to your favourite hotkey to toggle between outputs:

    $ SwitchAudioSource -s "Built-in Output" -s "Soundflower (2ch)"


text:
# what is this ?

a command line tool to manage SmartOS hosts.

# Prerequisites

- you have an ssh key
- your ssh public key is in authorized_keys on the server to allow passwordless login

# Usage

first you need to create a config file to define your environment:

```toml
# show custom properties in the list
[user_columns]
  some_property = "customer_metadata.some_property"

[global]
  # gateway_user = "root"
  gateway = "x.x.x.x"

[vmhost1]
  # user = "root"
  # gateway = "a.b.c.d"
  # gateway_user = "root"
  address = "y.y.y.y"

[vmhost2]
  # user = "root"
  # gateway = "a.b.c.d"
  # gateway_user = "root"
  address = "z.z.z.z"

```

All options except address (which makes no sense) can be defined in a global section, if present in a host section the later will be used, otherwise the global one is used.

Save te config file as "smartos_hosts.toml" and run the followings commands
in the same folder.

Once you have your file you can use the smanager command:

```bash
$ smanager list
```

repository: schmurfy/smartos-manager

repo_name: schmurfy/smartos-manager