text:
# Changelog

## 0.9.8

* Fix an issue that prevented params with new lines from being handled properly the hash routing plugin, thanks [maxthelion](https://github.com/maxthelion)
* Fix an issue with the way params are encoded and decoded [issue 70](https://github.com/olivernn/davis.js/issues/70), thanks [Valloric](https://github.com/Valloric)

## 0.9.7

* Pass request options through the location delegate to the location handling object.
* Pass request options through the request redirect method.
* Add a simpler hash routing plugin.

## 0.9.6

* Proper handling of relative paths using $.prop instead of $.attr [issue 58](https://github.com/olivernn/davis.js/issues/58)
* Remove redundent redeclaration inside utils.toArray [issue 60](https://github.com/olivernn/davis.js/pull/60)

## 0.9.5

* Stop trapping click events with modifier keys [issue 40](https://github.com/olivernn/davis.js/pull/40), thanks [manuel-woelker](https://github.com/manuel-woelker) and [Valloric](https://github.com/Valloric)

## 0.9.4

* Router scopes should apply to before and after filters [issue 54](https://github.com/olivernn/davis.js/issues/54)
* Scopes shouldn't be applied to routes defined with RegExp paths.

## 0.9.3

* More fixes for initial popstate bug [issue 52](https://github.com/olivernn/davis.js/issues/52)
* Fix issue with noIOS extension [issue 51](https://github.com/olivernn/davis.js/issues/51)
* Fix issue when delegating to server with query params [issue 43](https://github.com/olivernn/davis.js/issues/43)
* Add a timestamp to request objects.

## 0.9.2

* Fix initial popstate bug

## 0.9.1

* Fix bug with using route level middleware with routing shortcut methods.
* Fix bug with decoding url encoded parameters [issue 39](https://github.com/olivernn/davis.js/issues/39)

## 0.9.0

* Add support for scoped definition of routes using `scope`.
* Add support for route level middleware.
* Add support for splat params in route definition.
* Davis.location now accepts an options param, allowing to assign/replace routes silently.
* Changed the signature for creating Davis.Routes, can now just pass a string as the path.
* Closer adherence to the same origin policy when binding to links and forms.
* Fix bug where params in the request object were still URI encoded.
* Explicitly prevent default when binding to links and forms, allows better integration with ender.

## 0.8.1

* Fix issue with Davis.listener fixes [issue 32](https://github.com/olivernn/davis.js/issues/32)
* Move davis.fblike and davis.mixpanel into the correct directory

## 0.8.0

* Davis is no longer dependent on jQuery, can be used with any or no DOM library with the use of extensions.
* Added Zepto extension to allow Davis to be used with Zepto.
* More robust checking of link origins, protocols must match to be caught by Davis, thanks [jacobcoens](http://github.com/jacobcoens)
* Added Mixpanel plugin, thanks [hleinone](https://github.com/hleinone)
* Added Facebook Like plugin, thanks [hleinone](https://github.com/hleinone)
* Fixed several bugs with the hashRouting extension.

## 0.7.0

* Refactor of internals, many components now implemented as Davis plugins, making it easier to extend the library.
* Simplify build tools, removed dependencies on ruby and java.  Now all you need is make and node.js.  Thanks [visionmedia](http://github.com/visionmedia).
* The `Davis` convenience function no longer requires a config function to be passed in when creating an app.  [visionmedia](http://github.com/visionmedia)
* The `Davis` convenience function auto starts the app as soon as possible. [visionmedia](http://github.com/visionmedia).
* Changed default setting `generateRequestOnPageLoad`, now it is false by default.
* `Davis.logger` is now implemented as a plugin not a setting.
* Renamed `Davis.Request.prototype.asJSON` to `Davis.Request.prototype.toJSON`. [visionmedia](http://github.com/visionmedia).
* Fix browser inconsistency bug where Firefox would not fire a popstate event on page load.

## 0.6.2

* Fix [issue](https://github.com/olivernn/davis.js/pull/16) so that a requests' location includes any query params.  Fixed by [hleinone](https://github.com/hleinone).

## 0.6.1

* Normalise node name when checking link and form origins, fixes [bug](https://github.com/olivernn/davis.js/pull/12) when used in xhtml documents.  Reported by [sabberworm](https://github.com/sabberworm).
* Fix [issue](https://github.com/olivernn/davis.js/issues/14) when submitting forms with only file inputs or with no inputs.  Reported by [hleinone](https://github.com/hleinone).

## 0.6.0

* Ignore any links or forms that are not on the same origin, only listen to clicks on links and forms with a href or action from the same domain.
* Big upgrade to the hashRouting extension, adding fallback for browsers that don't support `onhashchange` & the ability to fallback to hash based routing in browsers that do not support pushState.  Many thanks to [jbaudanza](https://github.com/jbaudanza).
* Fix [bug](https://github.com/olivernn/davis.js/pull/6) in Davis.Request so that full urls are handled properly, [jbaudanza](https://github.com/jbaudanza).
* Fix [bug](https://github.com/olivernn/davis.js/pull/8) when parsing rails style nested params with arrays, thanks [ismasan](https://github.com/ismasan).
* Creating instances of Davis.Request should be more robust, fixes issues seen in some versions of Chrome.
* State data is pushed into the history state object under a `_davis` prefix to defend against any possible clashes with other code manipulating the history.
* Add extension to disable Davis support in iOS versions less than 5.

## 0.5.1

* Fixes required for Opera support now that Opera 11.50 supports pushState.
* Ensure that jQuery is never referenced as $.

## 0.5.0

* Introduce Davis.location object which acts as an interface to any kind of routing mechanism.  Expects to be passed a delegate object which will do the actual routing work.  By default the delegate is the HTML5 pushState module Davis.history.
* Renamed methods on Davis.history to match the interface set out by Davis.location.  `Davis.history.pushState` becomes `Davis.history.assign` & `Davis.history.replaceState` becomes `Davis.history.replace`.
* Added `Davis.extend` method for adding library level extensions.
* Added Davis.hashRouting extension allowing use of location.hash based routing.
* Changed `Davis.App.prototype.configure` so that the settings object is yielded as the first argument to the config function.

## 0.4.3

* Merge [pull request](https://github.com/olivernn/davis.js/pull/4) fixes issues with IE's console functions/objects and IE's handling of lastIndex, thanks to [jbaudanza](https://github.com/jbaudanza).

## 0.4.2

* Fixed [bug](https://github.com/olivernn/davis.js/issues#issue/3) by introducing a utils module which uses native implementations of `Array.prototype.every`, `Array.prototype.forEach`, `Array.prototype.filter`, `Array.prototype.map` if they exist and if not falls back to a non native implementation.  This allows Davis.js to fail gracefully in IE.  Thanks to to [jbaudanza](https://github.com/jbaudanza) for reporting the issue.

## 0.4.1

* If no route is found for the initial page load request don't stop the app
* Log a message when the app is stopped

## 0.4.0

* Only get requests should change the browser url, all others will create an entry in the history but not change the url
* By default any routes not handled by Davis will be automatically sent to the server.  This can be configured using the setting `handleRouteNotFound`
* Request methods and paths are now case insensitive
* Fixed bug which meant that restarting a Davis app would lead to events being bound to twice
* Work when jQuery is in no conflict mode

## 0.3.3

* Fixed [bug](https://github.com/olivernn/davis.js/issues#issue/2) when links contained other elements, reported by [kbingman](https://github.com/kbingman)

## 0.3.2

* Fixed bug which caused the initial page load to trigger two requests.
* Made the initial request for the page load configurable, by default it is on.

## 0.3.1

* fixed bug with `request.redirect` so that the browser url is set correctly.

## 0.3.0

* Added `app.use` to use plugins in a Davis.App
* Added `app.helpers` to add helper methods to a Davis.Request object, available with a route callback.
* Created a Davis.title plugin, a simple plugin to set the page title for each request.
* Created a Davis.google_analytics plugin, a simple plugin to enable google analytics tracking of requests.
* Can now throw errors that happen in a route callback, this is disabled by default but can be enabled using `app.settings.throwErrors`.  When disabled an http request is made to the server.
* Add `routeError` event, triggered when an error occurs in a route callback.

## 0.2.1

* `request.whenStale` callback should receive the new request as a param and have this bound to the
new request.

## 0.2.0

* Add `app.state` and `app.trans` to allow for routes that do not change the page url bar but are still navigable via the back and forward button.
* Add `request.whenStale` callback, called whenever a route becomes stale, i.e. when another route has been triggered by a new request.
* Fail more gracefully when `pushState` is not available [cmalvern](https://github.com/cmalven)
* Trigger 'unsupported' event when running in a browser that is unsupported

repository: ryanfb/hocr-reader

branch_name: refs/heads/gh-pages

repo_name: ryanfb/hocr-reader


text:
---
title: How to Build a Jekyll Blog for FREE
subtitle: Build Jekyll blog
header-img: Jekyll blog (1).png
categories:
  - blogging
featured-image: Jekyll blog (1).webp
slug: build-jekyll-blog-free
excerpt: In this blog, I will walk you through the process of building a Jekyll blog for FREE. You will learn the step-by-step process of building a jekyll website.
toc: true

---

So you finally decided to build a blog that costs you nothing. I am sure you have read the benefits of building a blog before taking the decision. Buckle up, as I take you through the next part which deals with building a free blog with Jekyll on Github pages.

To make you navigate through the blog in an easy way, I divided this blog into two parts:

Choosing the platform: Why Static Site Generator? What are its advantages over Wordpress?

Jekyll: Getting Started with Jekyll in Ubuntu and Windows

## Choosing the platform: Why Static Site Generator?

In 2017, I created my first ever blog on WordPress and it was an awesome experience. The process was not at all time consuming, let alone cost-effective. Since a lot of marketing experiments deal with Wordpress, it was obvious to be my initial choice. However, I wanted to experiment with something different; something which makes me learn one thing or two.

I stopped working on Wordpress as I invested a major chunk of my time learning HTML, CSS, and Javascript. SEO was not new to me; I am doing it since the beginning of my career. I wanted to do something more interesting.

In 2019, I decided to build my personal site on Github. I played around with Bootstrap for a while but found it time-consuming. The other day a friend of mine mentioned the concept of static-site-generators to me, I found it appealing. Since my favorite note-taking format remained Markdown, I liked the concept at first glance.

Wordpress was always an alternative for me but I dislikened the whole process of choosing, buying and renewing the hosting and domain name. With Static-site-generators, I had the option of serving the HTML on Github pages for FREE. Here’s why I settled on Jekyll using Github pages after trying out several Static-site options such as Pelican and Hugo. Of course, I had my other reasons to support the decision such as speed, cost-savings, security, maintainability, and customizations.

Let’s take these advantages one-by-one:

### Cost

One of the main reasons for choosing Jekyll over Wordpress would be the cost.

Wordpress makes your pocket loaded with investments like domain name, hosting (webserver), PHP and a database. Although most hosting plans give you a good deal for the first year but after a couple of years, it does get pricey.

For me, since I have hosting and domain for about three years, this came out to Rs. 2500 (hosting for 3 years) + Rs. 1000 (domain for 1 year). With static sites such as Jekyll, the cost goes down to Rs. 0/year (or only Rs. 1000 if I want a .com domain extension). What’s more, you can host your static site for free using platforms like Github Pages and Netlify.

### Speed

Another solid reason to build a blog with a Static-site generator is speed.

Wordpress gives you a dynamic way of loading the content live in a database, which gets converted into HTML only when a user wants to see the page. The entire process is request-heavy with steps like building the page from a template or theme, grabbing the content and sending the completed page to the user.

With Jekyll or any other static site, the whole site gets uploaded to the server as a folder full of assets (HTML, CSS, images, etc.). The entire process of requesting and fetching the content is seamless as the assets are already statically loaded on the server. This improves the page load speed significantly. With Wordpress, however, you still need to optimize the performance and speed with a variety of plugins which slows down the website. If you are still not convinced, Nikola has written a nice blog on the topic: “Why Static?”.

Below are tests I ran using the Pingdom Website Speed Test on my WordPress and static site.

#### WordPress Test

![Wordpress test](/images/Wordpress speed test.webp)

#### Static Site Test

![Wordpress test](/images/static site speed test.webp)

### Security

When was the last time you heard someone telling you to update your CMS and plugins for better security in Wordpress? If the stats are to be believed, over 70% of all WordPress installs are vulnerable to known security glitches.

Static sites, on the other hand, give you a free hand to experiment with your code without having to worry about malware. Static sites are built on a production machine (probably the machine you are reading this on) by static site generators, which take your code and spit out flat HTML files with CSS and JavaScript. When a user requests a page from your site, the server just sends them the file for that page, instead of building that page from various assets each time. No build process means standard hacking attacks like scripting or database security exploits just don’t work.

## Choosing Jekyll as a static site generator: Getting Started

The other day I was looking for options to build a static-site, the numbers are overwhelming. At the time of writing this blog, there are over 463 options to build a static site. And the numbers are increasing day by day!

Remember I mentioned about trying options such as Pelican and Hugo for building a blog. It was fun playing with them but I decided to stick with Jekyll. I will tell you exactly the reasons for choosing Jekyll as a static site generator in an upcoming blog.

### Prerequisite of working with Jekyll

Although you won’t require much language knowledge to get a static site up and running, I would still recommend you to polish basic HTML and CSS skills. You will require them during website customization. As an addition, I would recommend you to learn basic Git commands to work on Ubuntu.

Now that the prerequisites are known, let’s move on and learn how to build a blogging website with Jekyll for Free.

## Building a FREE blog: Setting up Jekyll on Github Pages

### *Step 1:* Installing Jekyll with Ruby

First things first, let's install Jekyll on your computer

Since Jekyll is a static site generator, there is no involvement of the server, database, and backend. All you need is to have a local copy of the site on your computer. You will edit the local files on your machine directly and deploy the changes to the Github repo which is the online version of the site.

To work with the local copy, you need to install Jekyll on your computer. The first step would be to update all the system packages in Ubuntu to their latest release.

sudo apt update
sudo apt -y upgrade
sudo reboot

To work with Jekyll, you will need to have a working Ruby development environment which includes libraries. Use the following commands to install Jekyll and various build tools required:

sudo apt -y install make build-essential

Install Ruby package and development tools:

sudo apt -y install ruby ruby-dev

The next step would be to instruct Ruby’s gem package manager to place gems in the user’s home directory.  Add Environment variable to ~/.bashrc field.

echo '# Install Ruby Gems to ~/gems' >> ~/.bashrc
echo 'export GEM_HOME=$HOME/gems' >> ~/.bashrc
echo 'export PATH=$HOME/gems/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

Use gem to Install Jekyll and Bundler which is a tool used to manage gem dependencies.

$ gem install bundler
Fetching: bundler-2.0.2.gem (100%)
Successfully installed bundler-2.0.2
Parsing documentation for bundler-2.0.2
Installing ri documentation for bundler-2.0.2
Done installing documentation for bundler after 2 seconds
1 gem installed

Install Jekyll on Ubuntu with the following command:

$ gem install jekyll

#Step 2:Choose a Jekyll theme you like to have on your Website

This is the thing I like about Jekyll: an extensive theming system. With Jekyll, you will find almost dozens of communities that offers community-maintained templates and styles to customize your site’s presentation.

You can find and preview Jekyll themes on the following galleries:

jamstackthemes.dev

jekyllthemes.org

jekyllthemes.io

Jekyll-themes.com

To install a theme, navigate to the theme’s Github Repo and fork it. In my case, I used Urban Jekyll template on my Jekyll website. Here’s a fork for the same:

![Forking the repo](/images/Forking the repo.webp){:class="lazyload"}

The next step will be to rename the repository to username.github.io. In my case, I shall rename it to rakshitsoral.github.io.

![Renaming the forked repo](/images/Renaming the forked repo.webp)

Now clone the repo to your local machine:

$ git clone https://github.com/rakshitsoral/urban-jekyll-template.git

Now move to the folder containing all the files:

$ cd urban-jekyll-template

Initialize the git repo

$ git init

Run the site on your local machine:

$ bundle exec jekyll serve

Navigate to http://localhost:4000/ and Voilla, your site is live. It should look like the following image:

![Urban Jekyll Template](/images/urban jekyll template.webp){:class="lazyload"}

It doesn’t look bad, does it?

Wrapping up

There you go! In this part, you learned how to build a FREE blog using Jekyll. In the next part of the series, I would walk you through the way I customized the whole site. It will include modifying the home page, setting up the Goodreads quote widget, adding recent posts widget and a lot more.

Untill then, Saayonara!

license: MIT

repository: rakshitsoral/urban-jekyll-template

branch_name: refs/heads/master

extension: md

gha_language: SCSS

gha_license_id: MIT

license_type: permissive

repo_name: rakshitsoral/urban-jekyll-template


text:
#libefsm -  Expandable FSM Implementation Library

##Description

This project contains various implementations of an infrastructure to create and design (Finite State Machines)[http://en.wikipedia.org/wiki/Finite-state_machine]  (FSMs). It is intended for testing, comparing and benchmarking different FSM implementations purposed for embedded C/C++ applications.

## Licensing

This library is licensed under the BSD 3-clause ("Newer") license.

##Installation

This is a standard CMake build. The following steps are used to build from source:

1. cd build/
2. cmake ..
3. make

----
Copyright (C) 2015, Vassilios Tsounis

repository: vastsoun/libefsm

repo_name: vastsoun/libefsm


text:
# A tool to explore the processes and their memory running inside of a Windows KVM machine

###### Prerequisites
- QT 5 with qmake

###### Compiling
qmake

make -j 8

Run as root.


text:
# Distances

Distance classes compute pairwise distances/similarities between input embeddings.

Consider the TripletMarginLoss in its default form:
```python
from pytorch_metric_learning.losses import TripletMarginLoss
loss_func = TripletMarginLoss(margin=0.2)
```
This loss function attempts to minimize [dap - dan + margin]+.

Typically, dap and dan represent Euclidean or L2 distances. But what if we want to use a squared L2 distance, or an unnormalized L1 distance, or a completely different distance measure like signal-to-noise ratio? With the distances module, you can try out these ideas easily:
```python
### TripletMarginLoss with squared L2 distance ###
from pytorch_metric_learning.distances import LpDistance
loss_func = TripletMarginLoss(margin=0.2, distance=LpDistance(power=2))

### TripletMarginLoss with unnormalized L1 distance ###
loss_func = TripletMarginLoss(margin=0.2, distance=LpDistance(normalize_embeddings=False, p=1))

### TripletMarginLoss with signal-to-noise ratio###
from pytorch_metric_learning.distances import SNRDistance
loss_func = TripletMarginLoss(margin=0.2, distance=SNRDistance())
```

You can also use similarity measures rather than distances, and the loss function will make the necessary adjustments:
```python
### TripletMarginLoss with cosine similarity##
from pytorch_metric_learning.distances import CosineSimilarity
loss_func = TripletMarginLoss(margin=0.2, distance=CosineSimilarity())
```
With a similarity measure, the TripletMarginLoss internally swaps the anchor-positive and anchor-negative terms: [san - sap + margin]+. In other words, it will try to make the anchor-negative similarities smaller than the anchor-positive similarities.

All **losses, miners, and regularizers** accept a ```distance``` argument. So you can try out the ```MultiSimilarityMiner``` using ```SNRDistance```, or the ```NTXentLoss``` using ```LpDistance(p=1)``` and so on. Note that some losses/miners/regularizers have restrictions on the type of distances they can accept. For example, some classification losses only allow ```CosineSimilarity``` or ```DotProductSimilarity``` as their distance measure between embeddings and weights. To view restrictions for specific loss functions, see the [losses page](losses.md)

## BaseDistance

All distances extend this class and therefore inherit its ```__init__``` parameters.

```python
distances.BaseDistance(collect_stats = False,
						normalize_embeddings=True,
						p=2,
						power=1,
						is_inverted=False)
```

**Parameters**:

* **collect_stats**: If True, will collect various statistics that may be useful to analyze during experiments. If False, these computations will be skipped. Want to make ```True``` the default? Set the global [COLLECT_STATS](common_functions.md#collect_stats) flag.
* **normalize_embeddings**: If True, embeddings will be normalized to have an Lp norm of 1, before the distance/similarity matrix is computed.
* **p**: The distance norm.
* **power**: If not 1, each element of the distance/similarity matrix will be raised to this power.
* **is_inverted**: Should be set by child classes. If False, then small values represent embeddings that are close together. If True, then large values represent embeddings that are similar to each other.

**Required Implementations**:
```python
# Must return a matrix where mat[j,k] represents
# the distance/similarity between query_emb[j] and ref_emb[k]
def compute_mat(self, query_emb, ref_emb):
    raise NotImplementedError

# Must return a tensor where output[j] represents
# the distance/similarity between query_emb[j] and ref_emb[j]
def pairwise_distance(self, query_emb, ref_emb):
    raise NotImplementedError
```

## BatchedDistance

Computes distance matrices iteratively, passing each matrix into ```iter_fn```.

```python
distances.BatchedDistance(distance, iter_fn=None, batch_size=32)
```

**Parameters**:

* **distance**: The wrapped distance function.
* **iter_fn**: This function will be called at every iteration. It receives ```(mat, s, e)``` as input, where ```mat``` is the current distance matrix, and ```s, e``` is the range of query embeddings used to construct ```mat```.
* **batch_size**: Each distance matrix will be size ```(batch_size, len(ref_emb))```.

**Example usage**:
```python
from pytorch_metric_learning.distances import BatchedDistance, CosineSimilarity

def fn(mat, s, e):
	print(f"At query indices {s}:{e}")

distance = BatchedDistance(CosineSimilarity(), fn)

# Works like a regular distance function, except nothing is returned.
# So any persistent changes need to be done in the supplied iter_fn.
# query vs query
distance(embeddings)
# query vs ref
distance(embeddings, ref_emb)
```

## CosineSimilarity
```python
distances.CosineSimilarity(**kwargs)
```

The returned ```mat[i,j]``` is the cosine similarity between ```query_emb[i]``` and ```ref_emb[j]```. This class is equivalent to [```DotProductSimilarity(normalize_embeddings=True)```](distances.md#dotproductsimilarity).

## DotProductSimilarity
```python
distances.DotProductSimilarity(**kwargs)
```
The returned ```mat[i,j]``` is equal to ```torch.sum(query_emb[i] * ref_emb[j])```

## LpDistance
```python
distances.LpDistance(**kwargs)
```
The returned ```mat[i,j]``` is the Lp distance between ```query_emb[i]``` and ```ref_emb[j]```. With default parameters, this is the Euclidean distance.

## SNRDistance
[Signal-to-Noise Ratio: A Robust Distance Metric for Deep Metric Learning](http://openaccess.thecvf.com/content_CVPR_2019/papers/Yuan_Signal-To-Noise_Ratio_A_Robust_Distance_Metric_for_Deep_Metric_Learning_CVPR_2019_paper.pdf){target=_blank}
```python
distances.SNRDistance(**kwargs)
```
The returned ```mat[i,j]``` is equal to:

```python
torch.var(query_emb[i] - ref_emb[j]) / torch.var(query_emb[i])
```

repository: KevinMusgrave/pytorch-metric-learning

gha_language: Python

repo_name: KevinMusgrave/pytorch-metric-learning


text:
title: React & Co
subtitle: Much more fun than Angular :-)
class: animation-fade
layout: true

.bottom-bar[
{{title}}
]

---

class: impact

# {{title}}

## {{subtitle}}

.title-oli[
Oliver Sturm • @olivers &bull<EMAIL_ADDRESS>]

.title-logo[

]

---

## Oliver Sturm

- Training Director at DevExpress
- Consultant, trainer, author, software architect and developer for over 25 years

- Contact<EMAIL_ADDRESS>
---

## Agenda

- The React Success Story
- Starting with the Basics
- Trend and Future: Functional React
- Tooling

---

## The React Success Story

.svg[
![Download stats from npmtrends.com](angular-react-vue.png)
]

---

## License Trouble?

- React licensing used to be "BSD + Patents"
- Never mind what that means, it's now standard MIT

---

class: impact

# DEMO

---

## Tooling

- JSX: Well supported by Babel, TypeScript and elsewhere (Markdown - check MDX!)
- Debugging: React Developer Tools

---

## Sources

- This presentation:

  - https://oliversturm.github.io/react-and-co
  - PDF download: https://oliversturm.github.io/react-and-co/slides.pdf

- Demo code:

  - https://github.com/oliversturm/react-and-co

---

class: impact

# Thank You

Please feel free to contact me about the content anytime.

.title-oli[
Oliver Sturm • @olivers &bull<EMAIL_ADDRESS>]

.title-logo[

]

repository: oliversturm/react-and-co

repo_name: oliversturm/react-and-co


text:
# Instagram tools
This repo is for tools which call the unnofficial [Instagram API](https://pypi.org/project/InstagramAPI/) to analyze followers and followings.

## Command Line tools

### cmd/followers.py

Prints a list of Instagram users who follow you but you don't follow.

Prints a list of Instagram users you follow but don't follow you.

To run this program create a .env file in the same folder containing these variables:

INSTA_CLIENT=your instagram user name
INSTA_SECRET=your instagram password

Install the required libraries:
```
pip install python-dotenv
pip install InstagramApi
```
Then run:
```
python followers.py
```

## Ideas for future projects
- Flask app you can log on to
- Timer triggered function that checks once per day and notifies of changes

repository: gbowerman/instagram

branch_name: refs/heads/main

repo_name: gbowerman/instagram


text:
Contains the environment files that I use across the applications that I use.

Installation:

```sh
curl -sSL https://raw.githubusercontent.com/dtanabe/envy/main/.installer/install.sh | sh
```

license: Unlicense

repository: dtanabe/envy

repo_name: dtanabe/envy


text:
# Passalora dendritica var. orbiculata (Desm.) Sacc., 1878 VARIETY

#### Status
SYNONYM

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

#### Published in
Michelia 1(no. 2): 265 (1878)

#### Original name
Cladosporium orbiculatum Desm., 1849

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Dothideomycetes/Pleosporales/Venturiaceae/Fusicladium/Fusicladium orbiculatum/ Syn. Passalora dendritica orbiculata/README.md

repo_name: mdoering/backbone


text:
## Process

Notes about the process surrounding the `galaxy-importer` package, which is a dependency of projects such as:
* Automation Hub [galaxy_ng](https://github.com/ansible/galaxy_ng)
* [pulp-ansible](https://github.com/pulp/pulp-ansible)
* Community Galaxy [galaxy](https://github.com/ansible/galaxy)

#### Issues and pull requests

* Issues are located at [issues.redhat.com JIRA](https://issues.redhat.com/issues/?jql=project=AAH)
* Add a changelog entry to `CHANGES/`. Changelog filename should be the number of the JIRA issue, and the extension of `.feature`, `.bugfix`, `.doc`, `.removal`, or `.misc` - see [towncrier](https://github.com/hawkowl/towncrier#news-fragments) for descriptions of each extension. Example: `CHANGES/56.feature`. File contents should be a one line description of the change.
* At least one commit must include a reference to a Jira issue on a single line in the format of `Issue: AAH-1111`
* If Pull Request is small enough not to need a Jira issue, at least one commit must include a single line with `No-Issue`
* Please run the tests in `Makefile` or install the pre-commit hook in `hooks/pre-commit` and correct any failures prior to submitting a pull request.

#### galaxy-importer Roadmap

* [Prioritized list of tickets](https://issues.redhat.com/issues/?jql=project%20in%20(AAH%2C%20AAP%2C%20ANSTRAT)%20AND%20resolution%20%3D%20Unresolved%20AND%20labels%20%3D%20importer%20ORDER%20BY%20priority%20DESC) labeled `importer`

#### Versioning

Versioning (x.y.z) following https://semver.org/
* Advance the x-stream if breaking backwards-compatibility
* Advance the y-stream for new features
* Advance the z-stream for bugfixes / ci / minor changes

#### Release steps

* Open PR with title `Release #.#.#`
  * Update `galaxy_importer/__init__.py` with new version number
    * Be aware of `galaxy-importer` version range dependencies in [pulp_ansible](https://github.com/pulp/pulp_ansible/blob/main/requirements.txt) and [galaxy_ng](https://github.com/ansible/galaxy_ng/blob/master/setup.py)
  * Run `$ towncrier` to update `CHANGES.rst`
* Merge PR
* Check the master branch CI on the merged commit to ensure it is green
* Tag the commit `v<#.#.#>`, and push the tag to upstream repo
* Check the master branch CI on the merged and tagged commit, it will execute a new job to publish to pypi

#### Testing in other systems

* Latest `galaxy-importer` release will get consumed into `pulp-ansible` nightly builds
* Automation Hub [JIRA AAH issues](https://issues.redhat.com/issues/?jql=project=AAH) may specify a `galaxy-importer` change and a `galaxy_ng` PR will include a new release of `galaxy-importer` for testing by QE
* Community Galaxy [galaxy](https://github.com/ansible/galaxy) importer issues will include a `galaxy` PR with new release of `galaxy-importer`, and get tagged for QE

repository: ansible/galaxy-importer

repo_name: ansible/galaxy-importer


text:
---
title: DebugServerNativeMethods.debugserver_client_receive_with_timeout method
---

Receives raw data using the given debugserver client with specified timeout.

```csharp
public static DebugServerError debugserver_client_receive_with_timeout(
    DebugServerClientHandle client, byte[] data, uint size, ref uint received, uint timeout)
```

| parameter | description |
| --- | --- |
| client | The debugserver client to use for receiving |
| data | Buffer that will be filled with the data received |
| size | Number of bytes to receive |
| received | Number of bytes received (can be NULL to ignore) |
| timeout | Maximum time in milliseconds to wait for data. |

## Return Value

DEBUGSERVER_E_SUCCESS on success, DEBUGSERVER_E_INVALID_ARG when one or more parameters are invalid, DEBUGSERVER_E_MUX_ERROR when a communication error occurs, or DEBUGSERVER_E_UNKNOWN_ERROR when an unspecified error occurs.

## See Also

* enum [DebugServerError](../DebugServerError.md)
* class [DebugServerClientHandle](../DebugServerClientHandle.md)
* class [DebugServerNativeMethods](../DebugServerNativeMethods.md)
* namespace [iMobileDevice.DebugServer](../../iMobileDevice-net.md)

<!-- DO NOT EDIT: generated by xmldocmd for iMobileDevice-net.dll -->

repository: qmfrederik/docsy-perf

gha_language: HTML

repo_name: qmfrederik/docsy-perf


text:
# Entity Shape Create
### Preconditions
Interface is running, logged in an empty region of a domain with editing rights

### Steps

#### Step 1
- run this [script URL](./test.js?raw=true) (from menu/Edit/Open and Run scripts From URL...)
- expected ![](./test.png)


text:
---
title: "February 2021 Releases"
date: 2021-02-03T00:00:00+01:00
tags: ["releases"]
draft: false
---

Hot on the heels of our January release we have a few small bug fixes to the previous release, and a number of very significant improvements to the discovery and configuration subsystems.

This is again a big release, and we suggest you do careful testing of your client applications in your testing environments after reading the `Upgrade Notes` in this post.

The focus of this release has been around Discovery and Configuration, we'll let the planned module changes bake a bit longer to ensure we're 100% stable where we are now before we undertake the next big change. Discovery features no fewer than 3 new discovery methods, we have the start of Data Providers in Compound Filters and exciting new project based configuration, read the full post for details.

Special thanks to Vincent Janelle, Romain Tartière and Ben Roberts for their contributions in this release.

<!--more-->
## Discovery Improvements

The full discovery feature set have been documented at [https://choria.io/docs/concepts/discovery/](https://choria.io/docs/concepts/discovery/), below is a list of improvements in this release:

 * New `external` discovery method allowing any programming language to be used to extend the discovery subsystem. [Go](https://github.com/choria-io/go-external) and [Python](https://github.com/optiz0r/py-mco-agent) supported with helpers.
 * New `inventory` discovery method to discover from a local state cache and supports prepared queries and compound filters
 * New `flatfile` method supporting JSON, YAML, Text Files and STDIN as sources. For YAML and JSON supports using GJSON to query nested structures.
 * Restore the `--nodes` flag, can now read any of the flatfile sources
 * Request chaining and filtering in the `choria req` command: `choria req package status package=php --filter-replies 'ok() && data("ensure")=="5.3.3-49.el6"' -j| choria req service restart service=httpd`
 * Support passing options to discovery methods using `--do`
 * When supplying `-I` filters that are not regular expressions, pql queries or inventory groups avoid discovery all together. Avoids crashing PuppetDB.
 * `choria discover` can now be used by scripts to perform discovery using the `--silent` and `--json` flags
 * Support data providers in the `-S` compound queries. Ship `choria`, `scout` and `config_item` data providers
 * Support all new discovery features in Ruby by invoking the `choria discover` command for discovery

This is a huge list of improvements, discovery in Choria is now better than it's ever been and our `inventory` discovery method is the first offline method to support compound queries. We'll post followup blog posts with details on some of these, meanwhile the new documentation covers everything.

### Inventory Discovery

I want to focus a bit on the `inventory` discovery method. This method allow you to maintain a YAML or JSON file that holds:

 * Detail about nodes - names, facts, classes, sub collective membership
 * Named node groups - essentially pre-created queries that has a name

Below is an example inventory file with 2 node groups - `web` and `db` - and 2 machines in it.  We can target all webservers using `-I group:web` when this discovery method is active.

Maintaining these files are a bit of a drag, you can see we have a `$schema` though, and many editors will download this schema and help you when editing the file.

If you already have these machines you can use Choria to build and maintain the inventory for you:

```nohighlight
$ choria tool inventory --update --dm mc inventory.yaml -W customer=acme
Discovering nodes .... 2

Wrote 2 nodes to /home/user/projects/web/inventory.yaml
```

Any group definitions that were already in your inventory.yaml will be kept, all the facts, classes etc will be updated in the file - so you don't need to maintain it by hand.

This method also supports compound filters to `choria discovery -S "with("nginx") && with("environment=prod")"` would totally work. This is the first time ever we support offline compound queries. Though, of course, without Data Providers.

While I would not recommend this, I've tested this with a 180 MB inventory JSON file containing 10 000 nodes - it worked fine.  The intended use though is for up to 1000 nodes I think, past that other methods will probably work better.

```yaml
$schema: https://choria.io/schemas/choria/discovery/v1/inventory_file.json
groups:
- name: web
  filter:
    classes:
      - nginx
- name: db
  filter:
    classes:
      - mysql
nodes:
  - name: n1.example.net
    classes:
      - nginx
    facts:
      customer: acme
      environment: prod
    collectives:
      - mcollective
      - customers
  - name: n1.example.net
    classes:
      - mysql
    facts:
      customer: acme
      environment: prod
    collectives:
      - mcollective
      - customers
```

## Configuration Improvements

In this release Romain Tartière added a great new feature to support project based configuration.  In short, if in a directory `/home/user/projects/web` you create `choria.conf` this file is read and applied over the normal configuration. This allows you to configure custom discovery, SSL, brokers and more on a per project basis.

First, we documented all the details about configuration, what files are queried and how, how to inspect running configuration, the file format and more.  This can e found on our docs site [https://choria.io/docs/configuration/reference/](https://choria.io/docs/configuration/reference/).

The new `choria tool config` improvements gives insight into the running configuration:

```nohighlight
$ cat choria.conf
plugin.choria.discovery.inventory.source = inventory.yaml
default_discovery_method = inventory
$ ls -l
-rw-rw-r-- 1 rip rip     58 Feb  3 11:17 choria.conf
-rw------- 1 rip rip 660300 Feb  3 11:18 inventory.yaml
$ choria discover -I group:webservers -v
Discovering nodes using the inventory method .... 19
...
Discovered 27 nodes using the inventory method in 0.19 seconds
```

You can see here we have a project specific configuration file `choria.conf` that sets this project to use the new inventory discovery method and has a custom inventory there. We discover the `group:webservers` in the inventory.

You can see your active configuration and what files were involved in resolving that configuration:

```nohighlight
$ choria tool config
Configuration Files:

   User Config: /etc/choria/client.conf
  Loaded Files: /etc/choria/client.conf
                /etc/choria/plugin.d/actionpolicy.cfg
                /etc/choria/plugin.d/choria.cfg
                /etc/choria/plugin.d/login.cfg
                /etc/choria/plugin.d/nrpe.cfg
                /etc/choria/plugin.d/puppet.cfg
                /home/user/work/web/choria.conf

Loaded Configuration:

                                       collectives: mcollective,mt_collective
                          default_discovery_method: inventory
                                          loglevel: warn
                                   main_collective: mcollective
```

## Upgrade Notes

We've done a lot of work on the discovery subsystem in this release, and some of it can simply not be made available to the Ruby client natively. We've therefore taken the decision to delegate all discovery from the Ruby client to the *choria* binary. The Ruby libraries will invoke *choria* and it will do the discovery.  This might seem a bit weird, but it's actually working out well in my experience. The Go clients can discover a 50 000 network in sub 2 seconds, a huge improvement over Ruby, overall this should improve the stability and repeatability of discovery for Ruby in addition to adding new behaviours. On the development side this removes a lot of duplicate code and means its easier for me to deliver a bug free experience.

Going forward we have to support at minimum the *mcorpc-ruby-support* gem version *2.24.1* and Choria Server at *0.20.1*, the Puppet modules will perform the Gem update, On RedHat and Debian/Ubuntu we will bump the Choria version, others will have to configure `choria::version` Hiera data to your version needs, but must be at least *0.20.1*

## [Choria Server version 0.20.2](https://github.com/choria-io/go-choria)

Links: [Changes](https://github.com/choria-io/go-choria/compare/v0.19.0...v0.20.2), [Release](https://github.com/choria-io/go-choria/releases/tag/v0.20.2)

### Enhancements

 * Sort classes tags in discovery command and elsewhere
 * Initial support for Data Providers, add `choria`, `scout`, `config_item` providers
 * Perform identity-only discovery optimization in `broadcast` and `puppetdb` discovery methods
 * Add a `--silent` flag to `choria discover` to improve script integration
 * Support go 1.15 by putting in work around to support Puppet SAN free TLS certificates
 * Add a bash completion script in `choria completion` in addition to current ZSH support
 * Adds a new `inventory` discovery method
 * Improve SRV handling when trying to find PuppetDB host
 * Improve `choria tool config` to show config files and active settings
 * Add project level Choria configuration
 * Allow options to be passed to discovery methods using `--do`
 * Support flatfile discovery from json, yaml, stdin and improve generated clients. Restore the `--nodes` flag
 * Add the `external` discovery method
 * Support request chaining in the req command
 * Restore the `rpcutil#get_config_item` and `rpcutil#get_data` actions

## Bug Fixes

* Improve progress bars on small screens
* Ensure we discover `rpcutil` in the `discover` command, improves PuppetDB integration
* Performance improvements for expr expression handling
* Improve identity handling when running on windows, non root and other situations

## [choria-mcorpc-support gem version 2.24.1](https://rubygems.org/gems/choria-mcorpc-support)

Links: [Changes](https://github.com/choria-io/mcorpc-ruby-support/compare/2.23.3...2.24.1), [Release](https://rubygems.org/gems/choria-mcorpc-support/versions/2.24.1)

**WARNING:** To use this version of the Gem you must have *Choria Server version 0.20.1* available locally.

### Enhancements

 * Remove legacy Data plugins
 * Delegate all discovery methods to the choria binary
 * Support project based configuration files

## Bug Fixes

* Improve rendering of packaged plugin README documents

## [choria/mcollective version 0.13.1](https://forge.puppet.com/choria/mcollective)

Links: [Changes](https://github.com/choria-io/puppet-mcollective/compare/0.13.0...0.13.1), [Release](https://forge.puppet.com/choria/mcollective/0.13.1/readme)

### Enhancements

 * Support agents without any extension, improving support for packaging `external` agents

## [choria/choria version 0.22.2](https://forge.puppet.com/choria/choria)

Links: [Changes](https://github.com/choria-io/puppet-choria/compare/0.21.0...0.22.2), [Release](https://forge.puppet.com/choria/choria/0.22.2/readme)

### Enhancements

 * Support `run_as` for playbooks
 * Ensure the `mcollective` class is included when just including `choria`
 * Ensure version `0.20.2` of Choria is installed on RedHat and Debian/Ubuntu machines

repository: choria-io/website

gha_language: CSS

repo_name: choria-io/website


text:
# Tube Status

Does it ever bother you when TfL claim to be operating a `good service` when what they mean is just normal service? I have rectified this with a pragmatic tube status page. You can view it at [unop.uk/tube](https://unop.uk/tube). It's designed with mobile browsers in mind (the page is as small as possible). If the service is anything other than bog standard then it links to the TfL responsive site.

The status comes in XML format from the [old TfL API](http://cloud.tfl.gov.uk/TrackerNet/LineStatus). Then [an XSLT](main.xsl) transforms it into the HTML to display. There is [some PHP](index.php) behind the scenes which retrieves the XML from the API and applies the transform.

You can add it to the home screen of your smart phone for easy access. It has some high resolution [icons](icons) for iOS and Android.

![Icon](icons/android-icon-192x192.png)

You'll need `php_xsl` for this to work and it's tested on PHP 5.6. If hosting on Azure then you'll need to upload `php_xsl.dll`. Then add `PHP_EXTENSIONS = bin/php_xsl.dll` to the app settings.

MIT Licensed

## Screenshots

![Home Screen](https://i.imgur.com/yjqIMuN.jpg)
![Tube Status](http://i.imgur.com/8pEjDKO.png)
![Task Switcher](https://i.imgur.com/7xIjZun.jpg)

repository: jpsingleton/London-Tube-Status

repo_name: jpsingleton/London-Tube-Status


text:
---
title: AVL Trees
layout: default.html
collection: trees
position: 12
---

In the previous section we looked at building a binary search tree. As
we learned, the performance of the binary search tree can degrade to
$$O(n)$$ for operations like `get` and `put` when the tree becomes
unbalanced. In this section we will look at a special kind of binary
search tree that automatically makes sure that the tree remains balanced
at all times. This tree is called an **AVL tree** after its
inventors: G.M. Adelson-Velskii and E.M. Landis. We have decided to focus on AVL trees as an example of self-balancing binary search trees, but there are many others such as the popular [red-black tree](https://en.wikipedia.org/wiki/Red%E2%80%93black_tree).

An AVL tree implements the Map abstract data type just like a regular
binary search tree, the only difference is in how the tree performs. To
implement our AVL tree we need to keep track of a **balance factor** for
each node in the tree. We do this by looking at the heights of the left
and right subtrees for each node. More formally, we define the balance
factor for a node as the difference between the height of the left
subtree and the height of the right subtree.

$$balanceFactor = height(leftSubTree) - height(rightSubTree)$$

Using the definition for balance factor given above we say that a
subtree is left-heavy if the balance factor is greater than zero. If the
balance factor is less than zero then the subtree is right heavy. If the
balance factor is zero then the tree is perfectly in balance. For
purposes of implementing an AVL tree, and gaining the benefit of having
a balanced tree we will define a tree to be in balance if the balance
factor is -1, 0, or 1. Once the balance factor of a node in a tree is
outside this range we will need to have a procedure to bring the tree
back into balance. The illustration below shows an example of an
unbalanced, right-heavy tree and the balance factors of each node.

![An unbalanced right-heavy tree with balance factors](figures/unbalanced.png)

Before we proceed any further let’s look at the result of enforcing this
new balance factor requirement. Our claim is that by ensuring that a
tree always has a balance factor of -1, 0, or 1 we can get better big O
performance of key operations. Let us start by thinking about how this
balance condition changes the worst-case tree. There are two
possibilities to consider, a left-heavy tree and a right heavy tree. If
we consider trees of heights 0, 1, 2, and 3,
The diagram below illustrates the most unbalanced
left-heavy tree possible under the new rules.

![Worst-case left-heavy AVL trees](figures/worst-case-AVL.png)

Looking at the total number of nodes in the tree we see that for a tree
of height 0 there is 1 node, for a tree of height 1 there is $$1+1
= 2$$ nodes, for a tree of height 2 there are $$1+1+2 = 4$$ and for a tree
of height 3 there are $$1 + 2 + 4 = 7$$. More generally the pattern we see
for the number of nodes in a tree of height h ($$N_h$$) is:

$$N_h = 1 + N_{h-1} + N_{h-2}$$

This recurrence may look familiar to you because it is very similar to
the Fibonacci sequence. We can use this fact to derive a formula for the
height of an AVL tree given the number of nodes in the tree. Recall that
for the Fibonacci sequence the $$i_{th}$$ Fibonacci number is given by:

$$F_0 = 0$$

$$F_1 = 1$$

$$F_i = F_{i-1} + F_{i-2}  \text{ for all } i \ge 2$$

An important mathematical result is that as the numbers of the Fibonacci
sequence get larger and larger the ratio of $$F_i / F_{i-1}$$ becomes
closer and closer to approximating the golden ratio $$\Phi$$ which is
defined as $$\Phi = \frac{1 + \sqrt{5}}{2}$$. You can consult a math text
if you want to see a derivation of the previous equation. We will simply
use this equation to approximate $$F_i$$ as $$F_i =
\Phi^i/\sqrt{5}$$. If we make use of this approximation we can rewrite
the equation for $$N_h$$ as:

$$N_h = F_{h+2} - 1, h \ge 1$$

By replacing the Fibonacci reference with its golden ratio approximation
we get:

$$N_h = \frac{\Phi^{h+2}}{\sqrt{5}} - 1$$

If we rearrange the terms, and take the base 2 log of both sides and
then solve for $$h$$ we get the following derivation:

$$\log{N_h+1} = (H+2)\log{\Phi} - \frac{1}{2} \log{5}$$

$$h = \frac{\log{N_h+1} - 2 \log{\Phi} + \frac{1}{2} \log{5}}{\log{\Phi}}$$

$$h = 1.44 \log{N_h}$$

This derivation shows us that at any time the height of our AVL tree is
equal to a constant(1.44) times the log of the number of nodes in the
tree. This is great news for searching our AVL tree because it limits
the search to $$O(\log{N})$$.

Implementation
---

Now that we have demonstrated that keeping an AVL tree in balance is
going to be a big performance improvement, let us look at how we will
augment the procedure to insert a new key into the tree. Since all new
keys are inserted into the tree as leaf nodes and we know that the
balance factor for a new leaf is zero, there are no new requirements for
the node that was just inserted. But once the new leaf is added we must
update the balance factor of its parent. How this new leaf affects the
parent’s balance factor depends on whether the leaf node is a left child
or a right child. If the new node is a right child the balance factor of
the parent will be reduced by one. If the new node is a left child then
the balance factor of the parent will be increased by one. This relation
can be applied recursively to the grandparent of the new node, and
possibly to every ancestor all the way up to the root of the tree. Since
this is a recursive procedure let us examine the two base cases for
updating balance factors:

-   The recursive call has reached the root of the tree.
-   The balance factor of the parent has been adjusted to zero. You
    should convince yourself that once a subtree has a balance factor of
    zero, then the balance of its ancestor nodes does not change.

<!-- literate trees/avl_tree.py -->

By keeping the tree in balance at all times, we can ensure that the
`get` method will run in order $$O(\log_2{n})$$ time. But the question is
at what cost to our `put` method? Let us break this down into the
operations performed by `put`. Since a new node is inserted as a leaf,
updating the balance factors of all the parents will require a maximum
of $$\log_2{n}$$ operations, one for each level of the tree. If a subtree
is found to be out of balance a maximum of two rotations are required to
bring the tree back into balance. But, each of the rotations works in
$$O(1)$$ time, so even our `put` operation remains $$O(\log_2{n})$$.

At this point we have implemented a functional AVL-Tree, unless you need
the ability to delete a node. We leave the deletion of the node and
subsequent updating and rebalancing as an exercise for you.

Over the past few sections we have looked at several data structures
that can be used to implement the map abstract data type.  To conclude this section, let’s summarize the
performance of each data structure for the key operations defined by the
map ADT.

operation |  Sorted List | Hash Table  | Binary Search Tree | AVL Tree
--- | --- | --- | --- | ---
`put` | $$O(n)$$    | $$O(1)$$   | $$O(n)$$   | $$O(\log_2{n})$$
`get` | $$O(\log_2{n})$$    | $$O(1)$$   | $$O(n)$$   | $$O(\log_2{n})$$
`in`  | $$O(\log_2{n})$$    | $$O(1)$$   | $$O(n)$$   | $$O(\log_2{n})$$
`del` | $$O(n)$$   | $$O(1)$$   | $$O(n)$$   | $$O(\log_2{n})$$

repository: jalshboul/algos

repo_name: jalshboul/algos


text:
# Helpdesk simulator game

The original helpdesk simulator is a simple, text-based adventure game
where you play as a new, bright-eyed IT helpdesk technician. As a new
employee at Incompecorp, your job is to help customers with their IT
issues, avoid disaster and improve your skills one ticket at a time.

When you're a high enough level, you'll be promoted to an IT manager.
It's then up to you to hire new technicians and manage the IT helpdesk
tickets, while training your new hires, to achieve the best outcome
possible.

Check out the sequel: [Helpdesk Simulator 2: Turn It Off and On Again](https://github.com/zakwarren/helpdesk-off-and-on)

## Quick start

1. Run helpdesk to begin.

2. You have the option of completing a short tutorial or jumping
   straight to the action.

3. The first time it runs, helpdesk will write default data to the
   data directory. These are:

   - disasters.json for the potential disasters that could occur
   - issues.json for the issues that people may encounter
   - names.json for the names of the people you interact with
   - options.json for the options available when solving an issue

4. Advanced users may wish to edit these data files. You can do this
   directly with any programme capable of editing json data.

5. Enjoy your helpdesk adventure!

## Contributing

Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct.

This app is written in python 3.6.

## Authors

- **zakwarren** - _Initial work_

## License

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

repository: zakwarren/helpdesk

repo_name: zakwarren/helpdesk


text:
---
title: Metrics
summary:
reviewed: 2022-02-28
component: Metrics
versions: 'Metrics:*'
related:
 - samples/open-telemetry
---

NOTE: This plugin can be enabled and configured with the [ServicePlatform Connector plugin](/platform/connecting.md).

partial: opentelemetry

The Metrics plugin collects metric data about the performance of running endpoints. This data can be forwarded to a ServiceControl monitoring instance and then viewed in ServicePulse.

To see performance monitoring in action, try the [standalone demo](/tutorials/monitoring-demo/).

For a full list of the performance metrics captured and their formal definitions, see [Metric definitions](definitions.md).

```mermaid
graph LR

subgraph Endpoint
  Metrics[Metrics<br>Plugin] -- Metric Data --> MetricsSC[Metrics<br>ServiceControl<br>Plugin]
end

MetricsSC -- Metric Data --> MQ

MQ[Metrics Queue] -- Metric Data --> Monitoring[ServiceControl<br>Monitoring<br>Instance]

Monitoring -- Endpoint<br>performance<br>data --> ServicePulse
```

## Set up metrics

To enable collecting metrics in an environment:

1. [Install a ServiceControl monitoring instance](/servicecontrol/monitoring-instances/)
2. [Install and configure the ServiceControl Metrics plugin in each endpoint](install-plugin.md)
3. (**MSMQ Transport only**) [Install the MSMQ queue length reporter in each endpoint](msmq-queue-length.md)
4. [View the performance data collected for endpoints in ServicePulse](in-servicepulse.md)

NOTE: [NServiceBus monitoring setup tutorial](/tutorials/monitoring-setup/) is an in-depth, step-by-step tutorial about installing and configuring everything to get the most out of performance monitoring.

 Nevertheless, it is not recommended to host a monitoring instance on the same machine that is hosting production endpoint instances.

### Wire usage

Each endpoint instance collects performance metrics which are buffered and then sent. A single metrics message contains a batch of values written in a compact binary format, making reporting very lightweight.

### Storage usage

A Service Control Monitoring instance processes Metric. The metric data is stored in RAM only. Logfiles are still written to disk. The metrics data are stored for at most one hour. A 100MB process can hold state for at least 100 endpoint instances.

### CPU usage

The metrics service is only performing simple summing aggregation logic. The CPU usage is low.

## Reporting metric data to other places

- Metrics can be reported to [Windows Performance Counters](performance-counters.md).
- [Observing raw metric data allows reporting to any 3rd party metric database](raw.md).

gha_language: C#

gha_license_id: NOASSERTION


text:
---
title: "Jason S. Lazerus"
date:   2017-01-01 08:04:23
categories: [Resume]
tags: [Resume]
permalink: /resume/
---
Experienced VP, Manager of Infrastructure & Security with a demonstrated track record of leading engineering teams and implementing highly functional and secure operating environments. Skilled in developing and executing infrastructure and support strategies for the entire infrastructure stack, as well as collaborating with business unit and technology constituents to select and implement software and services. Proficient in managing technical professionals to develop and implement strategic solutions and leading complex projects with multiple resources across the organization. Adept at developing and executing remediation plans for regulatory, audit, and risk-based technology reviews and leading response efforts for significant system and application outages or issues.

## Employment

`2021-Present`
__Eastern Bank__ V.P. Infrastructure and Security Manager
* Sets and executes infrastructure and support strategies. This includes the development of the strategy, architecture, and design for the entire infrastructure stack across the enterprise.
* Responsible for the security design of all infrastructure implementations, subject matter expert to contribute to analysis and design of all technology systems at the Bank.
* Works with business unit and technology constituents to lead the selection and implementation of software and services to provide a highly functional and secure operating environment.
* Responsible for managing a staff of technical professionals to develop and implement strategic solutions. This includes the server, network, and security infrastructure teams.
* Leads complex and inter-related projects collaborating with resources from multiple areas of the corporation, makes key strategic decisions on those projects, and ensures that those projects are completed on time and within budget (both monetary and Technology Division resource hours).
* Develop and execute remediation plans for regulatory, audit, and risk-based technology reviews.
* Maintains contracts with external vendors.
* Monitors the reliability of systems and services.
* Interfaces with business units to ensure needs and SLAs are met.
* Lead response for significant system and application outages or issues.

`2020-2021`
__Eastern Bank__ V.P. Security Operations Manager
#### Duties
##### Management
* Manages high-performing cyber security professionals in Incident Response, Information Assurance, Security Engineering and Identity and Access Management.
* Meets with auditors regularly to ensure compliance with regulations and internal policies.
* Manages security budget.
* Evaluates and purchases products and services to meet security goals.
* Drives security initiatives, leads projects, and improves processes.
* Meeting regularly with team members one-on-one to share and receive feedback and job-related tasks to improve on professional development.
* Perform annual performance assessments for direct reports.
* Defines training plans for direct reports.
* Provides weekly status updates to management regarding projects/issues.
* Meets with other teams to discuss technology related issues and for project planning.
* Manages vendor relationships.
* Manages hardware and virtual assets.
* Identifies and escalates both isolated and systemic technology issues.
* Tunes and configures security tools to maximize the effectiveness of time and detection of incidents.
* Conducts periodic lunch and learn training sessions.

##### Technical
* Manages SailPoint IDN Build Team. Current project ongoing to implement SailPoint IDN.
* Manages Public Key Infrastructure.
* Configures Azure SSO for SAML authentication.
* Responds to cyber security incidents.
* Writes scripts in PowerShell and Python to improve efficiency and manipulate data.
* Creates Splunk queries, alerts and dashboards

`2019-2020`
__Eastern Bank__ Information Assurance Manager
#### Duties
##### Management
* Managed a team of three high-performing cyber security professionals.
* Met with auditors regularly to ensure compliance with regulations and internal policies.
* Evaluates and purchases products and services to meet security goals.
* Drives security initiatives, leads projects, and improves processes.
* Meeting regularly with team members one-on-one to share and receive feedback and job-related tasks to improve on professional development.
* Perform annual performance assessments for direct reports.
* Defines training plans for direct reports.
* Provides weekly status updates to management regarding projects/issues.
* Meets with other teams to discuss technology related issues and for project planning.

`2017-2019`
__Eastern Bank__ Principal Information Assurance Analyst

`2016-2017`
__Eastern Bank__ Sr. Information Assurance Analyst
#### Duties
##### Vulnerability Management
* Oversees the vulnerability management program.
* Collaborates with several teams and vendors to ensure remediation or mitigation is achieved.
* Created automated methods for ticket creation and handling.
* Creates and monitors CIS security baselines for all network devices.
* Works with risk management to document exceptions.

##### Code Reviews
* Performs SAST and DAST code scanning for all code developed for Eastern Bank internally and by third parties. (Java, JavaScript, PowerShell, Python, PHP, HTML)
* Reviews findings to ensure no false positives are found and works with developers to mitigate true positives.

##### Incident Response
* Coordinates incident response efforts.
* Response to cyber security alerts generated by numerous sources.
* Created automated workflows to enhance the response time to incidents.
* Monitors SIEM and creates new alert methods as necessary.

##### Audit Coordination
* Coordinates the collection of data for auditors.
* Works with internal and external auditors to review and remediate audit findings.

##### Penetration Testing
* Provides penetration testing on a regular basis.
* Uses pentesting to validate certain vulnerabilities and to ensure security agents are functioning properly.
* Coordinates third-party pentests as needed.
* Works with system owners to remediate penetration test findings.

##### Digital Forensics
* Created and manages the digital forensics program.
* Captures hard drive and memory images during investigations.
* Works with third parties as necessary to ensure investigations are completed in a forensically sound method.

##### Development
* Writes scripts in PowerShell, Python and Java to gather and push data via numerous APIs.
* Uses Gitlab and code collaborator to store, share and review code woth co-workers.
* Uses CI/CD tool to automate script executions.

##### Business Intelligence
* MajorDomo role for Domo business intelligence platform.
* Works with multiple departments on bringing data into Domo.
* Creates ETLs and SQL scripts to transform data as needed.
* Supports users with their data from conception to production.

##### Project Management
* Manages security related projects when bringing in new products and vendors.
* Provides security advice and architecture design for all Technology projects.

`2007-2016`
__Stony Brook University__ Information Security Officer
#### Duties
##### Vulnerability Management
* Oversaw the vulnerability management programs.
* Collaborated with several vendors to ensure remediation or mitigation is achieved.
* Created and monitored CIS security baselines for all network devices.

##### Project Management
* Managed security related projects when bringing in new products and vendors.
* Provided security advice and architecture design for all technology projects.

##### Penetration Testing
* Provided penetration testing on a regular basis.
* Remediated findings with support of IT staff.

##### Incident Response
* Responded to cyber security alerts generated by numerous sources.
* Monitored SIEM and created new alert methods as necessary.

##### Firewall Management
* Implemented new firewall infrastructure.
* Created firewall rules as required.
* Created site-to-site VPNs with vendors.

##### Security Engineering
* Managed Checkpoint endpoint security system.
* Ensured all devices were encrypted and compliant with host based security.

##### HIPAA Security
* Served as the HIPAA Security Officer.
* Performed regular audits to ensure systems were HIPAA compliant.
* Provided annual HIPAA trajning to employees.

##### System Administration
* Provided server and domain administrator roles.
* Implementated and managed VMware environment.
* Implementated and managed Hyper-V environment.
* Performed server patching using Dell Kace.
* Implemented Desktop Authority product for system configuration management.
* Provided desktop support as needed.

##### Database Administration
* Managed medical records SQL databases.
* Managed R25 Scheduling Oracle database.

##### Risk Management
* Created policies and procedures for cyber security and HIPAA regulations.
* Performed risk assessments and documented risks.

`2005-2007`
__Stony Brook Medicine__ Help Desk Technician
#### Duties
##### End User Support
* Provided first line support to a large domain of over 10,000 users.
* Fielded over 2,000 calls/month.
* Managed broadcast e-mail moderation list.
* Provided assistance to client support as needed.

##### Project Support - SSO
* Worked with vendors to design the single sign-on system.
* Performed tests to ensure applications opened properly.
* Created a testing program for users and IT staff to ensure appropriate performance.
* Created a deployment plan for go-live.
* Worked with departments on troubleshooting.

##### Website Design
* Redesigned Information Technology website to bring it up to date.
* Customized HTML and CSS to adhere to corporate theme.

##### Application Administration
* Upgraded and managed Unicenter Service Desk ticketing system.
* Implemented  and mananged ACD call recording system.

## Education

`2011-2014`
__American Public University System__ Master of Science in Information Technology with a concentration in Digital Forensics

`2009-2011`
__American Public University System__ Bachelor of Science in Information Systems Security (Deans List)

## Certifications

* [GIAC Defensible Security Architecture](https://www.credly.com/badges/9b86a478-7e11-4d7e-80f1-fad635322a76/public_url)
* [GIAC Certified Forensic Analyst](https://www.credly.com/badges/14b4572f-4078-4a3d-97bf-881d46550325/public_url)
* [GIAC Certified Penetration Tester](https://www.credly.com/badges/6c9718db-2140-415c-bc0d-6096f2e161ce/public_url)
* [GIAC Certified Incident Handler](https://www.credly.com/badges/9835d2fb-e0da-407c-8b31-5e599b908c0c/public_url)
* [GIAC Certified Forensic Examiner](https://www.credly.com/badges/fad907b9-1b26-4e04-9326-5ba0764f6dbc/public_url)
* [GIAC Certified Enterprise Defender](https://www.credly.com/badges/cb666e43-74c1-438d-be4c-f3e8fa536456/public_url)
* [GIAC Security Essentials](https://www.credly.com/badges/982f97c4-3ba5-4d6b-b345-79b199e78b14/public_url)
* [Metasploit Pro Certified Specialist](https://www.credly.com/badges/189310e4-7fba-43ac-b5ec-ef1ca25cd82b/public_url)
* [Microsoft Certified: Azure Fundamentals](https://www.credly.com/badges/5ba059a9-c035-46fa-8b94-1d0f8ce39fe1/linked_in_profile)
* Microsoft Certified Desktop Support Technician
* Microsoft Certified Professional
* Certified HIPAA Security Specialist
* Certified HIPAA Professional
* [CompTIA Network+](https://www.credly.com/badges/2545473b-6f4a-4906-b3ef-588b575f63e7/public_url)
* [CompTIA A+](https://www.credly.com/badges/718f79dc-dc99-4fda-bf9d-7e3462e304aa/public_url)

## Projects

#### SailPoint IdentityNow Implementation `2021`
Led the build team for the SailPoint IdentityNow implementation which included personally onboarding over 325 applications in two months. Configured and managed the SailPoint application. Created new sources inclusive delimited, AD connected, and API connected sources. Created testing plans and managed change controls. Created training plans for end users.

#### Change Control Form and Workflow `2019`
Developed an approval form and workflow using Salesforce Lightning forms to improve an outdated change control process. Changes are entered into a form and a formula is calculated based on answers to user input in order to determine the impact of the change. The impact level determines the number of approvers needed for the change and all changes are tracked in Salesforce cases.

#### Cyber Alert Notification Workflow `2018`
Developed an automated workflow to handle cyber alerts using Microsoft Flow. This flow parses data generated in SIEM alerts to identify users, validates with the user the action that generated the alert, then sends the user's response to the security team for validation and finally, assists with the closing of the generated ticket.

#### Metrics Automation `2018`
Automated the gathering, display, and analysis of cyber security and project management metrics. Data from over 30 sources were gathered using SQL, API's, and spreadsheet exports. ETLs, filters and additional queries were used to combine data sources and charts were displayed using Domo.

#### Network Migration `2015`
To create a more secure network, all network devices for Student Health Services were migrated from a public network to a private class c network. New high-availability firewalls were installed and appropriate rules were created.

## Technical skills

* Powershell
* Python
* Splunk
* HTML and CSS
* Bash
* RegEx
* Git / Collaborator
* UNIX
* Microsoft Azure
* Cloudflare
* Akamai

## Areas of expertise

* Vulnerability Management
* Penetration Testing
* Security Metrics
* Incident Response
* API Management
* Risk Management

## Awards

Above and Beyond 4th Quarter 2022 - Eastern Bank

Above and Beyond 1st Quarter 2022 - Eastern Bank

Above and Beyond 1st Quarter 2021 - Eastern Bank

Above and Beyond 4th Quarter 2020 - Eastern Bank

Above and Beyond 2nd Quarter 2018 – Eastern Bank

Above and Beyond 4th Quarter 2017 – Eastern Bank

Above and Beyond 4th Quarter 2016 – Eastern Bank

[GIAC Advisory Board](https://www.credly.com/badges/cd6d34ab-f784-4375-a13b-4f8a201ee60c/public_url)

President’s Volunteer Service Award – Lifetime Achievement

## Volunteer Service
`2005-2015`
__Port Jefferson EMS__ President and Chief of Department / Various Officer Positions
#### Duties
##### Operations Management
* Managed 125 volunteers and employees.
* Created policies and procedures.
* Ensured staff availability to respond to alarms.
* Performed Incident Command in numerous situations.
* Coordinated response efforts during major emergencies.
* Provided first response to fire and ems alarms.
* Provided support to police during special situations.
* Created and monitored key performace indicators to ensure efficient practices are in place and to find areas for improvement.
* Provided planning for events.

##### Administration
* Provided input on creation of new bylaws.
* Chairman of the board of directors
* Ran multiple monthly meetings.
* Negotiated budget with multiple municipalities.
* Implemented electronic medical records system.

##### Training
* Created EMT training program for new recruits.
* Provided trainings for driving, CPR, and CEVO.
* Created continuing education program for EMS providers.

`2001-2015`
__Port Jefferson EMS__ EMT / Critical Care Technician
#### Duties
* Providing emergent care to patients in Suffolk County.
* Communicating and coordinating care with physicians and nurses at various hospitals.
* Ensuring vehicles met part 800 NYS DOH regulations.
* Provided safe transport for patients and crews.

## References

Available on request.


text:
# Setup
<%(TOC)%>

>**Note**: Most Online Services require you to have a [SpatialOS](https://docs.improbable.io) project. The Services support any SpatialOS project, whether you have created it using Unreal Engine with the [GDK for Unreal](https://docs.improbable.io/unreal), Unity using the [GDK for Unity](https://docs.improbable.io/unity), or [your own engine](https://docs.improbable.io/reference/latest/shared/byoe/introduction).

## Dependencies

You don't need any prior knowledge of cloud infrastructure technologies to start using the Online Services, but you'll need to learn about some of them as you progress.

There are also a few things you need to set up before getting started:

### SpatialOS

* **A SpatialOS project**

    The project can be one you have created with either the [GDK for Unreal](https://docs.improbable.io/unreal), the [GDK for Unity](https://docs.improbable.io/unity), or [your own engine](https://docs.improbable.io/reference/latest/shared/byoe/introduction).

    (If you don't have a project, you can follow the [GDK for Unreal Example Project](https://docs.improbable.io/unreal/latest/content/get-started/dependencies) or the [GDK for Unity FPS Starter Project](https://docs.improbable.io/unity/latest/projects/fps/get-started/get-started).)

    Note that your project doesn't need to be deployed to SpatialOS to set up Online Services but you do need a cloud deployment to test matchmaking.

* **The SpatialOS Tools**

    If you have a project, you will have the SpatialOS Tools installed. However, if you need to get them again, you can follow the SpatialOS Tools installation guides for [Windows](https://docs.improbable.io/reference/latest//shared/setup/win), [Mac](https://docs.improbable.io/reference/latest/shared/setup/mac), or [Linux](https://docs.improbable.io/reference/latest/shared/setup/linux).

### Cloud hosting

You need cloud hosting _in addition_ to your SpatialOS game deployment hosting. (This is billed according to your usage, and is entirely separate from any <%(LinkTo path="/shared/pricing-and-support/pricing-intro" title="SpatialOS costs" doctype="reference" version="latest")%>
.)

We recommend you set up a [Google Cloud Platform](https://console.cloud.google.com) project. Some of the services are platform-agnostic and should run anywhere; however, the extra configuration we have provided for setting up the cloud infrastructure is mostly Google-specific.

Go to the [project creation page](https://console.cloud.google.com/projectcreate) on the Google Cloud console. Give your project a name - remember, it can't be changed later!

There's a field to put in an organisation too. It's OK to leave this as `No organization` if you don't need this project to be part of one.

![]({{assetRoot}}img/get-started/google-cloud-project.png)

It might take Google a couple of minutes to create your project. Once it's ready, open the navigation menu (the hamburger in the top-left) and go to **Kubernetes Engine**.

<%(#Expandable title="What's Kubernetes Engine?")%>>Kubernetes Engine is Google's Kubernetes provision.

Kubernetes, commonly known as k8s, is a container-based orchestration service; you give it your applications, housed in containers, and provide some configuration, and it ensures your application stays available to users.

For example, if a container is defined as having 3 replicas, Kubernetes starts up 3 instances of that container. If one of them falls over or is stopped, Kubernetes immediately starts up another one for you. There will be more information on Kubernetes later in this guide but you can find out more on the [Kubernetes website](https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/).<%(/Expandable)%>

Kubernetes Engine isn't free, but you can sign up to the free trial if you need to. You'll know it's ready to go when you can see this dialog box:

![]({{assetRoot}}img/get-started/create-k8s-cluster.png)

Note that you can port these configurations to run on [Amazon Web Services](https://aws.amazon.com/), [Microsoft Azure](https://azure.microsoft.com/en-us/), [Alibaba Cloud](https://www.alibabacloud.com/), [DigitalOcean](https://www.digitalocean.com/), [Tencent Cloud](https://intl.cloud.tencent.com/) or any cloud hosting service.

### Third-party tools

* [.NET Core](https://dotnet.microsoft.com/download/dotnet-core) - required to build and run the C# services.
* [Docker](https://docs.docker.com/install/) - to build the container images.
* [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/) - used to deploy services to a cloud Kubernetes instance.
* _(Optional)_ [Docker Compose](https://docs.docker.com/compose/install/) - used to run the services locally.
* [Google Cloud SDK](https://cloud.google.com/sdk/) - to push built container images up to your Google Cloud project.
* [Terraform](https://www.terraform.io/) - to configure the different cloud services you use.

### The repository

Fork or clone the Online Services repository: [github.com/spatialos/online-services](http://github.com/spatialos/online-services).

We recommend you create a fork of the repository so that you can make whatever customizations you want.

<%(Nav hide="next")%>
<%(Nav hide="prev")%>

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

_2019-10-22 Page updated with editorial review_

_2019-07-16 Page added with limited editorial review_

repository: IceImprobable/online-services

repo_name: IceImprobable/online-services


text:
# express-spider-middleware

An ExpressJS middleware for detecting search engine crawlers and spiders, with the option of including a callback to perform additional search engine-specific logic such as logging or monitoring.

This module is a fork of Michael Heuberger's [spider-detector](https://github.com/binarykitchen/spider-detector). We use this module at [Wethrift.com](https://www.wethrift.com) to handle additional logging and monitoring of search engine crawlers.

## Install

```
npm install express-spider-middleware
```

## User-agent string detector

Detect whether any user-agent string matches a known crawler or bot.

```js
var detector = require('spider-detector')
detector.isSpider('baiduspider') // return true
```

## ExpressJS middleware - Detecting crawlers

Use as an ExpressJS middleware to attach an `isSpider` property to every request.

```js
var expressSpiderMiddleware = require('express-spider-middleware'),
    express  = require('express'),
    app      = express()

app.use(expressSpiderMiddleware.middleware())

app.get('/*', function(req, res) {
    if (req.isSpider()) {
        // handle request from search engine crawler
    } else {
        // handle all other requests
    }
})
```

## Using a callback to handle additional logic for all requests

The `.middleware()` method accepts an optional callback function that will execute for all routes when a crawler is detected.

```js
app.use(expressSpiderMiddleware.middleware(function(req){
  console.log('Crawler detected:', req.get('user-agent'))
}))
```

repository: teamwethrift/express-spider-middleware

gha_language: JavaScript

repo_name: teamwethrift/express-spider-middleware


text:
# my_setup

This is the script is used to set up my development environment.

## Prerequisites
* MacOS Mojave and higher (I've only tested it on Mojave)
* Mac OS X command line tools (`xcode-select --install`)
* Ruby 2.0.0 or higher (MacOS Sierra already has it)
* *Optional* [XQuartz](https://xquartz.macosforge.org/) - for X11

## Getting Started

Simply checkout the repo and run the provision script. The script is pretty minimal and reads like a shell script. The script is also idempotent so you don't have to worry about running it multiple times.

```bash
git clone https://github.com/ktham/my_setup.git ~/my_setup
cd my_setup
./provision
```

## Customizations
### zsh
Add your own files to `~/.zshrc.d` and it will automatically be loaded.

## Code Status

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

## License

The MIT license.

Copyright (c) 2019 Kevin Tham

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

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

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

gha_language: Ruby


text:
OBJECT ORIENTED PROGRAMMING (C++ PROJECT)

PROJECT NAME:-
Restaurant finder and food booking portal
PROJECT AIM:-
To develop an online booking for food items

PROJECT OBJECTIVE:-
This case study looks at the problem of setting up food orders by going to restaurants and hostels. If a
comes home after a work of 9 to 9 and after returning have to go to buy food is not productive. For every
order there is a back counter in restaurant and that needs much time and employee to get orders so
simultaneously. hence to solve this problem and increase efficiency we plan to design this project.

BENEFITS: -
1.this will minimize the employee numbers.
2.reduce more cost of labours.
3. less mistakes and more precise because it is fully programmed.

KEY FEATURES: -
-> Distance wise sorting and time taken for delivery.
-> Easy searching of preferable food items and dishes on the basis of categories.i. e veg and
Non-veg.
? Items will be sorted as per the ratings.
-> Authentication and authorization will be maintained. for placing orders:-
a. login by user:- he will create account by providing personal details.
b. Can save their dishes and restaurants in their food list.
c. From the menu decided by the restaurant they can choose their preferences on the basis of
cost and quantity.
-> Payment portal:- mode of payment followed by confirmation of user by OTP.
-> Feedback by the user including ratings and comments.

USER ACCESS: -
The software can be used by the app owner with local admins being the restaurant owners who
can add and delete names of restaurant and menus from their databases.
This will be friendly for the consumers too.

Team members: -
Anjali Mohapatra (B417008)
Pranay Agarwal (B117035)
Pratyush Mohapatra (B117036)
Priyanshu Sinha (B117042)
Atharva Choudhary (B117004)


text:
---
data_non_statistical: true
goal_meta_link: https://unstats.un.org/sdgs/metadata/files/Metadata-09-05-02.pdf
goal_meta_link_text: United Nations Sustainable Development Goals Metadata (PDF 382
  KB)
graph_type: line
indicator: 9.5.2
indicator_name: Researchers (in full-time equivalent) per million inhabitants
indicator_sort_order: 09-05-02
layout: indicator
permalink: /9-5-2/
published: true
reporting_status: complete
sdg_goal: '9'
target: Enhance scientific research, upgrade the technological capabilities of industrial
  sectors in all countries, in particular developing countries, including, by 2030,
  encouraging innovation and substantially increasing the number of research and development
  workers per 1 million people and public and private research and development spending
target_id: '9.5'
graph_title: Researchers (in full-time equivalent) per million inhabitants
un_custodian_agency: United Nations Educational Scientific and Cultural Organization
  (UNESCO)
un_designated_tier: '1'

source_active_1: true
source_organisation_1: Statistics Iceland
source_periodicity_1:
source_earliest_available_1:
source_geographical_coverage_1: Iceland
source_url_1:
source_url_text_1:
source_release_date_1:
source_next_release_1:
source_statistical_classification_1: National Statistic
source_contact_1<EMAIL_ADDRESS>---

In 2017, there were 2050 full-time equivalent positions in research in enterprises,
public institutions and universities.

repository: hagstofan/open-sdg-data

branch_name: refs/heads/develop

gha_language: Shell

repo_name: hagstofan/open-sdg-data


text:
# RSP Module
## Radio Frequency Analysis and Design

This section contains the following lessons:

1. Introduction to RF principles and components
2. The Electromagnetic Spectrum
3. Real world RF signals
4. Radio Frequency Modulation
5. Radio Frequency Demodulation
6. Further topics (time permitting)

Lessons should be followed in this order and the tutorial sheets should be attempted in the following order:

repository: TrivialProof/RF-analysis-design

repo_name: TrivialProof/RF-analysis-design


text:
---
layout:     post
title:      Positional determinacy for parity games, a forward approach
date:       2018-08-02 9:00:00
author:     Nathanaël Fijalkow
category:   Parity games
---

This post gives a proof of positional determinacy for parity games.
One may recognise it in the works of Emerson and Jutla (91) using modal mu-calculus, and also more explicitely in the works of Kupferman and Vardi (98).

We fix some notations. Consider a finite parity game with $n$ vertices and priorities in $[1,d]$.
The parity condition is satisfied by a play if the **maximal** priority seen infinitely often is even,
we write $\Parity_d$ to mean that the priorities range in $[1,d]$.
The two players are Eve and Adam, she controls the vertices depicted by circles and he controls the vertices depicted by squares.
We let $W_E(\Parity_d)$ denote the set of vertices from which Eve has a winning strategy, and $W_A(\Parity_d)$ for Adam.

For a set of vertices $U \subseteq V$, we let $\Pre(U) \subseteq V$ be the set of vertices from which Eve can ensure to reach $U$ in one step:
$$\Pre(U) = \{u \in V_E \mid \exists (u,v) \in E,\ v \in U\} \cup \{u \in V_A \mid \forall (u,v) \in E,\ v \in U\}.$$
We use $\overline{\Pre(U)}$ for the complement of $\Pre(U)$.
The condition $\Reach(U)$ is satisfied by plays visiting $U$ at least once, and $\Safe(U)$ by plays never visiting $U$.
We write $V_d$ for the set of vertices of priority $d$.

### Two recursive lemmas

The inductive statement is as follows:
we consider parity games with priorities in $[1,d]$ and two additional colours: $\Win$ and $\Lose$.
The vertices with colours $\Win$ or $\Lose$ are terminal: when reaching a terminal vertex,
the game stops and one of the players is declared the winner.
Formally, the objective is

$$\left( \Parity_d \cup \Reach(\Win) \right) \cap \Safe(\Lose)$$

> **Lemma:**
Assume that $d$ is even.
$$W_E (\left( \Parity_d \cup \Reach(\Win) \right) \cap \Safe(\Lose) )$$
is the greatest fixed point of the operator $Y \mapsto$
$$W_E \left(
\begin{array}{c}
\Parity_{d-1} \cup \Reach \left[ \Win \cup (V_d \cap \Pre(Y)) \right] \\
\cap \\
\Safe \left[ \Lose \cup (V_d \cap \overline{\Pre(Y)}) \right]
\end{array} \right)
$$

For the sake of the explanation and in the proof, we assume that $\Win = \Lose = \emptyset$.

In words:
$W_E(\Parity_d)$ is the largest set of vertices $Y$ such that from $Y$ Eve has a strategy ensuring that
* either the priority $d$ is never seen, in which case the parity condition is satisfied with lower priorities,
* or the priority $d$ is seen, in which case Eve can ensure to reach $Y$ in one step.

The even case.

**Proof:**
The fact that $W_E(\Parity_d)$ contains the greatest fixed point follows from the observation that any fixed point $Y$ is contained in $W_E(\Parity_d)$.
Indeed, if $Y$ is a fixed point, the strategy described above ensures parity: either it visits finitely many times $d$,
and then from some point onwards the parity condition is satisfied with lower priorities, or it visits infinitely many times $d$,
and then the parity condition is satisfied because $d$ is maximal and even.

Note that we are constructing positional strategies by taking the disjoint union of two positional strategies,
one for $W_E(\Parity_{d-1})$ for vertices of priorities less than $d$ and the other for $d \cap \Pre(W_E(\Parity_{d-1}))$.

The fact that $W_E(\Parity_d)$ is included in the greatest fixed point follows from the fact that it is itself a fixed point,
which is easy to check.

> **Lemma:**
Assume that $d$ is odd.
Then $W_E (\left( \Parity_d \cup \Reach(\Win) \right) \cap \Safe(\Lose) )$ is the least fixed point of the operator $X \mapsto$
$$W_E \left(
\begin{array}{c}
\Parity_{d-1} \cup \Reach \left[ \Win \cup (V_d \cap \Pre(X)) \right] \\
\cap \\
\Safe \left[ \Lose \cup (V_d \cap \overline{\Pre(X)}) \right]
\end{array} \right)$$

For the sake of the explanation and in the proof, we assume that $\Win = \Lose = \emptyset$.

In words: $W_E(\Parity_d)$ is the smallest set of vertices $X$ such that from $X$ Eve has a strategy ensuring that
* either the priority $d$ is never seen, in which case the parity condition is satisfied with lower priorities,
* or the priority $d$ is seen, in which case Eve can ensure to reach $X$ in one step.

The odd case.

**Proof:**
The fact that $W_E(\Parity_d)$ contains the least fixed point follows from the fact that it is itself a fixed point,
which is easy to check.

The fact that $W_E(\Parity_d)$ is included in the least fixed point is the interesting non-trivial bit.
It follows from the observation that any fixed point $X$ contains $W_E(\Parity_d)$.
To prove this, we show that $V \setminus X \subseteq W_A(\Parity_d) \subseteq V \setminus W_E(\Parity_d)$.
Note that here we are not relying on the determinacy of parity games: the second inclusion is very simple and always true,
it only says that Eve and Adam cannot win from the same vertex.

Indeed, if $X$ is a fixed point, from $V \setminus X$ Adam has a strategy ensuring that
* either the priority $d$ is never seen, in which case the parity condition is violated with lower priorities,
* or the priority $d$ is seen, in which case Adam can ensure to reach $V \setminus X$ in one step.

This strategy violates parity: either it visits finitely many times $d$,
and then from some point onwards the parity condition is violated with lower priorities,
or it visites infinitely many times $d$, and then the parity condition is violated because $d$ is maximal and odd.

**Remark:**
We could have said that the odd case is symmetric to the even case, swapping the role of the two players.
Indeed, the two claims are in some sense dual to each other (more precisely, this amount to negate the modal mu-calculus formula).
We do not take this road, because it requires assuming determinacy of parity games, which we avoided in this presentation,
and obtained as a corollary.

### Finishing the proof

We now explain how the two lemmas show that
if parity games with priorities in $[1,d-1]$ are positionally determined,
then parity games with priorities in $[1,d]$ are positionally determined.
Let

$$W = W_E (\left( \Parity_d \cup \Reach(\Win) \right) \cap \Safe(\Lose) )$$

Depending on the parity of $d$, either of the two lemmas show that

$$W = W_E (\left( \Parity_{d-1} \cup \Reach(\Win') \right) \cap \Safe(\Lose') )$$

with $\Win' = \Win \cup (V_d \cap \Pre(W))$ and $\Lose' = \Lose \cup (V_d \cap \overline{\Pre(W)})$

Observe that the latter can be seen as a parity game with priorities in $[1,d-1]$,
because vertices with priority $d$ have been added either to $\Win'$ or to $\Lose'$.
Let $\sigma_{d-1}$ be a positional winning strategy in this game.
The proof yields a positional winning strategy in the original game by taking the disjoint union of $\sigma_{d-1}$
and of the (positional) strategy $\sigma_d$ ensuring from $V_d \cap \Pre(W)$ to reach $W$ in one step.
This concludes the proof.


text:
# microstack-terraform-ansible-01
Single Node Microstack on Ubuntu - provisioned with Terraform - config with Ansible

See the file: **`instructions.txt`**

## TODO

1. Clean these files up to not use 'terraform' everywhere
2. Try specifying 'machine_type' in different way to state CPU, RAM, disk size.

    Its currently:

    ```text
    Flavor Name | m1.medium
    Flavor ID | 3
    RAM | 4GB
    VCPUs | 2 VCPU
    Disk | 20GB
    ```

    **`=> make changes and if they work, verify in GUI`**

3. Have the terraform files output info for use in a dynamic inventory thing for Ansible to use
4. Move the nginx setup into Ansible
    (and remove the sudo lines from provisioner, but replace with something else to keep as an example)

5. Add comments for all terraform & ansible code

6. Double check instructions and improve / fix as needed.

7. Open up any WEB links in terraform code (and elsewhere) and extract any useful info into comments (just incase web links disappear).

### AOB ?


text:
# How Telepresence works

We can use Telepresence to help us running KubeSphere apiserver locally.
Here is the toplogy of our services(ks-apiserver and openpitrix).Through this toplogy
we can understand how it works, which is conducive to our development.
![telepresence-toplogy](/images/telepresence-toplogy.png)

## What telepresence has done
1. Created a proxy in kubernetes cluster.
2. A two-way network tunel is established between the development machine and remote kubernetes cluster.thus,your local process can connect with the remote kubernetes cluster.

## How a request is processed
If you want to debug your local ks-apiserver process with telepresence, your request will follow the dotted line.
The solid line represents how a request is processed in production environment.

## How to debug a service in kubesphere
1. run telepresence like this
```jshelllanguage
telepresence --namespace kubesphere-system --swap-deployment ks-apiserver --expose 9090:9090 --run go run ./cmd/ks-apiserver/apiserver.go
```
the option of --swap-deployment tell kubernetes replace remote ks-apiserver with your local process in kubesphere-system namespace,
replace means scale the real ks-apiser deployment to 0, and then create a new deployment that proxy your local ks-apiserver process.
factly, the proxy in topology is the new deployment of ks-apiserver. when you exit telepresence session, kubernetes will scale ks-apiserver deployment(proxy)
to 0, and scale the real to 1 or other nums.


text:
[![R-CMD-check](https://github.com/KWB-R/urbanAnnualRunoff/workflows/R-CMD-check/badge.svg)](https://github.com/KWB-R/urbanAnnualRunoff/actions?query=workflow%3AR-CMD-check)
[![pkgdown](https://github.com/KWB-R/urbanAnnualRunoff/workflows/pkgdown/badge.svg)](https://github.com/KWB-R/urbanAnnualRunoff/actions?query=workflow%3Apkgdown)
[![codecov](https://codecov.io/github/KWB-R/urbanAnnualRunoff/branch/main/graphs/badge.svg)](https://codecov.io/github/KWB-R/urbanAnnualRunoff)
[![Project Status](https://img.shields.io/badge/lifecycle-experimental-orange.svg)](https://www.tidyverse.org/lifecycle/#experimental)
[![CRAN_Status_Badge](https://www.r-pkg.org/badges/version/urbanAnnualRunoff)]()
[![DOI](https://zenodo.org/badge/doi/10.5281/zenodo.6561481.svg)](https://doi.org/10.5281/zenodo.6561481)

**R Package for Deriving Urban Surfaces for Storm Runoff
Analysis**

Used in Project KEYS for generating inputs to
runoff model ABIMO for application in cities with data scarcity.

## Installation

For installing the latest release of this R package run the following code below:

```r
# Enable repository from kwb-r
options(repos = c(
  kwbr = 'https://kwb-r.r-universe.dev',
  CRAN = 'https://cloud.r-project.org'))

# Download and install keys.lid in R
install.packages('urbanAnnualRunoff')

# Browse the keys.lid manual pages
help(package = 'urbanAnnualRunoff')
```

## Workflow

The workflow for modelling urban annual runoff using the water balance model [ABIMO](https://github.com/umweltatlas/abimo) is described for the
two case-study sites in China here:

- [Jinxi](articles/workflow_jinxi.html) and

- [Tongzhou (Beijing)](articles/workflow_beijing.html)

repository: KWB-R/urbanAnnualRunoff

gha_language: R

repo_name: KWB-R/urbanAnnualRunoff