text:
# **Traffic Sign Recognition**

## Writeup

**Build a Traffic Sign Recognition Project**

The goals / steps of this project are the following:
* Load the data set (see below for links to the project data set)
* Explore, summarize and visualize the data set
* Design, train and test a model architecture
* Use the model to make predictions on new images
* Analyze the softmax probabilities of the new images
* Summarize the results with a written report

[//]: # (Image References)

[image1]: ./examples/hist_train.png "Visualization-train"
[image2]: ./examples/hist_test.png "Visualization-test"
[image3]: ./examples/hist_valid.png "Visualization-valid"
[image4]: ./test_images/17.jpg "Traffic Sign 1"
[image5]: ./test_images/14.jpg "Traffic Sign 2"
[image6]: ./test_images/25.jpg "Traffic Sign 3"
[image7]: ./test_images/02.jpg "Traffic Sign 4"
[image8]: ./test_images/22.jpg "Traffic Sign 5"
[image9]: ./examples/sample_images.PNG "Visualization-sample images"

## Rubric Points
### Here I will consider the [rubric points](https://review.udacity.com/#!/rubrics/481/view) individually and describe how I addressed each point in my implementation.

---
### Writeup / README

#### 1. Provide a Writeup / README that includes all the rubric points and how you addressed each one. You can submit your writeup as markdown or pdf. You can use this template as a guide for writing the report. The submission includes the project code.

You're reading it! and here is a link to my [project code](https://github.com/thayumaanavan/CarND-Traffic-Sign-Classifier-Project/blob/master/Traffic_Sign_Classifier.ipynb)

### Data Set Summary & Exploration

#### 1. Provide a basic summary of the data set. In the code, the analysis should be done using python, numpy and/or pandas methods rather than hardcoding results manually.

I used the numpy library to calculate summary statistics of the traffic
signs data set:

* The size of training set is 34799
* The size of the validation set is 4410
* The size of test set is 12630
* The shape of a traffic sign image is (32, 32, 3)
* The number of unique classes/labels in the data set is 43

#### 2. Include an exploratory visualization of the dataset.

Here is an exploratory visualization of the data set.  As per below charts, the amount of examples per class in every dataset show similar shapes and regardless from not having an uniform distributions, the amount of examples per class in the training set is proportional to the same class in validation and test datasets per class.

Training                   |  Validation               |  Testing
:-------------------------:|:-------------------------:|:-------------------------:
![][image1]                |  ![][image2]              |  ![][image3]

The images come in RGB format and are already contained in numpy arrays and the labels come as a list of integers.

*Image data shape = (32, 32, 3)
*Number of classes = 43

Every image has a corresponding label and these labels correspond to a category of traffic signal. These categories can be seen in the file signnames.csv.

![][image9]

### Design and Test a Model Architecture

#### 1. Describe how you preprocessed the image data. What techniques were chosen and why did you choose these techniques? Consider including images showing the output of each preprocessing technique. Pre-processing refers to techniques such as converting to grayscale, normalization, etc. (OPTIONAL: As described in the "Stand Out Suggestions" part of the rubric, if you generated additional data for training, describe why you decided to generate additional data, how you generated the data, and provide example images of the additional data. Then describe the characteristics of the augmented training set like number of images in the set, number of images for each class, etc.)

The pre-processing pipeline consists in three different steps.

* Grayscale: The RGB channels disappear and only one channel corresponding to intensities remain.This allows to reduce the numbers of channels in the input of the network without decreasing the performance. In fact, as Pierre Sermanet and Yann LeCun mentioned in their paper ["Traffic Sign Recognition with Multi-Scale Convolutional Networks"](http://yann.lecun.com/exdb/publis/pdf/sermanet-ijcnn-11.pdf), using color channels did not seem to improve the classification accuracy.
```
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
```
* Histogram equalization: The contrast of the image is enhanced obtaining a more uniform histogram.
```
gray_equalized = cv2.equalizeHist(gray)
```
* Normalization: The values of the intensity image no longer go from 0 to 255, but they range now from -1 to 1 in floating point format. Still using Matplotlib visualization the image looks identical to equalized one.
```
norm_image = (gray_equalized - 128.0)/ 128.0
```

#### 2. Describe what your final model architecture looks like including model type, layers, layer sizes, connectivity, etc.) Consider including a diagram and/or table describing the final model.

My final model consisted of the following layers:

| Layer         		|     Description	        					|
|:---------------------:|:---------------------------------------------:|
| Input         		| 32x32x1 Grayscale image   							|
| Convolution 3x3     	| 1x1 stride, valid padding, outputs 28x28x6 	|
| RELU					|												|
| Max pooling	      	| 2x2 stride,  outputs 14x14x6 				|
| Convolution 3x3     	| 1x1 stride, valid padding, outputs 10x10x16 	|
| RELU					|												|
| Max pooling	      	| 2x2 stride,  outputs 5x5x16 				|
| Flatten  | outputs 400 |
| Fully connected		| Input = 400 and Output = 120        							|
| RELU					|												|
| Fully connected		| Input = 120 and Output = 84        							|
| RELU					|												|
| Fully connected		| Input = 84 and Output = 43 |

#### 3. Describe how you trained your model. The discussion can include the type of optimizer, the batch size, number of epochs and any hyperparameters such as learning rate.

To train the model, I used below parameter values.
* Optimizer: AdamOptimizer
* batch size : 128
* epochs : 50
* Learning Rate : 0.0009

#### 4. Describe the approach taken for finding a solution and getting the validation set accuracy to be at least 0.93. Include in the discussion the results on the training, validation and test sets and where in the code these were calculated. Your approach may have been an iterative process, in which case, outline the steps you took to get to the final solution and why you chose those steps. Perhaps your solution involved an already well known implementation or architecture. In this case, discuss why you think the architecture is suitable for the current problem.

My final model results were:
* validation set accuracy of 0.946 (94.6%)
* test set accuracy of 0.931(93.1%)

I used the same [LeNet architecture](http://yann.lecun.com/exdb/lenet/) and preprocessing codes used in the LeNet lab class. But not able to get beyond 89%.
Then I improved the preprocessing steps followed in the paper
["Traffic Sign Recognition with Multi-Scale Convolutional Networks"](http://yann.lecun.com/exdb/publis/pdf/sermanet-ijcnn-11.pdf) and also added histogram equalization.
Also, I have tweaked the learning rate(to 0.0009) and epoch (to 50).
After this change, I was able to improve the accuracy of the model as mentioned above.

### Test a Model on New Images

#### 1. Choose five German traffic signs found on the web and provide them in the report. For each image, discuss what quality or qualities might be difficult to classify.

Here are five German traffic signs that I found on the web:

Test 1                     |  Test 2                   |  Test 3
:-------------------------:|:-------------------------:|:-------------------------:
![][image4]               |  ![][image5]             |  ![][image6]

Test 4                     |  Test 5
:-------------------------:|:-------------------------:
![][image7]               |  ![][image8]

Below are the qualities of test images which might be difficult to classify:
The images might be difficult to classify because they are in different size, with water mark and clear shape with no shadow.
* Test 1 & 4 have watermarks.
* Test 3 is tilted slightly which may cause difficulty for the model.
* Test 5 has leaves in some part of the shape and also shadow falling on it.

#### 2. Discuss the model's predictions on these new traffic signs and compare the results to predicting on the test set. At a minimum, discuss what the predictions were, the accuracy on these new predictions, and compare the accuracy to the accuracy on the test set (OPTIONAL: Discuss the results in more detail as described in the "Stand Out Suggestions" part of the rubric).

Here are the results of the prediction:

| Image			        |     Prediction	        					|
|:---------------------:|:---------------------------------------------:|
| 17      		        | 17  									        |
| 14     			    | 14							    |
| 25					| 25				|
| 2	      		    | 1		 				        |
| 22			        | 25      							            |

The model was able to correctly guess 3 of the 5 traffic signs, which gives an accuracy of 60%.

#### 3. Describe how certain the model is when predicting on each of the five new images by looking at the softmax probabilities for each prediction. Provide the top 5 softmax probabilities for each image along with the sign type of each probability. (OPTIONAL: as described in the "Stand Out Suggestions" part of the rubric, visualizations can also be provided such as bar charts)

These are the top 5 probabilities
```[[  1.00000000e+00   1.19873390e-13   7.82299354e-16   1.72693960e-18
    1.31664106e-18]
 [  9.98637855e-01   8.75854457e-04   3.48322385e-04   4.75172637e-05
    4.59054681e-05]
 [  1.00000000e+00   3.83663325e-18   1.29936029e-21   9.04603366e-25
    2.77326640e-25]
 [  9.99998093e-01   1.87811895e-06   6.92120250e-11   2.86236353e-14
    4.05694689e-15]
 [  9.99978423e-01   1.95940811e-05   1.22328186e-06   8.53118195e-07
    5.78888670e-09]]
 ```

 These are corresponding classes of probabilities
 ```
 [[17 26  0 13 40]
 [14 38  3  8 26]
 [25 22 36  5 38]
 [ 1  6  0 10  5]
 [25 29 22 31 18]]
 ```

* Correct class: 17, 5 most probable classes: [17 26  0 13 40]
* Correct class: 14, 5 most probable classes: [14 38  3  8 26]
* Correct class: 25, 5 most probable classes: [25 22 36  5 38]
* Correct class: 2, 5 most probable classes: [ 1  6  0 10  5]
* Correct class: 22, 5 most probable classes: [25 29 22 31 18]

For class 2 image, it's value is not found in the top 5 probable class itself. For class 22, it's value is found in 3rd place.


text:
# Quick Start

A no frills, no fuss, introduction the "core" APIs of Easy Peasy. Perfect for
the newcomer.

- [Create the store](#create-the-store)
- [Binding the store to your React app](#binding-the-store-to-your-react-app)
- [Using state in your components](#using-state-in-your-components)
- [Defining actions to perform state updates](#defining-actions-to-perform-state-updates)
- [Dispatching actions](#dispatching-actions)
- [Encapsulating side effects via thunks](#encapsulating-side-effects-via-thunks)
- [Dispatching thunks within your components](#dispatching-thunks-within-your-components)
- [Deriving state via computed properties](#deriving-state-via-computed-properties)
- [Using computed properties](#using-computed-properties)
- [Persisting state](#persisting-state)

## Create the store

Define your store by providing a plain old JavaScript object based model to the
[createStore](/docs/api/create-store.html) function.

```javascript
import { createStore } from 'easy-peasy';

const store = createStore({
  todos: [],
});
```

> Note: Your model can be as complex/nested as you like. Feel free to compose it
> from imports as your state structure scales in complexity.

## Binding the store to your React app

Surround your application with the
[StoreProvider](/docs/api/store-provider.html) component, providing it your
[store](/docs/api/store.html) instance.

```javascript
import { StoreProvider } from 'easy-peasy';
import { store } from './store';

ReactDOM.render(
  <StoreProvider store={store}>
    <App />
  </StoreProvider>,
  rootEl,
);
```

## Using state in your components

The [useStoreState](/docs/api/use-store-state.html) hook allows you to access
your store's state.

```javascript
import { useStoreState } from 'easy-peasy';

function Todos() {
  const todos = useStoreState((state) => state.todos);
  return (
    <ul>
      {todos.map((todo) => (
        <li>{todo.text}</li>
      ))}
    </ul>
  );
}
```

## Defining actions to perform state updates

Place an [action](/docs/api/action.html) within your model to support updates.

```javascript
import { createStore, action } from 'easy-peasy';

const store = createStore({
  todos: [],
  addTodo: action((state, payload) => {
    state.todos.push({ text: payload, done: false });
  }),
});
```

The [action](/docs/api/action.html) will receive the state which is local to it.
Update the state by directly mutating the `state` argument.

> Don't worry, under the hood we will convert the operation into an immutable
> update against your store by using [Immer](https://github.com/immerjs/immer).

## Dispatching actions

The [useStoreActions](/docs/api/use-store-actions.html) hook allows you to
access [actions](/docs/api/action.html) from your components.

```javascript
import { useStoreActions } from 'easy-peasy';

function AddTodoForm() {
  const addTodo = useStoreActions((actions) => actions.addTodo);
  const [value, setValue] = React.useState('');
  return (
    <>
      <input onChange={(e) => setValue(e.target.value)} value={value} />
      <button onClick={() => addTodo(value)}>Add Todo</button>
    </>
  );
}
```

In this example, we resolve the `addTodo` action, and bind it to the click of
the "Add Todo" button. When the button is clicked it will dispatch the `addTodo`
action, providing the text of the new todo item as the payload.

## Encapsulating side effects via thunks

[Thunks](/docs/api/thunk.html) provide us with the capability to encapsulate
side effects, whilst also having the ability to dispatch actions in order to
update our state accordingly.

```javascript
import { action, thunk } from 'easy-peasy';

const model = {
  todos: [],
  addTodo: action((state, payload) => {
    state.todos.push(payload);
  }),
  saveTodo: thunk(async (actions, payload) => {
    const { data } = await axios.post('/todos', payload);
    actions.addTodo(data);
  }),
};
```

Within our thunk we execute an API request. We subsequently utilize the returned
data, dispatching the `addTodo` action to update our state.

## Dispatching thunks within your components

Thunks are accessible in exactly the same manner as actions, i.e. via the
[useStoreActions](/docs/api/use-store-actions.html) hook.

```javascript
import { useStoreActions } from 'easy-peasy';

function AddTodoForm() {
  const saveTodo = useStoreActions((actions) => actions.saveTodo);
  const [value, setValue] = React.useState('');
  return (
    <>
      <input onChange={(e) => setValue(e.target.value)} value={value} />
      <button onClick={() => saveTodo(value)}>Add Todo</button>
    </>
  );
}
```

## Deriving state via computed properties

It is a common requirement within state management to need derived state. A
basket component might need to derive the total price. A paging component may
need the total number of items. There are many cases that can appear as your
application evolves.

You can create derived state via the [computed](/docs/api/computed.html) API.

```javascript
import { computed } from 'easy-peasy';

const store = createStore({
  todos: [{ text: 'Learn easy peasy', done: true }],
  completedTodos: computed((state) => state.todos.filter((todo) => todo.done)),
});
```

Easy Peasy will do all of the required optimization under the hood to keep your
computed properties as performant as possible.

## Using computed properties

[Computed](/docs/api/computed.html) properties are accessed just like any other
state.

```javascript
import { useStoreState } from 'easy-peasy';

function CompletdTodos() {
  const completedTodos = useStoreState((state) => state.completedTodos);
  return (
    <>
      {completedTodos.map((todo) => (
        <Todo todo={todo} />
      ))}
    </>
  );
}
```

## Persisting state

Should you wish to persist your state, or part of it, you can utilise the
[persist](/docs/api/persist.html) API to do so.

```javascript
import { persist } from 'easy-peasy';

const store = createStore(
  persist({
    count: 1,
    inc: action((state) => {
      state.count += 1;
    }),
  }),
);
```

This simple adjustment will make Easy Peasy save your store state into
`sessionStorage`. Easy Peasy will persist your state every time it changes.

The next time your store is created Easy Peasy will look for any persisted data
and use it to rehydrate your state if it exists.

This process is asynchronous, but you can utilise the
[useStoreRehydrated](/docs/api/use-store-rehydrated.html) hook to make sure the
rehydration has completed prior to rendering your components.

```javascript
import { useStoreRehydrated } from 'easy-peasy';

const store = createStore(persist(model));

function App() {
  const isRehydrated = useStoreRehydrated();
  return isRehydrated ? <Main /> : <div>Loading...</div>;
```

license: MIT

repository: ctrlplusb/easy-peasy

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive

repo_name: ctrlplusb/easy-peasy


text:
# Node.js Web Application

The following is a web application template.  It is NOT a complete program.

This template code demonstrates how to communicate with a blockchain from a Node.js web application.  It does not show how to listen for incoming requests nor how to authenticate your web users as this is application specific.  The code below is intended to demonstrate how to interact with a Hyperledger fabric blockchain from an existing web application.

You may retrieve the sample application file:
```
curl -o app.js https://raw.githubusercontent.com/hyperledger/fabric/master/examples/sdk/node/web-app.js
```

See the embedded comments below.

```javascript
/**
 * This example shows how to do the following in a web app.
 * 1) At initialization time, enroll the web app with the blockchain.
 *    The identity must have already been registered.
 * 2) At run time, after a user has authenticated with the web app:
 *    a) register and enroll an identity for the user;
 *    b) use this identity to deploy, query, and invoke a chaincode.
 */
var hfc = require('hfc');

// Create a client chain.
// The name can be anything as it is only used internally.
var chain = hfc.newChain("targetChain");

// Configure the KeyValStore which is used to store sensitive keys
// as so it is important to secure this storage.
// The FileKeyValStore is a simple file-based KeyValStore, but you
// can easily implement your own to store whereever you want.
// To work correctly in a cluster, the file-based KeyValStore must
// either be on a shared file system shared by all members of the cluster
// or you must implement you own KeyValStore which all members of the
// cluster can share.
chain.setKeyValStore( hfc.newFileKeyValStore('/tmp/keyValStore') );

// Set the URL for membership services
chain.setMemberServicesUrl("grpc://localhost:7054");

// Add at least one peer's URL.  If you add multiple peers, it will failover
// to the 2nd if the 1st fails, to the 3rd if both the 1st and 2nd fails, etc.
chain.addPeer("grpc://localhost:7051");

// Enroll "WebAppAdmin" which is already registered because it is
// listed in fabric/membersrvc/membersrvc.yaml with its one time password.
// If "WebAppAdmin" has already been registered, this will still succeed
// because it stores the state in the KeyValStore
// (i.e. in '/tmp/keyValStore' in this sample).
chain.enroll("WebAppAdmin", "DJY27pEnl16d", function(err, webAppAdmin) {
   if (err) return console.log("ERROR: failed to register %s: %s",err);
   // Successfully enrolled WebAppAdmin during initialization.
   // Set this user as the chain's registrar which is authorized to register other users.
   chain.setRegistrar(webAppAdmin);
   // Now begin listening for web app requests
   listenForUserRequests();
});

// Main web app function to listen for and handle requests.  This is specific to
// your application but is provided here to demonstrate the pattern.
function listenForUserRequests() {
   for (;;) {
      // WebApp-specific logic goes here to await the next request.
      // ...
      // Assume that we received a request from an authenticated user
      // 'userName', and determined that we need to invoke the chaincode
      // with 'chaincodeID' and function named 'fcn' with arguments 'args'.
      handleUserRequest(userName,chaincodeID,fcn,args);
   }
}

// Handle a user request
function handleUserRequest(userName, chaincodeID, fcn, args) {
   // Register and enroll this user.
   // If this user has already been registered and/or enrolled, this will
   // still succeed because the state is kept in the KeyValStore
   // (i.e. in '/tmp/keyValStore' in this sample).
   var registrationRequest = {
        enrollmentID: userName,
        // Customize account & affiliation
        account: "bank_a",
        affiliation: "00001"
   };
   chain.registerAndEnroll( registrationRequest, function(err, user) {
      if (err) return console.log("ERROR: %s",err);
      // Issue an invoke request
      var invokeRequest = {
        // Name (hash) required for invoke
        chaincodeID: chaincodeID,
        // Function to trigger
        fcn: fcn,
        // Parameters for the invoke function
        args: args
     };
     // Invoke the request from the user object and wait for events to occur.
     var tx = user.invoke(invokeRequest);
     // Listen for the 'submitted' event
     tx.on('submitted', function(results) {
        console.log("submitted invoke: %j",results);
     });
     // Listen for the 'complete' event.
     tx.on('complete', function(results) {
        console.log("completed invoke: %j",results);
     });
     // Listen for the 'error' event.
     tx.on('error', function(err) {
        console.log("error on invoke: %j",err);
     });
   });
}
```

repository: ccccccccjl/hyperledger

repo_name: ccccccccjl/hyperledger


text:
The following text (section *Damian's reply*) is a verbatim quote from
an e-mail [1] received from Damian Conway in response to a query for
his view on proper handling of text in declarator blocks.

Note the verbatim text has been slightly edited by additional
formatting (but no word changes) for this Markdown document.

# Damian's reply

You asked:

> what do you think is appropriate treatment of blank lines between lines of text?

In my opinion, declarator comments should preserve all whitespace on
every line (including the terminating newline and any empty lines),
unchanged.

The reasoning is simple: if the whitespace is preserved exactly then
it can be retrieved exactly. And, if the user wants the text as a
single-line string (i.e. as it is currently supplied), then they can
get that very easily with just:

    my $single_line_text  =  &foo.WHY.words.join(' ');

But if the whitespace is removed during compilation (as it currently
is), then there is no possible way to get back the original structure
of the comment text. And we have no idea whether or not that structure
was important (as it might be of the comment is something like a
table).

So, in order to maximize the information that the user has access to,
the right choice is to preserve all the whitespace (including newlines
and empty lines).

The attached .raku file is a small test case that summarizes my
expectations of how declarator blocks should be processed and what
.WHY, .WHY.leading, and .WHY.trailing should return. I hope it is
helpful.

# His example program that was attached to the e-mail:

See [declarator_block_expectations.raku](./declarator_block_expectations.raku).

# References

1. E-mail =>
    From: Damian Conway<EMAIL_ADDRESS>    Date: Sun, 24 May 2020 05:11:12 +0000
    Message-ID<EMAIL_ADDRESS>    Subject: Re: S26: Leading and trailing declarator blocks
    To: Tom Browder<EMAIL_ADDRESS>

repository: rakudo/rakudo

branch_name: refs/heads/main

gha_language: Raku

repo_name: rakudo/rakudo


text:
---
id: 586
title: 'SECURED: T-Mobile myTouch 4G gets Guardian'
date: 2010-11-09T23:26:59-04:00
author: n8fr8
layout: post
guid: https://guardianproject.info/2010/11/09/secured-t-mobile-mytouch-4g-gets-guardian/
permalink: /2010/11/09/secured-t-mobile-mytouch-4g-gets-guardian/
categories:
  - App Reviews
  - HowTo
tags:
  - hardware
---
One of the services we provide at the Guardian Project is taking any off the shelf Android phone and setting it up to be generally more secure, privacy minded and updated with a powerful suite of trusted apps. Today we were excited to get our hands on a myTouch 4G, manufactured by HTC and sold by T-Mobile. Really beautiful piece of hardware, and once we got our hands on it, a powerhouse of encrypted, anonymous and circumventing communications.

Brief list of our current trusted app suite (not all are open-source but they are tested/vetted as best we can otherwise): Orbot (Tor on Android), Firefox with ProxyMob add-on, TextSecure, OtRChat, RedPhone, SipDroid with VPN, DroidTracker, Norton Mobile Security Suite, Android Privacy Guard with K9Mail for GPG, OISafe and OINotes for locally encrypted data collection and more!

All in all, through our own development work and the larger Android security community, things are really coming together. With hardware like the 4G, it can all be put into a shiny, blazing package.

repository: guardianproject/info

gha_language: CSS

gha_license_id: NOASSERTION

repo_name: guardianproject/info


text:
# nRF9160: Google Cloud IoT Core with BLE
####################

This project enables the nRF9160DK and Thingy:91 to connect to the Google Cloud IoT Core using MQTT, as well as implementing BLE functionality. Follow the instructions to setup the application correctly.

## BLE support on Thingy:91
There isn't native support for BLE on the Thingy:91 in NCS yet, but [this fork](https://github.com/crfosse/sdk-nrf/tree/bee_dev_new) implements the necessary changes to the Thingy:91 board files. Change to this fork when building this sample, and the hci_lpuart sample for the Thingy:91.


text:
---
layout: post
title: CrossFit
headerImage:
permalink: /crossfit/
---

This class delivers a fitness style that is, by design, broad, general, and inclusive for any level of athlete. It is a strength and conditioning program built on constantly varied, if not randomized, functional movements executed at high intensity. This program combines elements of gymnastics, Olympic Weightlifting and resistance training with traditional and non-traditional tools, combined to create a great workout for any person looking to get fit. CrossFit training challenges the body in a variety of ways and is completely scalable and easily modified to suit any exerciser. This program is guaranteed to improve cardiovascular endurance, stamina, strength, flexibility, power, speed, coordination, accuracy, agility and balance.

****

**Crossfit Training Cost**

10-pack of Classes: $150

2 Classes/Week: $90/month

Unlimited adult classes (including Crossfit and Olympic Lifting): $150/month

Couples Unlimited Rate: $200 ($100 each)

Drop-In Rate: $20

**Days/Times:**

Monday-Friday: 5:30am - 6:30m

Monday-Friday: 6:30am - 7:30am

Monday-Saturday: 12pm - 1pm

Monday-Friday: 4pm - 5pm

Monday-Friday: 5pm - 6pm

Monday-Thursday: 6pm - 7pm

Saturday: 7am - 8am

**Additional Details:**

Gender: Male/Female

Ages: 18+


text:
Build a demand forecasting model to predict daily liquor sales in Iowa in 2021
==============================

Motivation
------------
Being a liquor retailer with retail stores across various locations in Iowa, the ability to accurately forecast daily demand for liquor consumption is key to avoid stockouts (which reduce customer satisfaction and result in revenue loss) as well as overstock (which causes higher than expected inventory and warehousing costs). Good demand forecasts reduce uncertainty as demand is extremely volatile and subjected to many influencing factors.

However, traditional forecasting models such as ARIMA, AutoRegressive Integrated Moving Average, and exponential smoothing methods, where only historical data is considered, are getting outdated because of the increased amount of data generated from businesses and external sources.

Machine learning carries demand forecasting to the next step; it enables enhanced forecasts based on real-time data using internal and external data sources such as demographics, weather, online reviews and social media. With the help of external data and modern machine learning algorithms, supply chain networks can outperform networks managed more manually by data analysts and adapt to external changes. According to McKinsey Digital, ML-powered forecasting can reduces errors by 30 to 50% in supply chain networks. The improved accuracy leads up to a 65% reduction in lost sales due to inventory out-of-stock situations and warehousing costs decrease around 10 to 40%.

In retail distribution and store replenishment, the benefits of good forecasting include the ability to attain excellent product availability with reduced safety stocks, minimized waste, as well as better margins, as the need for clearance sales are reduced. Further up the supply chain, good forecasting allows manufacturers to secure availability of relevant raw and packaging materials and operate their production with lower capacity, time and inventory buffers.

Owing to the potential business benefits, it makes sense to explore whether it is feasible to build an ML model to predict daily liquor demand in Iowa in 2021.

Business Goals & Success Metrics
------------
I want to build a machine learning solution that predicts daily demand for liquor in Iowa for the next 30 days, with 90% accuracy.

Being a liquor retailer with retail stores across various locations in Iowa, such a demand forecasting model can help me to better manage my inventory to ensure uninterrupted supply of products as well as avoid overstocking.

To measure the forecast accuracy, applicable metrics include Mean Absolute Percentage Error (MAPE), Mean Absolute Error (MAE), Mean Absolute Deviation (MAD) and [forecast bias](https://www.relexsolutions.com/resources/measuring-forecast-accuracy/). It is important to note that forecast bias measures accuracy whereas MAD & MAPE measure forecast error.

Project Organization
------------

    ├── LICENSE
    ├── Makefile           <- Makefile with commands like `make data` or `make train`
    ├── README.md          <- The top-level README for developers using this project.
    ├── data
    │   ├── external       <- Data from third party sources.
    │   ├── interim        <- Intermediate data that has been transformed.
    │   ├── processed      <- The final, canonical data sets for modeling.
    │   └── raw            <- The original, immutable data dump.
    │
    ├── docs               <- A default Sphinx project; see sphinx-doc.org for details
    │
    ├── models             <- Trained and serialized models, model predictions, or model summaries
    │
    ├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
    │                         the creator's initials, and a short `-` delimited description, e.g.
    │                         `1.0-jqp-initial-data-exploration`.
    │
    ├── references         <- Data dictionaries, manuals, and all other explanatory materials.
    │
    ├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
    │   └── figures        <- Generated graphics and figures to be used in reporting
    │
    ├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
    │                         generated with `pip freeze > requirements.txt`
    │
    ├── setup.py           <- makes project pip installable (pip install -e .) so src can be imported
    ├── src                <- Source code for use in this project.
    │   ├── __init__.py    <- Makes src a Python module
    │   │
    │   ├── data           <- Scripts to download or generate data
    │   │   └── make_dataset.py
    │   │
    │   ├── features       <- Scripts to turn raw data into features for modeling
    │   │   └── build_features.py
    │   │
    │   ├── models         <- Scripts to train models and then use trained models to make
    │   │   │                 predictions
    │   │   ├── predict_model.py
    │   │   └── train_model.py
    │   │
    │   └── visualization  <- Scripts to create exploratory and results oriented visualizations
    │       └── visualize.py
    │
    └── tox.ini            <- tox file with settings for running tox; see tox.readthedocs.io

--------

Project based on the cookiecutter data science project template. #cookiecutterdatascience

gha_language: Jupyter Notebook


text:
# Row Level Security Example

The following is a complete example showing how to leverage PostgreSQL row level security with JWTs to restrict data access.

[row level security example project](https://github.com/olirice/nebulo/tree/master/examples/row_level_security)

repository: GACWR/nebulo

repo_name: GACWR/nebulo


text:
From Zooniverse raw classifications to chunk- and segment-level analysis

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

THIS IS OUTDATED and no longer needed. See README at the top level.

## Step 0.  Installation

### 1. Install Python 3
Find here instructions on how to install Python for
[Linux](https://docs.python-guide.org/starting/install3/linux/) ,
[MacOS](https://docs.python-guide.org/starting/install3/osx/) and
[Windows](https://docs.python-guide.org/starting/install3/win/).

### 2. Create the virtual environment using the venv module included with Python3.
For example to create one in the local directory called ?mypython?, type the following:

Mac OS / Linux
```
python3 -m venv mypython
```
Windows
```
py -m venv mypython
```

### 3. Activate the virtual environment
You can activate the python environment by running the following command:

Mac OS / Linux
```
source mypython/bin/activate
```
Windows
```
mypthon\Scripts\activate
```
Then you can confirm you're in the virtual environment by checking the location of your Python interpreter, it should point to the env directory.

On macOS and Linux:
```
which python
.../env/bin/python
```
On Windows:
```
where python
.../env/bin/python.exe
```
As long as your virtual environment is activated pip will install packages into that specific environment and you?ll be able to import and use packages in your Python application.

If you want to switch projects or otherwise leave your virtual environment, simply run:
```
deactivate
```

### 4. Add needed packages

Python packages required:

* jupyter
* pandas

all packages can be installed with [pip](https://pip.pypa.io/en/stable/installing/):
```
pip install pydub
```

In the future, when you want to re-enter the virtual environment just follow the same instructions above about activating a virtual environment. There's no need to re-create the virtual environment nor re-install the packages.

It is assumed that you are working at the top level of the github repo. All scripts are in `data_analyses/code/`. In addition, we assume you put files from zooniverse (subjects' description, classifications) inside `data_analyses/files_from_zooniverse`, and that you put other (including human-generated) files inside `data_analyses/files_from_elsewhere`.

## Step 1. If needed, activate python 3 env

ONLY DO THIS IF NEEDED, see installation for details.

Mac OS / Linux
```
source mypython/bin/activate
```
Windows
```
mypthon\Scripts\activate
```

## Step 2. Combine chunk metadata with chunk within-zooniverse subject descriptions, with child/recording information

This step takes as input:

1) chunk metadata (in this case, files_from_elsewhere/metadata_all_PU.csv)
2) chunk within-zooniverse subject descriptions (not passed as a parameter here, in this case files_from_zooniverse/maturity-of-baby-sounds-subjects.csv)
3) a file linking ChildID's to filenames (not passed as a parameter here, files_from_elsewhere/filename_links.csv)

```
$ python data_analyses/code/recover_zooniverse_metadata.py data_analyses/files_from_elsewhere/metadata_all_PU.csv data_analyses/output/metadata_all_PU.csv
```

This step produces a file that contains, for each chunk, information from metadata_all_PU.csv as well as the subject description. We will call this our new chunk metadata file.

## Step 3. Combine the new chunk metadata file with all the other information

This is done in R, code called `generate_jslhr_data.R`, inside `202010_jslhr`. Please see comments in there.

repository: LAAC-LSCP/zoo-babble-validation

gha_language: TeX

repo_name: LAAC-LSCP/zoo-babble-validation


text:
# Cassandra Gudina & Saidova in Gudina, Saidova & Troitskaya, 1968 GENUS

#### Status
ACCEPTED

#### According to
IRMNG Homonym List

#### Published in
in Gudina, Saidova & Troitskaya, Dokl. Akad. Nauk SSSR 182: 226.

#### Original name
null

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# HSM-SYS crate

This crate is the unsafe C to Rust interface for the HSM API library.

This crate represents the functions that the HSM API implements. This crate is
used by the HSM-RS crate to provide more Rust-friendly interfaces.

## TPM functionality

The default hsm library built as part of this crate has two modes for the TPM functional interface:
an in-memory keystore, and a TPM device keystore.  The default is the in-memory keystore. To enable
the TPM device keystore set an environment variable `IOTEDGE_USE_TPM_DEVICE` to "ON".

You may need additional setup for a TPM device see [README-TPM](README-TPM.md) for details.

## Memory allocation

The current HSPM API functions expect the calling function to allocate
memory for the the caller to use.  The caller (in this case, the Rust crate) is
expected to free this memory.

## Maintenance.

This file was initially generated via the
[bindgen](https://rust-lang-nursery.github.io/rust-bindgen/) tool from
source [`hsm_client_data.h`](https://github.com/Azure/azure-iot-hsm-c/inc/hsm_client_data.h)
and then hand-edited for conciseness and usability. We expect that the size of
the API will remain fairly small and that continued editing by hand will be a
small effort. The version of the HSM API this is based from is the "Commit Id"
in `lib.rs`- please update the commit id when updating from a new version of
the header file.

## Build dependencies

This crate is dependent on CMake being installed. On Debian based linux systems,
this can be installed with

```
sudo apt-get install build-essential cmake libcurl4-openssl-dev uuid-dev valgrind
```

On Windows:
1) Install CMake from [cmake.org](https://cmake.org/).
2) Install OpenSSL
    Open an admin level PS
    PS> cd edgelet\build\windows
    PS> . .\openssl.ps1
    PS> Get-OpenSSL
    Close PS

### Valgrind

Valgrind was added to the linux build dependencies. We are using Valgrind for detecting
memory leaks, unassigned variables, and overruns in the dev mode iothsm library.

Valgrind slows down the tests considerably, so the iothsm library in hsm-sys runs tests with
valgrind turned off by default.  If you wish to run valgrind, set the
environment variable "RUN_VALGRIND".

## Linking

This crate needs to be linked to a library which implements the functions in
`hsm_client_data.h`

gha_language: C#


text:
# mary.json

## Weekly Integration Tests: Preference Sets

This preference set is used for the
[weekly integration tests](http://wiki.gpii.net/w/Weekly_Integration_Test_Plan) and is manually tested on a regular basis. The expected system behaviour on login is described here.

It has also been used in the [third review of Cloud4all](https://github.com/GPII/universal/blob/master/testData/preferences/review3/review3-preferences.md).

## Details
`mary.json`: preference set with only common format terms for the following settings:
* enable the on-screen keyboard,
* Rule-Based Matchmaker.

repository: mcanthony/universal

repo_name: mcanthony/universal


text:
# *Ganoderma lucidum* bioprocess microbiome analysis
This repository is for my G. lucidum bioprocess microbiome analysis project.

**Introduction**

Ganoderma lucidum is an ecologically and economically important wood-degrading fungus. From a economic perspective, *G. lucidum* is cultivated for numerous applications, such as medicinal and material. The bioprocess used to grow the fungus--often, a solid-state fermentation--is increasingly understood to harbor a rich microbiome that affects bioprocess outcomes and product characteristics.

This repository contains tools for studying the microbiome of various *G. lucidum* bioprocesses.

## References
 Markup : 1. Zhang B, Yan L, Li Q, Zou J, Tan H, Tan W, Peng W, Li X, Zhang X. Dynamic succession of substrate-associated bacterial composition and function during Ganoderma lucidum growth. PeerJ. 2018 Jun 13;6:e4975. doi: 10.7717/peerj.4975. PMID: 29915697; PMCID: PMC6004108.


text:
# Create HTTPS certificates for Docker

re [Hosting ASP.NET Core images with Docker Compose over HTTPS](https://docs.microsoft.com/en-us/aspnet/core/security/docker-compose-https)

```shell
dotnet dev-certs https -ep \${HOME}/.aspnet/https/productserviceapi.pfx -p 1111
dotnet dev-certs https --trust
```

```yaml
services:
  environment:
    - ASPNETCORE_ENVIRONMENT=Development
    - ASPNETCORE_URLS=https://+:443;http://+:80
    - ASPNETCORE_Kestrel__Certificates__Default__Password=1111
    - ASPNETCORE_Kestrel__Certificates__Default__Path=/https/productserviceapi.pfx
  volumes:
    - ~/.aspnet/https:/https:ro
```

```shell
docker run --name <your-name> -p 80:80 -p 443:443 -v ${HOME}/.aspnet/https:/https/ <your-image>
```

repository: cecilphillip/aspnetcore-web-services

repo_name: cecilphillip/aspnetcore-web-services


text:
# Standby Node in the  **Need Repair \(WAL\)**  State

## Symptom

The  **Need Repair \(WAL\)**  fault occurs on a standby node of the openGauss.

## Cause Analysis

The primary and standby DB instances are disconnected due to network faults or insufficient disk space. As a result, logs are not synchronized between the primary and standby DB instances, and the database cluster fails to start.

## Procedure

Run the  **gs\_ctl build -D**  command to rebuild the faulty node. For details, see the build parameter in the  _openGauss Tool Reference_.


text:
surespot-ios  [![App Store](https://www.surespot.me/images/Available_AppStore.png)](https://itunes.apple.com/us/app/surespot/id790314865)
============

ios surespot client

surespot is a mobile messaging application that secures all messages using end-to-end encryption.

Contribute
=========

surespot is free to download and free to use because we believe that every person has the right to access a tool they
can use to communicate without being subjected to data mining, behavior trending, and other surveillance liberties
corporations and authorities have taken with our communications. We created surespot because we were tired of editing ourselves.
If you support this work and appreciate surespot please show it and consider donating your time or money.
In turn, we will pass along support to the Electronic Frontier Foundation (EFF) who work tirelessly to defend your digital rights.

[![donation](https://www.surespot.me/images/contribute-button.png)](https://www.surespot.me/contribute.html)

Localization
=========

If you would like to contribute/improve a translation:

 1. Visit our [Transifex project page](https://www.transifex.com/projects/p/surespot) and make an account if you don't have one already.
 2. Go to the [resources tab](https://www.transifex.com/projects/p/surespot/resources/) to add a new language or improve an existing translation.

THANK YOU TO OUR CONTRIBUTORS:

* Jean Schmitt, repat, mrbiber, leibi,gehfab for the German translations.
* Jorge Iván Andrés Contreras Pereira, Cesar Schulzbacher, Manuel Perez, vndtta for the Spanish translations.
* sharkyiwc and boing for the French translations.
* lgasp, dickhead, Mauriziopz, mangholb and riky, besa, for the Italian translations.

About
=========

Copyright (c) 2012-14, 2fours. All rights reserved.
If you would like to use this code
please contact us at [support@2fours.com](mailto:support@2fours.com).

This software additionally references or incorporates the following sources
of intellectual property, the license terms for which are set forth
in the sources themselves:

Third-party Libraries
=========

The following dependencies are bundled with surespot, but are under
terms of a separate license:

* [AGWindowView](https://github.com/hfossli/AGWindowView) - Copyright (c) 2013 Agens AS (http://agens.no/)
* [AFNetworking](https://github.com/AFNetworking/AFNetworking) - Copyright (c) 2013 AFNetworking (http://afnetworking.com/)
* [REMenu](https://github.com/romaonthego/REMenu) - Copyright (c) 2013 Roman Efimov (https://github.com/romaonthego)
* [SDWebImage](https://github.com/rs/SDWebImage) - Copyright (c) 2009 Olivier Poitrey<EMAIL_ADDRESS>* [MWPhotoBrowser](https://github.com/mwaterfall/MWPhotoBrowser) - Copyright (c) 2010 Michael Waterfall
* [UIImageViewAligned](https://github.com/reydanro/UIImageViewAligned) - Copyright (c) 2013 Andrei Stanescu
* [Toast](https://github.com/scalessec/Toast) - Copyright (c) 2013 Charles Scalesse.
* [Reachability](https://github.com/tonymillion/Reachability) - Copyright (c) 2011-2013, Tony Million.
* [SwipeView](https://github.com/nicklockwood/SwipeView) - Copyright (C) 2010 Charcoal Design
* [QR-Code-Encoder-for-Objective-C](https://github.com/myang-git/QR-Code-Encoder-for-Objective-C) - Licensed under the Apache License, V2.0 http://www.apache.org/licenses/LICENSE-2.0
* [SVPullToRefresh](https://github.com/samvermette/SVPullToRefresh) - Copyright (C) 2012 Sam Vermette
* [CocoaLumberjack](https://github.com/CocoaLumberjack/CocoaLumberjack) - Copyright (c) 2010, Deusty, LLC
* [SocketRocket](https://github.com/square/SocketRocket) - Licensed under the Apache License, v2.0 http://www.apache.org/licenses/LICENSE-2.0
* [socket.io-objc](https://github.com/pkyeck/socket.IO-objc) - Copyright (c) 2011-12 Philipp Kyeck <http://beta-interactive.de>
* [InAppSettingsKit](https://github.com/futuretap/InAppSettingsKit) - Copyright (c) 2009-2010:
Luc Vandal, Edovia Inc., http://www.edovia.com
Ortwin Gentz, FutureTap GmbH, http://www.futuretap.com
* [GrowingTextView](https://github.com/HansPinckaers/GrowingTextView) - Copyright (c) 2011 Hans Pinckaers
* [ShareKit](https://github.com/K-Be/ShareKit) - MIT Copyright (c) Nate Weiner
* [TTTAttributedLabel](https://github.com/mattt/TTTAttributedLabel) -  Copyright (c) 2011 Mattt Thompson (http://mattt.me/)
* [UIAlertView-Blocks](https://github.com/ryanmaxwell/UIAlertView-Blocks) - Copyright (c) 2013 Ryan Maxwell
* [cryptopp-5.6.2-ios](https://github.com/noloader/cryptopp-5.6.2-ios) - The Crypto++ Library (as a compilation) is currently licensed under the Boost Software License 1.0 - August 17th, 2003 <http://www.boost.org/users/license.html>

repository: jlund/surespot-ios

repo_name: jlund/surespot-ios


text:
[![Netlify Status](https://api.netlify.com/api/v1/badges/c6f44d34-0570-4ca0-9d3d-cabdaa2b3afb/deploy-status)](https://app.netlify.com/sites/nextjs-netlify-blog-template/deploys)
[![MADE BY Next.js](https://img.shields.io/badge/MADE%20BY%20Next.js-000000.svg?style=flat&logo=Next.js&labelColor=000)](https://nextjs.org/)

# DEV BLOG

This is a dev blog that I made with Next.js and is hosted on netlify for CI and CMS.

I wanted to learn server side rendering and Next.js is the new hot thing so here it is 🤠

I mean look how fast this thing is

### Visit it [here](https://daeedev.netlify.app)

![](https://github.com/daee-kang/dev-blog/blob/master/demo.gif)

Why did I make this site? https://daeedev.netlify.app/posts/how-i-made-this-site

repository: daee-kang/dev-blog

gha_language: TypeScript

repo_name: daee-kang/dev-blog


text:
# ToolsPack.NLog

NLog helper - format the structured logs with `Newtonsoft.Json` as described in the [NLog documentation](https://github.com/NLog/NLog/wiki/How-to-use-structured-logging)

Usage:

```csharp
JsonSerializerSettings jsonSerializerSettings = new JsonSerializerSettings {
    NullValueHandling = NullValueHandling.Ignore,
    ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
    Formatting=Formatting.Indented
};
NLog.Config.ConfigurationItemFactory.Default.JsonConverter = new ToolsPack.NLog.NewtonsoftJsonSerializer(jsonSerializerSettings);
```

Shortcut:

```csharp
LogQuickConfig.UseNewtonsoftJson()
```

Update:

You can also use the new `System.Text.Json` serializer.

```csharp
LogQuickConfig.UseMicrosoftJson()
```

In unit test and for most basic logging needs:

```csharp
LogQuickConfig.SetupConsole();
```
or
```csharp
LogQuickConfig.SetupFile("./log/app.log");
```
or
```csharp
LogQuickConfig.SetupFileAndConsole("./log/app.log");
```

once setup, you can write logs as usual:

```csharp
private static readonly NLog.ILogger log = NLog.LogManager.GetCurrentClassLogger();
log.Info("{@request}", req); //structured logging

```

Some library (APS.NET Core) require a `Microsoft.Extensions.Logging.ILogger` for logging.
You can use `NLog` to create one: https://stackoverflow.com/a/60859465/347051

```csharp
private static readonly ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddNLog(LogQuickConfig.SetupFileAndConsole("./log/app.log"));
    //LogQuickConfig.UseMicrosoftJson();
});
private static readonly ILogger<Program> log = loggerFactory.CreateLogger<Program>();

log.LogInformation("{@request}", jsonRequest);
```


text:
# Security Policy

## Reporting a Vulnerability

The Airship community is committed to expediently confirming, resolving, and
disclosing all reported security vulnerabilities. To report a security
vulnerabillity, please refer to our [vulnerability management process][1].

[1]: https://docs.airshipit.org/learn/vulnerabilities.html

repository: airshipit/airshipctl

gha_language: Go

repo_name: airshipit/airshipctl


text:
# Pullup

[![GitHub release](https://img.shields.io/github/release/tommy351/pullup.svg)](https://github.com/tommy351/pullup/releases) [![CircleCI](https://circleci.com/gh/tommy351/pullup/tree/master.svg?style=svg)](https://circleci.com/gh/tommy351/pullup/tree/master) [![codecov](https://codecov.io/gh/tommy351/pullup/branch/master/graph/badge.svg)](https://codecov.io/gh/tommy351/pullup)

Pullup is a Kubernetes add-on that helps you deploy pull requests on a Kubernetes cluster based on existing resources and cleanup resources automatically when pull requests are closed or merged.

## Prerequisites

Pullup requires Kubernetes 1.7 and later which supports Custom Resource Definitions (CRD).

## Installation

Install Pullup CRDs and components in `pullup` namespace.

```sh
# Install the latest version
kubectl apply -f https://github.com/tommy351/pullup/releases/latest/download/pullup-deployment.yml

# Install a specific version
kubectl apply -f https://github.com/tommy351/pullup/releases/download/v0.3.3/pullup-deployment.yml
```

The YAML file is generated with [kustomize](https://github.com/kubernetes-sigs/kustomize). You can see source files in [deployment](deployment) folder. It contains:

- Pullup custom resource definitions (CRD).
- A Service account.
- RBAC for accessing Pullup CRD, writing events and the leader election.
- Deployments of the controller and the webhook.
- A service exposing the webhook server.

## RBAC

After Pullup is installed, you have to grant access of the resources that you defined in webhooks. If your Kubernetes cluster is not RBAC enabled, you can skip this section.

You have to create `Role` and `RoleBinding` (or `ClusterRole` and `ClusterRoleBinding` for all namespaces), set `verbs` to `["get", "create", "update"]` for each kind of resources and bind the role to the pullup service account.

The following example includes `Deployment` and `Service`. See [here](https://kubernetes.io/docs/reference/access-authn-authz/rbac/) for more details about RBAC.

```yaml
---
apiVersion: rbac.authorization.k8s.io/v1
# Change this to ClusterRole to apply in all namespaces.
kind: Role
metadata:
  name: pullup-deployment
rules:
  # Deployment
  - apiGroups: ["apps", "extensions"]
    resources: ["deployments"]
    verbs: ["get", "create", "update"]
  # Service
  - apiGroups: [""]
    resources: ["services"]
    verbs: ["get", "create", "update"]
---
apiVersion: rbac.authorization.k8s.io/v1
# Change this to ClusterRoleBinding to apply in all namespaces.
kind: RoleBinding
metadata:
  name: pullup-deployment
# Bind to the pullup service account
subjects:
  - kind: ServiceAccount
    name: pullup
    namespace: pullup
# Refer to the role above
roleRef:
  kind: Role
  name: pullup-deployment
  apiGroup: rbac.authorization.k8s.io
```

## Documentation

- [Getting Started](docs/getting-started.md)
- [Architecture](docs/architecture.md)
- [References](docs/references.md)
- [Troubleshooting](docs/troubleshooting.md)

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md) for information about setting environment.

## Todos

- [ ] Merge resources using [Structured Merge and Diff](https://github.com/kubernetes-sigs/structured-merge-diff)
- [ ] Test more kinds of resources
- [ ] End-to-end tests

repository: forkkit/pullup

repo_name: forkkit/pullup


text:
---
speaker: Sucharit Sarkar (UCLA)
title: "Khovanov homotopy type"
date: 31 March, 2021
time: 9:00 pm
series: "Geometry & Topology Seminar"
venue: MS teams (team code hiq1jfr)
website: https://math.iisc.ac.in/~vvdatar/gt_Current.html
---

The Khovanov chain complex is a categorification of the Jones polynomial and is built using a functor from Kauffman's cube of resolutions to Abelian groups.
By lifting this functor to the Burnside category, one can construct a CW complex whose reduced cellular chain complex agrees with the Khovanov complex.
This produces a Khovanov homotopy type whose reduced homology is Khovanov homology. I will present a general outline of this construction, starting with
Khovanov's functor. This work is joint with Tyler Lawson and Robert Lipshitz.

repository: siddhartha-gadgil/DeptWeb

gha_language: HTML

repo_name: siddhartha-gadgil/DeptWeb


text:
# Scidraw Graphics 📦
A collection of graphical representations and plots developed with the `scidraw` package in Mathematica.

## Useful resources

* scidraw tutorial - Brave Search 🔗 https://search.brave.com/search?q=scidraw+tutoril
* SciDraw: Publication-quality scientific figures with Mathematica 🔗 https://scidraw.nd.edu/
* Index of /beta 🔗 https://scidraw.nd.edu/beta/
* SciDraw: Publication-quality scientific figures with Mathematica 🔗 https://scidraw.nd.edu/
* SciDraw: Publication-quality scientific figures with Mathematica 🔗 https://scidraw.nd.edu/
* SciDrawGuide.pdf 🔗 https://library.wolfram.com/infocenter/MathSource/8958/SciDrawGuide.pdf
* Create Plots Using Mathematica -- from Wolfram Library Archive 🔗 https://library.wolfram.com/infocenter/TechNotes/4167/
* SciDraw: Publication-quality scientific figures with Mathematica 🔗 https://scidraw.nd.edu/

repository: basavyr/scidraw-graphics

repo_name: basavyr/scidraw-graphics


text:
Okavango
========

Data streams from Dr. Steve Boyes trip down the delta

Issues
------
See Google Doc

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

Python >=3.3

requires housepy

    sudo pip-3.3 install -r requirements.txt

install geojson from python 3 branch: https://github.com/brianhouse/geojson
make sure your version of setuptools is upgraded

make sure the server is on top of the time:

    tzselect
    sudo apt-get install ntp

install ffmpeg: http://ffmpeg.org/trac/ffmpeg/wiki/UbuntuCompilationGuide

Running
-------

    sudo ./scripts/start.sh

### Copyright/License

Copyright (c) 2013 Brian House and Jer Thorp

This code is released under the MIT License and is completely free to use for any purpose. See the LICENSE file for details.


text:
# Chapter 8: Important C Syntax that Textbooks Often Do Not Cover

## What does this chapter cover?

- What other textbooks don't
  - macros
  - preprocessor
  - linkage
  - const

### Cultivate Robust and Flourishing Macros

Two types of macros exist
- expands to an expression
- block of instructions

Rules for macros
- Parentheses! Put all inputs in parentheses unless you have a specific reason not to.
- Avoid double usage to ensure macros expand properly.
- Use curly braces for blocks.
  - there are edge cases here, but the best solution is to warn the user.

### The Preprocessor

The preprocessor uses the `#` token to
- mark directives
- stringize an input
- concatenate tokens

The preprocessor also merges two string literals if they are adjacent.

You can use a two octothorps to join two things that are not strings.

The code on page 168 leverages different features of the preprocessor to provide variables that kept track of array lengths.

There's a subsection related to macro arguments as well.

### Test Macros

*skip; out of scope of current SoftSys understanding*

### Header Guards

This section introduces the power of `#ifndef` and `#endif` to prevent multiple declarations.

You can simplify this even further by using `#pragma once` at the head of the file to be included once.

You can also use the preprocessor to comment out code in a nested fashion, but the nesting must be correct or you will get an error.

### Linkage with static and extern

Use the `extern` keyword to indicate external linkage.

Use the `static` keyword to indicate static linkage.
- file scope variables - only affects linkage
- block scope variables - only affects memory model
- functions - only affects linkage

You can also precede the declaration of your function in your .h to be included everywhere, so to speak.

### Externally Linked Variables in Header Files

To use `extern`,
- declare the variable with the keyword `extern` in a header to be included anywhere the variable will be used
- declare the variable as usual in only one .c file.

### The const Keyword

The `const` keyword is a "literary device" for the programmer. The author recommends to use it when possible. to make sure that data that shouldn't change, doesn't.

Caveats:
1. Data marked as `const` under one name can be modified using a different name.

### Noun-Adjective form

This section introduces the "right-to-left" rule. With this, the author notes that you can switch a type name and `const` and they will mean the same thing. This section recommends `int const` as opposed to `const int` because it helps with the right-to-left rule.

### Tension

This highlights the tension that arises when you pass a `const` as a non-`const` parameter. You have to first ask yourself if the function could modify the `const`. If not, the book suggests that you could cast the `const` to a non-`const` to quiet the compiler.

### Depth

If you really need to protect only the lowest level in your hierarchy of types, your best bet is to put a note in the documentation.

### The `char const**` Issue

This section talks about the need to make an explicit cast when using a `char const**`. It boils down to the previous point that `const`s can be changed under a different name.

There is a subsection on booleans, and what is important to know is that you can read `if(x)` to be "if x is true".


text:
---
layout: post
title: First meeting tomorrow!
---

Hey there. Just wanted to remind everyone that our first meeting is tomorrow after school in Mrs. York's room.

If you have a laptop, feel free to bring it. Go ahead and download the free version of [Unity](https://store.unity.com/).
We're gonna learn how to make some video games! I can't wait to get started.
If you haven't already, follow the [twitter](https://twitter.com/sphscodeclub), and join the [slack group](https://join.slack.com/t/sphscodeclub/shared_invite/enQtMjgzMDE1Mzc3MjY4LTY5ODdmZDJhODdhNzEzNTg1ODk2NDQ4YTNmMzY4YzhhNWExMjk1NjUxY2RkNGM1MWMwZDllZWQ3NjRjNGJlNWI)!

– Tyler


text:
# .NET Core - Open Source Unit Test Coverage and Reports
When I work on my personal projects I normally use Visual Studio Community or Visual Studio Code. Lately I decided to pay more attention to the coverage on those projects, and being used to having the Visual Studio Enterprise subscription on my job, I tried to run the "Analyze Code Coverage for All Tests" from Visual Studio. It turns out that that options is only available for the Enterprise edition. After a second of frustration it came to my mind the question "if I depend on Visual Studio to analyze the code coverage, what am I going to do when working on my Fedora laptop?", so I did some investigation and found a way (there a lot) to run the analysis on both, my Windows and Linux machines.
## Setting up the demo projects
In order to provide a more "realistic" scenario, I will be creating multiple projects. I will also use mostly the console so it doesn't matter what OS or editor you are using, you should be able to follow along. Keep in mind that in some cases you'll to change the forward slashes to backslashes on Windows.

Open the console and navigate to any directory where you want to set up the solution and run:
```
mkdir UnitTestCoverageDemo
cd UnitTestCoverageDemo
dotnet new sln
mkdir src
mkdir tests
cd src
dotnet new classlib -n UnitTestCoverageDemo.Calculations
dotnet new classlib -n UnitTestCoverageDemo.Services
dotnet add UnitTestCoverageDemo.Services/UnitTestCoverageDemo.Services.csproj reference UnitTestCoverageDemo.Calculations/UnitTestCoverageDemo.Calculations.csproj
cd ../tests
dotnet new xunit -n UnitTestCoverageDemo.Calculations.Tests
dotnet new xunit -n UnitTestCoverageDemo.Services.Tests
dotnet add UnitTestCoverageDemo.Calculations.Tests/UnitTestCoverageDemo.Calculations.Tests.csproj reference ../src/UnitTestCoverageDemo.Calculations/UnitTestCoverageDemo.Calculations.csproj
dotnet add UnitTestCoverageDemo.Services.Tests/UnitTestCoverageDemo.Services.Tests.csproj reference ../src/UnitTestCoverageDemo.Services/UnitTestCoverageDemo.Services.csproj
cd ..
dotnet sln UnitTestCoverageDemo.sln add ./**/**/**.csproj
```
Now lets open the solution using some editor. First, delete every auto-generated class and then create a couple of classes for each non-test project.

On UnitTestCoverageDemo.Calculations, create SimpleCalculation.cs.
```
using System;

namespace UnitTestCoverageDemo.Calculations
{
    public class SimpleCalculation
    {
        public Int32 Add(Int32 n, Int32 m)
        {
            return n + m;
        }

        public Int32 Substract(Int32 n, Int32 m)
        {
            return n - m;
        }

        public Int32 Multiply(Int32 n, Int32 m)
        {
            return n * m;
        }

        public Int32 Divide(Int32 n, Int32 m)
        {
            if (m == 0)
            {
                throw new ArgumentOutOfRangeException(nameof(m));
            }

            return n / m;
        }
    }
}
```
On UnitTestCoverageDemo.Calculations, create ComplexCalculation.cs.
```
using System;

namespace UnitTestCoverageDemo.Calculations
{
    public class ComplexCalculation
    {
        public Int32 Power(Int32 n, Int32 m)
        {
            if (m == 0)
            {
                return 1;
            }

            var result = n;
            for (int i = 1; i < m; i++)
            {
                result *= n;
            }

            return result;
        }

        public Int32 Round(Decimal n)
        {
            var intPart = (Int32)n;
            var difference = n - intPart;

            if (difference >= 0.5M)
            {
                return intPart + 1;
            }

            return intPart;
        }
    }
}
```
On UnitTestCoverageDemo.Services, create FigureService.cs.
```
using System;
using UnitTestCoverageDemo.Calculations;

namespace UnitTestCoverageDemo.Services
{
    public class FigureService
    {
        private readonly SimpleCalculation _simpleCalculation;
        private readonly ComplexCalculation _complexCalculation;

        public FigureService()
        {
            // Who's got time for DI anyways?
            this._simpleCalculation = new SimpleCalculation();
            this._complexCalculation = new ComplexCalculation();
        }

        public Int32 SquareArea(Int32 s)
        {
            var area = this._complexCalculation.Power(s, 2);

            return area;
        }

        public Int32 RectangleArea(Int32 b, Int32 h)
        {
            var area = this._simpleCalculation.Multiply(b, h);

            return area;
        }

        public Int32 TriangleArea(Int32 b, Int32 h)
        {
            var doubleArea = this._simpleCalculation.Multiply(b, h);
            var area = this._simpleCalculation.Divide(doubleArea, 2);

            return area;
        }

        public Int32 RectanglePerimeter(Int32 b, Int32 h)
        {
            var halfPerimeter = this._simpleCalculation.Add(b, h);
            var perimeter = this._simpleCalculation.Multiply(halfPerimeter, 2);

            return perimeter;
        }
    }
}
```
On UnitTestCoverageDemo.Services, create MoneyService.cs.
```
using System;
using UnitTestCoverageDemo.Calculations;

namespace UnitTestCoverageDemo.Services
{
    public class MoneyService
    {
        private readonly SimpleCalculation _simpleCalculation;
        private readonly ComplexCalculation _complexCalculation;

        public MoneyService()
        {
            // Who's got time for DI anyways?
            this._simpleCalculation = new SimpleCalculation();
            this._complexCalculation = new ComplexCalculation();
        }

        public Int32 Spend(Int32 money, Int32 price)
        {
            if (money < price)
            {
                throw new ArgumentOutOfRangeException(nameof(price));
            }

            var left = this._simpleCalculation.Substract(money, price);

            return left;
        }

        public Int32 ForgetTheChange(Decimal money)
        {
            var withoutTheChange = this._complexCalculation.Round(money);

            return withoutTheChange;
        }
    }
}
```
On UnitTestCoverageDemo.Calculations.Tests, create ComplexCalculationTests.cs.
```
using System;
using Xunit;

namespace UnitTestCoverageDemo.Calculations.Tests
{
    public class ComplexCalculationTests
    {
        private readonly ComplexCalculation _sut;

        public ComplexCalculationTests()
        {
            this._sut = new ComplexCalculation();
        }

        [Theory]
        [InlineData(5, 2, 25)]
        [InlineData(2, 3, 8)]
        [InlineData(5, 0, 1)]
        public void Power_Returns_FirstParameterElevatedToTheSecondParameter(Int32 firstParameter, Int32 secondParameter, Int32 expectedResult)
        {
            // Arrange

            // Act
            var result = this._sut.Power(firstParameter, secondParameter);

            // Assert
            Assert.Equal(expectedResult, result);
        }

        [Theory]
        [InlineData(5.25, 5)]
        [InlineData(7.5, 8)]
        [InlineData(6.75, 7)]
        public void Round_Returns_RoundedNumber(Decimal number, Int32 expectedResult)
        {
            // Arrange

            // Act
            var result = this._sut.Round(number);

            // Assert
            Assert.Equal(expectedResult, result);
        }
    }
}
```
On UnitTestCoverageDemo.Services.Tests, create MoneyServiceTests.cs.
```
using System;
using Xunit;

namespace UnitTestCoverageDemo.Services.Tests
{
    public class MoneyServiceTests
    {
        private readonly MoneyService _sut;

        public MoneyServiceTests()
        {
            this._sut = new MoneyService();
        }

        [Theory]
        [InlineData(200, 50, 150)]
        [InlineData(300, 300, 0)]
        public void Spend_Returns_RemainingMoney(Int32 money, Int32 price, Int32 remaining)
        {
            // Arrange

            // Act
            var result = this._sut.Spend(money, price);

            // Assert
            Assert.Equal(remaining, result);
        }

        [Theory]
        [InlineData(10.89, 11)]
        [InlineData(250.35, 250)]
        public void ForgetTheChange_Returns_RoundedMoney(Decimal money, Int32 rounded)
        {
            // Arrange

            // Act
            var result = this._sut.ForgetTheChange(money);

            // Assert
            Assert.Equal(rounded, result);
        }
    }
}
```
## Installing required packages and tools
Now that we have our project set, we can run our tests. Open a console on the solution directory and run:
```
dotnet test
```
You'll see that they run successfully but no information about our current coverage, which of course is extremely poor. So, let's install what we need.

We need coverlet.collector NuGet package on each Unit Test project, we can check that they are installed running from the solution directory:

```
dotnet list package
```
If the package appears on the list then we are ready to go, if not (or if you want to update it) run from each project directory:
```
dotnet add package coverlet.collector
```
Now lets install the Report Generator as a global tool.
```
dotnet tool install --global dotnet-reportgenerator-globaltool
```
If already installed, run:
```
dotnet tool update --global dotnet-reportgenerator-globaltool
```
## Generating the report
To generate the reports, we need to run the test command with some additional parameters that will generate files containing information about our coverage. We will use the cobertura format here but you can read about other formats [here](https://github.com/coverlet-coverage/coverlet).

Run the following command from the solution directory:
```
dotnet test --collect:"XPlat Code Coverage" --results-directory:"./.coverage"
```
The "XPlat Code Coverage" argument is a friendly name that corresponds to the data collectors from Coverlet. You can read more about it [here](https://docs.microsoft.com/en-us/dotnet/core/testing/unit-testing-code-coverage). The "./.coverage" is to specify the directory where the results will be stored. If none is specified, it will default to a TestResults directory inside each project.

Inside the ".coverage" directory we have now two directories with GUID as names and inside those directories we have two files named "coverage.cobertura.xml". Those files contain the result for our code coverage analysis, but unless you're fluent in XML (I'm not), then there is not much use for us as humans. So let's create a readable report that is friendlier to our eyes.

Run the following on the terminal from the solution directory:
```
reportgenerator "-reports:.coverage/**/*.cobertura.xml" "-targetdir:.coverage-report/" "-reporttypes:HTML;"
```
If we now open the index.html file inside the .coverage-report directory, we will see a much nicer report that tells us that we suck at covering because we didn't even cover half of our code, but at least we now have all the details to easily correct this.

Before continuing let's analyze the command. Our first parameter "-reports:.coverage/**/*.cobertura.xml" is going to find all the "coverage.cobertura.xml" files regardless of the GUID naming the directories. The second parameter "-targetdir:.coverage-report/" will just tell the Report Generator where to store the final report, and the last parameter "-reporttypes:HTML;" will generate an HTML report for us to view on the browser. If you want to know more in detail about all the possible options, you can read more [here](https://github.com/danielpalme/ReportGenerator).
## Automating the process
All of this is great, but it is really painful to run this manually every time, and besides that if you think of the directory structure that is going to be created for a second, you'll see a bigger problem... yeah, that's right, unless we delete everything before the next run we will have no way to identify which files are the ones for that run, because the GUIDs are randomly generated. Let's make everything better then with some scripts. I made a couple, one for Linux and one for Windows. If you are on a MAC I assume that the Linux one will work just fine, but it might need a few modifications.

Linux Script (BASH):
```
#!/usr/bin/bash
# Parameters - Solution
SOLUTION_FILE_NAME=""
COVERAGE_COVERLET_DIR=".coverage"
COVERAGE_REPORT_DIR=".coverage-report"

# Parameters - Coverlet
DATA_COLLECTOR_FORMAT="cobertura"
COVERLET_OUTPUT_FORMAT="cobertura"
COVERLET_OUTPUT_EXTENSION=".xml"
COLLECT="XPlat Code Coverage"
COVERAGE_FILE_NAME="coverage.$COVERLET_OUTPUT_FORMAT$COVERLET_OUTPUT_EXTENSION"

# Parameters - Report Generator
REPORT_TYPES="HTML;cobertura;"
HTML_REPORT_INDEX_FILE_NAME="index.html"

# Calculated Parameters - Solution - CHANGE WITH EXTREME CAUTION
SOLUTION_DIR="$(dirname $(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd))"
SOLUTION="$SOLUTION_DIR/$SOLUTION_FILE_NAME"

# Calculated Parameters - Coverlet - CHANGE WITH EXTREME CAUTION
COVERAGE_RUN_IDENTIFIER=$(uuidgen)
COVERLET_OUTPUT="$SOLUTION_DIR/$COVERAGE_COVERLET_DIR/$COVERAGE_RUN_IDENTIFIER"

# Build and Test
dotnet test $SOLUTION --collect:"$COLLECT" --results-directory:"$COVERLET_OUTPUT" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format="$DATA_COLLECTOR_FORMAT"

# Calculated Parameters - Report Generator - CHANGE WITH EXTREME CAUTION
TARGET_DIR="$COVERAGE_REPORT_DIR/$COVERAGE_RUN_IDENTIFIER"
REPORT_HTML_FILE="$SOLUTION_DIR/$COVERAGE_REPORT_DIR/$COVERAGE_RUN_IDENTIFIER/$HTML_REPORT_INDEX_FILE_NAME"
COVERAGE_FILES=$(find $COVERLET_OUTPUT/**/* -maxdepth 1 | awk -vORS=";" '{ print $1 }' | sed "s/\;$/\n/")

# Generate Report
reportgenerator "-reports:$COVERAGE_FILES" "-targetdir:$TARGET_DIR" "-reporttypes:$REPORT_TYPES"

# Open Report
xdg-open $REPORT_HTML_FILE > /dev/null 2>&1
```
For this script to run properly you will also need to install uuidgen tool. On Fedora, CentOS and RHEL (if not already installed) it is on the util-linux package, util-linux-ng for CentOS 6. On Debian the package is called uuid-runtime. On other distributions it might be better for you to search for it online or try running the uuidgen command to see if you already have it. Remember to also grant execution permissions to the script.

```
chmod u+x run_tests.sh #or whatever name you want
```
Windows Script (Powershell):
```
# Parameters - Solution
$SolutionFileName = "WAM.sln"
$CoverageCoverletDir = ".coverage"
$CoverageReportDir = ".coverage-report"

# Parameters - Coverlet
$DataCollectorFormat = "cobertura"
$CoverletOutputFormat = "cobertura"
$CoverletOutputExtension = ".xml"
$Collect = "XPlat Code Coverage"
$CoverageFileName = "coverage.$CoverletOutputFormat$CoverletOutputExtension"

# Parameters - Report Generator
$ReportTypes = "HTML;cobertura;"
$HtmlReportIndexFileName = "index.html"

# Calculated Parameters - Solution - CHANGE WITH EXTREME CAUTION
$SolutionDir = (Get-Item $PSScriptRoot).Parent.FullName
$Solution = [IO.Path]::Combine($SolutionDir, $SolutionFileName)

# Calculated Parameters - Coverlet - CHANGE WITH EXTREME CAUTION
$CoverageRunIdentifier = [GUID]::NewGuid().ToString()
$CoverletOutput = [IO.Path]::Combine($SolutionDir, $CoverageCoverletDir, $CoverageRunIdentifier)

# Build and Test
dotnet.exe test $Solution --collect:"$Collect" --results-directory:"$CoverletOutput" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format="$DataCollectorFormat"

# Calculated Parameters - Report Generator - CHANGE WITH EXTREME CAUTION
$TargetDir = [IO.Path]::Combine($CoverageReportDir, $CoverageRunIdentifier)
$ReportHtmlFile = [IO.Path]::Combine($SolutionDir, $CoverageReportDir, $CoverageRunIdentifier, $HtmlReportIndexFileName)
$TestResultsDirs = Join-Path $CoverletOutput -ChildPath **\*
$CoverageFiles = (Split-Path $TestResultsDirs -Resolve | ForEach-Object -Process {[IO.Path]::Combine($_, $CoverageFileName)}) -join ";"

# Generate Report
reportgenerator.exe "-reports:$CoverageFiles" "-targetdir:$TargetDir" "-reporttypes:$ReportTypes"

# Open Report
Invoke-Item $ReportHtmlFile
```
If you create the script by copy pasting, you might need to change the execution policy to be able to run it (or sign the certificate yourself). If you change the execution policy, I would recommend to use RemoteSigned, so you can run your own scripts locally. To do that, open Powershell as administrator and run:
```
Set-ExecutionPolicy RemoteSigned
```
The scripts are kind of self explanatory at this point, feel free to change them and do any modifications. They are thought to be run from inside a scripts directory in the solution directory:
```
UnitTestCoverageDemo
|
|_ scripts
| |
| |_ run_tests.sh
| |
| |_ run_tests.ps1
|
|_ UnitTestCoverageDemo.sln
|
*
*
```
If you want to use a different directory structure, you might need to do some modifications to them. Executing this scripts will run the tests, create the coverage files, create the report and open the report.
## Thanks!
Thanks for reading this article! I hope this was helpful and as fun to read as it was to write!

[LinkedIn article](https://www.linkedin.com/pulse/net-core-open-source-unit-test-coverage-reports-federico-antu%25C3%25B1a)

repository: fedeantuna/UnitTestCoverageDemo

repo_name: fedeantuna/UnitTestCoverageDemo


text:
---
title: Project Rescue
description: Projects critical to business needs can rack up significant technical debt. Feature development slows. Maintenance and security fixes pile up. Versions of the technology powering the project have reached end-of-life. Key technical people have moved on. The project spirals towards a perilous end. When this happens, the project needs to be rescued.
slug: project-rescue
related-projects:
  Webstats: 'webstats'
  Full Slate: 'full-slate-rails-upgrade'
  EssayJack: 'essayjack-code-audit'
---

1. Code Audit
  * We’ll deep dive into your codebase and technical processes, identify what is working and what isn’t, then recommend a suitable course of action.
2. Optimization and Support
  * We’ll provide immediate support for your application, even if our recommendation is to significantly rework things. Your business still needs to function in the short term after all.
3. Technical Debt Repayment
  * Whether we have agreed to carry out some refactoring of the existing application, re-architect larger pieces of it or perform a complete rebuild - this is when we get busy implementing this work.
4. Custom Software Development
  * With the project back on track, we can transition into providing more typical product development for your application.
5. In-House Team
  * Eventually you may prefer to staff your technical team yourself. We can help you do that, and help hand off associated responsibilities too.


text:
# Official rpm available

**Axosoft now offers official RPM packages** on the [gitkraken website](https://www.gitkraken.com).
They are guaranteed to be up to date and should be used instead of this script.

repository: antars-es/gitkraken

repo_name: antars-es/gitkraken


text:
Engram keyboard layout
======================

© 2021 Arno Klein

Version 2.0

Description
-----------

# Arno's Engram key layout

Engram is a key layout optimized for comfortable and efficient touch typing in English
created by [Arno Klein](https://binarybottle.com),
with [open source code](https://github.com/binarybottle/engram) to create other optimized key layouts.

Letters are optimally arranged according to a scoring model that reflects ergonomics factors that promote reduction of lateral finger movements and increase in efficient typing of high-frequency letter pairs:

                B Y O U   L D W V Z
                C I E A   H T S N Q
                G X J K   R M F P

Punctuation marks are logically grouped together in the middle columns (accessed by the Shift and R-Alt keys) and numbers are paired with mathematical and logic symbols (accessed by the Shift Key):

     [{ 1| 2= 3~ 4+  5<  6>  7^ 8& 9% 0* ]} /\
        bB yY oO uU  '(  ")  lL dD wW vV zZ #$ @`
        cC iI eE aA  ,;  .:  hH tT sS nN qQ
        gG xX jJ kK  -_  ?!  rR mM fF pP

Links
-----

https://engram.dev

https://github.com/binarybottle/engram-layout

Supported Platforms
-------------------
 * Windows
 * macOS
 * Linux
 * Web
 * Desktop devices

ToDo
----

repository: keymanapp/keyboards

repo_name: keymanapp/keyboards


text:
---
title: Adafruit Microcontrollers and Circuitpython
date: 20 Nov 2019
---

Adafruit's more advanced micro controllers come with a version of
[MicroPython](http://micropython.org/) installed on them called
 [Circuitpython](https://learn.adafruit.com/welcome-to-circuitpython/what-is-circuitpython).
I have worked with some of these micro controllers and really like them.

## What is it?

CircuitPython is a lean and efficient implementation of the Python 3 programming language that includes a small subset of the Python standard library and is optimised to run on microcontrollers and in constrained environments.

## Documentation

[CircuitPython Latest Docs](https://circuitpython.readthedocs.io/en/latest/docs/index.html)
[Adafruit CircuitPython Library Bundle Docs](https://circuitpython.readthedocs.io/projects/bundle/en/latest/index.html)

## Libraries

There are a lot of libraries available:

- [Adafruit's github repos](https://github.com/adafruit/Adafruit_CircuitPython_Bundle)
- [HCSR-04 drivers](https://github.com/mmabey/CircuitPython_HCSR04)

## Boot

![](boot.png)

## USB Serial Connection to REPL

You can interact with the board's REPL using `screen /dev/tty* 115200`. Linux serial is typically `/dev/ttyACM*` and Apple is `/dev/usbmodem*`. You can stop `screen` with `Ctl-a` then `k`.

## Trinket M0

<img src="Trinket_M0.png" width="500px">

repository: walchko/github-blog

repo_name: walchko/github-blog


text:
# Software Components: Acropolis

___

[Video](https://youtu.be/QzX9Yxg6490)

Acropolis is a distributed data plane for either VMs or container-based applications that runs across a cluster of nodes delivering enterprise storage and virtualization services. Acropolis is also the foundation of an HCI solution that transforms HCI into a Hybrid Cloud OS.

Here are the main components:

* The Distributed Storage Fabric (DSF)
* The Acropolis Hypervisor (AHV)
* Scale-out storage services
* Advanced virtual networking

[Acroplois: Distrubuted Storage Fabric](https://youtu.be/_nVCuhNx4is)

Here is a representation of the Distributed Storage Fabric (DSF). The DSF simplifies storage and data management for virtual environments, by pooling flash and hard disk drive storage across a Nutanix cluster and exporting it as a data store to the virtualization layer as Small Computer Systems Interface (iSCSI), Network File System (NFS), and Server Message Block (SMB) which are all different ways of data sharing.

DSF offer capabilities:

* Snapshots
* Compression
* Cloning
* Data locality
* Deduplication
* Erasure coding
* Tiering
* Replication

[Acropolis: AHV](https://youtu.be/bhTCVZeyaGw)

Acropolis Hypervisor (or AHV) is a comprehensive virtualization solution that’s included as part of the Nutanix solution, bundled with Acropolis.

AHV is the virtualization layer in the illustration example. It enables a variety of key capabilities including:

* Backup
* Disaster recovery
* Host and VM high availability
* Dynamic scheduling

[Acropolis: Scales-out Storage Services](https://youtu.be/AYFqKKTIZ0A)

Nutanix allows you leverage scale-out, fully software-defined storage services via Nutanix Files, Nutanix Volumes, and Nutanix Objects.

* Nutanix Files file services provides access to Microsoft Windows via SMB 2.1 and to Linux and Unix via the NFS v4 protocol. It also scales and load balances multiple nodes in the cluster, growing capacity and performance as needed.
* Nutanix Volumes block services provides iSCSI access to applications that require direct access to block storage. This can be non-virtualized systems, or virtual machines with specific requirements. Volumes uses the DSF to scale I/O across the entire cluster and can load balance and accelerate specified Volume Groups.
* Nutanix Buckets object storage services is a software-defined object storage solution that non-disruptively scales out while lowering overall costs. It supports an industry-standard S3-compatible REST API to handle petabytes of unstructured data.

[Acropolis: Virtual Networking](https://youtu.be/GZGeljseVS4)

Nutanix Flow:

* Delivers advanced networking and security services, providing visibility into the virtual network, application-centric protection from network threats and automation of common networking operations.
* Allows organizations to deploy software-defined virtual networking without having to install and manage additional products that have separate management and independent software maintenance requirements.
* Provides detailed visualization of communications between VMs, making it simple and straight-forward to set the right policies for the environment.
* Micro-segmentation provides granular control and governance of all traffic into and out of a VM, or groups of VMs. It ensures that only permitted traffic between application tiers or other logical boundaries is allowed and protects against advanced threats propagating within the virtual environment.
* Provides API-based notifications enabling third-party network devices to observe VM lifecycle events, such as the instantiation of a new VM into the Nutanix environment.

path: /2.5 Software Components Acropolis.md

filename: 2.5 Software Components Acropolis.md


text:
---
title: Citable workflows
redirect_from: /citable/
---

Workflows registered in <https://workflowhub.eu/> that are _public_ can be assigned a [DOI](https://www.doi.org/) (Digital Object Identifier) so that they can more easily be cited in academic work.

WorkflowHub DOIs are registered with [DataCite](https://datacite.org/) using the [DataCite Metadata Schema](https://schema.datacite.org/), meaning that the metadata joins the scholarly knowledge graphs [DataCite Commons PID Graph](https://commons.datacite.org/doi.org?query=client.uid:borq.00002-2021) and [OpenAIRE Research Graph](https://graph.openaire.eu/) ([example](https://explore.openaire.eu/search/software?pid=10.48546%2Fworkflowhub.workflow.160.1)).

## Assign a workflow DOI

You can assign DOIs for workflows you have registered and that you have been given write access to.  You are not able to make DOIs for other people's workflows.

Each version of the workflow must be registered separately. You can create a [new version](https://about.workflowhub.eu/Updating-a-registered-workflow/) of a workflow that has been assigned a DOI, without necessarily giving the new version a DOI yet.

Note that DOI minting is only enable on the production instance <https://workflowhub.eu/>, although you can try the below instructions up to the _"Publish"_ step on the sandbox instance <https://dev.workflowhub.eu/>.

### Check metadata

Before you mint a DOI, make sure you check the correctness of the [metadata of the workflow entry](https://about.workflowhub.eu/Registering-a-workflow-with-a-diagram-and-abstract-CWL/), and that it makes sense globally, as this will be part of the DataCite registration. Use _Actions -> Edit Workflow_ and _Actions -> Manage workflow_ to fill in:

* Title (is it specific enough)
* Creators (you can include registered WorkflowHub users or others by name)
* Status of workflow
* Description
* License

For each of the registered users, it may be good to check that their [ORCID](https://orcid.org/) identifier has been registered. This ensures that the people will be uniquely identified. Users can edit _"My Profile"_ to link to ORCID.

### Freezing the Workflow version

Before we can mint a DOI, we need to _freeze_ the version of the workflow in WorkflowHub, so that its metadata stay consistent with the DOI registration.

![Freeze version](https://user-images.githubusercontent.com/253413/151150858-53c72ec7-3b9d-4349-9b99-8449eea396f9.png)

### Publishing workflow

![public](https://user-images.githubusercontent.com/253413/151160453-e471389f-1824-4390-a182-59ee8d684d4d.png)

You need to check this workflow is _Public_. Either click the button as above, or edit under _Manage Workflow_:

![permissions](https://user-images.githubusercontent.com/253413/151153355-2eefc5e6-c019-43bd-b041-633c7e15fb4c.png)

### Generate DOI

Now we can create a DOI:

![Generate a DOI](https://user-images.githubusercontent.com/253413/151153468-b6e63f0f-955c-4d08-aeec-9183a00ee840.png)

A pop-up will remind you to revise the metadata and confirm:

![Comfirm DOI](https://user-images.githubusercontent.com/253413/151153585-994b0d33-74c9-4ab3-b1b5-7a8669405810.png)

### Finding DOI

DOIs that have been minted for workflows are shown as part of the workflow entry:

![doi in listing](https://user-images.githubusercontent.com/253413/151153977-ece6cfe0-4aa1-437b-a7f8-7e0a395d76f9.png)

### Citing Workflows

You can generate a citation for a chosen journal style in the _Citation_ box:

![citation](https://user-images.githubusercontent.com/253413/151154405-d027f1ef-2c27-4c94-ab03-0fb141b8611b.png)

Note that as this generated citation is based on the corresponding [CSL styles](https://citationstyles.org/), which may not include the DOI as part of its template for Software citations, or may append a `.` to the shown URL.

Therefore remember to add the DOI to the citation in your reference manager, for instance as a comment or URL.

Example:

Douglas Lowe and Genís Bayarri. 2021. “Protein Ligand Complex MD Setup Tutorial Using BioExcel Building Blocks (Biobb) (Jupyter Notebook).” _WorkflowHub_.
<https://doi.org/10.48546/workflowhub.workflow.56.2>

### Retrieving DataCite metadata

You can look up the DataCite metadata of WorkflowHub DOI registrations using their [programmatic APIs](https://datacite.org/integratorapis.html) or the [DataCite Commons](https://commons.datacite.org/).

For instance, from <https://commons.datacite.org/doi.org/10.48546/workflowhub.workflow.56.2> we can download the metadata as [DataCite XML](https://api.datacite.org/application/vnd.datacite.datacite+xml/10.48546/workflowhub.workflow.56.2), [DataCite JSON](https://api.datacite.org/application/vnd.datacite.datacite+json/10.48546/workflowhub.workflow.56.2), [Schema.org JSON-LD](https://api.datacite.org/application/vnd.schemaorg.ld+json/10.48546/workflowhub.workflow.56.2), [CiteProc JSON](https://api.datacite.org/application/vnd.citationstyles.csl+json/10.48546/workflowhub.workflow.56.2), [BibTex](https://api.datacite.org/application/x-bibtex/10.48546/workflowhub.workflow.56.2), [RIS](https://api.datacite.org/application/x-research-info-systems/10.48546/workflowhub.workflow.56.2).

**Note**: The schema.org metadata rendered by DataCite may differ slightly from the more complete metadata embedded in a WorkflowHub entry's HTML and RO-Crate.

Example of returned DataCite XML following [DataCite Schema 4.3](https://schema.datacite.org/meta/kernel-4.3/):

```xml
<?xml version="1.0" encoding="UTF-8"?>
<resource xmlns="http://datacite.org/schema/kernel-4" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://datacite.org/schema/kernel-4 http://schema.datacite.org/meta/kernel-4.3/metadata.xsd">
  <identifier identifierType="DOI">10.48546/WORKFLOWHUB.WORKFLOW.56.2</identifier>
  <titles>
    <title xml:lang="en-gb">Protein Ligand Complex MD Setup tutorial using BioExcel Building Blocks (biobb) (jupyter notebook)</title>
  </titles>
  <descriptions>
    <description xml:lang="en-gb" descriptionType="Abstract"># Summary

This tutorial aims to illustrate the process of setting up a simulation system containing a protein in complex with a ligand, step by step, using the BioExcel Building Blocks library (biobb). The particular example used is the T4 lysozyme L99A/M102Q protein (PDB code 3HTB), in complex with the 2-propylphenol small molecule (3-letter Code JZ4).

      ....
  </descriptions>
  <creators>
    <creator>
      <creatorName>Lowe, Douglas</creatorName>
      <nameIdentifier nameIdentifierScheme="ORCID" schemeURI="https://orcid.org">https://orcid.org/0000-0002-1248-3594</nameIdentifier>
    </creator>
    <creator>
      <creatorName>Bayarri, Genís</creatorName>
    </creator>
  </creators>
  <publicationYear>2021</publicationYear>
  <publisher>WorkflowHub</publisher>
  <resourceType resourceTypeGeneral="Workflow">Workflow</resourceType>
</resource>
```

**Tip**: You can access these citations programmatically using DataCite's [content negotiation](https://support.datacite.org/docs/datacite-content-resolver) on resolving the DOI.

### Citing a Workflow without a DOI

Note that if a workflow has not got a DOI, you can still cite it using the versioned WorkflowHub _SEEK ID_, e.g. <https://workflowhub.eu/workflows/263?version=1>

You will need to generate the metadata (e.g. _title_ yourself as it has not been verified for citation by the authors.

Warning: As workflow versions without DOIs may not be frozen, it is also possible that the author later decides to withdraw the workflow from public view. Authors may subsequently edit the metadata of a given version, but not its downloadable content.

repository: workflowhub-eu/about

repo_name: workflowhub-eu/about


text:
# django-mongoblog

## Install

Make sure that you have the django-mongoblog/mongoblog directory on your PYTHONPATH.
Then add the application to your INSTALLED_APPS:

    INSTALLED_APPS = (
        ...
        'mongoblog',
    )

and to your urls.py:

    urlpatterns = patterns('',
        ...
        url(r'^blog/', include('mongoblog.urls')),
        ...
    )

The connection is currently made in mongoblog.views to support testing for
mongodb using the testrunner shipped with this app. To use the testrunner,
install the django-mongorunner, change your settings.py and add:

    TEST_RUNNER = 'mongorunner.TestRunner'

## Settings
The following settings are available for the database connection.

    MONGOBLOG_DATABASE_NAME
    MONGOBLOG_DATABASE_USERNAME
    MONGOBLOG_DATABASE_PASSWORD
    MONGOBLOG_DATABASE_HOST
    MONGOBLOG_DATABASE_PORT

## Dependencies

 * Django-1.2-beta-1 (should work with earlier versions without the use of the testrunner)
 * mongoengine
 * PyMongo

## Example
Check mongoblog/views.py and the templates for example usage. To add posts to your mongo-database, simple run the Django interactive shell:

    python manage.py shell

and use the following to add a test Entry.

    from mongoblog.models import Entry
    # status is needed to make the post show up on the blog, otherwise it will default to a draft which will not be visible
    Entry(title='Hello world!', body='This is a test entry!', status=Entry.STATUS_PUBLIC).save()

## Other info
The connection could be moved from the view to settings.py. The reason it's located in views.py is to make the test-suite work with the testrunner that is creating a temporary database. Putting the connection in settings.py will override the testrunners attempt to create and use the test-database. If you don't need to run any tests, feel free to move it if you feel like it.

repository: xintron/django-mongoblog

repo_name: xintron/django-mongoblog


text:
# oracle

This repository is code for the publication "Mapping the functional landscape of the receptor binding domain of T7 bacteriophage by deep mutational scanning" at https://elifesciences.org/articles/63775

repository: raman-lab/oracle

gha_language: R

repo_name: raman-lab/oracle


text:
# generator-jhipster-skipserverweb
[![NPM version][npm-image]][npm-url] [![Build Status][travis-image]][travis-url] [![Dependency Status][daviddm-image]][daviddm-url]
> JHipster blueprint, Blueprint that allows for a Java web layer to be skiped during code generation.

# Introduction

This is a [JHipster](https://www.jhipster.tech/) blueprint, that is meant to be used in a JHipster application.

This blueprint is intended for applications/projects that would like to take benefit from JHippster generator capabilities in creating Java JPA model, DTO's, JPA Repositories and Service layer, but **do not need** Controllers, Mappers and other components specific for Web applications.

Examples of this kind of applications would be: Spring Shell CLI apps, or Java FX based Desktop applications.

In short once installed this bluprint will skip the generation of all web components.

**What this blueprint does not do at the moment.**

Current version of the bluprint does not change build files: gradle.build or pom.xml.

You still need to manually remove web dependencies you do not need from these!

# Supported JHipster version
Current version of the JHipster generator this bluprint is adjusted for, is JHipster version 6.10.5.

# Prerequisites

As this is a [JHipster](https://www.jhipster.tech/) blueprint, we expect you have JHipster and its related tools already installed:

- [Installing JHipster](https://www.jhipster.tech/installation/)

# Installation

## With NPM

To install this blueprint:

```bash
npm install -g generator-jhipster-skipserverweb
```

To update this blueprint:

```bash
npm update -g generator-jhipster-skipserverweb
```

## With Yarn

To install this blueprint:

```bash
yarn global add generator-jhipster-skipserverweb
```

To update this blueprint:

```bash
yarn global upgrade generator-jhipster-skipserverweb
```

# Usage

To use this blueprint in your Jhipster project run the command bellow:

```bash
jhipster --blueprint skipserverweb
```

## Running local Blueprint version for development

During development of blueprint, please note the below steps. They are very important.

1. Link your blueprint globally

Note: If you do not want to link the blueprint(step 3) to each project being created, use NPM instead of Yarn as yeoman doesn't seem to fetch globally linked Yarn modules. On the other hand, this means you have to use NPM in all the below steps as well.

```bash
cd generator-jhipster-skipserverweb
npm link
```

2. Link a development version of JHipster to your blueprint (optional: required only if you want to use a non-released JHipster version, like the master branch or your own custom fork)

You could also use Yarn for this if you prefer

```bash
cd generator-jhipster
npm link

cd skipserverweb
npm link generator-jhipster
```

3. Create a new folder for the app to be generated and link JHipster and your blueprint there

```bash
mkdir my-app && cd my-app

npm link generator-jhipster-skipserverweb
npm link generator-jhipster (Optional: Needed only if you are using a non-released JHipster version)

jhipster -d --blueprint skipserverweb

```

# License

Apache-2.0 © [Domagoj Madunić]()

[npm-image]: https://img.shields.io/npm/v/generator-jhipster-skipserverweb.svg
[npm-url]: https://npmjs.org/package/generator-jhipster-skipserverweb
[travis-image]: https://travis-ci.org/dmadunic/generator-jhipster-skipserverweb.svg?branch=master
[travis-url]: https://travis-ci.org/dmadunic/generator-jhipster-skipserverweb
[daviddm-image]: https://david-dm.org/dmadunic/generator-jhipster-skipserverweb.svg?theme=shields.io
[daviddm-url]: https://david-dm.org/dmadunic/generator-jhipster-skipserverweb