text:
---
id: 56
title: The Technical Interview
date: 2009-02-15T19:58:38+00:00
author: benjamin hysell
layout: post
guid: http://benjaminhysell.com/?p=56
permalink: /archive/2009/02/the-technical-interview/
categories:
  - hiring
  - interviewing
tags:
  - hiring
  - interviewing
---
I love the interview process...no, no, no, not the part where you are applying for a job, no, heavens no.  I love being on the other side of the table performing the interview and asking the questions.  Being interviewed?  Another topic for another time.

During your career, be it in software or otherwise, you will likely find yourself in a position to interview new people to join your company.  This task is not one to be taken lightly, good talent is hard to find, and making a hiring mistake can be very difficult to correct.  So what is one to do?

I found myself in this situation a few years back.  My team was growing, and we had the opportunity to hire a couple co-op students from the local university.  I had sat in on a few technical interviews before for other co-op students where I was more an observer than participant.  A couple of times during those early interviews when I was asked if I had anything to ask the applicant, I would usually respond with a, “nope.”  At that time I didn't bring too much to the table.

This time around not only did I want to participate, but I wanted to run the interviews.

What follows is my typical interview “script”.  I call it a script because everyone involved plays a role, including the candidate.  The script metaphor works because we need to follow the same basic outline from interview to interview in order to accurately compare candidates.  My team and I have run this script around 30-40 times as of this post, and so far we have had great results in who we have hired.  Of course, your mileage may vary.

Some may ask, “if you are providing your script, and I interview for you, won't that be like cheating?”

Yes, yes it would.  If you plan to ever interview with me in whatever company I'm working for in the future and I'm sitting on the other side of the table from you I'll know you've read this post.  You'll know that I know, and I'll know that you know that I know.  It won't be pretty; the tension in the air will be palatable.  We won't even get to the first question before I jump up on the table and scream “I know!” and you'll respond, "I'm sorry!" and the weeping will begin.

Actually have it, bring in a copy of this post, I'm not too worried.  This isn't like having the answers to the SAT.    I know others before me have interviewed people for technical positions with great success, ::see Microsoft and Apple:: so there must be lots of material on the web to say how they do it?

There is.

Most of it is outdated.

Most of it is directed at the interviewee.

Except one.

::I'm sure there are others, but if I said, 'lots and lots of others,' it would lose the dramatic effect.::

I have taken Joel's, The Guerrilla Guide to Interviewing, and tweaked it here and there.  Take a minute and read version 3.0, which I linked to above before going on.

All read up?  Good.  Let's begin.

Hiring Criteria

Simple:

Smart

Gets Things Done

Passionate

Joel covers 'smart' and 'gets things done' at length in his guide, I won't repeat them here.  However, I don't think he calls out how much of a role passion plays in hiring an engineer.  I'll cover more on passion down below.

The Team

I am an avid believer in having multiple people in the room for interviews; not only does this save time, but everyone will hear the same exact thing.  This is key when comparing notes about the candidate afterwards.  I keep three people on my team, with three different roles.

The Lead - The Lead runs the show.  They are the ones who ask most of the questions, they take care of meeting the candidate at the door, and pacing the interview.

Number 2 - Number 2 drives smaller sections of the interview, often focusing on schooling, prior projects, and prior jobs.  As the interview gets going The Lead and Number 2 will often tag team back and forth on the different sections of the interview.  Having a Number 2 in the room is a great stress relief to The Lead as they can chime in with clarifying questions if The Lead misses something and give The Lead a chance to gather their notes and not talk the entire time.  Where The Lead runs the overall structure of the interview, the Number 2 fills in with a supporting role.

The Jerk - The Jerk plays a key role during the 'writing code' section of the interview.  Their job: challenge the candidate and see how they react to adversity during the interview.  The Jerk is charged with asking the pointed, hard questions during the coding phase of the interview.

Typically, I like to have everyone on the interview team be full time developers who buy into the interview process, i.e. we have all discussed the format of the interview beforehand and we all know our roles.  There is nothing worse than getting into an interview and appearing like no one knows what they are supposed to do next.

The Time of the Interview

Have The Lead meet the candidate in the foyer/reception area/whatever you have available and walk them back to the conference room.  Typically during the walk I try to make some small talk, “How's the weather outside”, etc.  The goal is to try to get the candidate as relaxed as possible given the circumstances.  The last thing you should be doing is walking silently with a look of contempt on your face.  This person may become your new co-worker; try to make them feel welcomed to your company.

The Introduction

Introduce everyone on the team and thank the candidate for coming in today.  I like to layout the format of the interview so there aren’t any surprises.  A typical format will be:

Talk a little bit about yourself, your passions.

Dive into past work experiences, or for co-ops classes and projects

The whiteboard question(s)

Any questions for us the interviewers

Talk about the company

A couple of points about the format:

We never say how many questions there will be at the whiteboard.  Ever.  Normally we have a very easy one, and a very hard one.  There is no point going into the hard question if the candidate cannot pass the easy question.

Always close by talking about the company and how great it is to work there.    This will likely be the last thing the candidate will remember as they leave your office, and I would like to leave them with the thought of, “Wow, that was a tough interview.  I hope I did well because I would love to work there.”  At least if they do not get an offer letter they can tell their friends how cool your place is to work and not create any ill will.

Talk a Little Bit About Yourself

The key, get the candidate to relax, get them talking about something they are experts on, themselves.  This is a great place to ask the softball questions, such as:

Where do you see yourself in five years?  It doesn't have to be work related.

If you could get out of bed every morning and be living your dream job what would you be doing?

What do you read on a daily/weekly basis to keep up to date in our industry?

All of these questions are those horrible open-ended type questions that don't have any real answer, but they serve a key purpose.  Get the candidate talking and try to get them to not feel as stressed about the interview.  Out of this section you will likely learn what they are passionate about, if anything, if they have any vision for the future, and what they do to hone their craft.

There is nothing worse than having someone come in and go, "I don't know where I want to be in five years."  Really?  No idea?  None?  Living on a beach, write a couple of books, anything at all would suffice for this question.  I'm looking for a spark of personality, what are your interests, are you passionate about anything?

Passion is one key indicator I have found when hiring engineers.  Show me someone who has zero passion for anything and I'll show you an unproductive engineer.  Show me a guy who is passionate about his family and I'll show you a person who writes solid, robust code so he can leave at the end of the day to spend time with his family, and not be called in on the weekend to fix sloppy code.

Asking about their dream job again attacks their passion.  Do they love writing LabVIEW VI's that talk to hardware or are they hardcore Ruby on Rails developers at heart.  These are key things to know if you are trying to hire a SQL DBA.

Lastly, our world is changing so quickly, we need to stay on top of what is going on out there if we hope to be viable in this industry 10, 20, 30 years down the road.  Learning if your candidate has a passion for their craft, and a desire to hone and refine it, for me, is a key hiring point.  If you are going to stop learning the second you see that offer letter I'm not interested.

Work / Project Experience

I like to have Number 2 take the lead here and drive this section.  During the intro and the open ended questions section he has had plenty of time to review the resume, listen to the first few answers, and craft a few questions based on those answers about the candidate’s past roles, and in the case of co-ops, classes and project experiences.  Again, this section is fairly open ended with the goal to get the candidate to talk about a subject they know the most about, themselves.

Hopefully the first two sections will give you an insight into the candidate, their personality, what they have done in their past jobs, and their goals for the future.  This is the warm and fuzzy feeling you might have on a first date as you sit down to get to know someone.  However, once this section is over the real fun begins.

The Whiteboard

The whiteboard is single handedly the scariest piece of equipment ever invented for a job interview.  It’s big, it’s blank, and a whole mess of code is going to be written on it.  As The Lead, it’s your job to relax the candidate before they get up to the whiteboard.  I will often say:

"Ok, lets get you up to the whiteboard for a coding question.  I know you are not at your desk with your favorite compiler; the whiteboard compiler is very forgiving.  It doesn't care about semi-colons or perfect curly brace placement.  "

"We also know you don't have Google at your fingertips in here.  For this interview, we'll be your Google.  If you have any questions you would normally ask Google, ask us."

"We care about how you are thinking about the problem at hand, we want to hear your process of how you are going to solve the question."

This preamble sets the stage for the whiteboard in that:

I don't care what the code looks like, as long as the candidate can explain it and it resembles some sort of programming language.  Writing out sentences 'read in input from user' will not work, I need to see how you would go about doing that, but I don't care if you miss a semi-colon in the process.

I expect people to know a fair amount about the position they are applying for, but if something escapes them that they might use Google to look up I don't want that to stall the interview.

"The question: Given three integers write a function that will tell me if they form a right triangle."

::Anyone who has read anything I've put out in the past couple of years should recognize this question as one I have used a bunch of times for many, many articles, examples, and even a code challenge for the Viewpoint eNewsletter.::

Simple, yes?

Actually for such a simple question we have seen dozens of methods to solving it.  And here is the key, by this point, we, the interview team, know which ones work and which ones don't.  We know the caveats of each solution, and if you walk into my interview knowing how to solve this question and whip off an answer in five seconds, we will still have much to discuss.

This question is the heart of the interview.  As simple as it may seem watching someone solve it tells you a lot about how this person will work out if they are hired.  What am I looking for?

Questions.  The way in which the question is asked is incomplete.  What do the sides represent?  Are they lengths of the sides?  Coordinates in a plane?  Can the candidate ask for clarification in a situation where all of the information isn't initially given?

Ability to ask for help.  Assume they have asked the question, "What do the sides represent?" and you further go onto explain they are the lengths of the sides of the triangle.  Maybe the candidate doesn't remember the Pythagorean theorem.  I like to see the candidate ask for help.  At least if they are spinning their wheels for a minute or two and then 'come up for air' and ask for help it is better than dead silence for the next 20 minutes.  Likely we have all encountered areas where we needed to ask for help, I'm looking for people who know their limitations and are not afraid to ask.

Coach-ability.  This is huge.  If you provide direction how well does the candidate take it?  Do they take it in stride?  Do they fight you on it?  Their reaction based on a suggestion will provide loads of insight into what it might be like to work with the candidate on a daily basis.

Ability to take criticism.

To this point I have been silent on the subject of The Jerk.  During the whiteboard section of the interview is where The Jerk shines.  Likely the candidate will pound out an answer to the question above, its time for The Jerk to put the code through its paces.

First question from The Jerk: "Are you happy with the solution?"

Now to be clear, The Jerk shouldn't be 'a jerk' when posing these questions.  However, 'technical hard-ass' might be more fitting.  The Jerk asks the tough questions, The Jerk is curt and to the point...not quite the 'good cop, bad cop routine', but something close.  What this does is allow The Lead and Number 2 to observe what happens when the candidate encounters an adversarial character.  How will they react?  Do they flip out yell expletives and storm out of the room?  Or, can they handle the pressure?

The Jerk also nails the candidate on other questions that are often not thought about:

What happens if I run 0, 5, 5 through the application?

What about -3, -4, -5?

What about max int?

Or if the candidate solved the problem perfectly there is always:

"There is something wrong with your solution."

How the candidate responds to this will likely make or break the interview.

Fits of screaming and crying...probably a no hire

Diplomatically explains to The Jerk that no, the function is correct and here is why...hire that person on the spot.

If someone in a situation like an interview can diplomatically explain why The Jerk is wrong and they are correct, in such a situation where there is a clear imbalance of power and they don't resort to name calling, this is a very clear sign into how this person is going to work out.

If for some reason the candidate doesn't grasp what a right triangle is, or doesn't take direction, or sets the table on fire while doing the whiteboard question, this is where we would have them sit back down and wrap up the interview.  This is why we never say how many questions will be done at the whiteboard.

Our second question, "Build me a function that calculates n!".

Again, allow The Jerk to drive the questioning, asking why they did their answer iteratively vs. recursively.  If the candidate nails the first question often times this question is used after the interview to separate the good from the best.

Any Questions for Us?

After the question(s) at the whiteboard we start to bring the interview to a close.  The Lead normally asks, "Do you have any questions for us?"  At this point one would hope the candidate has a few questions, what do you do here, what is it like to work here, etc, etc.  Open up and share as much as you can with the candidate without violating terms/agreements/etc.  These questions often roll into:

Talk About the Company

"Always be closing" or rather "Always be selling your company"...what you are about to relay to the candidate will stick with them as they walk out the door.  Does your company do really cool things?  Let them know!  Do you have monthly company meetings where food is provided?  Let them know!  Does everyone have an office?  Let them know!  Do you work on really cool cutting edge projects?  Let them know!

I would like to have every candidate walk out the doors going, "Wow, cool company.  Even if I don't get an offer there I'm going to tell my friends how tough an interview it was, but how much fun it would have been to work there."

The last thing you want to do is create any ill will on the part of the candidate as they leave to tell their friends and peers.  In such an interconnected world why spread a seed of ill will for no good reason other than an interview that didn't result in a job offer?

The Walk

Thank the candidate for coming in when there are no more questions to be asked and walk them back to where you picked them up.  Give them a timeline of when you expect to make your decision, hand them a business card so they can ask any follow up questions if they think of any and bid them a good day.

Walk back to the conference room for the final vote.

The Final Vote

The final vote is simple; it’s a 'hire', 'no hire' vote.  Snap decision, and there is no 'maybe'.  One 'no hire' in the group results in a 'no hire' result.  Each one of you had a different vantage point for the interview, and if you all can't agree to hire the candidate they are likely not the best person for the job.  As I said, there is no 'maybe', or 'maybe, but not for doing X'.  What if they are hired for another function, and that function goes away and the only thing for them to do is 'do X', now you've hired the wrong person, and you are stuck with them.

Where the 'hire', 'no hire' gets tricky is if you have three candidates who you would all hire, but you only have one position.  Right after the interview it is best to rank everyone for the position and keep the ranking updated after every interview.  At the end of the interview process you will have a nice list of candidates that you can then make offers to, and if one of them refuses you already know who you are going to hire next.

In Closing

There are a few items in technical interviews I hate with a passion.  Avoid adding these to your interviews at all cost:

Brainteasers – An example - given 9 dots on a piece of paper connect them all with four straight lines.  Brainteasers are not good interview questions, the only thing they will tell you if someone gets one right is that they are good at brainteasers, they don’t tell you if they are good programmers.

Fact questions - Any question that normally would be looked up by any given programmer isn't a great question.    I don't.

Illegal questions - I am not a lawyer, but I'm sure your HR department can brief you on all the questions you cannot ask during an interview.  Understand these types of questions before conducting an interview.  I'm talking race, sex, religion, all the major mostly common sense items most people wouldn't ask.  Again, I am not a lawyer, so check with your HR department before proceeding.

I hope that using these guidelines will help you conduct your next technical interview and find a person who is smart, gets things done, but has passion for their job and career.


text:
# Re-envision build execution with the Gradle Worker API

- Paul Merlin
- Gary Hale

#

- in-process
- out-of-process (daemons)
- isolation modes

## Less Work

- classloaders
- exec/javaexec
  - spawning processes
- caching

### Worker Daemons

- reuse jvm process
- JavaExec spawns new JVM
- relegate GC impact to separate JVM

## More Work in Parallel

- fill "empty space"
- divide and conquer
- immutability

### Worker Threads

## Isolation Modes

- None
  - worker thread
- Classloader
  - worker thread
  - use different library versions
- Process
  - worker daemon
  - different environment variables
  - system properties
  - java version

Immutable work items enable "parallel by default"

# Case Study

Paul

https://github.com/eskatos/gradle-wsdl-plugin

@Inject - required on constructor
WorkerExecutor getWorkerExecutor()

workerExecutor.submit(class) { config ->
    config.isolatinoMode = IsolationMode.PROCESS
    config.forkOptions { systemProperty() }

}

# Current Status 4.0

- in-process, out-of-process
- daemons are build session scoped
- supports runnable

# Future 4.1+

- daemons reused 4.1-M1
- control reuse level
- gradle tasks use workers
- worker API convenience task
- service injection
- support for cllable
- composition and chaining of work
- in-process workers use cached classloaders

# Exec Task

- use None isolation mode
- get some parallelism
- wait for service injection

license: MIT

repository: phatblat/GradleSummit

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: phatblat/GradleSummit


text:
# React a11y package

This package holds some utility to add accessibility support to any react components.

At the moment it supports The following gesture with keyboard:

- Tree
- Calendar
- List

# Calendar

HOC API:

```javascript
import { Gesture } from '@talend/react-a11y';

function MyCalendar(props) {
	//...
}

export default Gesture.withCalendarGesture(MyCalendar);
```

## props and html structure

In the upper example the HOC will inject onKeyDown props. It manage the focus on the correct day and is able to call `props.goToPreviousMonth(cb)` or `props.goToNextMonth(cb)` if needed.

Lookup of item in the dom is based on the following selector: `td > button[data-value]`

# Tree

HOC API:

```javascript
import { Gesture } from '@talend/react-a11y';

function MyTree(props) {
	//...
}

export default Gesture.withTreeGesture(MyTree);
```

## props and html structure

props:

- onSelect(event, item) [enter, space]
- onToggle(event, item) [left, right]
- onToggleAllSiblings(event, siblings) [*]

selectors:

- root selector: `ref.closest('ul[role="tree"]')`
- node selector: `root.querySelector('li[role="treeitem"]')`

# List

HOC API:

```javascript
import { Gesture } from '@talend/react-a11y';

function MyList(props) {
	//...
}

export default Gesture.withListGesture(MyList);
```

## props and html structure

No props on this one but the following selectors:

- root selector: `ref.closest('ul[role="list"]')`
- node selector: `root.querySelector('li[role="listitem"]')`

repository: Talend/ui

gha_language: JavaScript

repo_name: Talend/ui


text:
---
id: page-plugin
title: Plugins - Key Authentication
header_title: Key Authentication
header_icon: /assets/images/icons/plugins/key-authentication.png
breadcrumbs:
  Plugins: /plugins
---

Add a Key Authentication (like an apikey) to your APIs, either in a header, in querystring parameter, or in a form parameter.

---

## Installation

Add the plugin to the list of available plugins on every Kong server in your cluster by editing the [kong.yml][configuration] configuration file:

```yaml
plugins_available:
  - keyauth
```

Every node in the Kong cluster should have the same `plugins_available` property value.

## Configuration

Configuring the plugin is straightforward, you can add it on top of an [API][api-object] (or [Consumer][consumer-object]) by executing the following request on your Kong server:

```bash
$ curl -X POST http://kong:8001/apis/{api}/plugins \
    --data "name=keyauth" \
    --data "value.key_names=key_name1,key_name2"
```

`api`: The `id` or `name` of the API that this plugin configuration will target

form parameter                          | description
 ---                                    | ---
`name`                                  | The name of the plugin to use, in this case: `keyauth`
`value.key_names`                       | Describes an array of comma separated parameter names where the plugin will look for a valid credential. The client must send the authentication key in one of those key names, and the plugin will try to read the credential from a header, the querystring, a form parameter (in this order). For example: `apikey`
`value.hide_credentials`
*optional*  | Default `false`. An optional boolean value telling the plugin to hide the credential to the upstream API server. It will be removed by Kong before proxying the request

## Usage

In order to use the plugin, you first need to create a consumer to associate one or more credentials to. The Consumer represents a developer using the final service/API.

### Create a Consumer

You need to associate a credential to an existing [Consumer][consumer-object] object, that represents a user consuming the API. To create a [Consumer][consumer-object] you can execute the following request:

```bash
$ curl -X POST http://kong:8001/consumers/ \
    --data "username=user123" \
    --data "custom_id=SOME_CUSTOM_ID"
```

parameter                       | description
 ---                            | ---
`username`
*semi-optional*   | The username of the consumer. Either this field or `custom_id` must be specified.
`custom_id`
*semi-optional*  | A custom identifier used to map the consumer to another database. Either this field or `username` must be specified.

A [Consumer][consumer-object] can have many credentials.

### Create a Key Authentication credential

Then you can finally provision new key credentials by making the following HTTP request:

```bash
$ curl -X POST http://kong:8001/consumers/{consumer}/keyauth \
    --data "key=some_key"
```

`consumer`: The `id` or `username` property of the [Consumer][consumer-object] entity to associate the credentials to.

form parameter          | description
 ---                    | ---
`key`
*optional*     | You can optionally set your own unique `key` to authenticate the client. If missing, the plugin will generate one.

## Headers sent to the upstream server

When a client has been authenticated, the plugin will append some headers to the request before proxying it to the upstream API/Microservice, so that you can identify the consumer in your code:

* `X-Consumer-ID`, the ID of the Consumer on Kong
* `X-Consumer-Custom-ID`, the `custom_id` of to the Consumer (if set)
* `X-Consumer-Username`, the `username` of to the Consumer (if set)

You can use this information on your side to implement additional logic. You can use the `X-Consumer-ID` value to query the Kong Admin API and retrieve more information about the Consumer.

[api-object]: /docs/{{site.data.kong_latest.version}}/admin-api/#api-object
[configuration]: /docs/{{site.data.kong_latest.version}}/configuration
[consumer-object]: /docs/{{site.data.kong_latest.version}}/admin-api/#consumer-object
[faq-authentication]: /docs/{{site.data.kong_latest.version}}/faq/#how-can-i-add-an-authentication-layer-on-a-microservice/api?


text:
# sbt-scalajs-bundler  [![Scala.js](https://www.scala-js.org/assets/badges/scalajs-0.6.29.svg)](https://www.scala-js.org) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.github.karasiq/sbt-scalajs-bundler/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.github.karasiq/sbt-scalajs-bundler)
SBT plugin for auto compilation of web assets (js, css, html)

# How to use
Add line in your `plugins.sbt`:
```scala
addSbtPlugin("com.github.karasiq" % "sbt-scalajs-bundler" % "%version%")
```

Write configuration in `build.sbt`:
```scala
// Enable bundler plugin
enablePlugins(SJSAssetBundlerPlugin)

// Assets will be compiled to "webapp" resources directory
Compile / scalaJsBundlerAssets ++= {
  import com.karasiq.scalajsbundler.dsl.{Script, _}
  val bootstrap = github("twbs", "bootstrap", "v3.3.6") / "dist"
  val jsDeps = Seq(
    Script from "org.webjars" % "jquery" % "2.1.3" / "jquery.js", // Requires corresponding entry in libraryDependencies
    Style from bootstrap / "css" / "bootstrap.css",
    Script from bootstrap / "js" / "bootstrap.js"
  )

  val staticDir = (baseDirectory in frontend)(_ / "webapp").value
  val staticFiles = Seq(
    // Static files
    Html from staticDir / "html" / "index.html",
    Script.withMime(Mimes.coffeescript) from staticDir / "scripts" / "script.coffee",
    Style.withMime(Mimes.less) from staticDir / "css" / "style.less", // Requires less4j library in classpath
    Image("favicon.ico").withMime(Mimes.ico) from staticDir / "img" / "favicon.ico"
  )

  Bundle("index", jsDeps, (bootstrap / "fonts" / "glyphicons-halflings-regular").fonts(), staticFiles, SJSApps.app(frontend).value)
}
```

# Examples
* [Nanoboard frontend](https://github.com/Karasiq/nanoboard)
* [scalajs-videojs test page](https://github.com/Karasiq/scalajs-videojs)
* [scalajs-bootstrap test page](https://github.com/Karasiq/scalajs-bootstrap)
* [scalajs-highcharts test page](https://github.com/Karasiq/scalajs-highcharts)

# License
The MIT License (MIT)

Copyright (c) 2016 Karasiq

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

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

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

repository: Karasiq/sbt-scalajs-bundler

gha_language: Scala

gha_license_id: MIT

repo_name: Karasiq/sbt-scalajs-bundler


text:
# Simple Jekyll build
> Adding CI for Jekyll without actions and without publishing

## Sample

Below is a workflow generated by the GitHub when it suggests a Jekyll workflow for your project. It uses a `docker run` step without using an aciton from the marketplace.

- `main.yml`
    ```yaml
    name: Jekyll site CI

    on:
      push:
        branches: [ master ]
      pull_request:
        branches: [ master ]

    jobs:
      build:
        runs-on: ubuntu-latest

        steps:
          - uses: actions/checkout@v2

          - name: Build the site in the jekyll/builder container
            run: |
              docker run \
              -v ${{ github.workspace }}:/srv/jekyll -v ${{ github.workspace }}/_site:/srv/jekyll/_site \
              jekyll/builder:latest /bin/bash -c "chmod 777 /srv/jekyll && jekyll build --future"
    ```

## Persisting

Note that the sample this only **builds** a Jekyll site and does **not persist it** or deploy to GH Pages.

That can be managed in a separate step - or use one of the marketplace actions which does that all in one.

See cookbook pages:

- [GH Pages Actions](gh-pages-actions.md) doc in this Jekyll section
- [Deploy GH Pages](../deploy-gh-pages/) doc in a more generic section that can still be used for Jekyll


text:
# Differences in Working Memory Capacity Affect Online Spoken Word Recognition: Evidence from Eye-Movements

Mixed modelling analysis for *Differences in Working Memory Capacity Affect Online Spoken Word Recognition: Evidence from Eye-Movements* (in review). See [./notebook.Rmd](./notebook.Rmd) for step-by-step procedures.

## Requirements

+ R (3.4.3+)
+ Rstudio (1.1.423+)
  - *Optional; other software for building the R-markdown notebook may be used*

For our analysis these software were obtained with Anaconda Navigator (1.8.7) to increase reproducibility. More information and downloads can br found on the [Anaconda website](https://www.anaconda.com/)

## R libraries

R library packages were acquired from the CRAN website https://cran.r-project.org/.

| Package                                                                     | Version | Used in
|:----------------------------------------------------------------------------|:--------|:----------------
| [`VWPre`](https://cran.r-project.org/web/packages/VWPre/index.html)         | 1.1.0   | data preparation
| [`dplyr`](https://cran.r-project.org/web/packages/dplyr/index.html)         | 0.7.6   | data preparation
| [`forcats`](https://cran.r-project.org/web/packages/forcats/index.html)     | 0.2.0   | data preparation
| [`knitr`](https://cran.r-project.org/web/packages/knitr/index.html)         | 1.18    | data preparation
| [`magrittr`](https://cran.r-project.org/web/packages/magrittr/index.html)   | 1.5     | data preparation
| [`purrr`](https://cran.r-project.org/web/packages/purrr/index.html)         | 0.2.4   | data preparation
| [`readr`](https://cran.r-project.org/web/packages/readr/index.html)         | 1.1.1   | data preparation
| [`stringr`](https://cran.r-project.org/web/packages/stringr/index.html)     | 1.2.0   | data preparation
| [`tibble`](https://cran.r-project.org/web/packages/tibble/index.html)       | 1.4.2   | data preparation
| [`tidyr`](https://cran.r-project.org/web/packages/tidyr/index.html)         | 0.7.2   | data preparation
| [`tidyverse`](https://cran.r-project.org/web/packages/tidyverse/index.html) | 1.2.1   | data preparation
| [`zeallot`](https://cran.r-project.org/web/packages/zeallot/index.html)     | 0.1.0   | data preparation
| [`lme4`](https://cran.r-project.org/web/packages/lme4/index.html)           | 1.1-15  | modelling
| [`Hmisc`](https://cran.r-project.org/web/packages/Hmisc/index.html)         | 4.1-1   | modelling
| [`nloptr`](https://cran.r-project.org/web/packages/nloptr/index.html)       | 1.0.4   | modelling

## Correspondance

For questions or comments regarding the paper, including requests for access to the data under analysis, please address all correspondence to the corresponding author:

**Boaz M. Ben-David, PhD**
Communication, Aging and Neuropsychology Lab (CANlab),
Baruch Ivcher School of Psychology, Interdisciplinary Center (IDC) Herzliya
P.O. Box 167, Herzliya, 4610101, Israel

e-mail:
<a href="mailto:boaz.ben.david<EMAIL_ADDRESS>

Phone:
+972-9-9602429

Fax:
+972-9-9602845

For questions or comments regarding the analysis tools software presented in this repository, including requests for support or offers of contribution, please address *electronic correspondence only* to the software's author:

**Joshua Estrin Skrzypek**

e-mail:
<a href="mailto:jskrzypek<EMAIL_ADDRESS>

GitHub:
@jskrzypek

## Attribution

All of the software and files used in the analysis that are presented in this repository were prepared by their author, Joshua Estrin Skrzypek (@jskrzypek). The work of the analysis itself was performed in collaboration with the authors of the paper.


text:
---
title: ON/RAMP payment API v1.4.13

version: 1.4.13

language_tabs: # must be one of https://git.io/vQNgJ
  - shell: cURL

#toc_footers:
#  - Sign Up for a Developer Key

includes:
  - server_to_server

search: true

code_clipboard: true
---

# ON/RAMP merchant integration.

## Terminology and Acronyms

- Merchant: The service using **ON/RAMP** as payment processor.
- User: The physical person who sends or receives funds to/from the merchant through **ON/RAMP**.
- CC: credit card.

## Base URL

Production:
**[https://api.onramp.ltd/s2s](https://api.onramp.ltd)**

Test:
**[https://stage-api.onramp.ltd/s2s](https://stage-api.onramp.ltd)**

## Changelog

Changes since v1.4.12:

- Added `x_api_key` parameter on the crypto ingress iframe flow

Changes since v1.4.11:

- Specified parameters required for new bank payment

Changes since v1.4.10:

- Added `card_type` to ingress flow parameters
- Added `order_id` to ingress flow parameters

Changes since v1.4.9:

- Made street and city fields required

Changes since v1.4.8:

- Updated confirmation callback

Changes since v1.4.7:

- Docummented the addition of `op_id` for `create_operation` endpoint

Changes since v1.4.6:

- Updated some fields for 3DS

Changes since v1.4.5:

- Updated some fields for 3DS

Changes since v1.4.4:

- Updated 3ds values

# Calling **ON/RAMP** API endpoints

**ON/RAMP** offers a simple REST API taking JSON values as request payload, and returning JSON
values as response.

All calls shall be made using **`POST`** method.

Every call shall include the headers:

- `Content-Type: application/json`

- `X-XCO-Authorization: Bearer AUTH_TOKEN`

Where `AUTH_TOKEN` is replaced with merchant's API key.

## Error handling

All ON/RAMP endpoints respect standard HTTP semantics. Errors can be detected from response
status code:

| Status code | Meaning                                        |
| ----------- | ---------------------------------------------- |
| **200**     | Everything was ok. Success.                    |
| **400**     | Invalid request parameters. See response body. |
| **500**     | Temporary ON/RAMP server malfunction.          |

Requests resulting in 4xx errors **must not be retried** as-is, that will not resolve the error.

Requests giving 5xx errors may be retried. If retried, the retry interval must multiplicatively
increase in geometric progression, using [exponential backoff][]. E.g. retry 1 after 160ms, retry 2
after 320ms, retry 3 after 640ms, retry 4 after 1280ms, and so on.

[exponential backoff]: https://en.wikipedia.org/wiki/Exponential_backoff

## Webhook callbacks

Some endpoints involve _callbacks:_ ON/RAMP system will sometimes make requests to
Merchant-provided URLs.

All callbacks invoked by ON/RAMP are made using **`POST`** method.

In callback response, any HTTP status code besides 200 **is treated as callback failure**.

repository: on-ramp/api-doc

branch_name: refs/heads/develop

gha_language: SCSS

repo_name: on-ramp/api-doc


text:
### reprepare our own tumor data set using my pipeline

I have prepared our own tumor data set on [day4](https://github.com/crazyhottommy/Epigenome_RoadTrip/blob/master/daily_notes/2018-03-16_day4.md#time-to-prepare-our-own-tumor-data)

Since I wrote a [snakemake pipeline](https://github.com/crazyhottommy/pyflow-epilogos), I will re-process it with the pipeline.
Moreover, the tumor data were called by chromHMM using 18states. some states can
be combined.

![](https://github.com/crazyhottommy/Epigenome_RoadTrip/blob/master/pics/emissions_18.png)

E1 and E2 are both active enhancers. E3 and E16 are low states. E4 and E5 are both transcribed enhancers.
E12 is artifacts, enriched for every histone mark.

The 18 state model can be combined to 15 state.

I will use scripts to do the [state recoding](https://github.com/crazyhottommy/pyflow-epilogos/blob/master/scripts/recode_dense_seg_state_color.py) and [bin merging](https://github.com/crazyhottommy/pyflow-epilogos/blob/master/scripts/merge_bin.py).

Finally, I will import to R and do filtering of the features.

```bash
ssh railab
cd /rsrch2/genomic_med/krai/scratch/TCGA_CCLE_SKCM/SKCM_MSTC_CCLE_RUN/snakemake_ChIPseq_pipeline/12chromHMM
rm 20SKCM_chromHMM/*
cp 16CCLE_10MSTC_20_SKCM_CHROMHMM_OUTPUT/M*-P*segments.bed 20SKCM_chromHMM/

ls 20SKCM_chromHMM/
M028-P008_18_segments.bed  M275-P008_18_segments.bed  M409-P011_18_segments.bed  M762-P008_18_segments.bed
M035-P010_18_segments.bed  M305-P009_18_segments.bed  M527-P010_18_segments.bed  M807-P010_18_segments.bed
M137-P008_18_segments.bed  M306-P008_18_segments.bed  M642-P008_18_segments.bed  M822-P010_18_segments.bed
M233-P010_18_segments.bed  M357-P010_18_segments.bed  M721-P010_18_segments.bed  M852-P008_18_segments.bed
M263-P011_18_segments.bed  M399-P010_18_segments.bed  M749-P010_18_segments.bed  M857-P010_18_segments.bed

cd ~/scratch
mkdir SKCM_RoadTrip
cd SKCM_RoadTrip
git clone https://github.com/crazyhottommy/pyflow-epilogos
source activate py351
module load R/3.4.1-shlib
cd pyflow-epilogos/

# I modified the sample2json.py a bit to only extract M028 rather than M028-P008 as the sample name.
 python3 sample2json.py --segment_dir /rsrch2/genomic_med/krai/scratch/TCGA_CCLE_SKCM/SKCM_MSTC_CCLE_RUN/snakemake_ChIPseq_pipeline/12chromHMM/20SKCM_chromHMM/

 cat  ~/scratch/TCGA_CCLE_SKCM/SKCM_MSTC_CCLE_RUN/snakemake_ChIPseq_pipeline/12chromHMM/16CCLE_10MSTC_20_SKCM_CHROMHMM_OUTPUT/M028-P008_18_dense.bed | sed '1d' | cut -f4,9 | sort -k1,1V |  uniq | tee my_map.txt
1       0,0,255
2       51,102,255
3       0,153,204
4       0,255,255
5       51,255,153
6       51,255,0
7       0,204,51
8       0,102,0
9       0,0,51
10      204,0,51
11      255,0,204
12      204,153,255
13      204,204,102
14      255,255,0
15      255,255,204
16      102,51,153
17      51,102,102
18      102,153,51

## edit the my_map.txt by hand, add header.

cat my_map.txt
old_state       new_state       new_color
1       1       0,0,255
2       1       0,0,255
3       2       0,153,204
4       3       0,255,255
5       3       0,255,255
6       4       51,255,0
7       5       0,204,51
8       6       0,102,0
9       7       0,0,51
10      8       204,0,51
11      9       255,0,204
12      10      204,153,255
13      11      204,204,102
14      12      255,255,0
15      13      255,255,204
16      2       0,153,204
17      14      51,102,102
18      15      102,153,51

nano config.ymal
# epilogos, WT: 2,18,20  NRAS: 1,10,13,19  BRAF: 3-9,11-12,14-17

./pyflow-epilogos.sh

```
Finishes within minutes.

### merging

```bash
cd 03combine_sample_segs
ls
combined_seg.txt  epilogos_input.txt

# the combined_seg.txt has a header.
wc -l
3095682 combined_seg.txt
3095681 epilogos_input.txt
6191363 total

## 3 billion base across genome, 1kb get down to 3 million bins! about right:)

# merge the bins
../scripts/merge_bin.py --ifile combined_seg.txt --ofile SKCM_merged_seg.tsv

wc -l *
3095682 combined_seg.txt
3095681 epilogos_input.txt
1537399 SKCM_merged_seg.tsv

# this cut down the features to 1.5 million.
```

### filtering

```r
library(tidyverse)
library(readr)
seg_df<- read.table("SKCM_merged_seg.tsv", header =T, stringsAsFactor = F)
seg_df_state<- dplyr::select(seg_df, -chr, -start, -end)

seg_df_state<- as.data.frame(seg_df_state)

## test if every column has the same string for every row

apply(seg_df_state, 1, function(x) length(unique(x)) == 1) %>% table()

ind<- apply(seg_df_state, 1, function(x) length(unique(x)) == 1)

seg_df_sub<- seg_df[!ind, ]

write.table(seg_df_sub, "SKCM_seg_df_sub.tsv", sep = "\t", col.names =T, row.names = F, quote =F)

```

### further filtering

```r
library(dplyr)
library(rlang)
library(caret)

meta_data<- read.table("data/epigenome_SKCM/tumor_meta.txt", stringsAsFactors = F, sep = "\t", header =T)

## need to figure out a better way to select the columns...
new_data<- seg_df_sub %>% distinct(M028, M035, M137, M233, M263, M275, M305, M306, M357, M399, M409, M527, M642, M721, M749, M762, M807, M822, M852, M857, .keep_all = T)

dim(new_data)
[1] 1218880      23
> dim(seg_df_sub)
[1] 1518714      23

## cut down to 1.2 million features across the genome.

x_data<- as.matrix(new_data[,-c(1:3)])

rownames(x_data)<- paste(new_data$chr, new_data$start, new_data$end, sep = ":")

## transpose the matrix.
x_data<- t(x_data)

## random forest does not like matrix if it is not numeric. turn back to a dataframe
x_data<- data.frame(x_data)

resp_data<- merge(x = data.frame(sample = rownames(x_data)), y = meta_data, by.x = "sample", by.y = "sample", all.x = T, all.y = F)

save(x_data, resp_data, file = "SKCM_rf_input.rda")
```

```bash
## roughly how many features left per chromosome.

less -S SKCM_seg_df_sub.tsv | sed '1d' | cut -f1| sort -V| uniq -c

130391 chr1
 123896 chr2
 100925 chr3
  82016 chr4
  94359 chr5
  83096 chr6
  93021 chr7
  83607 chr8
  58734 chr9
  69512 chr10
  71949 chr11
  72777 chr12
  44281 chr13
  47977 chr14
  48516 chr15
  46024 chr16
  49551 chr17
  37060 chr18
  40388 chr19
  40677 chr20
  20240 chr21
  24345 chr22
      9 chrM
  53632 chrX
   1731 chrY
```


text:
lazyobject 0.0.1
================

A thread-safe LazyObject class for Python.

The LazyObject class is a wrapper for another
class that can be used to delay instantiation
of the wrapped class.

This was copied from Django and modified to add
thread safety.
https://github.com/django/django/blob/master/django/utils/functional.py

Why
---

This lets you create module-level objects
that will not initialize until first accessed.
This library simply adds thread-safety to Django's
version, to ensure that only 1 thread will initialize
the object.

Installation
------------

    pip install lazyobject

Usage
-----

    from lazyobject import ThreadSafeLazyObject

    class MyLazyClass(ThreadSafeLazyObject):
      def _setup(self):
        my_real_object = create_my_object()
        self._wrapped = my_real_object

    my_lazy_object = MyLazyClass()

repository: apnarm/lazyobject

repo_name: apnarm/lazyobject


text:
# mumble_ptt_caps_lock_led
A python program to let the LED of your caps lock key display your mumble PTT state.

This is very nice if caps lock is also the PTT key.
To do that first disable the caos lock key: `setxkbmap -option caps:none`

This program is split into two parts:
  - Script to update the LED using `/sys/`. This needs to be run as root.
  - Script to extract the PTT state from mumble.

The second script uses the dbus messages of mumble updating the taskbar icon.
For this to work, the taskbar icon needs to be enabled.

branch_name: refs/heads/main


text:
##Example - Complex Value Types
US2MapperKit's support for mapping complete types allows for creating object types as other objects generated. Let's assume in the example below that the business listing result returns a sub-dictionary for a location, and we would like to store it as a Location type.

**Response Dictionary**

```
{
	'business_uuid'  	 :<PHONE_NUMBER>754775807,
	'business_name'  	 : 'UsTwo Restaurant',
	'business_rating' 	 :  5,
	'business_location   :
		{
			'longitude' : 40.7053319,
			'latitude'  : -74.0129945
		},
	'business_open'    	 : 1
}

```

First, create a model mapping for the Location object.

**Location.plist**

![alt tag](/documentation/readme_assets/location_plist.png?raw=true)

Once the model mapping for a location has generated a `Location` object, and it has been added to the project, update the Business object mapping by defining a location property typed as **Location**

**Business.plist**

![alt tag](/documentation/readme_assets/business_location_example.png?raw=true)

When parsing the data for a `Business` object, US2MapperKit will create a `Location` instance, and will assign the resulting value to the location property of the `Business` instance before returning it :)

gha_language: Swift

gha_license_id: NOASSERTION


text:
### [CVE-2018-18563](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-18563)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

An issue was discovered in Roche Accu-Chek Inform II Instrument before 03.06.00 (Serial number below 14000) and 04.x before 04.03.00 (Serial Number above 14000), CoaguChek Pro II before 04.03.00, CoaguChek XS Plus before 03.01.06, CoaguChek XS Pro before 03.01.06, cobas h 232 before 03.01.03 (Serial Number below KQ0400000 or KS0400000) and cobas h 232 before 04.00.04 (Serial Number above KQ0400000 or KS0400000). Improper access control to a service command allows attackers in the adjacent network to execute arbitrary code on the system through a crafted Poct1-A message.

### POC

#### Reference
- https://ics-cert.us-cert.gov/advisories/ICSMA-18-310-01

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/ee59ce6acc27454a9b5d94889ec3bf80)](https://app.codacy.com/manual/aballiet/SaveScreen?utm_source=github.com&utm_medium=referral&utm_content=aballiet/SaveScreen&utm_campaign=Badge_Grade_Dashboard)
[![Build Status](https://travis-ci.com/aballiet/SaveScreen.svg?branch=master)](https://travis-ci.com/aballiet/SaveScreen)

# SaveScreen Android App

SaveScreen allows you to turn off the screen of your Android device while keeping your current app running (Youtube, Chrome or a game for example).
It uses the proximity sensor to turn the screen off.

This project has been initialized in order to fulfill user of reddit : [see here](https://www.reddit.com/r/deeptown/comments/ffsl49/tip_app_to_turn_off_your_screen_while_maximizing/)

## Screenshot
<img src="https://github.com/aballiet/SaveScreen/raw/master/readme_ressources/screenshot.jpg" width="300">

## Install the app
You can either use the APK given [here](https://github.com/aballiet/SaveScreen/raw/master/app/release/app-release.apk) or use the one generated by yourself from the source code (see instructions below)

Copy it (or download it) on your Android device and proceed to its installation.

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.

```bash
$ git clone https://github.com/aballiet/SaveScreen.git
$ cd SaveScreen
$ gradle assemble             # This will generate two files in project/build/apk/
```

- app-debug-unaligned.apk
- app-release-unsigned.apk

### Prerequisites

Android Studio with SDK >= 21

## Generate an APK

- Open the project in Android Studio
- Go to : Build -> Generate Signed Bundle / APK
- You can find the generated APK in : app/release/app-release.apk

## Built With

* [Android Studio ](https://developer.android.com/studio) - The IDE to create Android app

## Authors

* **Antoine Balliet**

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

## Acknowledgments

* Very simple app yet, need a notification system to ensure app is running or not.

repository: aballiet/SaveScreen

repo_name: aballiet/SaveScreen


text:
### Adapter

#### Intent
"Convert the interface of a class into another interface clients expect. Adapter lets
classes work together that couldn't otherwise because of incompatible interfaces." (GoF)

#### Also Known As
Wrapper

#### Motivation
The user has to apply the function target_invoker put can't change it. It requires an argument of type
InvokerTarget. But the target that the user actually wants use is of type UserTarget. The problem is, that
UserTarget is not compatible with target_invoker.


text:
# Autogenerate API Interface
First, make sure you have [go](https://golang.org/) installed.  Then:

```shell
git clone https://github.com/ipfs/http-api-docs "$GOPATH/src/github.com/ipfs/http-api-docs"
cd "$GOPATH/src/github.com/ipfs/http-api-docs"
make install
```

Then, back in this folder:

```shell
go run main.go > ../aioipfs_api/autoapi.py
```

repository: bmuller/aioipfs-api

repo_name: bmuller/aioipfs-api


text:
# shttp
[![GoDoc](https://godoc.org/github.com/alaska/shttp?status.svg)](https://godoc.org/github.com/alaska/shttp) [![Go Report Card](https://goreportcard.com/badge/github.com/alaska/shttp)](https://goreportcard.com/report/github.com/alaska/shttp)

---

Let's make solid, encrypted Golang webservers easy!

## What
This package is an attempt to track best practices for a hardened and secure `net/http` server while getting out of your way as much as possible.

## Why
I was initially inspired to write this little helper library by [Filippo Valsorda](https://github.com/FiloSottile)'s [Gopher Academy blog post](https://blog.gopheracademy.com/advent-2016/exposing-go-on-the-internet/) on self serving go TLS directly to the Internet. `net/http`'s defaults are tuned more for local services, after all, which isn't good enough for exposure to the big bad Internet, which is full of unsavory types. It should be easy to make a server that is resistent to the usual sorts of jerk-offery.  Now that `crypto/tls` is not slow1, it should be the default whenever possible.

Later, while I was looking into self-certification and support for [Let's Encrypt](https://letsencrypt.org/getting-started/), I came across [autocert](https://godoc.org/golang.org/x/crypto/acme/autocert), and [a proposal](https://github.com/golang/go/issues/17053) to add it to the standard library (or at least docs on how to use it). Incorporating this along with rudimentary self-signing support seemed like a natural extension to my "make good crypto easy" idea, so I added that in too.

I was also very influenced by [George Tankersley](https://github.com/gtank)'s, excellent [cryptopasta](https://github.com/gtank/cryptopasta) anti-library, introduced during his talk at GopherCon 2016.

## How
```go
import (
        "fmt"
        "log"
        "net/http"

        "github.com/alaska/shttp"
        "github.com/alaska/shttp/certprovider"
)

func handler(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "You've accessed %s\n", r.URL.Path[1:])
}

func main() {
        provider, err := certprovider.SelfSign("testcorp", "<IP_ADDRESS>,::1")
        if err != nil {
                log.Fatalln(err.Error())
        }

        s := shttp.NewServerWithRedirect(":https", provider)

        http.HandleFunc("/", handler)

        if err := s.ListenAndServeTLS(); err != nil {
                log.Fatalln(err.Error())
        }
}

```

```
$ curl -k https://localhost/stuff
You've accessed stuff
$ curl -k http://localhost/things
<a href="https://<IP_ADDRESS>/things">Moved Permanently</a>.

$ curl -kL http://localhost/things
You've accessed things

$ openssl s_client -showcerts -cipher ECDHE-RSA-AES256-GCM-SHA384 -connect <IP_ADDRESS>:443 </dev/null
CONNECTED(00000003)
depth=0 O = testcorp
verify error:num=18:self signed certificate
verify return:1
depth=0 O = testcorp
verify error:num=10:certificate has expired
notAfter=May 29 16:00:00 1981 GMT
verify return:1
depth=0 O = testcorp
notAfter=May 29 16:00:00 1981 GMT
verify return:1
---
Certificate chain
 0 s:/O=testcorp
   i:/O=testcorp
-----BEGIN CERTIFICATE-----
MIIDCzCCAfOgAwIBAgIQJqtozqpBq/KgQDnrAo4ISDANBgkqhkiG9w0BAQsFADAT
MREwDwYDVQQKEwh0ZXN0Y29ycDAeFw03MDAxMDEwMDAwMDBaFw04MTA1MjkxNjAw
MDBaMBMxETAPBgNVBAoTCHRlc3Rjb3JwMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
MIIBCgKCAQEAw3CLrQtbwUHq9FbxE0wkOO6r2YnO7eFNEp9Xzru2/Bo4OFFLLca/
7pRM+Z/lzu6terB2aa7W5jhFp1ePyTvruEftSaRsrPLAeoJ9ayBrJSjn5vMMLo8I
q278nrdvPqmtFSh/AchxFAdZAAngRcOrC0hHs/1D8qZ/6krU9jpWB7L8oTLOX8hB
KEUAN0mkFfdD2/qs2kjJw8JPgOg3gY13qcLfQ4gqiuwujotifEsnxly95qLmoHTJ
HiwfVjwof9ZLyicXvW+EeSd+wANVessPtolWQChnP8/KcYOjX7QXnUWCAKKe55jA
oXGlU44Qymzj5Pqd9hNSTfXBa5mMCFJbfQIDAQABo1swWTAOBgNVHQ8BAf8EBAMC
AqQwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDwYDVR0TAQH/BAUwAwEB/zAhBgNVHREE
GjAYhwR/AAABhxAAAAAAAAAAAAAAAAAAAAABMA0GCSqGSIb3DQEBCwUAA4IBAQCH
23rXyP5vmFm060zquVTXKnBjwc1vuFzUd+/XVBzYfsRW0NDZvzILSf6bOkEaZq/Y
nSAR5oWSDsbbOPsqh/BziivAVL3dyj8dJmLqaUS2lko8cMB5rw0HcqGn4V7RjD68
y1A1AmZXG0Jo5Ulo2iXRrqF0CDMa2FNTAeTBsNhgZEXotkn8HMqASaaSSsO/+gTu
a1PrD71GYqD9FHmLhnY3GysmhLoX9gDJF7DWTpssEhEdHgp3fxz90vQ9s3UDvgb0
EipWe4+OzG31Ze0+Yyk1zkSc0ue0cDXqCpD/i4TOqhmv5PRl66i/Jj93UYotJ8cA
zPGYVRvDmAnP75bEyanI
-----END CERTIFICATE-----
---
Server certificate
subject=/O=testcorp
issuer=/O=testcorp
---
No client certificate CA names sent
Peer signing digest: SHA384
Server Temp Key: ECDH, P-256, 256 bits
---
SSL handshake has read 1389 bytes and written 266 bytes
---
New, TLSv1/SSLv3, Cipher is ECDHE-RSA-AES256-GCM-SHA384
Server public key is 2048 bit
Secure Renegotiation IS supported
Compression: NONE
Expansion: NONE
No ALPN negotiated
SSL-Session:
    Protocol  : TLSv1.2
    Cipher    : ECDHE-RSA-AES256-GCM-SHA384
    Session-ID: 5B4DB1A851ADFA7BBA98AC845905092F20DD89BB7C510B777760FF581F12DCF2
    Session-ID-ctx:
    Master-Key: 1AEB005E20921023757DA783A32FDA5C5AA5C9615ED07E6EF0B0A7EF0CD79F0531A84EE2AADC2B00AB5589B8C7BACE76
    Key-Arg   : None
    PSK identity: None
    PSK identity hint: None
    SRP username: None
    TLS session ticket:
    0000 - bc ba f4 a0 0b 22 f9 68-bd 33 8a ac 57 6b a8 4f   .....".h.3..Wk.O
    0010 - 87 ae b2 47 f4 70 17 80-c5 bd 00 c7 7b c8 68 c3   ...G.p......{.h.
    0020 - 11 06 bc 52 eb 2f 38 d5-c4 7f 61 0f f9 34 a7 c5   ...R./8...a..4..
    0030 - 55 05 f0 f5 ef 42 9d 10-4e a4 dc 41 60 d1 c6 2c   U....B..N..A`..,
    0040 - 76 28 48 d3 fd 84 26 89-2e 34 4c 51 44 e0 86 c9   v(H...&..4LQD...
    0050 - c4 31 16 f6 db 34 ef c2-09 1b 45 ff 3c aa cb 9c   .1...4....E.<...
    0060 - 17 e7 53 0a 83 f9 fc 6e-cd 66 91 a5 d9 77 a9 0b   ..S....n.f...w..
    0070 - fa c2 0b 0c 69 a2 15 c9-                          ....i...

    Start Time:<PHONE_NUMBER>
    Timeout   : 300 (sec)
    Verify return code: 10 (certificate has expired)
---
DONE
$
```

## Todo
### Best practices
I'm keen on any suggestions on low-hanging best practices I can implement. Feel free to send me a PR with any ideas you might have. Currently the timeouts are not adjustable, and are a simple first pass. I'm not sure what the most sensible defaults are, and whether they should be able to be tweaked, either directly or using a profile.

### Security Audit
This library is still in development (though I am anxious to see it to stability as soon as possible), but it could use an audit by someone who knows crypto better than me (which is probably pretty much anyone involved in crypto).  I'd especially be interested in whether or not the self-signed cert strategy is something I should even bother leaving in or not, but at the very least I'd like to make sure that the code I shamelessly cribbed from [generate_cert.go](https://golang.org/src/crypto/tls/generate_cert.go) is correct.

### Integration
I'm also curious as to whether or not I should try and at least provide a method to return a standard `net/http` server.  This would conceivably allow shttp to act as a convenient drop-in replacement for `net/http`, though it would also allow for accidental mucking about with the internals of the server and TLS configuration, and I would generally prefer to err on the side of caution when making an "easy" library for a hardened web server with crypto.

## Caveats
### STILL IN DEVELOPMENT
Seriously, it's not even stable; don't put it in production yet.

### Architectural Support
As mentioned in the article, at this time the the only architecture that supports [fast, optimized assembly versions](https://blog.cloudflare.com/go-crypto-bridging-the-performance-gap/) of the necessary crypto primitives is amd64, so this package will not compile on other architectures.  If and when such support becomes available, I will be sure to add it.

### Let's Encrypt
As of this first push, Let's Encrypt support is still being tested, and should be considered experimental. Of particular note are the concerns raised over rate limiting in the proposal mentioned above.

1See *Architectural Support* above


text:
### 0.5.0 - July 12 2019
* Updated README
* Forwarded remaining `IrcClient` members, making them visible from `IrcConnection` API.
* Fixed `IrcConnection.SendMessage`/`IrcConnection.SendMessageAsync` to appear as a method instead of a property.

### 0.4.0 - July 12 2019
* Added an `IrcClient.ConnectAsync` constructor taking an `EndPoint`.
* `IrcClient.ReadTimeout` is now in milliseconds.
* Removed asynchronous `IrcClient.NextMessage` method.
* Added a graceful reconnect feature in `IrcClient.ReconnectAsync`/`Irc.ClientReconnect` and `IrcConnection.ReconnectAsync`/`IrcClient.Reconnect`.
* `IrcConnection.OnReady` is now correctly marked as `internal`.
* `MessageReceived`, `SendMessage` and `SendMessageAsync` are now usable from the `IrcConnection` type.
* Unit tests are correctly run at build time.

### 0.3.0 - May 25 2019
* Valid TLS protocols are now determined by the OS.
* Improved naming conventions for `IrcConnection` members.
* Target framework changed to .NET Core 2.2.
* Upgraded to FAKE 5 and improved build automation scripts.

### 0.2.0 - July 9 2017
* `NumericResponse` takes a numeric string now, and decomposes a response into its parameters
* Added a `ReadTimeout` property to `IrcClient`
* Added an experimental `IrcConnection` type encapsulating the dynamic state of the client and server
* Added some nonstandard response codes
* Added new constructors for `IrcClient` taking an `IPAddress` or `EndPoint`
* Added support for IRCv3 capability negotiation (via `IrcConnection`)

### 0.1.1 - May 6 2016
* Fixes to unit testing
* Fixes to pattern matching

### 0.1.0 - May 5 2017
* Clean up Paket dependencies
* Change `IrcRecipient` to `IrcPrefix`
* Added pattern matching for nickname, user and hostmasks
* Added unit tests

### 0.0.1 - April 27 2017
* Initial release


text:
# sfm-flickr-harvester
A harvester for flickr content as part of [Social Feed Manager](https://gwu-libraries.github.io/sfm-ui).

[![Build Status](https://travis-ci.org/gwu-libraries/sfm-flickr-harvester.svg?branch=master)](https://travis-ci.org/gwu-libraries/sfm-flickr-harvester)

## Development

For information on development and running tests, see the [development documentation](http://sfm.readthedocs.io/en/latest/development.html).

When running tests, provide Flickr credentials either as a `test_config.py` file or environment variables (`FLICKR_KEY`,
`FLICKR_SECRET`).  An example `test_config.py` looks like:

    FLICKR_KEY = "acbdfdfe6b8bba356e8ef278ed65dbbc8"
    FLICKR_SECRET = "16264549fc54cc33eb"

## Running harvester as a service
Flickr harvester will act on harvest start messages received from a queue. To run as a service:

    python flickr_harvester.py service <mq host> <mq username> <mq password>

## Process harvest start files
Flickr harvester can process harvest start files. The format of a harvest start file is the same as a harvest start message.  To run:

    python flickr_harvester.py seed <path to file>

## Iterating over photo records in a WARC

    python flickr_photo_warc_iter.py <path to WARC>

## Running exporter as a service
Flickr exporter will act on export start messages received from a queue. To run as a service:

    python flickr_exporter.py service <mq host> <mq username> <mq password> <SFM UI REST API url>

## Process export start files
Flickr exporter can process export start files. The format of an export start file is the same as an export start message.  To run:

    python flickr_exporter.py file <path to file> <SFM UI REST API url>

## Harvest start messages
Following is information necessary to construct a harvest start message for the flickr harvester.

### User harvest type

Type: flickr_user

Api methods called:
  * people.findByUsername to get nsid if username provided
  * people.getInfo
  * people.getPublicPhotos
  * photos.getInfo for each photo

Required parameters:
  * username or nsid

Optional parameters:
  * incremental: True (default) or False
  * sizes:  List of [photo size labels](https://www.flickr.com/services/api/flickr.photos.getSizes.html).  Default is Thumbnail, Large, and Original.

Summary:
  * user
  * photo

Extracted urls: Urls are generated for each photo for each size.

### Authentication

Required parameters:
  * key
  * secret

repository: gwu-libraries/sfm-flickr-harvester

gha_language: Python

repo_name: gwu-libraries/sfm-flickr-harvester


text:
# mustache.js - Logic-less {{mustache}} templates with JavaScript

> What could be more logical awesome than no logic at all?

[![Build Status](https://travis-ci.org/janl/mustache.js.svg?branch=master)](https://travis-ci.org/janl/mustache.js) [![Gitter chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/janl/mustache.js)

[mustache.js](http://github.com/janl/mustache.js) is an implementation of the [mustache](http://mustache.github.com/) template system in JavaScript.

[Mustache](http://mustache.github.com/) is a logic-less template syntax. It can be used for HTML, config files, source code - anything. It works by expanding tags in a template using values provided in a hash or object.

We call it "logic-less" because there are no if statements, else clauses, or for loops. Instead there are only tags. Some tags are replaced with a value, some nothing, and others a series of values.

For a language-agnostic overview of mustache's template syntax, see the `mustache(5)` [manpage](http://mustache.github.com/mustache.5.html).

## Where to use mustache.js?

You can use mustache.js to render mustache templates anywhere you can use JavaScript. This includes web browsers, server-side environments such as [node](http://nodejs.org/), and [CouchDB](http://couchdb.apache.org/) views.

mustache.js ships with support for both the [CommonJS](http://www.commonjs.org/) module API and the [Asynchronous Module Definition](https://github.com/amdjs/amdjs-api/wiki/AMD) API, or AMD.

And this will be your templates after you use Mustache:

!['stache](https://cloud.githubusercontent.com/assets/288977/8779228/a3cf700e-2f02-11e5-869a-300312fb7a00.gif)

## Install

You can get Mustache via npm.

```bash
$ npm install mustache --save
```
or install with bower:

```bash
$ bower install --save mustache
```

## Command line tool

mustache.js is shipped with a node based command line tool. It might be installed as a global tool on your computer to render a mustache template of some kind

```bash
$ npm install -g mustache

$ mustache dataView.json myTemplate.mustache > output.html
```

also supports stdin.

```bash
$ cat dataView.json | mustache - myTemplate.mustache > output.html
```

or as a package.json `devDependency` in a build process maybe?

```bash
$ npm install mustache --save-dev
```

```json
{
  "scripts": {
    "build": "mustache dataView.json myTemplate.mustache > public/output.html"
  }
}
```
```bash
$ npm run build
```

The command line tool is basically a wrapper around `Mustache.render` so you get all the features.

If your templates use partials you should pass paths to partials using `-p` flag:

```bash
$ mustache -p path/to/partial1.mustache -p path/to/partial2.mustache dataView.json myTemplate.mustache
```

## Who uses mustache.js?

An updated list of mustache.js users is kept [on the Github wiki](http://wiki.github.com/janl/mustache.js/beard-competition). Add yourself or your company if you use mustache.js!

## Contributing

mustache.js is a mature project, but it continues to actively invite maintainers. You can help out a high-profile project that is used in a lot of places on the web. There is [plenty](https://github.com/janl/mustache.js/issues) of [work](https://github.com/janl/mustache.js/pulls) to do.  And a hero.

### Your First Contribution

- review a [Pull Request](https://github.com/janl/mustache.js/pulls)
- fix an [Issue](https://github.com/janl/mustache.js/issues)
- update the [documentation](https://github.com/janl/mustache.js#usage)
- make a website
- write a tutorial

* * *

## Usage

Below is a quick example how to use mustache.js:

```js
var view = {
  title: "Joe",
  calc: function () {
    return 2 + 4;
  }
};

var output = Mustache.render("{{title}} spends {{calc}}", view);
```

In this example, the `Mustache.render` function takes two parameters: 1) the [mustache](http://mustache.github.com/) template and 2) a `view` object that contains the data and code needed to render the template.

## API

Following is an [rtype](https://git.io/rtype) signature of the most commonly used functions.

```js
Mustache.render(
  template  : String,
  view      : Object,
  partials? : Object,
) => String

Mustache.parse(
  template              : String,
  tags = ['{{', '}}']   : Tags,
) => Token[]

interface Token [String, String, Number, Number, Token[]?, Number?]

interface Tags [String, String]

```

## Templates

A [mustache](http://mustache.github.com/) template is a string that contains any number of mustache tags. Tags are indicated by the double mustaches that surround them. `{{person}}` is a tag, as is `{{#person}}`. In both examples we refer to `person` as the tag's key. There are several types of tags available in mustache.js, described below.

There are several techniques that can be used to load templates and hand them to mustache.js, here are two of them:

#### Include Templates

If you need a template for a dynamic part in a static website, you can consider including the template in the static HTML file to avoid loading templates separately. Here's a small example using `jQuery`:

```html
<!DOCTYPE HTML>
<html>
<body onload="loadUser()">
<div id="target">Loading...</div>
<script id="template" type="x-tmpl-mustache">
Hello {{ name }}!
</script>
</body>
</html>
```

```js
function loadUser() {
  var template = $('#template').html();
  Mustache.parse(template);   // optional, speeds up future uses
  var rendered = Mustache.render(template, {name: "Luke"});
  $('#target').html(rendered);
}
```

#### Load External Templates

If your templates reside in individual files, you can load them asynchronously and render them when they arrive. Another example using `jQuery`:

```js
function loadUser() {
  $.get('template.mst', function(template) {
    var rendered = Mustache.render(template, {name: "Luke"});
    $('#target').html(rendered);
  });
}
```

### Variables

The most basic tag type is a simple variable. A `{{name}}` tag renders the value of the `name` key in the current context. If there is no such key, nothing is rendered.

All variables are HTML-escaped by default. If you want to render unescaped HTML, use the triple mustache: `{{{name}}}`. You can also use `&` to unescape a variable.

If you'd like to change HTML-escaping behavior globally (for example, to template non-HTML formats), you can override Mustache's escape function. For example, to disable all escaping: `Mustache.escape = function(text) {return text;};`.

If you want `{{name}}` _not_ to be interpreted as a mustache tag, but rather to appear exactly as `{{name}}` in the output, you must change and then restore the default delimiter. See the [Custom Delimiters](#custom-delimiters) section for more information.

View:

```json
{
  "name": "Chris",
  "company": "<b>GitHub</b>"
}
```

Template:

```
* {{name}}
* {{age}}
* {{company}}
* {{{company}}}
* {{&company}}
{{=<% %>=}}
* {{company}}
<%={{ }}=%>
```

Output:

```html
* Chris
*
* <b>GitHub</b>
* <b>GitHub</b>
* <b>GitHub</b>
* {{company}}
```

JavaScript's dot notation may be used to access keys that are properties of objects in a view.

View:

```json
{
  "name": {
    "first": "Michael",
    "last": "Jackson"
  },
  "age": "RIP"
}
```

Template:

```html
* {{name.first}} {{name.last}}
* {{age}}
```

Output:

```html
* Michael Jackson
* RIP
```

### Sections

Sections render blocks of text one or more times, depending on the value of the key in the current context.

A section begins with a pound and ends with a slash. That is, `{{#person}}` begins a `person` section, while `{{/person}}` ends it. The text between the two tags is referred to as that section's "block".

The behavior of the section is determined by the value of the key.

#### False Values or Empty Lists

If the `person` key does not exist, or exists and has a value of `null`, `undefined`, `false`, `0`, or `NaN`, or is an empty string or an empty list, the block will not be rendered.

View:

```json
{
  "person": false
}
```

Template:

```html
Shown.
{{#person}}
Never shown!
{{/person}}
```

Output:

```html
Shown.
```

#### Non-Empty Lists

If the `person` key exists and is not `null`, `undefined`, or `false`, and is not an empty list the block will be rendered one or more times.

When the value is a list, the block is rendered once for each item in the list. The context of the block is set to the current item in the list for each iteration. In this way we can loop over collections.

View:

```json
{
  "stooges": [
    { "name": "Moe" },
    { "name": "Larry" },
    { "name": "Curly" }
  ]
}
```

Template:

```html
{{#stooges}}
<b>{{name}}</b>
{{/stooges}}
```

Output:

```html
<b>Moe</b>
<b>Larry</b>
<b>Curly</b>
```

When looping over an array of strings, a `.` can be used to refer to the current item in the list.

View:

```json
{
  "musketeers": ["Athos", "Aramis", "Porthos", "D'Artagnan"]
}
```

Template:

```html
{{#musketeers}}
* {{.}}
{{/musketeers}}
```

Output:

```html
* Athos
* Aramis
* Porthos
* D'Artagnan
```

If the value of a section variable is a function, it will be called in the context of the current item in the list on each iteration.

View:

```js
{
  "beatles": [
    { "firstName": "John", "lastName": "Lennon" },
    { "firstName": "Paul", "lastName": "McCartney" },
    { "firstName": "George", "lastName": "Harrison" },
    { "firstName": "Ringo", "lastName": "Starr" }
  ],
  "name": function () {
    return this.firstName + " " + this.lastName;
  }
}
```

Template:

```html
{{#beatles}}
* {{name}}
{{/beatles}}
```

Output:

```html
* John Lennon
* Paul McCartney
* George Harrison
* Ringo Starr
```

#### Functions

If the value of a section key is a function, it is called with the section's literal block of text, un-rendered, as its first argument. The second argument is a special rendering function that uses the current view as its view argument. It is called in the context of the current view object.

View:

```js
{
  "name": "Tater",
  "bold": function () {
    return function (text, render) {
      return "<b>" + render(text) + "</b>";
    }
  }
}
```

Template:

```html
{{#bold}}Hi {{name}}.{{/bold}}
```

Output:

```html
<b>Hi Tater.</b>
```

### Inverted Sections

An inverted section opens with `{{^section}}` instead of `{{#section}}`. The block of an inverted section is rendered only if the value of that section's tag is `null`, `undefined`, `false`, *falsy* or an empty list.

View:

```json
{
  "repos": []
}
```

Template:

```html
{{#repos}}<b>{{name}}</b>{{/repos}}
{{^repos}}No repos :({{/repos}}
```

Output:

```html
No repos :(
```

### Comments

Comments begin with a bang and are ignored. The following template:

```html
<h1>Today{{! ignore me }}.</h1>
```

Will render as follows:

```html
<h1>Today.</h1>
```

Comments may contain newlines.

### Partials

Partials begin with a greater than sign, like {{> box}}.

 Just avoid infinite loops.

They also inherit the calling context. Whereas in ERB you may have this:

```html+erb
<%= partial :next_more, :start => start, :size => size %>
```

Mustache requires only this:

```html
{{> next_more}}
```

Why? Because the `next_more.mustache` file will inherit the `size` and `start` variables from the calling context. In this way you may want to think of partials as includes, imports, template expansion, nested templates, or subtemplates, even though those aren't literally the case here.

For example, this template and partial:

    base.mustache:

Names

    {{#names}}
      {{> user}}
    {{/names}}

    user.mustache:
    {{name}}

Can be thought of as a single, expanded template:

```html
<h2>Names</h2>
{{#names}}
  <strong>{{name}}</strong>
{{/names}}
```

In mustache.js an object of partials may be passed as the third argument to `Mustache.render`. The object should be keyed by the name of the partial, and its value should be the partial text.

```js
Mustache.render(template, view, {
  user: userTemplate
});
```

### Custom Delimiters

Custom delimiters can be used in place of `{{` and `}}` by setting the new values in JavaScript or in templates.

#### Setting in JavaScript

The `Mustache.tags` property holds an array consisting of the opening and closing tag values. Set custom values by passing a new array of tags to `parse()`, which gets honored over the default values, or by overriding the `tags` property itself:

```js
var customTags = [ '<%', '%>' ];
```

##### Pass Value into Parse Method
```js
Mustache.parse(template, customTags);
```

##### Override Tags Property
```js
Mustache.tags = customTags;
// Subsequent parse() and render() calls will use customTags
```

#### Setting in Templates

Set Delimiter tags start with an equals sign and change the tag delimiters from `{{` and `}}` to custom strings.

Consider the following contrived example:

```html+erb
* {{ default_tags }}
{{=<% %>=}}
* <% erb_style_tags %>
<%={{ }}=%>
* {{ default_tags_again }}
```

Here we have a list with three items. The first item uses the default tag style, the second uses ERB style as defined by the Set Delimiter tag, and the third returns to the default style after yet another Set Delimiter declaration.

According to [ctemplates](https://htmlpreview.github.io/?https://raw.githubusercontent.com/OlafvdSpek/ctemplate/master/doc/howto.html), this "is useful for languages like TeX, where double-braces may occur in the text and are awkward to use for markup."

Custom delimiters may not contain whitespace or the equals sign.

## Pre-parsing and Caching Templates

By default, when mustache.js first parses a template it keeps the full parsed token tree in a cache. The next time it sees that same template it skips the parsing step and renders the template much more quickly. If you'd like, you can do this ahead of time using `mustache.parse`.

```js
Mustache.parse(template);

// Then, sometime later.
Mustache.render(template, view);
```

## Plugins for JavaScript Libraries

mustache.js may be built specifically for several different client libraries, including the following:

  - [jQuery](http://jquery.com/)
  - [MooTools](http://mootools.net/)
  - [Dojo](http://www.dojotoolkit.org/)
  - [YUI](http://developer.yahoo.com/yui/)
  - [qooxdoo](http://qooxdoo.org/)

These may be built using [Rake](http://rake.rubyforge.org/) and one of the following commands:
```bash
$ rake jquery
$ rake mootools
$ rake dojo
$ rake yui3
$ rake qooxdoo
```
## Testing

In order to run the tests you'll need to install [node](http://nodejs.org/).

You also need to install the sub module containing [Mustache specifications](http://github.com/mustache/spec) in the project root.
```bash
$ git submodule init
$ git submodule update
```
Install dependencies.
```bash
$ npm install
```
Then run the tests.
```bash
$ npm test
```
The test suite consists of both unit and integration tests. If a template isn't rendering correctly for you, you can make a test for it by doing the following:

  1. Create a template file named `mytest.mustache` in the `test/_files`
     directory. Replace `mytest` with the name of your test.
  2. Create a corresponding view file named `mytest.js` in the same directory.
     This file should contain a JavaScript object literal enclosed in
     parentheses. See any of the other view files for an example.
  3. Create a file with the expected output in `mytest.txt` in the same
     directory.

Then, you can run the test with:
```bash
$ TEST=mytest npm run test-render
```
### Browser tests

Browser tests are not included in `npm test` as they run for too long, although they are ran automatically on Travis when merged into master. Run browser tests locally in any browser:
```bash
$ npm run test-browser-local
```
then point your browser to `http://localhost:8080/__zuul`

### Troubleshooting

#### npm install fails

Ensure to have a recent version of npm installed. While developing this project requires npm with support for `^` version ranges.
```bash
$ npm install -g npm
```
## Thanks

mustache.js wouldn't kick ass if it weren't for these fine souls:

  * Chris Wanstrath / defunkt
  * Alexander Lang / langalex
  * Sebastian Cohnen / tisba
  * J Chris Anderson / jchris
  * Tom Robinson / tlrobinson
  * Aaron Quint / quirkey
  * Douglas Crockford
  * Nikita Vasilyev / NV
  * Elise Wood / glytch
  * Damien Mathieu / dmathieu
  * Jakub Kuźma / qoobaa
  * Will Leinweber / will
  * dpree
  * Jason Smith / jhs
  * Aaron Gibralter / agibralter
  * Ross Boucher / boucher
  * Matt Sanford / mzsanford
  * Ben Cherry / bcherry
  * Michael Jackson / mjackson
  * Phillip Johnsen / phillipj
  * David da Silva Contín / dasilvacontin


text:
# Track App
## V1
App that allows Users to creates Tracks and Footprints detailing interesting geographical areas travelled.

## Frameworks
MapKit

CoreLocation

Firebase

## User Stories
As a user I would like to:

Track my location

Take and store photos of a location

Organize photos by category

See all photos associated with each category

See interesting attractions near my current location

Broadcast my location to other users of the app - V2

Share my photo/activity on social media

Create a user profile

## Model
### User Profile
Name
Description
Image
[Track]

### Track
Comprised of 1 or more Footprints

[Footprint]
Description
User

### Footprint
User will have at least one footprint showing their current location. Must remember to ask permission and give ability to hide current location.

Image

Latitude

Longitude

Description

Track

## Firebase
### Database
Design proper JSON feed based on model
### Storage
Database will contain a file storage reference for each photo

# Track App User Stories

## User Story 1 - Track my location
### Model
Hook up to Firebase

Authenticate or create user

Core location sets the user’s current location

![](https://github.com/melbrng/TrackApp/blob/master/images/user_1.png)

### View and View Controllers
Login/auth UI and add track button

Map View with current user location

Enable map to show interesting attractions near my current location

### Test
Create a test user and verify authentication

## User story 2 - Take and store photos of a location
### Model
Implement a Footprint class for photo, latitude/longitude/GPS, description and write back data to Firebase database

### View and View Controllers
UI to access camera or choose photos from the photo library

UI for selected photo and for setting footprint attributes

![](https://github.com/melbrng/TrackApp/blob/master/images/user_2.png)
![](https://github.com/melbrng/TrackApp/blob/master/images/user_2a.png)

## User story 3 - Organize photos by category
### Model
Allow a user to assign each footprint to an existing Track or create/assign to a new Track

###View and View Controllers
Photo UI and track category dropdown

Track UI for creating a new track and assign to footprint

## User story 4 - see all photos associated with each Track
### Model

Retrieve all footprints for the logged in user

![](https://github.com/melbrng/TrackApp/blob/master/images/user_4.png)

###View and View Controllers

Tableview UI that allows the user to scroll through all photos (footprints) in a category (Track)

Photo UI to view selected track

##User story 5 - set up a user profile

### Model
Implement a user class for the profile name, description and profile image

### View and View Controllers
User profile UI for creating or editing user information

User profile UI will contain a tableView of Tracks

![](https://github.com/melbrng/TrackApp/blob/master/images/user_5.png)

## User story 6 - Share my photo/activity on social media

### Model
Allow the user to share footprint photos on social media

### View and View Controllers
Photo UI add Facebook, Twitter buttons

# Track App V2
## Brainstorm:
Allow users to follow each other’s Tracks

broadcast my location to other users of the app

Incorporate hiking trails

repository: melbrng/TrackApp

gha_language: Objective-C

repo_name: melbrng/TrackApp


text:
---
id: kubera-teaming
title: Kubera Manual Testing Teaming
sidebar_label: Kubera teaming
---

### Below test cases are executed manully for teaming

#### ProjectOwner can invite others in his/her Project.
- Invitation should be send to the invitee

#### To view pending invites
- Users who have not accepted the invite can be viewed

#### Only invitee can accept or reject invitation
- Accept or Decline request can be seen in invitation page

#### Validate invitation reject process
- The status to the inviter will be shown as rejected

#### Validate invitation accept process
- From manage project dashboard he/she can see the project the user is part of.(invited user dashboard)
- Inviter can view that user in All user tab

#### Project owner can only change the member role
- Role of invited user can be changed successfully

#### To verify Project Owner access
- Can invite others to his project.
- Can change the role of the member in his project.
- Can delete a member from a project.

#### To verify Project Admin access
- Can connect or disconnect clusters
- Can manage alerts
- can upgrade cluster
- Can create dmaas schedules
- Can restore any backups

#### To verify Project Read Admin access
- Connect cluster button on cluster page should be invisible
- Cannot perform openEBS upgrade

#### To verify Project  Member access
- Restricted user, no access
- In manage project(project page), project should not be clickable

#### Non Project owner can not change the member role
- Role of invited user can not  be changed

#### To check that no console error is shown
- No console error is shown during accepting of invitation


text:
---
title: Using the API
description: ''
position: 4.2
category: Developer
---
The HTTP API allows you to send messages to us using JSON over HTTP. You can either talk to the API using your current HTTP library or you can use one of the pre-built libraries.

[Full API documentation](https://apiv1.postalserver.io)

<alert>
This API does not support managing all the functions of Postal. There are plans to introduce a new v2 API which will have more functionality and significantly better documentation. We do not have an ETA for this. Additionally, we will not be accepting any pull requests to extend the current API to have any further functionality than it currently does.
</alert>

## General API Instructions

* You should send POST requests to the URLs shown below.
* Parameters should be encoded in the body of the request and `application/json` should be set as the `Content-Type` header.
* The response will always be provided as JSON. The status of a request can be determined from the `status` attribute in the payload you receive. It will be `success` or `error`. Further details can be found in the `data` attribute.

An example response body is shown below:

```javascript
{
  "status":"success",
  "time":0.02,
  "flags":{},
  "data":{"message_id":"xxxx"}
}
```

To authenticate to the API you'll need to create an API credential for your mail server through the web interface. This is a random string which is unique to your server.

To authenticate a request to the API, you need to pass this key in the `X-Server-API-Key` HTTP header.

## Sending a message

There are two ways to send a message - you can either provide each attribute needed for the e-mail individually or you can craft your own RFC 2822 message and send this instead.

Full details about these two methods can be found in our API documentation:

* [Sending a message](https://postalserver.github.io/postal-api/controllers/send/message)
* [Sending an RFC 2822 message](https://postalserver.github.io/postal-api/controllers/send/raw)

For both these methods, the API will return the same information as the result. It will contain the `message_id` of the message that was sent plus a `messages` hash with the IDs of the messages that were sent by the server to each recipient.

```javascript
{
<EMAIL_ADDRESS>  "messages":{
    "john@example.com":{"id":37171, "token":"a4udnay1"},
    "mary@example.com":{"id":37172, "token":"bsfhjsdfs"}
  }
}
```

repository: jaydrogers/docs

repo_name: jaydrogers/docs


text:
# Employee Managment System

## Table of Contents
[Description](#description)
[Installation](#Installation)
[Test](#Testing)
[Project Links](#live-Site-and-Repo)
[Contributors](#Contributors)

## Description
* This app is used to sort through employee lists by Roles, Departments, and Employees.

## Installation
* No installations needed.

## Testing
* None available

## Repo
* [Repo](https://github.com/cailinyoung/cyoung-employee-system)

## Contributors
* Contributor: [Cailin Young](https://github.com/cailinyoung)

repository: cailinyoung/cyoung-employee-system

repo_name: cailinyoung/cyoung-employee-system


text:
---
layout: post
title:  "Beautiful Quotes"
date:   2015-06-24
categories: Quotes
excerpt:
comments: true
---

*Keep away from people who try to belittle your ambitions. Small people always do that, but the really great make you feel that you, too, can become great.* -- **Mark Twain**

*Freedom to be your best means nothing unless you're willing to do your best.* -- **Colin Powell**

*It doesn’t matter if you try and try and try again, and fail. It does matter if you try and fail, and fail to try again.* -- **Charles Kettering**

*Your history is not your destiny.* -- **Alan Cohen**

*You can tell more about a person by what he says about others than you can by what others say about him.*
-- **Audrey Hepburn**

*Don't marry the person you think you can live with; marry only the individual you think you can't live without.*
-- **James Dobson**

1. Define your goals and be specific
2. Deconstruct the skill into sub-skills
3. Focus on the most frequently used sub-skills
4. Eliminating the barrier of practice
5. Pre-commit to the first 20 hours.


text:
# Core-Django-1
This Repository contains code for my gallery application. An application that allows you to view some photos that I find interesting.
##### By Comfort
## Description
A personal gallery application that I display my photos for others to see.
#### Link to deployed site
https://cgallery1.herokuapp.com/
## Table of content
1. [Description](#description)
2. [Setup and installations](#setup-and-installations)
3. [Contributing](#contributing)
4. [Bugs](#bugs)
5. [Contact me](#support-and-contact-details)
6. [Licensing](#license)
## Setup and installations
* Fork the data onto your own personal repository.
* Clone Project to your machine
* Activate a virtual environment on terminal: `source virtual/bin/activate`
* Install all the requirements found in requirements file.
* On your terminal run `python3.8 manage.py runserver`
* Access the live site using the local host provided
### Prerequisites
1. [Python3.8](https://www.python.org/downloads/)
2. [virtualenv](https://virtualenv.pypa.io/en/stable/installation/)
3. [Pip](https://pip.pypa.io/en/stable/installing/)
## Technologies Used
    - Python 3.8
    - HTML
    - Bootstrap 3
    - Heroku
    - Postgresql
    - Django
#### Run the app
```bash
python3.8 manage.py runserver
```
Open [localhost:8000](http://<IP_ADDRESS>:8000/)
## Contribution
Incase of any contributions, feel free to do so by visiting[this link](https://github.com/C-Museo/Core-Django-1.git).
### License
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
Copyright (c) 2020 **mus**


text:
# Count the smiley faces! (6 kyu)

http://www.codewars.com/kata/count-the-smiley-faces

Given an array (arr) as an argument complete the function countSmileys that should return the total number of smiling faces.

Rules for a smiling face:

- Each smiley face must contain a valid pair of eyes. Eyes can be
  marked as : or ;
- A smiley face can have a nose but it does not have to. Valid characters
  for a nose are - or ~
- Every smiling face must have a smiling mouth that should be marked with
  either ) or D.

No additional characters are allowed except for those mentioned.

Valid smiley face examples:

```
:) :D ;-D :~)
```

Invalid smiley faces:

```
;( :> :} :]
```

url: https://raw.githubusercontent.com/novsunheng/codewars/c54b1d822356889b91587b088d02ca0bd3d8dc9e/(6 kyu) Count the smiley faces/(6 kyu) Count the smiley faces.md

repository: novsunheng/codewars

filename: (6 kyu) Count the smiley faces.md

repo_name: novsunheng/codewars


text:
# hc2UploadScene

hc2UploadScene uploads a referenced lua-script to the Fibaro HC2 systems.

It is a powerful tool intended to create a round-trip workflow. Plays together with hc2UploadScene and hc2DownloadScene commands.

## Usage

[NOTE: We assume that you have configured access to your Fibaro HC2 system as described in [CONFIGURATION](../../README.md#configuring-your-installation)]

`hc2UploadScene ExampleScene.lua` uploads the file `ExampleScene.lua`.

***

```txt
> hc2UploadScene -h

  Usage: hc2UploadScene [options] <lua-script>

  <lua-script> the file to be uploaded

  Options:
  --log-level, -l    Log level, one of panic, fatal, error, warn or warning, info, debug, trace
                     (default info)
  --cfg-file, -c     The config file to use (default /Users/the/.hc2-tools/config.json)
  --init, -i         Create a default config file as defined by cfg-file, if set. If not set
                     ~/.hc2-tools/config.json will be created.
  --test, -t         Just print information about the contacted HC2 system
  --create-header    Create the FIBARO_GIT_HEADER if set
  --dont-upload, -d  Don't upload the file but print only
  --version, -v      display version
  --help, -h         display help

  HC2 options:
  --user, -u         Username for HC2 authentication
  --password, -p     Password for HC2 authentication
  --url              URL of the Fibaro HC2 system, in the form http://...

  Scene options:
  --scene-id, -s     The sceneId that shall be used. If none given, create a new scene and implies
                     createHeader if header is missing (default -1)
  --room-id, -r      The roomId that shall be used. Implies createHeader if header is missing
                     (default -1)
  --scene-name       The scene name that shall be used. If none given and no header in file, than
                     take filename without file extenion and implies createHeader if header is
                     missing

  Require Expand options:
  --dont-expand      Don't expand the require statements
  --expand-path, -e  Where to search for the included libraries

  Version:
    hc2UploadScene 1.0.0

  Read more:
    github.com/theovassiliou/hc2-tools
```

***

## Examples

`hc2UploadScene -s 55 ExampleScene.lua` uploads the file `ExampleScene.lua` and uses the sceneID `55`. If the sceneID does not exists `hc2UploadScene` returns with error and exit code `1`.

## Library expansion

hc2Uploads enables the support of lua `require()` statements by expanding the library referenced in the `require()`statement inline in the file, before uploading

- `--expand-path` defines the search-path-root where to search for the included libraries.
  For example
    using `require('lib/Debug')` in the lua scene requires the source code inlined in the uploaded lua script.
    With `--expand-path ~/hc2/` the `hc2UploadScene`-tool will look for the required scene at `~/hc2/lib/Debug.lua`
- `--dont-expand` prohibits the expansion, and keeps the lua script as it is.

## config-file

The file has the following structure

```json
{
    "url":"http://hc.2.ip.address",
    "username":"admin",
    "password":"theAdminPassword"
}
```

Please note that you do not have to use the admin user, but any user who has access to desired scenes.

gha_language: Go


text:
# UNIX-Shell
The objective of this project was to implement a basic shell in C that supports and job control and also implements basic signal handling.

Files:

Makefile	# Compiles your shell program and runs the tests
README		# This file
tsh.c		# The shell program that you will write and hand in
tshref		# The reference shell binary.

# The remaining files are used to test your shell
sdriver.pl	# The trace-driven shell driver
trace*.txt	# The 15 trace files that control the shell driver
tshref.out 	# Example output of the reference shell on all 15 traces

# Little C programs that are called by the trace files
myspin.c	# Takes argument <n> and spins for <n> seconds
mysplit.c	# Forks a child that spins for <n> seconds
mystop.c        # Spins for <n> seconds and sends SIGTSTP to itself
myint.c         # Spins for <n> seconds and sends SIGINT to itself