text:
---
layout: single-page
title: "From shared experiences to shared knowledge and common solutions: collaborating to improve web-based tools in Latin America and the Caribbean"
date: 2020-08-01
type: Workshop & Documentation
funding: GBIF & co-founders
lead: GBIF Brazil
year: 2020
status: On-going
---

## {{ page.title }}

#### Description

Having developed largely independently of each other, the GBIF nodes of the [Latin America and Caribbean region](https://www.gbif.org/the-gbif-network/latin-america) have implemented different solutions for organizing and displaying biodiversity data and deploying related information services. This fragmented approach has often come with high costs, particularly in terms of supporting individual bespoke solutions.

To represent the region's natural capital effectively in all its richness, the project team led by SiBBr (Sistema de Informação sobre a Biodiversidade Brasileira) will organize a workshop to explore their experience, capacity and challenges as they aim to exchange knowledge, methodologies and tools for sharing and using biodiversity data and information in the regional scenario.

For example, Brazil, Costa Rica and Argentina have each opted for customized Living Atlases, successfully deploying certain modules to facilitate data analysis and visualization. This approach, however, places specific demands on integrating national taxonomic databases and species information.

The project will encourage participants to address common issues together, such as

- Building and improving national-scale taxonomic databases
- Identifying tools and approaches that consolidate species catalogs quickly and efficiently
- Simplifying the implementation, support and maintenance of national data portals, reporting and visualisation

The workshop may also identify partnership opportunities for implementing common solutions that simplify data management and increase the national systems' long-term sustainability. Such improved cooperation between the region's nodes may also increase the confidence of both publishers and users of national information systems.

#### Participants

| Organization | Role |
|--------------|------|
{% for project in site.data.projects.CESP2020-006 -%}
| {{ project.organisation }}  | {{ project.role }} |
{% endfor %}

#### Agenda & Resources

repository: melecoq/la-website

repo_name: melecoq/la-website


text:
# Traffic Test 2

The mesh routing program batman-adv is tested on lattice structures of different sizes.
Test platfom is a i7-6500U CPU @ 2.50GHz (2 cores) with 8 GB RAM.
Every test was performed 10 times to calculate the standard deviation (error bars).

## Result

![image](traffic-batman-adv-lattice4_sd.png)

## Creation

`sudo ./run.sh` runs the test (will take about a day).
`./plot.sh` will create graphs using gnuplot.

repository: WirelessWizard/meshnet-lab

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: WirelessWizard/meshnet-lab


text:
# slug

A slug is a snapshot of your application code that is ready to run on the platform.

## Actions

### `info`

`heroku.apps({app_id_or_name}).slugs({slug_id}).info({callback});`

Method | Path
--- | ---
GET | /apps/{app_id_or_name}/slugs/{slug_id}

### `create`

`heroku.apps({app_id_or_name}).slugs().create({attributes}, {callback});`

Method | Path
--- | ---
POST | /apps/{app_id_or_name}/slugs

license: MIT

repository: KeshawnSharper/BackEnd

gha_license_id: MIT

repo_name: KeshawnSharper/BackEnd


text:
## About [![build status](https://secure.travis-ci.org/SaltwaterC/dynamo-backup-streams.png?branch=master)](https://travis-ci.org/SaltwaterC/dynamo-backup-streams) [![NPM version](https://badge.fury.io/js/dynamo-backup-streams.png)](http://badge.fury.io/js/dynamo-backup-streams)

Backup / Restore DynamoDB node.js streams. Designed to be used in various pipelines in order to build custom backup / restore solutions. Both Backup and Restore handle properly few things, like back-pressure and capacity usage (including auto-scaling).

## System requirements

 * node.js 6+

`aws-sdk` must be installed before using this library. A DynamoDB client instance must be passed to the Backup / Restore constructor.

## Backup

Implemented as node.js Readable stream. Built on top of DynamoDB Scan with ConsistentRead. It outputs a stream of JSON encoded DynamoDB items separated by newline.

The backup.js example shows how a pipeline with Backup works. In this particular case, the Backup stream is piped into gzip, then piped into a file.

```javascript
var AWS = require('aws-sdk');
var Backup = require('dynamo-backup-streams').Backup;
var backupStream = new Backup({
  client: new AWS.DynamoDB(),
  table: 'table_name'
});

// get an output stream somehow
backupStream.pipe(outputStream); // do stuff with the stream
```

The Backup constructor accepts an options object. The spec for that object:

 * `client` - DynamoDB client instance created with `new AWS.DynamoDB()`
 * `table` - indicates the DynamoDB table name to backup. This is the only compulsory option.
 * `capacityPercentage` - the percentage of the read capacity units to use on DynamoDB to be used as the total target capacity. Default: 25.
 * `retries` - the number of retries for each read request. Default: 10.
 * `delay` - the target delay in milliseconds between each request. Default: 1000.
 * `concurrency` - the number of workers to use for reading the data. Each worker reads a Scan segment. Default: 4.
 * `fixedCapacity` - Number to operate on a fixed capacity e.g. needed to utilize tables in [on demand mode](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.OnDemand
).
 Make sure to consult the [available throughput in your region](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html#default-limits-throughput). Default undefined

The actual capacity requirements are calculated on each request. One read unit equals to 4KB/s of throughput. DynamoDB Scan counts the total size of the items for the purpose of capacity usage which makes this operation very efficient. On each request, the used capacity is compared against the target capacity of the worker. The target capacity is then adjusted accordingly. The total target capacity is checked against DynamoDB every 60 seconds to see if auto-scaling has kicked in. The target capacity of the worker is calculated by dividing the total target capacity to the number of workers and rounding down to the nearest integer unit. The read capacity per worker can't be smaller than 1.

If the size of a typical item is greater than the maximum request size which can be as low as 1 read unit per worker, then the capacity usage would be higher than the specified percentage. You may need to reduce the number of workers to fit into the capacity target.

The maximum throughput which can be achieved per worker is 257 read units (1028 KB/s). This is the throughput limit of DynamoDB partitions. Basically, a worker is needed for every 257 read units in order to fully utilise the read capacity, if desired.

The delay option should not be adjusted, unless there's a reason to do so. Bear in mind that the delay value is a target, not the actual delay between the current and the next request. The capacity is computed dynamically, however, since it's in KB/s, a request needs to be executed, on average, every second. With network latency which can't be predicted and auto-scaling, a fixed offset won't work for achieving this 1 request/second target. Every request is measured to see how much time it takes to process. This time difference is then subtracted from the delay target, then the next request is scheduled based on this dynamic offset.

If the stream is paused, no data is being read from DynamoDB. The status of the paused state is checked every 250 milliseconds. The stream would emit data events for requests still in flight. The stream would be fully paused once all the DynamoDB Scan requests have been completed.

## Restore

Implemented as node.js PassThrough stream. Built on top of DynamoDB BatchWriteItem. The input is a stream created by Backup. For all intents and purposes this object must be used as a Writable stream. The Readable bit is passed internally to [readline](https://nodejs.org/api/readline.html) to tokenise the input stream into lines which then are parsed as JSON. readline is handling the back-pressure whenever the line buffer is filled.

The restore.js example shows how a pipeline with Restore works. In this particular case, a file read stream is piped into gunzip, then piped into the Restore stream.

```javascript
var AWS = require('aws-sdk');
var Restore = require('dynamo-backup-streams').Restore;
var restoreStream = new Restore({
  client: new AWS.DynamoDB(),
  table: 'table_name'
});

// get an input stream somehow
inputStream.pipe(restoreStream);
```

The Restore constructor accepts an options object. The spec for that object:

 * `client` - DynamoDB client instance created with `new AWS.DynamoDB()`
 * `table` - indicates the DynamoDB table name to backup. This is the only compulsory option.
 * `capacityPercentage` - the percentage of write capacity units to use on DynamoDB to be used as the total target capacity. Default: 25.
 * `retries` - the number of retries for each write request. Default: 10.
 * `delay` - the target delay in milliseconds between each request. Default: 1000.
 * `concurrency` - the number of workers to use for writing the data. Default: 1.
 * `bufferSize` - the size of the line buffer created by reading from readline. Default: 250 * `concurrency`.
 * `maxItems` - the maximum number of items in a batchWriteItem request. Default: 25. Max: 25.
 * `fixedCapacity` - Number to operate on a fixed capacity e.g. needed to utilize tables in [on demand mode](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.OnDemand
).
 Make sure to consult the [available throughput in your region](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html#default-limits-throughput). Default undefined

The same formulas for capacity sizing and request timings used for the Backup stream apply. There are certain differences though. One write unit equals to 1KB/s of throughput. DynamoDB BatchWriteItem counts the size of each individual item and the value is rounded up to the nearest KB. This makes the capacity sizing tad inefficient compared to Scan. The general limits for BatchWriteItem apply: up to 25 items per batch, 400KB as the maximum size of the item, and 16MB as the total size of the BatchWriteItem request.

If the lines buffer is full, readline is paused until the buffer size drops under the set limit. Because readline doesn't pause the stream immediately, i.e the in flight input Buffers may still trigger line events, the actual size of the line buffer may be higher, but not by much. By default, the capacity of this buffer is set dynamically. Each worker adds 250 units to the line buffer limit. Since the main limitation is the slow throughput of DynamoDB writes, this buffer would be pretty much full for the whole duration of the restore process.

This stream emits the close event when the line buffer is drained and the readline stream is closed. This indicates that no more writes are being done to DynamoDB.

## AWS Authentication

By default, if no authentication options are being specified, aws-sdk tries to use the environment variables or the instance profile credentials (if running on EC2).

The minimum environment variables required to make it work:

 * `AWS_REGION`
 * `AWS_ACCESS_KEY_ID`
 * `AWS_SECRET_ACCESS_KEY`

To use a credentials profile saved as ini files with environment variables:

 * `AWS_REGION`
 * `AWS_PROFILE`

To specify in code a credentials profile:

```javascript
new AWS.DynamoDB({
  credentials: new AWS.SharedIniFileCredentials({
    profile: 'profile_name'
  })
});
```

## Screenshots

These screenshots display the capacity usage for a large table backup with auto-scaling turned on.

![large-table-1h.png](/screenshots/large-table-1h.png?raw=true "large-table-1h.png")

![large-table-3h.png](/screenshots/large-table-3h.png?raw=true "large-table-3h.png")

repository: SaltwaterC/dynamo-backup-streams

gha_language: JavaScript

repo_name: SaltwaterC/dynamo-backup-streams


text:
# Get Application Insights Key Action

GitHub Action to Azure Application Insights instrumentation key

```yaml
# File: .github/workflows/workflow.yml

on: push

env:
  RESOURCE_GROUP_NAME: sample-rg
  APPLICATION_INSIGHTS_NAME: sample-insights
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: azure/login@v1 # Login to Azure
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}
      - name: Get Application Insights Key
        # id: insights # step id for later reference
        uses: waeltken/get-application-insights-key-action@v1
        with:
          resource-group-name: ${{ env.RESOURCE_GROUP_NAME }}
          application-insights-name: ${{ env.APPLICATION_INSIGHTS_NAME }}
        # The Action exposes the Application Insights Instrumentation Key as
        # ${{ env.APPLICATION_INSIGHTS_KEY }}
        # You can also access the value from the steps output like this:
        # ${{ steps.insights.outputs.key }}
      - name: "run more steps"
        # APPLICATION_INSIGHTS_KEY environment variable visible here:
        run: echo $APPLICATION_INSIGHTS_KEY
```

branch_name: refs/heads/main


text:
Can typography enhance art in webcomics?
Can typography enhance art in webcomics?
Lettering is an integral part of making comics, either web or print. But can it be more than words on a page? We talked to two artists about typography in webcomics to find out.
2016-04-16
Ben Gremillion
Tags

My handwriting sucks. Blame it on a lifetime of typing or a lack of coordination, but I can’t seem to get straight lines or graceful curves at tiny sizes.

When we started marketing the Grawlix CMS, we wanted that *comic look* without getting [all cheeky](http://blog.fonts.com/2011/04/comic-sans-pro/). So we bought [CC Legendary Legerdemain](http://www.comicbookfonts.com/Legendary-Legerdemain-p/bl052.htm), now our signature type family.

That got us thinking about words in comics. **How can artists use text as a visual tool?**

## Using typography to reinforce style

We talked to Nate Piekos, creator of [the comic font site Blambot](http://blambot.com), about how to choose the right type face (or family) for the job.

> “If the artist inks with a brush, the style guide should reflect that.”

“Matching a font style (or a group of fonts/balloons/caption styles, called a ‘style guide’) to the artwork is top priority,” Nate said. “If the artist inks with a brush, the style guide should reflect that.

You can almost feel the detail in his custom typefaces at [his webcomic Atlan](http://www.realmofatland.com). His and other sites use typography to make words blend into the art. For example, the 8-bit style in [Diesel Sweeties](http://www.dieselsweeties.com/archive/2047) by Richard Stevens carries through to its deliberately pixellated words. [Hark, a Vagrant](http://www.harkavagrant.com/index.php?id=256) by Kate Beaton has hand-written text that comes straight from the artist’s hand, and it shows.

> “Using typed text allowed me to ensure that it would always be consistent and, furthermore, simpler to create and alter.”

Joe England of [Zebra Girl](http://www.zebragirl.thecomicseries.com) fame told us that he recently moved from hand-written dialogue to a typeface, he created his own font to mimic his handwriting.

“The decision to change was made because, while I was rather proud of my hand-written text, it was occasionally difficult to read and always, always time consuming to create. Not to mention sometimes difficult to draw around,” Joe said. “Using typed text allowed me to ensure that it would always be consistent and, furthermore, simpler to create and alter.”

## Walls of text

Even the right typeface can work against visual storytelling. The “wall of text” problem occurs when readers must plow through entire paragraphs of dialogue or narration. Too much text *informs* without *engaging.*

> “It's usually very obvious when a balloon has too much dialogue…”

Many comics do fine without text. Pages in Scurry by Mac Smith leans on its outstanding visuals [when the action picks up](http://www.scurrycomic.com/scurry-comic/2016/3/2/scurry-pg16). But when a comic needs dialogue, a narrator or onomatopoeia, text enters the picture.

So is there a rule of thumb for the most text a word balloon should hold? That is, when does a balloon become a wall of text?

“No, but it's usually very obvious when a balloon has too much dialogue and should be broken into several balloons,” Nate said. “The biggest hint is when there are too many trains of thought going on. Separate ideas that should be split up.”

## Drawing conclusions

We’ve seen some creative typography out there, but the best uses their choice of typeface, color and weight to enhance their art. Whether you’re telling a dramatic fantasy story, a slice-of-life comedy, or publishing one-off dailies, text is an opportunity to reinforce your style.


text:
---
layout: page
short-title: 15-400
title: Stealthy Attacker Complexity in Cyber-Physical Systems
permalink: /15400/
comments: false
author_footer: false
---

This is the homepage for my 15-400 research project. I will be posting regular
updates on my research during the S20 semester.

## Brief Description

- **Who:** I will be working under [Eunsuk Kang](eskang.github.io),
assistant professor in the Institute for Software Research at
Carnegie Mellon University.
- **What:** I will be studying the relative complexity between supervisors and
stealthy attackers in a cyber-physical system. This will involve defining an
appropriate notion of complexity that makes sense for both attackers and
supervisors and then considering questions such as
  - How complex does an attacker have to be, as a function of the supervisor's
  complexity, to guarantee a stealthy attack?
  - How complex does an attacker have to be, as a function of the supervisor's
  complexity, to make a stealthy attack possible in some cases?
  - How complex does a supervisor have to be, as a function of the attacker's
  complexity, to prevent a stealthy attack?
  - How complex does a supervisor have to be, as a function of the attacker's
  complexity, to make a stealthy attack preventable in some cases?
- **So What:** Nowadays, cyber-physical systems are found in all sorts of
safety-critical applications, such as in automotive vehicles. Consequently,
attacks on cyber-physical systems are an important concern for system designers.
Upon detection of an attack, it is often a viable option for a safety-critical
system to simply shut itself down, thus preventing any harm. However, such
detection is by definition impossible for stealthy attacks, which makes them
particularly frightening and especially important to understand. My work will
enable cyber-physical system designers to obtain security guarantees on their
systems. By measuring the complexity of their systems and applying the bounds
I will derive, cyber-physical system designers will be able to obtain lower
bounds on the complexity of any stealthy attacker, which may be useful in ruling
out threats from certain classes of actors.

## Research Proposal

- [Writeup](/docs/15400/proposal.pdf)
- [Slides](/docs/15400/proposal_slides.pdf)

## Milestone Reports

- [Milestone Report 1](/docs/15400/Milestone_1_Report.pdf)
- [Milestone Report 2](/docs/15400/Milestone_2_Report.pdf)
- [Milestone Report 3](/docs/15400/Milestone_3_Report.pdf)
- [Milestone Report 4](/docs/15400/Milestone_4_Report.pdf)
- [Milestone Report 5](/docs/15400/Milestone_5_Report.pdf)
- [Milestone Report 6](/docs/15400/Milestone_6_Report.pdf)
- [Milestone Report 7](/docs/15400/Milestone_7_Report.pdf)

## Results
- [Research Poster](/docs/15400/15400_Poster.pdf)
- [Final Paper](/docs/15400/15400_Final_Paper.pdf)


text:
---
title: S3
book: tutorials
section: deployment
chapter: aws
slug: aws-s3
weight: 10
---
Before we setup our API and PDF servers, we need to first setup an S3 Bucket which will contain the uploaded PDF's used by the PDF server.

 - To setup an S3 bucket, we will first just navigate to the S3 section of Amazon AWS by clicking on the home page, and then typing **S3** in the Search bar. Click on **S3** in the Search results.

    ![](/assets/img/integrations/aws/eb/s3.jpg){: .img-fluid .img-thumbnail }

 - On the next page, click on the **Create Bucket** button.
 - On the next page, give it a **Bucket Name** of **pdf-server**, and then click **Next**
 - Now skip over the **Configure Options** page by pressing **Next**
 - Now skip over the **Set permissions** page by pressing **Next**
 - Finally, press **Create Bucket** to create your new S3 bucket.
 - Now that we have an S3 bucket created, we now need to create an **IAM** role with admin rights to this S3 bucket. We will do this by navigating back to the AWS homepage and then typing **IAM** in the Search bar.

    ![](/assets/img/integrations/aws/eb/iam.jpg){: .img-fluid .img-thumbnail }

 - Within the **IAM** page, we will create a new user by clicking on **Users** and then clicking on **Add User**.

    ![](/assets/img/integrations/aws/eb/adduser.jpg){: .img-fluid .img-thumbnail }

 - In the next page, we will call our User **pdf-server**, and we will want to make sure to check the **Programmatic Access** under the Access Type section. Then click the **Next** button.

    ![](/assets/img/integrations/aws/eb/iam-access.jpg){: .img-fluid .img-thumbnail }

 - In the **Permissions** page, we will want to **Attach existing policies directly**, and then we will want to **Create Policy**.

    ![](/assets/img/integrations/aws/eb/attach-policy.jpg){: .img-fluid .img-thumbnail }

 - This will open up the "Create Policy" page. In this page, we will first want to click on **Choose a service**. Select **S3**.

    ![](/assets/img/integrations/aws/eb/policy-service.jpg){: .img-fluid .img-thumbnail }

 - Skip over the **Actions** section.

    ![](/assets/img/integrations/aws/eb/policy-actions.jpg){: .img-fluid .img-thumbnail }

 - In the next **Resources** section, we will want to click on the **Add ARN** link next to the **bucket** section. Here we will provide our **pdf-server** bucket in the name, and then click **Add**

    ![](/assets/img/integrations/aws/eb/s3-arn.jpg){: .img-fluid .img-thumbnail }

 - In the **object** resource section, click **Add ARN** and then provide the **pdf-server** bucket name, and then click on the **Any** checkbox for the **object** section.

    ![](/assets/img/integrations/aws/eb/s3-object.jpg){: .img-fluid .img-thumbnail }

 - For the other **Resources**, click on them and then click on the **Any** settings for all of them. When you are done, it should look like the following.

    ![](/assets/img/integrations/aws/eb/s3-resources.jpg){: .img-fluid .img-thumbnail }

 - You can now click on the **Review Policy** button at the bottom of the page.
 - For the **Name**, just provide **pdf-server-s3**, then click on the **Create policy** button.

    ![](/assets/img/integrations/aws/eb/s3-policy.jpg){: .img-fluid .img-thumbnail }

 - Now that a policy has been created, we can attach that policy to the **IAM** role by going back to that page and then search for **pdf-server-s3** in the search bar.

    ![](/assets/img/integrations/aws/eb/user-policy.jpg){: .img-fluid .img-thumbnail }

 - Now, click on the **Next** button in the **IAM** wizard. Skip ahead until you get to the **Review** page, and then click **Create user**
 - On the next page, make sure to copy the **Access Key ID** as well as the **Secret access key**, and save this for later. We are now ready to move onto setting up the **Elastic Beanstalk** deployment!


text:
# Project Authors

The following people have made contributions to the project (in alphabetical order by
last name) and are considered "The RockHound Developers":

* [Santiago Soler](https://github.com/santisoler)
* [Leonardo Uieda](https://github.com/leouieda)
* [Agustina Pesce](https://github.com/aguspesce)

repository: fatiando/rockhound

gha_language: Python

repo_name: fatiando/rockhound


text:
# Proton
Proton IoT - Internet of Things control panel using Flask to easily send/receive data from MQTT.

This works using Flask (Python web framework) and Bootstrap for the frontend to make it look nice and run quite well on most screen sizes.

![alt text](https://github.com/JP-W/Proton/raw/master/PROTONDIAG.png)

In the diagram, the "Door controller" node is only an example; many other types of node can be added to the system.

repository: JP-W/Proton

repo_name: JP-W/Proton


text:
---
title: "Project FAQ"
linkTitle: "Project FAQ"
description: Project FAQ
tags: ["FAQ"]
weight: 70
aliases:
  - /report/project-faq
---

{{% pageinfo %}}

{{< table_of_contents >}}

{{% /pageinfo %}}

## Do I have to read every Piazza post?

Yes.

There are very view posts in Piazza, typically much less than 10 per
week. If you were taking a live class I am sure you get also 10+ tips
and comments from the instructors. Piazza is a mechanism for us to
communicate to the entire online class.

Use piazza to discuss things. You can also use it to discuss issues in
your projects with other class mates openly.

## I see something mssing or wrong in this FAQ. How can I correct or add it?

If you see something missing that we shoudl add, please edit this web
page and create a pull request with your changes:

[Edit here](https://github.com/cybertraining-dsc/cybertraining-dsc.github.io/edit/main/content/en/report/checklist.md)

## Where to get help?

We often use the term TA instead of AI as AI in this class has a
specific meaning related to class content.

TA hours are posted at

* <https://piazza.com/class/kedccsbsthm5sc?cid=179>

If a TA is not available during that time, you have the right to ask
for an alternative time.

## Do I have to work weekly on the project?

Yes.

Please plan to set aside a **significant** time every week for your
project. We include your weekly progress in the grade. This is because
you will fail if you do not set sufficient time aside and start your
project in the week before the deadline.

## When are updates due?

Updates are due every week from the time that the project has been
announced. The updates will be committed by you to github.com. TAs
will be reviewing your updates The weekly progress will be check by
the TA's while looking at the GitHub insights page.

TAs or instructors may make comments to your repository. It is your
responsibility to make sure to stay in sync with the content in the
repo. Best is to use a tool such as a command line tool or a GUI tool
to stay in sync with the repo.

## How do I define a project?

Please take a look at the class content and select a topic that
interests you. Your project needs to be related to *big data* and
provide an analysis of the data. You may choose a topic that is only
explained later on in class. In this case, you can explore the topic
ahead of time before it is explained in class. Previous class material
is posted for all topics. If you have a question, work with the TA's
and instructors.

Please remember this is not just an AI class to demonstrate a specific
AI method. Your project must have a section or an explanation of how your
project relates or could relate to big data.

However, it is **not** required to use a huge dataset for this class.

The class has also the ability to do projects related to cloud
infrastructure. In that case, please contact Gregor directly to assess
if you have enough qualifications and can succeed in the project.

## Project Directory

The following is the best structure for your project

* `project/project.md` # your project report. This is a must.
* `project/project.bib` # your project bib file if you use jabref
* `project/plan.md` # for final submission move your Plan section here
* `project/images` # place all images in this directory
* `project/code/`

   Move your python code or notebooks here.

* `project/data`

  Your project must not have (large) data in GitHub, instead you must
  have a program that downloads the data.  best is to add project/data
  to your .gitignore file See more information on the data section.

Make sure you create in your paper citations and references to your own
code and GitHub directory.

## Filenames

Filenames must be precise, and we recommend using lower case file names
in most cases (some Python class files may also contain capital
letters). Filenames must not have spaces included in them. We will not
review any information included in a file that contains spaces or
characters that are not in [a-Z0-9] and the _ and - characters. We will
return your project without review and assign an "F" as those files
cause issues.

All image file names must be lower case.

Her an example of an image file name that is wrong in many ways:

* `project/images/THIS IS Gregor's Image.PNG`

Wrong because

1. contains spaces contains
2. capital letters
3. contains ' which is not allowed ever
4. has an ending with capital letters

## Project Proposal

This is a snapshot of your final project. You do not have to use the
words *I* or *plan* simply write it as if you already decided to do
the project and make it look like a final paper's snapshot. Your
paper must follow a typical research paper outline. The project
ideally provides a novel feature that has not been presented by
others. Just replication what others in the community did may not be
lead to the best result. If you have not researched if others have
done your project, It also will not lead to your best result.

A sample of a report is provided at

* Raw:
<https://raw.githubusercontent.com/cybertraining-dsc/fa20-523-312/main/project/project.md>
* <https://cybertraining-dsc.github.io/report/fa20-523-312/project/project/>

Sections that must be included

* Abstract
* Introduction
* Related Research
  Identify similar projects and describe what you do differently
* Data
  Write about which data you choose
* Analysis
  Write about your intended analysis
* Plan
  Provide a plan that lists what you do every week.(This plan is to be
  removed before the final submission at the end of the semester.
  You can move it into a file called project/plan.md
  in case you like to preserve it
* Refernces

Please make sure that the refernce section is the last section in the document.

## Reports without programming

It is possible for undergraduates, but not for graduate students to do
a report that does not include programming. You will automatically get
a half grade point deduction, and the best grade achievable will be an
A-. The report will typically be 25% to 50% longer than a project
with programming. It must be comprehensive and have a more in-depth background
section. Proper citations are a must. Citations are
typically much more in reports due to the nature of it.

 This is a must.
* report/report.bib # your project bib file
* report/plan.md # for final submission move your Plan section here
* report/images # place all images in thsi directory

It is our **strong** recommendation that you use jabref for assisting you
with the management of your references! You will save a lot of time
while using it and assure that the format will be correct, which is
important for reports!

## Formal writing

They shall not use the word "I" in the report.

see also: <https://piazza.com/class/kedccsbsthm5sc?cid=181>

We do allow, however, the words *we*, *you*

In general:

* Do not use first-person pronouns ("I", "me", "my", "us", etc.). ...
* You must not use contractions such as don't or 've ...
* Avoid colloquialism and slang expressions. ...
* Avoid nonstandard diction. ...
* When using an abbreviation, it must be defined before its first use
  in brackets): Artificial Intelligence (AI) ... Avoid the creation of unnecessary abbreviations. It is better to say big data instead of BD
* Avoid the overuse of short and simple sentences.
* Avoid the overuse of very long and complex sentences.

### colons

A colon is :

* They shall not use a space before a colon ever.
* They shall not use colons in section headers.

### Quotes

* They shall not use "quoted quotes" to highlight.
* They shall use *italic* to highlight

Quotes are reserved for citations and must be followed by a citation
that is included in your reference section.

## Update and check the submission

Once you submit your paper, you need to dow the following.

1. modify the README.yaml file and update the information of your project in it. Keep it up to date in case authors or title changes. We use this information to mine all Gitrepos, and thus it must be up to date all the time.
   In case you are in a group, make sure you preserve the authors' order in the list among all group members. The person that has the repo for the project must be the first author.

	Example for single author: <https://github.com/cybertraining-dsc/fa20-523-312/README.yaml>

2. Check every week if your report renders correctly and if your
   report is listed at <https://cybertraining-dsc.github.io/report/>
   Click on your paper link, your student link, and your edit link to ensure they all work correctly. If not, please correct them via a
   pull request (you can edit that page and see how we do it for other students).

## Using Markdown

We no longer accept any document format that is not markdown. We use
proper markdown that must not include any HTML tags. submissions with
HTML tags will be rejected without reviews. You must look at our
template in raw format to see what features of markdown we use. Your
file may not be properly rendered in GitHub (e.g., abstract and table
of content, as well as references look differently), but it will be on our Web
site.

## References and citations

You must have a reference section from the get-go. We use
footnotes to showcase the references as GitHub does not support proper
references in markdown. However, we use footnotes in a straightforward and
specific way that requires you to be careful with the dot at the end of
the sentence. The footnotes must not be after the dot, but they must
be within the dot. The reason is that at one point, we will
automatically replace your footnotes with a [number] theme. You do not
have to do this; we will do this. This is simpler than it sounds for
you, so we give an example:

When you use the citations, you MUST for us do them before the dot that
closes the sentence that you cite in or refers to. They do require you
do the `[^1]` before the dot

wrong: `This is a sentence with reference.[^1]`

correct: `This is a sentence with reference [^1]`.

wrong: `Simon says "Hallo".[^1]`

The reference section must be the last section in your report

```
## 8. Refernces

[^1]:  This is where you put the citation information.
```

See, there is no space before the :

see also https://piazza.com/class/kedccsbsthm5sc?cid=45

Please make sure that different refernces are separated by an empty
line.

### Format of References

Although we use footnotes in markdown, we will use the propper IEEE
format style for citations. Please google it. The easiest way for you
to get IEEE references is to use jabref and manage your references there
and just copy the rendered content from jabrefs display window into
your markdown reference section. Make sure to remove all HTML tags.
If you use jabref, please submit your references as project.bib file

### URLs in the text

In case you use URLs in the text, they must be followed by a citation
with it being referenced in the reference section by a label.

### References that are not cited in the text

You must not have any references that you have not cited in the text

### Images that you copied

In case you copied an image from the internet, it must have a citation
in the caption and be referenced in the reference section.

If you use figures, check carefully with our template, do not invent
your own method. We will reject your paper without review if you do it
wrong.

### How to include images

We have provided a clear example. Do not invent your own method or use
relative links. Images must be cited with a link to the raw image in
GitHub. See our example!

## Programs

### Python

You are allowed to use python notebooks or python programs. All of
which must be checked into GitHub in your assigned repo. Sometimes notebooks have a cache
that is too big for GitHub, this you need to make sure to always clear
the cache before you check it into GitHub.

### Otherprogramming langauges

Use python.

### Data

Please add a "download" data function that downloads the data from the
source. Do not store the actual data in Github.
The download function must have a logic that does not download the
data when it is already downloaded. Python makes this easy with
`os.path` and `python requests`. We recommend you use python requests
and not `urllib`. You can share the download function openly with each
other.

In case of questions discuss on piazza.

See also:

* <https://piazza.com/class/kedccsbsthm5sc?cid=227>
* <https://piazza.com/class/kedccsbsthm5sc?cid=142>

### Images from Programs

You can create png files of graphics so you can include them in your
project.md. Make sure you add a save image function and do not just
create screenshots. Matplotlib and other graphics frameworks have an
API call for this.

There are many good and even specialized graphics libraries that you
can use, examples are

* matplotlib
* bokeh
* seaborn
* ...

See also: <https://piazza.com/class/kedccsbsthm5sc?cid=226>

### Bechmark

Your program must use cloudmesh benchmark. It includes a convenient
StopWatch and benchmark print function.

see: <https://piazza.com/class/kedccsbsthm5sc?cid=103>

## Template Links

Here are the relevant URLs to them, which you naturally can find from
our report web page. But as some of you have not visited the web page
at

* <https://cybertraining-dsc.github.io/report/>

* <https://cybertraining-dsc.github.io/report/fa20-523-312/project/project/>
* <https://raw.githubusercontent.com/cybertraining-dsc/fa20-523-312/main/project/project.md>

See that githib does not quite render it properly, but it will by ok
for a superficial view and editing.

* <https://github.com/cybertraining-dsc/fa20-523-312/blob/main/project/project.md>

Make sure to check your report at

* <https://cybertraining-dsc.github.io/report/>

which will be updated weekly


text:
---
layout: post
title: "Magnetic ground states and magnetodielectric effect in RCr(BO3)(2) (R =
   Y and Ho)"
urlLink: https://dx.doi.org/10.1103/PhysRevB.95.174410
categories: publications
---
By: Sinclair, Zhou, Lee *etal*.

**PHYSICAL REVIEW B**, Volume:95, Issue:17, Article Number:174410

filename: 2017-05-08-PHYSICAL REVIEW B.md

gha_language: HTML


text:
# Note-taker
![](https://img.shields.io/badge/license-MIT%20License-blue?style=flat-square)
## Description
CLI application that uses the inquirer npm package to prompt questions to the user about project information, then using that information a professional README file is generated.
Deployed at: Very good application is deployed at: https://notetaker-wgobrie1.herokuapp.com/notes.html

## Table of Contents
* [Installation](#installation)
* [Usage](#usage)
* [License](#license)
* [Questions](#questions)

## Installation
1. Just click the link, no worries about installing this one

OR

1. Download files or clone
2. Install dependancies
3. Deploy locally (on on heroku)

## Usage
Use deployed application, or locally deployed one

## License
This project is convered under the MIT License.

## Questions
For questions about this project, please see my GitHub at [Wgobrie1](https://github.com/Wgobrie1), or reach out by email at<EMAIL_ADDRESS>


text:
---
layout: default
---

# 1997-12-18 - Re: Can I do Pubkic Domain that -

## Header Data

From: "Bruce Balden"<EMAIL_ADDRESS>To: "Nobuki Nakatuji"<EMAIL_ADDRESS>Message Hash: 0f0324e4e1767a19c07dae0e74d2e34c3d617b8baa2b92c7ec77afbdb966125e

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1997-12-18 02:54:36 UTC

Raw Date: Thu, 18 Dec 1997 10:54:36 +0800

## Raw message

```
{% raw  %}From: "Bruce Balden"<EMAIL_ADDRESS>Date: Thu, 18 Dec 1997 10:54:36 +0800
To: "Nobuki Nakatuji"<EMAIL_ADDRESS>Subject: Re: Can I do Pubkic Domain that -
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Are you looking for access to the MISTY source code? It's still illegal to
export it pending an appeal to the U.S. Supreme Court. Even if that appeal
fails, Congress will likely pass amended laws and/or the NSA/Commerce Dept
will issue revised regulations on the same day that an unfavourable decision
is announced.

Those guys just never learn that not only is the barn door open, but that
contents were never theirs to begin with.

-----Original Message-----
From: Nobuki Nakatuji<EMAIL_ADDRESS>To<EMAIL_ADDRESS><EMAIL_ADDRESS>Date: Wednesday, December 17, 1997 6:22 PM
Subject: Can I do Pubkic Domain that -

>Can I do Pubkic Domain that I posted MISTY source code before?
>
>
>______________________________________________________
>Get Your Private, Free Email at http://www.hotmail.com

{% endraw %}
```

## Thread

+ Return to [December 1997](/archive/1997/12)

+ Return to "["Bruce Balden" <balden@mail.bc.rogers.wave.ca>](/authors/bruce_balden_balden_at_mail_bc_rogers_wave_ca_)"
+ Return to "[David Honig <honig@otc.net>](/authors/david_honig_honig_at_otc_net_)"
+ Return to<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)](/authors/dlv_at_bwalk_dm_com_dr_dimitri_vulis_kotm_)"
+ Return to "[Jon Galt <jongalt@everest.pinn.net>](/authors/jon_galt_jongalt_at_everest_pinn_net_)"
+ Return to "[Tim May <tcmay@got.net>](/authors/tim_may_tcmay_at_got_net_)"

+ 1997-12-18 (Thu, 18 Dec 1997 10:54:36 +0800) - Re: Can I do Pubkic Domain that - - _"Bruce Balden"<EMAIL_ADDRESS>  + 1997-12-18 (Thu, 18 Dec 1997 14:56:29 +0800) - [Re: Can I do Pubkic Domain that -](/archive/1997/12/4a37191bdbd8fbaf2aed6f840b828c1fe5ead828314145b3d7331ae494a2771a) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
  + 1997-12-18 (Fri, 19 Dec 1997 03:27:29 +0800) - [Re: Can I do Pubkic Domain that -](/archive/1997/12/8b749fd74a723f8fae64186f6e823d3300e8356ee326cba800dbc2a080ca5217) - _David Honig<EMAIL_ADDRESS>    + 1997-12-18 (Fri, 19 Dec 1997 06:28:55 +0800) - [Re: Can I do Pubkic Domain that -](/archive/1997/12/4501ae067c1cb8fc8234b265e32dd3c7640a5ae48f29fa72f243cf3040dfa3d2) - _David Honig<EMAIL_ADDRESS>      + 1997-12-19 (Sat, 20 Dec 1997 02:24:59 +0800) - [Re: Can I do Pubkic Domain that -](/archive/1997/12/868a106a671bdcbac8109e7157d15e053c80323d4c52515d5010f1c73e7075e7) - _David Honig<EMAIL_ADDRESS>      + 1997-12-22 (Tue, 23 Dec 1997 06:38:05 +0800) - [Re: Can I do Pubkic Domain that -](/archive/1997/12/9c99b64bcdc50bec56b9ddc62753427f6dc701f035dfac36797ed152c4af30dc) - _Jon Galt<EMAIL_ADDRESS>  + 1997-12-18 (Fri, 19 Dec 1997 05:07:15 +0800) - [Re: Can I do Pubkic Domain that -](/archive/1997/12/d95c78bea09793303a3ce73870970f47ce6195e01d0039107a77aad3f2f06388) - _Tim May<EMAIL_ADDRESS>    + 1997-12-19 (Fri, 19 Dec 1997 10:44:42 +0800) - [Re: Can I do Pubkic Domain that -](/archive/1997/12/22c6a02617d9cb90899b1d996355164b5c1b9abb8a9167614150801213432c61) - _Tim May<EMAIL_ADDRESS>


text:
Below is the same very, *very* simple reactive application written in both Kindred and Meteor, which I'd consider Kindred's most elegant rival (and primary inspiration).

The app behaves as follows:

- When users type input into a text box, the corresponding `keycode` of each key stroke is displayed next to it, and
- when users press a button, the number next to it (originally set to 0) is incremeneted.

In **Meteor**, the app is defined in two files, a template file and corresponding javascript:

*client/numbers.html*
```html
<body>
    {{> numbers}}
</body>

<template name="numbers">
    <span class="keycode">{{keycode}}</div>
    <input class="keycode" placeholder="Enter text" />
    <span class="num">{{num}}</div>
    <button class="increment">Increment</button>
</template>
```

*client/numbers.js*
```javascript
Session.setDefault('counter', 0);

Template.numbers.helpers({
    num: function () {
        return Session.get('counter');
    },
    keycode: function () {
        return Session.get('keycode');
    },
});

Template.numbers.events({
    'click button': function () {
        Session.set('counter', Session.get('counter') + 1);
    },
    'keydown input': function (e) {
        Session.set('keycode', e.keyCode);
    },
});
```

In **Kindred**, the same app can be written:

```javascript
var numbers = {
    keycode: null,
    keycode_input: {
        html: "input",
        attr: {
            placeholder: "Enter text",
        },
        onkeydown: function(e) {
            this.keycode = e.keyCode;
        },
    },
    num: 0,
    increment: {
        html: "button",
        innerHTML: "Increment",
        onclick: function() {
            this.num++;
        },
    },
};
Kindred.present(numbers, Kindred.root);
```

The result of `Kindred.present(numbers, document.getElementById("example2"))` is:

There are significant advantages to the Kindred framework:

- reduction of code size by ~⅓
- fewer concepts/APIs (no templates, no Session variable to trigger reactivity)
- simpler modularity through pure javascript
- objects & renderers more easily shared across projects

The advantages that show themselves in this trivial example only grow in more complex projects, where the consistency and maleability of the code base can greatly impact how long it takes to make changes.

[TODO: the state of objects should persist past page refreshes -- this will require hooking it up to peer-to-peer network.]


text:
  Sleek, intuitive, and powerful company for faster and easier software development.

  Explore More»

  Github
  ·
  LinkedIn
  ·
  Youtube
  ·
  Instagram

## Table of content

- [Details](#project-details)
- [Changelog](#changelog)
- [Code of conduct](#code-of-conduct)
- [Usage](#usage)
- [Commands](#commands)
- [Issues](#issues)
- [Copyright and license](#copyright-and-license)

## Project Details
- ID - X1
- Title - Integrity
- Started on - 09/04/2020

## Changelog
All the changes will be addressed in [CHANGELOG.md](https://github.com/koders-in/integrity/blob/master/CHANGELOG.md) file

## Code of conduct
- **Pitch in!**, and offer what help you can, as there is never enough time to do everything. If you noticed that something is lacking in the documentation, you're probably right, so do generate as much issues as possible.
- Assume good intentions. English is the language of the team except for some situations, but, it is not every user's native language. Try to avoid too much slang, abbreviations, or idiomatic expressions.
- Keep it civil, courteous and polite. No personal attacks.
- Don't waste people's time by generating unimportant issues.
- Please don't push files anywhere.
- For suggestions, please raise an issues.
- If you are a collaborator of this repository, please don't merge pull requests without confirmation from the owner.

## Usage
Use prefix `&` before using any commands.

### Commands
- ```version``` : Shows current version
- ```ping```: Checks online status
-  ```image _image_name_```: Fetches any random image on imagename
-  ```meme```: Fetches any random meme
- ```poll _subject_```: Put a poll on the subject among channel
- ```playmusic _url_```: Plays music in voice channel
- ```skipmusic ```: Skips music
- ```stopmusic```: Stops and bot leaves from voice channel

### Issues

You can find all our previous updates on changelog.
Have a bug or a feature request? Please first read the code of conduct and search for existing and closed issues. If your problem or idea is not addressed yet, [please open a new issue](https://github.com/koders-in/integrity/issues).

## Copyright and license

Code and documentation copyright 2017-2020 by the [koders](https://www.koders.in). Code released under the [MIT License](https://en.wikipedia.org/wiki/MIT_License).

 Made with ♡ by  Koders


text:
# Why use jsblocks?

<br />

## MV-ish

Model-View-Controller, Model-View-Collection, Model-View-ViewModel, Model-View-Whatever, Hierarchical Model-View-Controller or nothing at all - jsblocks has you covered.
A Model-View-Collection layer stands on top of the main DOM syncing core. This MVC layer is extremely powerful and enables easy creation of complex applications.
The MVC layer is also modular, so you could remove it if you don't need the extra functionality, making your code base lighter.

## Debugging experience

The debugging experience is a major factor that is often overlooked.
It brings an easier learning curve and faster development cycles.
This is why jsblocks concentrates a lot of effort in building a great debugging experience.
Let's take a look at an example of what jsblocks offers.

![debugging experience](/img/debugging.gif)

## Server-side rendering

Client-side frameworks suffer major drawbacks like:
 * Lack of SEO optimization because content is rendered on the client and search engines do not execute JavaScript
 * Slow performance because entire app logic is executed and rendered on the user machine on every page load
 * Laggy experience represented by the content changing between the page first loads and the time DOM is ready

There is a way to address all this issues by executing the entire client-side logic on the server.
This approach enables the content to be sent fully rendered from the server eliminating mentioned problems.
Also, jsblocks makes performance improvements so performance will no longer heavily depend on the user machine.

And it's super easy to setup:

```javascript
var blocks = require('blocks');
var server = blocks.server();
```

For detailed documentation on server-side rendering you could head up [here](../introduction/server-side-rendering.md).

## Fast

Performance is important. For a framework that manages your whole site, it's even more important.
And for data-heavy operations, it is absolutely essential. This is why jsblocks has an architecture designed with
performance in mind. We beat the competition and also provide server-side rendering.
We are fast now but we have even bigger plans for the future.

## Modular

jsblocks is made out of modules. Each module is independent and could be optionally removed from the framework.
You can decide your needs and preferences and optionally remove any unneeded modules.
Get your own custom jsblocks build containing only the modules you need [here](http://jsblocks.com/download#custom-build).

## Built-in utility library

Since a major part of our application logic is moved to the client, we need tools to handle complex data manipulations.
These tools should be intuitive and fast. The jsvalue module that is part of jsblocks achieves extremely high
performance by using advanced, dynamic code generation to create the fastest methods on the fly.

Let's look at an example that shows the power of the utility library:

```javascript
// returns true because the second condition is true
blocks
    .range(1, 100)
    .map(function (value) {
        return value * 2;
    })
    .filter(function (value) {
        return value % 2 == 0 && value < 50;
    })
    .contains(0)
    .or()
    .contains(22);
```

## Feature rich

 * Two-way data binding using observables that could be extended to bring any level of customization needed
 * Build in queries to work with the DOM while never actually touching it
 * Intuitive CSS3 Transitions & Animations and advanced, cross browser compatible JavaScript animations
 * Model-View-Controller architecture for building complex applications
 * Routing mechanism for single-page applications
 * Easy to setup connections to a service that automatically observes and changes via observables
 * Lazy loading of resources

## Forward thinking

We have a lot of things planned for the future, and the readers who are interested enough to read to the bottom
are a perfect audience.
 * Platform not just a framework - frameworks like Angular, Ember, React handle only the client-side of things.
 However we build complete solutions and there should be an easy(while optional) way to work with databases and services.
 * Virtual DOM - jsblocks architecture is build on top of a Virtual DOM and we want to share it with you.
 The final goal is cleaner way to work with the DOM while having better performance than directly touching the DOM.
 * jsvalue(utility library) as a separate library - the built-in utility library will be soon available as a separate project
 * Templating engine - it's also exciting to know that we are working on other interesting projects that aim to ease
 developers lives

repository: ch-wisdom/jsblocks-docs

repo_name: ch-wisdom/jsblocks-docs


text:
---
layout: post
title:  predicting brexit negotiations
date:   2016-10-05 10:30:00
---

**Update** [ Jan-2018 ]: Does Brexit end not with a bang but a whimper? [Simon Wren-Lewis](https://mainlymacro.blogspot.co.uk/2018/01/does-brexit-end-not-with-bang-but.html)

-----------------------
Thinking through the possible outcomes of the Brexit negotiations, and inspired by [this spatial model](https://medium.com/@chrishanretty/spatial-politics-and-brexit-negotiations-fc078bb709e7#.bz6e3hmb3), here’s my take:
The setup follows the article linked above:
>“I’m going to posit two dimensions to the negotiations: a freedom of movement dimension, and a single market access dimension.
The poles of these dimensions are relatively clear:
at one end of the freedom of movement dimension, you have current levels of freedom of movement; at the other end, you have no greater freedom of movement than that which exists between the UK and other third countries
at one end of the single market access dimension, you have current levels of access; at the other end, you have the panoply of tariff-and non-tariff barriers found in the WTO option.”

-----------------------
First, looking at the position for the UK…

![](https://cdn-images-1.medium.com/max/1600/1*YkL3xb6JiNopbql_1x5IYg.png){:height="70%" width="70%"}

**Hard Brexit point**  —-  trade on WTO terms and no freedom of movement.

**Soft Brexit point**  —-  the Norway model, full single market access and full freedom of movement.

**The UK ideal point**  —-  full single market access and no freedom of movement. This minimises the economic cost of leaving the single market and satisfies calls to limit immigration (arguably respecting the referendum)

**The UK indifference curve**  -—  “Points in the space which are equally far from this ideal point are equally (un)palatable to the UK. Points equally far from this ideal point can be joined by an indifference curve. I’ve drawn one such indifference curve in the plot.”

-----------------------
For the EU we see…

![](https://cdn-images-1.medium.com/max/1600/1*4Pbp1FhKsy4aw9fP5YgX0w.png){:height="70%" width="70%"}

**The EU ideal point**  -—  trade on WTO terms and full freedom of movement. Why? Because Brexit poses an existential threat to the EU, who can send a clear signal by making the cost to the UK severe.

**The EU indifference curve**

-----------------------
Putting the UK and EU indifference curves together gives us a line of possible solutions…

![](https://cdn-images-1.medium.com/max/1600/1*Ty6yFsgxDS459MSMzi8qzA.png){:height="70%" width="70%"}

(Keep in mind here, the closer the indifference curve is to the ideal point, the better the solution is. For example, blue curves closer to the bottom right are better for the EU)

The actual solution will be somewhere on the yellow segment of the possible solution line…

![](https://cdn-images-1.medium.com/max/1600/1*xA3yfEvmDkilfiT885Bf0Q.png){:height="70%" width="70%"}

This is because for solutions outside of the yellow segment, the UK or EU would be better off forcing a hard brexit, or acquiescing to a soft brexit.

-----------------------
Given that the EU holds the stronger negotiating position the likely outcome is shown by the yellow dot.

![](https://cdn-images-1.medium.com/max/1600/1*gZN8d3uQl6XLkWUBzEkwbQ.png){:height="70%" width="70%"}

This would mean:
- a big reduction in access to the single market, but not to WTO terms
- a milder reduction to freedom of movement, but tighter restrictions nonetheless

So… not great news for the UK. The economic impact is going to be severe, and restrictions to immigration more limited. Less of a “red, white, and blue” Brexit, and more of a black and blue Brexit.


text:
# email_reminders

The main idea is to search for things that need to remember, and send an email.

Below there is a config that search in a DB to send a remember about a payment that is an open state.

```
# boleto_reminder.ini

[db]
host: xxx.yyy.rds.amazonaws.com
name: dbname
user: username
password: password
port: 3306

[mandrill]
api_key: apikey
google_analytics_campaign<EMAIL_ADDRESS>google_analytics_domains:  www.example.com
reply_to<EMAIL_ADDRESS>website: www.example.com

[reminder]
action_name: Payment in open state
reminder_template_name: doc-reminder
summary_template_name: doc-reminder-summary
tables: orders o
fields: transaction_id, name, email, doc, guid as order_id
filter: (o.status = 'waiting_payment') and (datediff(now(),o.dt_created) >= 3) and (o.reminders <= 2) and (o.transaction_id <> 0)
attachment_url: https://www.example.com/preorder/pdfgenerator.php?doc=${doc}
send_resume_to<EMAIL_ADDRESS>update: update orders set reminders=reminders+1 where guid='${order_id}'
```


text:
# TopLog

### Description
 - When big and fancy loggers are not suitable for debugging there is TopLog.

### Key features
 - Header only
   - One file to include to start the fun
 - No third parties
 - No additional binaries
 - Out of the box ready
   - No need to recompile or start some install process.

### Work flow

1. Isolate peace of code where problem might be.

```c++
double process( double a, double b, double c )
 { // It is somewhere in this function.
  double s = 0;
  s += a*a;        //<< Might be here
  s += sqrt( b );   //<< Might be here
  s + = sin( c );  //<< Might be here
  return s;
 }

std::cout << process( 1, -2, 3 ) << std::endl;
```

2. Populate with TopLog macros
```c++
#include "TopLog.hpp"

double process( double a, double b, double c )
 {   TOPLOG_SCOPE;
  double s = 0;    TOPLOG_COMMENT("Initialization");
  s += a*a;        TOPLOG_VALUE(a);
  s += sqrt( b );   TOPLOG_VALUE(b);
  s += sin( c );  TOPLOG_VALUE(c);
  return s;
 }

std::cout << process( 1, -2, 3 ) << std::endl;
```

3. Fix the problem
```c++
#include "TopLog.hpp"

double process( double a, double b, double c )
 { TOPLOG_SCOPE;
  double s = 0;    TOPLOG_COMMENT("Initialization");
  s += a*a;        TOPLOG_VALUE(a);
  if( b < 0 )
   { TOPLOG_SCOPE;
    BIG_FANCY_LOGGER_MESSAGE("Second value is negative.")
    b = -b; TOPLOG_VALUE(b);
   }
  s += sqrt( b );   TOPLOG_VALUE(b);
  s += sin( c );  TOPLOG_VALUE(c);
  return s;
 }

std::cout << process( 1, -2, 3 ) << std::endl;
```

4. Remove TopLog!!!
```c++
double process( double a, double b, double c )
{
    double s = 0;
    s += a*a;
    if( b < 0 )
     {
      BIG_FANCY_LOGGER_MESSAGE("Second value is negative.")
      b = -b;
     }
    s += sqrt( b );
    s += sin( c );
    return s;
}
```

5. DONE!!!

### Install

 - Clone the project.
 - Take src\TopLog.hpp and put for you in some suitable place.
 - Use TopLog

repository: dmilos/TopLog

repo_name: dmilos/TopLog


text:
# Introduction to Time Series Classes

## Class List

{% set datetime_info = [
  [
	"javax.time.calendar.LocalDate",
	"com.opengamma.util.timeseries.localdate",
	"1 Day",
	"ArrayLocalDateDoubleTimeSeries",
	"ListLocalDateDoubleTimeSeries",
	"MapLocalDateDoubleTimeSeries"
  ],
  [
	"java.util.Date",
	"com.opengamma.util.timeseries.date",
	"1 Day",
	"ArrayDateDoubleTimeSeries",
	"ListDateDoubleTimeSeries",
	"MapDateDoubleTimeSeries"
  ],
  [
	"java.sql.Date",
	"com.opengamma.util.timeseries.sqldate",
	"1 Day",
	"ArraySQLDateDoubleTimeSeries",
	"ListSQLDateDoubleTimeSeries",
	"MapSQLDateDoubleTimeSeries"
  ],
  [
	"javax.time.calendar.ZonedDateTime",
	"com.opengamma.util.timeseries.zoneddatetime",
	"1 millisecond",
	"ArrayZonedDateTimeDoubleTimeSeries",
	"ListZonedDateTimeDoubleTimeSeries",
	"MapZonedDateTimeDoubleTimeSeries"
  ],
  [
	"java.util.Date",
	"com.opengamma.util.timeseries.datetime",
	"1 millisecond",
	"ArrayDateTimeDoubleTimeSeries",
	"ListDateTimeDoubleTimeSeries",
	"MapDateTimeDoubleTimeSeries"
  ],
  [
	"java.lang.Double",
	"com.opengamma.util.timeseries.yearoffset",
	"variable, but << 1 microsecond",
	"ArrayYearOffsetDoubleTimeSeries",
	"ListYearOffsetDoubleTimeSeries",
	"MapYearOffsetDoubleTimeSeries"
  ]
] %}

Java Date Type	OG Package	Accuracy	Array Storage	List Storage	Map Storage

{% for jdpn, ogpn, dur, array_cls, list_cls, map_cls in datetime_info %}

  {{ jdpn }}
  {{ ogpn }}
  {{ dur }}
  {{ array_cls }}
  {{ list_cls }}
  {{ map_cls }}
{% endfor %}

## Quick Start - Jython

{{ d['time-series.py|fn|idio|jythoni|pyg']['local-date-imports'] }}

To build up a time series of local dates:

{{ d['time-series.py|fn|idio|jythoni|pyg']['build-ts-up'] }}

To create a time series from an existing time series:

{{ d['time-series.py|fn|idio|jythoni|pyg']['ts-from-existing'] }}

Or an array:

{{ d['time-series.py|fn|idio|jythoni|pyg']['ts-from-arrays'] }}

## Quick Start - Java

{{ d['TimeSeriesExample.java|pyg'] }}

Here is output generated by running this Java example:

{{ d['TimeSeriesExample.java|java'] }}

## Guide

### Types of Value

The time series library splits into two primary classes of time series

Object time series - generic classes with efficient storage of the date/time of each data point, and an object reference for each value
Double time series - specifically designed to store double-precision floating point values as native types (as opposed to Double objects)

Both of these hierarchies implement the TimeSeries<DATE_TYPE, VALUE_TYPE> interface.

### Date Formats

For each type of type series there are a separate set of classes availble to support different underlying date formats.  The approach of the library is to always store date/times as either primitive integers (for dates) or longs (date/times), and to convert to/from richer types on the fly as necessary.  The underlying representations are referred to as FastTimeSeries and FastObjectTimeSeries and can directly, although their operation is totally transparent, and there are few reasons to access the primitive values.  The formats available for date (with one day resolution) encoding are:

DateTimeSeries (a java.util.Date to day resolution)
SQLDateTimeSeries (a java.sql.Date)
LocalDateTimeSeries (a JSR-310 LocalDate)

and for date/times (stored generally as 64-bit milliseconds since the epoch (1/1/1970)):

DateTimeTimeSeries (a java.util.Date to full resolution)
ZonedDateTimeTimeSeries (a JSR-310 ZonedDateTime)
DateOffsetTimeSeries (a special class where the date is represented as a double-precision floating point value for the number of years from a fixed date - this makes it extremely easy to perform certain cash-flow analytics)

### Storage Data Structure Choices

Just to make life more complicated there is a choice of how the series is stored:

A primitive array - these series are immutable
Use this when you have a fixed data set ready

A list - existing implementations use a high speed primitive arraylist implementation
Use this when you're building up a series in date order
This implements one of the Mutable*TimeSeries interfaces and can have items removed, added, etc.

A map, existing implementations use a high speed optimized map for primatives
Use this when you're creating non-linear distributions of data points as you go
This implements one of the Mutable*TimeSeries interfaces and can have items removed, added, etc.

### Conversions

All time series implementations have an almost exhaustive range of conversion methods to convert from one representation to another.  For example you could create a time series based on a java.sql.Date and convert it easily to a JSR-310 LocalDate series with no additional code.  Just use the .to*TimeSeries methods.  The only option not available is to convert to a series backed by a map directly, the methods only support conversion to a 'Mutable' time series of a particular type, which is always backed by a list.

### Operations

All operators are simply methods on the time series object.  Unary operators return objects of the same type as the operand (the object in question!).

{{ d['time-series.py|fn|idio|jythoni|pyg']['unary-ops'] }}

Time Series Ops

{{ d['time-series.py|fn|idio|jythoni|pyg']['sub-series'] }}

Summaries - returns aggregates or summaries of the values in the series

{{ d['time-series.py|fn|idio|jythoni|pyg']['summaries'] }}
{{ d['time-series.py|fn|idio|jythoni|pyg']['info'] }}

Binary operators return objects of the type of the object being invoked (the left hand side).  Operators will generally perform any necessary conversions internally to allow any reasonable series to be passed as a parameter.

There are three types of binary operator:

#### Scalar

Each element in the source series is operated on by the same scalar value.

{{ d['time-series.py|fn|idio|jythoni|pyg']['binary-ops-scalar'] }}

#### Standard

Takes the intersection of the dates in both series to populate the resultant time series.

{{ d['time-series.py|fn|idio|jythoni|pyg']['binary-ops'] }}

#### Union

Takes the union of the dates, and simply copies dates that are only in one series.

{{ d['time-series.py|fn|idio|jythoni|pyg']['union'] }}

### Methods

{{ d['time-series.py|fn|idio|jythoni|pyg']['methods-list'] }}


text:
# JFDI

_Adopting the JFDI mantra in your life._

A project by [Si](https://twitter.com/Si) following a talk on [Beating Imposter Syndrome](http://sijobling.com/talks/beating-imposter-syndrome-mkgn/) and a [productivity post on getting things done](https://superyesmore.com/jfdi-fe1a0c5a2c537cbc758c71f46c62bfb3).

Very early days but, in the true essence of JFDI, this is the first attempt at doing something and will be an iterative evolution.

If you'd like to contribute or find out more, reach out to [@Si on Twitter](https://twitter.com/Si) with hashtag `#JFDI`. (Previously, [@FFSJFDIUD](https://twitter.com/ffsjfdiud) was setup but it's a bit excessive on the expletives)

## Ideas

* Feed of #JFDI hashtag tweets, photos, videos…
* To-do app with a different approach to leaving things for later
* Content to motivate and inspire others to JFDI such as meme generators and GIFs (possible opportunity for using [jfdi.design](https://jfdi.design))
* Merchandise to promote JFDI (posters, t-shirts etc)

## JFDI.DESIGN

Need some way to generate GIF memes when people need to react to open opportunities for saying "JFDI".
Are there any open-source image generators that create animated GIFs we can use?
Where should this be hosted? Heroku, Digital Ocean, normal?
RESTful API would be ideal to allow integration with other apps (Slack, Twitter, FB etc…)
Slack shortcut `/JFDI` displays a GIF

repository: si/jfdi

repo_name: si/jfdi


text:
---
title: Before Spec API
---

The `before:spec` event fires before a spec file is run. The event only fires when running via `cypress run`.

# Syntax

{% partial code_runs_in_node %}

```js
on('before:spec', (spec) => { /* ... */ })
```

**{% fa fa-angle-right %} spec** ***(Object)***

Details of the spec file, including the following properties:

Property | Description
--- | ---
`name` | The base name of the spec file (e.g. `login_spec.js`)
`relative` | The path to the spec file, relative to the project root (e.g. `cypress/integration/login_spec.js`)
`absolute` | The absolute path to the spec file (e.g. `/Users/janelane/my-app/cypress/integration/login_spec.js`)

# Usage

You can return a promise from the `before:spec` event handler and it will be awaited before Cypress proceeds running the spec.

## Log the relative spec path to stdout before the spec is run

```javascript
module.exports = (on, config) => {
  on('before:spec', (spec) => {
    // spec will look something like this:
    // {
    //   name: 'login_spec.js',
    //   relative: 'cypress/integration/login_spec.js',
    //   absolute: '/Users/janelane/app/cypress/integration/login_spec.js',
    // }

    console.log('Running', spec.relative)
  })
}
```

# See also

- {% url "After Spec API" after-spec-api %}
- {% url "Before Run API" before-run-api %}
- {% url "After Run API" after-run-api %}
- {% url "Plugins Guide" plugins-guide %}
- {% url "Writing a Plugin" writing-a-plugin %}

repository: voyy/cypress-documentation

branch_name: refs/heads/develop

repo_name: voyy/cypress-documentation


text:
#Conditionals
Conditionals are a way to give your robot decision making abilities. We do this by
evaluating an expression to be either TRUE or FALSE.

In order to "evaluate" an expression, we need to know what "operators" are. Here's the
list we'll start with (Relational Operators):

Operator  |  Meaning          |   Example     | Result of Example
--------- | ----------------- | ------------- | -------------
==     |  Equal to         |  5 == 5  | this is true, because 5 is "equal to" 5
!=     |  Not Equal to     |  5 != 3  | this is also true, 5 does "not equal" 3
>      |  Greater than     |  5 > 3   | this is true, 5 is "greater than" 3
<      |  Less than        |  5 < 3   | this is NOT true, 5 is not "less than" 3
>=     |  Greater than or equal to  |  5 >= 5  | this is true, 5 is "equal to" 5
<=     |  Less than or equal to    |  5 <= 6  | this is true, 5 is "less than" 6

We'll start with an "if" conditional. "If" is a keyword that will help us to evaluate our
statement.  For example, when you play Simon Says, in your mind, you're making the decision
whether to carry out the command based on "if" the caller says "Simon Says" before they say
the command.  We would write that like this:

  	if (caller says "Simon Says")
  	{
      	do the command
  	}

So, we're "evaluating" the part in parentheses - we call this the "expression". If that is
true, then we continue inside the curly brackets. Otherwise, we skip what's in the curly
brackets and continue on after that.

The way we write this in actual code is:

    if (TRUE)
    {
        doThisCommand();
    }

or

    if ( 5 == 5 ) // which evaluates to TRUE
    {
        doThisCommand();
    }

The program in the `main.c` file will test some expressions and move the robot either
forward or backward. The robot will start behind the start line on Mat A. Read through the
code and try to predict which blocks will be executed and which will be ignored. Then,
determine if the robot will end up back in the starting box, or somewhere past the starting
line on the game board. _If you don't have the Jr. Botball game boards, you can just put the
robot down in front of a line and see if the robot ends up back on the same side of the line
that it started._

After running the program, take a look at the console on the robot. You'll see which blocks
were actually executed by reading the output on the console.

*Note:*

The code used in these tutorials is intended to run on the KIPR Link controller and written in
the KISS Platform. You can find information about the KIPR Link and KISS Platform at
http://www.kipr.org/hardware-software. The KISS Platform includes a simulator, so you can run
the code on your computer without a robot. Our Botball team currently participates in the Junior
Botball Challenge sponsored by KIPR. You can view more information for the challenge at
http://www.juniorbotballchallenge.org.

repository: newcastle-jr-botball/conditionals

repo_name: newcastle-jr-botball/conditionals


text:
---
title: Azure Data Migration Service - Prologue
tags:
    - technology
    - powershell
    - Azure
    - SQL
    - cloud
    - windows
comments: true
---

My company has been planning on shifting our production software service to a cloud service for quite some time, and the past two years we've been focused on getting our software to a point where we could perform a lift and shift of our data onto Azure. Initially our plan was to just move directly to VMs, but then Microsoft's Azure SQL platform became rather enticing. It was cost effective (cheaper than running VMs of similar size), and easier to manage with an environment to keep it secure.

This begs the following questions (which will be answered in a future blog post)

* How do we migrate to Azure at scale?
    * Data requirements are around 1.5 TB per environment, which we have 4 of.
* How do we keep downtime of our production SaaS environment to a minimum?
    * Unfortunately software isn't in a place where we can do independent migration of customers to new locations. Thats on the todo.

There will be a series of posts in the very near future about how we addressed these problems and more. As of writing this post, the project is still in progress, but in terms of automation code, its complete and initial testing of our staging environment has gone smoothly.

gha_language: SCSS


text:
---
slug: /events/beyond-uiux
name: Beyond UI/UX
date: 2023-06-26
location: 1st floor Seminar Hall
cover: './cover.jpg'
link: https://forms.gle/PkCUKLGB873ia2jw8
feedback_link:
---

## Beyond UI/UX

Are you fascinated by the world of UI/UX design and eager to learn how to create captivating user experiences? 👀

What if we tell you that you can unlock the secrets of UI/UX design all by yourself!✨

To delve deeper into this exciting field, join us for an immersive workshop on the UI/UX experience, conducted by the DESIGN TEAM at SOSC!🙌🏻

### Date and Time: 26th June 2023, 3:30 PM

## Speakers

- [Zeliq Zayyan](https://www.linkedin.com/in/zeliq-zayyan-14b313193/), Design Lead - SOSC
- [Toshan SM](https://www.linkedin.com/in/toshan-sm-2b72891b9/), Design co-lead - SOSC

## Prerequisite

- A laptop
- Mouse is recommended

## Post Event Report

The UI/UX workshop was an engaging and interactive session that provided participants with a comprehensive understanding of UI and UX design principles. They learned about user research, wireframing, prototyping, and usability testing. Through practical exercises, participants gained hands-on experience in creating wireframes and prototypes using industry-standard tools. They explored design principles such as typography, color theory, and layout, as well as interaction design and user flow. The workshop emphasized the iterative nature of UI/UX design and the importance of user feedback. By the end, participants had a solid foundation in UI/UX design principles and practical skills to create visually appealing and user-friendly digital experiences, equipped with industry-standard design tools and techniques.

In summary, the UI/UX workshop provided an immersive learning experience, empowering participants to enhance their UI/UX design skills. They learned to create intuitive and visually appealing user experiences through user-centric design, wireframing, prototyping, and usability testing. The workshop fostered a creative and collaborative environment, enabling participants to develop their design thinking and problem-solving abilities in the field of UI/UX design.

### Media

repository: so-sc/sosc-website

repo_name: so-sc/sosc-website


text:
Naming conventions code review:
=========================================

__Root Module structure:__
* Util - contains code that could belong to/become separate libraries
* Routing - internal hash url-fragment routing as a visual component
* Reuse - component logic that makes coding each CRUD component easy
* Thing - CRUD component for 'Thing' entity (implemented on top or Reuse)
* App - bring everything together

__Leaf Module conventions:__
* Follows loosely the common View/Model/Message/Main separation, uses Logic.elm instead of more common Update.elm
* Logic module typically contains update function and often combines Model/Message if these are small
* Thing.<\*>.<\*>Main.elm modules have main methods for developing and testing sub-components (read, list, edit) in isolation.  The 'real' main is in App.Main module.

__.servant, .handcoded, .reactor, .deploy source files:__
* There are 3 versions of Thing.Model and Thing.Http modules.
You can switch parts of Elm code between Servant generated Elm code (sh use_servant.sh) or 'hand-coded' model, http and JSON parsing code (sh use_handcoded.sh).  The source code defaults to Servant generated.

* There are 3 versions of StaticConfig: StaticConfig.elm, StaticConfig.reactor, and StaticConfig.deploy.
StaticConfig.elm defaults to (is the same as) StaticConfig.reactor.  During deployment to server this code is temporarily replaced with
StaticConfig.deploy. (see [elm_deploy_to_yesod](elm_deploy_to_yesod.sh) and [elm_deploy_to_servant](elm_deploy_to_servant.sh) files).

[back to Project](https://github.com/rpeszek/crud-ex-frontend-elm.git)

repository: rpeszek/crud-ex-frontend-elm

repo_name: rpeszek/crud-ex-frontend-elm


text:
# Music App Design

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
[![Platform](https://img.shields.io/badge/platform-android-green.svg)](http://developer.android.com/index.html)
[![API](https://img.shields.io/badge/API-16%2B-brightgreen.svg?style=flat)](https://android-arsenal.com/api?level=16)

Introduction
-----

This project was made to try the following technologies and features:

* [Shared Transition]
* [LottieAnimation](https://airbnb.design/lottie/)
* [ConstraintLayout](#documentation)
* [MotionLayout](#min-sdk)
* [githubActions]

Created this cool design from [Appetiser Apps](https://www.uplabs.com/appetiser) as an android application.

  <img alt="Design on Uplabs" src="/images/preview.png" width="500" height="400" />

LICENCE
-----

LightProgress by [Mejdi Hafiane] is licensed under an [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0).


text:
# Hands---Gesture---Recognition

DEMO :: https://youtu.be/yq6pG16Ycx4

Project Overview

Hand gesture recognition system is used for interfacing between computer and human
using hand gesture. We are going to implement a system that recognizes Gesture input
using webcam & performs the Specified Operation.

Problem and Solution Statement

This is very useful for a hands-free approach. It is useful in media player. A simple gesture
could pause or play the movie or increase the volume even while sitting afar from the
computer screen.

Benchmark (How this solution is better?)

It follows hand free approach. So, one can easily control this from long distance.

Implementation strategy

We are going to implement a system that recognizes Gesture input using webcam &
performs the Specified Operation. For taking input from webcam we use OPENCV in
python. Then we are going to implement neural network in python for recognizing the web-
Cam input and initialize some specific task to this input.


text:
# sshd

Ansible role to install and configure sshd

## Installation

```yaml
   ansible-galaxy install zerodowntime.awk
   ansible-galaxy install zerodowntime.selinux_python
   ansible-galaxy install zerodowntime.sshd
```

## Requirements

This role requires Ansible 2.7 or higher.

Supported platforms:

```yaml
  platforms:
    - name: EL
      versions:
        - 7
    - name: Ubuntu
      versions:
      - bionic
      - xenial
```

## Default role variables

| Variable name                         | Required? |  Type  | Description                                                                                |
|:------------------------------------- |:---------:|:------:|:-------------------------------------------------------------------------------------------------------------------- |
| sshd__package_state                   |    yes    | string | installed packages state                                                                                |
| sshd__port                            |    yes    |  int   | Specifies the port number that sshd listens on                                                                       |
| sshd__address_family                  |    yes    | string | Specifies which address family should be used by sshd                                                                |
| sshd__listen_address                  |    yes    |  list  | Specifies the local addresses sshd should listen on.                                                                 |
| sshd__hostkey                         |    yes    |  list  | Specifies a file containing a private host key used by SSH                                                           |
| sshd__permit_root_login               |    yes    | string | Specifies whether root can log in using ssh.                                                                         |
| sshd__password_authentication         |    yes    |  bool  | Specifies whether password authentication is allowed                                                                 |
| sshd__syslogfacility                  |    yes    | string | Gives the facility code that is used when logging messages                                                           |
| sshd__loglevel                        |    yes    | string | Gives the verbosity level that is used when logging messages                                                         |
| sshd__usedns                          |    yes    |  bool  | Specifies whether sshd should look up the remote host                                                                |
| sshd__x11forwarding                   |    yes    |  bool  | Specifies whether X11 forwarding is permitted.                                                                       |
| sshd__authorizedkeysfile              |    yes    | string | Specifies the file that contains the public keys that can be used for user authentication                            |
| sshd__printlastlog                    |    no     |  bool  | Specifies whether sshd should print the date and time                                                                |
| sshd__kexalgorithms                   |    yes    |  list  | Specifies the available Key Exchange algorithms                                                                      |
| sshd__ciphers                         |    yes    |  list  | Specifies the ciphers allowed for protocol version 2.                                                                |
| sshd__macs                            |    yes    |  list  | Specifies the available MAC (message authentication code) algorithms.                                                |
| sshd__authenticationmethods           |    yes    | string | Specifies the authentication methods that must be successfully completed for a user to be granted access             |
| sshd__subsystem_sftp_options          |    no     | string | Specifies Subsystem sftp options                                                                                |
| sshd__acceptenv                       |    no     |  list  | Specifies which environment variables sent by the client will be copied to the sessions user environment.            |
| sshd__maxauthtries                    |    yes    |  int   | Specifies the maximum number of authentication attempts permitted per connection.                                    |
| sshd__maxsessions                     |    yes    |  int   | Specifies the maximum number of open shell ...                                                                       |
| sshd__pubkeyauthentication            |    yes    |  bool  | Specifies whether public key authentication is allowed                                                               |
| sshd__allowagentforwarding            |    no     |  bool  | Specifies whether ssh-agent(1) forwarding is permitted                                                               |
| sshd__printmotd                       |    yes    |  bool  | Specifies whether sshd(8) should print /etc/motd when a user logs                                                    |
| sshd__allowtcpforwarding              |    no     |  bool  | Specifies whether TCP forwarding is permitted.                                                                       |
| sshd__permittunnel                    |    yes    |  bool  | Specifies whether tun(4) device forwarding	is allowed.                                                               |
| sshd__clientaliveinterval             |    yes    |  int   | Sets a timeout interval in	seconds	after which if no data has been received from	the client                          |
| sshd__clientalivecountmax             |    yes    |  int   | Sets the number of client alive messages which may	be sent	with out sshd receiving any messages back from the client |
| sshd__gssapiauthentication            |    yes    |  bool  | Specifies whether user authentication based on GSSAPI is allowed.                                                    |
| sshd__denyusers                       |    no     |  list  | list of deny user name patterns                                                                                |
| sshd__allowusers                      |    no     |  list  | list of allowed user name patterns                                                                                |
| sshd__denygroups                      |    no     |  list  | list of deny groups name patterns                                                                                |
| sshd__allowgroups                     |    no     |  list  | list of allow groups name patterns                                                                                |
| sshd__logingracetime                  |    yes    | string | The server	disconnects after this time if the user	has not	successfully logged in                                    |
| sshd__challengeresponseauthentication |    yes    |  bool  | Specifies whether challenge-response authentication is allowed                                                       |

**All variables are described in [defaults/main.yml](defaults/main.yml) file.**

## Static role variables

| Variable name                |  Type  | Description                             |
|:---------------------------- |:------:|:--------------------------------------- |
| sshd__config                 | string | sshd config path                        |
| sshd__service_name           | string | sshd service name                       |
| sshd__moduli_file            | string | sshd moduli file path                   |
| sshd__moduli_min             |  int   | Remove small Diffie-Hellman moduli size |
| sshd__packages               |  list  | installed packages names                |
| sshd__default_syslogfacility | string | Default syslog facility                 |
| sshd__subsystem_sftp         | string | Default subsystem sftp                  |

**All static variables are described in [vars/main.yml](vars/main.yml) file.**

## Example Playbook

```yaml
    - hosts: all
      become: true
      roles:
        - role: zerodowntime.sshd
```

## License

[Apache License 2.0](LICENSE)

## Support

<EMAIL_ADDRESS>

repository: zerodowntime/ansible-role-sshd

repo_name: zerodowntime/ansible-role-sshd


text:
# nf-core/configs: MUNIN Configuration

All nf-core pipelines have been successfully configured for use on the MUNIN cluster.

## Usage

To use, run the pipeline with `-profile munin`.

This will download and launch the [`munin.config`](../conf/munin.config) which has been pre-configured with a setup suitable for the MUNIN cluster.

Example: `nextflow run -profile munin`

### Singularity

This is the default behavior of this configuration profile.

Using this profile, if no singularity image are available, one will be downloaded from dockerhub, and converted to a Singularity image before execution of the pipeline.

It is also possible to specify the singularity profile:

Example: `nextflow run -profile munin,singularity`

### Docker

It is also possible to execute the pipeline using Docker.

Using this profile, if no docker image are available, one will be downloaded from dockerhub before execution of the pipeline.

Example: `nextflow run -profile munin,docker`

## Below are non-mandatory information on iGenomes specific configuration

A local copy of the iGenomes resource has been made available on the MUNIN cluster so you should be able to run the pipeline against any reference available in the `igenomes.config` specific to the nf-core pipeline.
You can do this by simply using the `--genome <GENOME_ID>` parameter.

> NB: You will need an account to use the MUNIN cluster in order to run the pipeline. If in doubt contact @szilva.

repository: nf-core/configs

gha_language: Nextflow

repo_name: nf-core/configs


text:
better-pull-requests
====================

⚠ ⚠ ⚠

_This was an experiment from 2014, back when GitHub's code review tools were much sparser (i.e. no support for two-column diffs or multi-comment reviews). This ultimately led to my discovering [Reviewable](https://reviewable.io/), a hosted "better pull requests" which I highly recommend, and [webdiff](https://github.com/danvk/webdiff), a web-based `git diff` that I use every day._

⚠ ⚠ ⚠

----

An improved UI for github pull requests

The key features this adds on top of github's standard Pull Request UI are:

1. Two-column diff with expandable context
2. Diffs between arbitrary commits in a pull request
3. Draft comments which can be reviewed and published in batches

It also includes nice to haves like syntax coloring and keyboard shortcuts.

This tool is implemented using the github API and is designed to interoperate
with the code review tools on github.com. It's possible to do a code review
where one of the parties uses github's tools and the other does not. This also
lets you continue to use other tools built around github's Pull Requests, e.g.
Jenkins.

Setting Up
==========

    virtualenv env                   # make a new virtualenv named 'env'.
    source env/bin/activate          # activate the env (local pip, python).
    pip install -r requirements.txt  # install the requirements in the env.
    cp config.template app.cfg
    $EDITOR app.cfg                  # See notes below
    export BETTER_PR_CONFIG=app.cfg
    python app.py

Now visit http://localhost:5000/ and OAuth into your app.

Then visit ```http://localhost:5000/:owner/:repo/pulls``` to view open pull
requests for any github repo. For example, you can visit
http://localhost:5000/danvk/test-repo/pulls to see pull requests in my test repo.

Getting a github client secret
==============================

OAuthing into github is essential for this server, so it requires you to set up
an app on github before you run. This is easy to do! Just go
[here](https://github.com/settings/applications/new) and fill out the form on
github. Request the ```repo``` and ```user``` scopes and set the callback URL to
```http://localhost:5000/oauth_callback```. The other fields can be anything you
like.

Once you've registered your app, you need to put its ID and secret into a
configuration. The provided config.template file shows you what this should
look like.

Testing
=======

To check for silly errors and run the unit tests:

    pylint -E *.py
    python *_test.py

gitcritic also has a simple golden screenshot test. To use it, install casperjs
(e.g. "brew install casperjs" on Mac OS X) and run:

    export BETTER_PR_CONFIG=testing.config; python app.py
    casperjs test pdiff-tests/*.js

repository: danvk/better-pull-requests

repo_name: danvk/better-pull-requests


text:
It uses regular expressions to take piped data
and convert substrings that look like Unix time into human-readable timestamps.

This is for those of us who have Unix time logs and want to see when events occurred as lazily as possible.

## Installation

```
git clone https://github.com/ajduberstein/shut.git
cd shut
python setup.py install
```

## Usage

```
echo '{"ts":<PHONE_NUMBER>, "level": "ERROR", "msg": "A mistake at some time"}' | shut
# {"ts": "2015-08-31 05:36:27", "level": "ERROR", "msg": "A mistake at some time"}
```

Since Unix time could in theory be between negative and positive infinity, you may choose to provide a reasonable range
for timestamps. The default is to parse a string for numbers greater than a year ago and less than a year from today.

```
echo '{"ts": 584928000, "level": "INFO", "msg": "Die Hard release date"}' | shut --min-date 1988-01-01
# {"ts": "1988-07-15 00:00:00", "level": "ERROR", "msg": "A mistake at some time"}
```

Feel free to feed Unix times as args as well:

```
echo '{"ts": 584928000, "level": "INFO", "msg": "Die Hard release date"}' | shut --min-date 567993600
# {"release_date": "1988-07-15 00:00:00", "msg": "Die Hard release date"}
```

I can't think of why a max range would be useful, but perhaps you can:

```
echo '{"ts": 584928000, "level": "INFO", "msg": "Die Hard release date"}' | shut --min-date 1988-01-01
# {"release_date": "1988-07-15 00:00:00", "msg": "The Die Hard franchise has grossed $2015-06-23 19:06:02.00 globally"}
echo '{"ts": 584928000, "level": "INFO", "msg": "Die Hard release date"}' | shut --min-date 1988-01-01 --max-date 2013-02-14
# {"release_date": "1988-07-15 00:00:00", "msg": "The Die Hard franchise has grossed $1435086362.00 globally"}
```

repository: ajduberstein/shut

repo_name: ajduberstein/shut


text:
@parent bit-docs-process-tags/types/tag
@typedef {Boolean=false} bit-docs-process-tags/types/tag.keepStack Tag.keepStack

@description Don't pop the stack when `true`. Useful for implementing opening
and closing [bit-docs-process-tags/types/tag]s.

@body

## Use

Set to `true` for tags like [bit-docs-js/tags/codestart] and
[bit-docs-js/tags/codeend].

repository: bit-docs/bit-docs-process-tags

repo_name: bit-docs/bit-docs-process-tags