text:
# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]

### Added
- Support for reading JSON from clipboard

### Fixed
- Focus line jumping when toggle on closed braces

## [0.1.0-beta] - 2020-11-15

### Added

- Support configuration
- Add modes "emacs" and "vim" as predefined key mappings

### Fixed

- Focus line jumping around when moving up / below

## [0.1.0-alpha.3] - 2020-10-18

### Added

- Support for reading JSON from pipe

## [0.1.0-alpha.2] - 2020-10-17

### Added

- Auto-completion support for pyfx
- Add log configuration

## [0.1.0-alpha.1] - 2020-10-12

### Added

- Add doctest into the CI
- Add Travis CI test for MacOS
- Host docs on readTheDocs

## [0.1.0-alpha] - 2020-10-11

### Added

- Initial commit with pyfx

[unreleased]: https://github.com/cielong/pyfx/compare/v0.1.0-beta...HEAD
[0.1.0-beta]: https://github.com/cielong/pyfx/compare/v0.1.0-alpha.3...v0.1.0-beta
[0.1.0-alpha.3]: https://github.com/cielong/pyfx/compare/v0.1.0-alpha.2...v0.1.0-alpha.3
[0.1.0-alpha.2]: https://github.com/cielong/pyfx/compare/v0.1.0-alpha.1...v0.1.0-alpha.2
[0.1.0-alpha.1]: https://github.com/cielong/pyfx/compare/v0.1.0-alpha...v0.1.0-alpha.1
[0.1.0-alpha]: https://github.com/cielong/pyfx/v0.1.0-alpha

repository: swipswaps/pyfx

repo_name: swipswaps/pyfx


text:
# Sticky

A simple note taking and clipboard managing desktop application made using

- react and redux
- NeDB
- electron
- draft.js

<img src="https://github.com/nadunindunil/sticky/blob/dev/gif/demo.gif?raw=true" width="800" height="500">

### How to use

Install sticky in your system and use `ctrl+down` whenever you want an assist from Sticky.

### Functionalities

- Sticky can show your clipboard and save a value if you want
- create your shortnotes and edit, delete.
- Rich text util comes with Draft.js
- search your notes
- Easy access with simple key bindings

Install sticky in your system and use `ctrl+down` whenever you want an assist from Sticky.

### Developer guide
use
```
npm run dev
```
to start the project in dev mode.

use
```
npm run build
```
to build the project

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
project_path: /web/_project.yaml
book_path: /web/ilt/pwa/_book.yaml

{# wf_updated_on: 2017-04-14 #}
{# wf_published_on: 2017-04-14 #}

# Introduction to Progressive Web App Architectures {: .page-title }

What makes a Progressive Web App? This video explains the architecture of a
PWAs, and many of the major features and best practices. Topics covered include
caching for performance and offline functionality, app shell architecture, add
to homescreen, push notifications, tools for building service workers, mobile
web payments, and credentials management.

{% setvar videoId "LaS_5jUeh_0" %}
{% setvar slidesId "1Xu8FDXCPi7SGOArRgLKjrXWArvAUB4ESdKw9ecWqw0s" %}

{% include "web/ilt/pwa/_slides.html" %}

repository: shanselman/WebFundamentals

repo_name: shanselman/WebFundamentals


text:
---
# Documentation: https://wowchemy.com/docs/managing-content/

title: "Accenture Working with Institute for Data Science to Combat Software Supply Chain Attacks"
subtitle: ""
summary: ""
authors: []
tags: []
categories: []
date: 2023-02-08T18:17:45-05:00
lastmod: 2023-02-08T18:17:45-05:00
featured: false
draft: false

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
# Focal points: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight.
image:
  caption: ""
  focal_point: ""
  preview_only: false

# Projects (optional).
#   Associate this post with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `projects = ["internal-project"]` references `content/project/deep-learning/index.md`.
#   Otherwise, set `projects = []`.
projects: []
---

*Written by: Michael Giorgio*

{{<figure src="PXL_20220729_132613811.jpg">}}

Accenture, a leader in information consulting services, is collaborating with NJIT’s Institute for Data Science, led by **Distinguished Prof. David Bader**, to develop methods to mitigate risks arising in the use of open-source components in the software supply chain.

Modern cloud-based software is incredibly complex and often uses open-source code, which is cost-free and provides developers with countless libraries of prewritten functions. But that openness is also a risk, because anyone can change the code and it's not always clear who made the changes or what motivated them. [A recent malicious exploit](https://www.techtarget.com/searchsecurity/news/252527814/Tenable-72-of-organizations-remain-vulnerable-to-Log4Shell) in open-source code grabbed headlines in 2021, and continues to pose a risk today.

Lisa O’Connor, global leader of cybersecurity research and development for Accenture, shared the importance of this collaboration. “Understanding supply chain cyber risk is a business resilience imperative. It’s not enough to know the application or service, it’s essential that we understand the code components that make up the application or service,” O’Connor said.

Traditional software bill-of-materials (SBOM) applications — inventories of all the components of a software program, such as containers, licenses, microservices, security patches and versions — may no longer be sufficient to keep track of the software supply chain for security purposes.

Bader and his team, along with peers at Accenture, aim to explore the benefits of next-generation software bills of materials and the traceability of the software supply chain to identify security threats. They are applying structures known as knowledge graphs to model the connections between the software components.

{{<figure src="benevolent AI.png" caption=" A knowledge graph visually maps data and represents relationships (edges) between entities (nodes). Credit: Benevolent AI">}}

By examining these graphs using Bader’s graph analytical tools, software developers can identify and isolate vulnerable components that may put their software at risk. Finally, the technology makes suggestions about which components to include and which to be removed or strengthened.

“Protecting the open-source software supply chain has tremendous impact to the security of businesses and government. Combining our expertise, the Institute’s real-world graph analytics and Accenture’s cybersecurity expertise, yields a world-class team for addressing this critical supply chain problem,” Bader stated.

"We're excited about this collaboration with the Accenture team and the results we hope to achieve together," Bader added. "We plan to share our results in the months to come."

https://news.njit.edu/accenture-working-institute-data-science-combat-software-supply-chain-attacks

gha_language: Shell

gha_license_id: MIT


text:
# level-test

> Inject temporary and isolated level stores ([`leveldown`][leveldown], [`level-js`][level-js], [`memdown`][memdown] or custom) into your tests.

[![level badge][level-badge]](https://github.com/Level/awesome)
[![npm](https://img.shields.io/npm/v/level-test.svg?label=&logo=npm)](https://www.npmjs.com/package/level-test)
[![Node version](https://img.shields.io/node/v/level-test.svg)](https://www.npmjs.com/package/level-test)
[![Test](https://github.com/Level/level-test/actions/workflows/test.yml/badge.svg)](https://github.com/Level/level-test/actions/workflows/test.yml)
[![codecov](https://codecov.io/gh/Level/level-test/branch/master/graph/badge.svg)](https://codecov.io/gh/Level/level-test)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
[![Funding](https://opencollective.com/level/tiers/badge.svg?color=orange)](#donate)

**If you are upgrading:** please see [`UPGRADING.md`](UPGRADING.md).

## Usage

Create a fresh db, without refering to any file system or DOM specifics,
so that the same test can be used in the server or the browser! Use whatever test framework you like.

```js
const level = require('level-test')()
const db = level({ valueEncoding: 'json' })
```

In node it defaults to [`leveldown`][leveldown] for storage, using a unique temporary directory. In the browser it defaults to [`level-js`][level-js].

No database name is needed since `level-test` generates unique random names. For disk-based systems it uses [`tempy`](https://github.com/sindresorhus/tempy#readme) and in the browser it uses [`uuid/v4`](https://github.com/kelektiv/node-uuid#version-4).

```js
const level = require('level-test')()
const db = level()
```

In either environment use of [`memdown`][memdown] can be forced with `options.mem`:

```js
const level = require('level-test')({ mem: true })
const db = level({ valueEncoding: 'json' })
```

Or use [any `abstract-leveldown` compliant store](https://github.com/Level/awesome#stores)! In this case `level-test` assumes the storage is on disk and will thus create a unique temporary directory, unless you pass `mem: true`.

```js
const rocksdb = require('rocksdb')
const level = require('level-test')(rocksdb)
const db = level({ valueEncoding: 'json' })
```

## API

### `ctor = levelTest([store][, options])`

Returns a function `ctor` that creates preconfigured [`levelup`](https://github.com/Level/levelup) instances with temporary storage. The `store` if provided must be a function and [`abstract-leveldown`](https://github.com/Level/abstract-leveldown) compliant. Options:

- `mem`: use `memdown` as `store` (or assume that `store` _is_ `memdown`), default false.
- Any other option will be merged into `ctor` options, the latter taking precedence.

These are equal:

```js
const db1 = require('level-test')({ valueEncoding: 'json' })()
const db2 = require('level-test')()({ valueEncoding: 'json' })
```

### `db = ctor([options][, callback])`

Returns a [`levelup` instance](https://github.com/Level/levelup#api) via [`level-packager`](https://github.com/Level/packager) which wraps the underlying store with [`encoding-down`](https://github.com/Level/encoding-down). In short: the db is functionally equivalent to [`level`](https://github.com/Level/level). You get deferred open, encodings, Promise support, readable streams and more!

Options are passed to [`levelup`](https://github.com/Level/levelup) (which in turn passes them on to the store when opened) as well as [`encoding-down`](https://github.com/Level/encoding-down).

Please refer to the [`levelup` documentation](https://github.com/Level/levelup#levelupdb-options-callback) for usage of the optional `callback`.

## Contributing

[`Level/level-test`](https://github.com/Level/level-test) is an **OPEN Open Source Project**. This means that:

> Individuals making significant and valuable contributions are given commit-access to the project to contribute as they see fit. This project is more like an open wiki than a standard guarded open source project.

See the [Contribution Guide](https://github.com/Level/community/blob/master/CONTRIBUTING.md) for more details.

## Donate

Support us with a monthly donation on [Open Collective](https://opencollective.com/level) and help us continue our work.

repository: Level/level-test

gha_language: JavaScript

repo_name: Level/level-test


text:
---
layout: post
title: "A Novel Adaptive Kernel for the RBF Neural Networks"
date: 2019-05-09 11:38:57
categories: arXiv_CV
tags: arXiv_CV Classification Gradient_Descent
author: Shujaat Khan, Imran Naseem, Roberto Togneri, Mohammed Bennamoun
mathjax: true
---

* content
{:toc}

##### Abstract
In this paper, we propose a novel adaptive kernel for the radial basis function (RBF) neural networks. The proposed kernel adaptively fuses the Euclidean and cosine distance measures to exploit the reciprocating properties of the two. The proposed framework dynamically adapts the weights of the participating kernels using the gradient descent method thereby alleviating the need for predetermined weights. The proposed method is shown to outperform the manual fusion of the kernels on three major problems of estimation namely nonlinear system identification, pattern classification and function approximation.

##### Abstract (translated by Google)

##### URL
[http://arxiv.org/abs/1905.03546](http://arxiv.org/abs/1905.03546)

##### PDF
[http://arxiv.org/pdf/1905.03546](http://arxiv.org/pdf/1905.03546)


text:
# Bucket Sort

Bucket sort is a comparison sort algorithm that operates on elements by dividing them into different buckets and then sorting these buckets individually. Each bucket is sorted individually using a separate sorting algorithm or by applying the bucket sort algorithm recursively. Bucket sort is mainly useful when the input is uniformly distributed over a range.

Assume one has the following problem in front of them:

One has been given a large array of floating point integers lying uniformly between the lower and upper bound. This array now needs to be sorted. A simple way to solve this problem would be to use another sorting algorithm such as Merge sort, Heap Sort or Quick Sort. However, these algorithms guarantee a best case time complexity of O(NlogN). However, using bucket sort, the above task can be completed in O(N) time.

```
pip install allalgorithms
```

## Usage

```py
from allalgorithms.sorting import bucket_sort

arr = [77, 2, 10, -2, 1, 7]

print(bucket_sort(arr))
# -> [-2, 1, 2, 7, 10, 77]
```

## API

### bucket_sort(array)

> Returns a sorted array

##### Params:

- `array`: Unsorted Array

gha_language: Python


text:
layout-project
__Author:__ Daniel Hartnell

## Description

layout-project is my attempt to build a 2 column page layout with HTML and CSS.

[https://hartnelld.github.io/layout-project/](https://hartnelld.github.io/layout-project/)

## Setup Instructions

This website is hosted courtesy of GitHub Pages. As stated above, you can access it [here](https://hartnelld.github.io/layout-project/). If you want to host it yourself you can clone a copy of the repository and open it in your web browser of choice.

>$ git clone https://github.com/hartnelld/layout-project.git

__Note:__ You'll want to make sure you're checking out the gh-pages branch. This is not syncd to the master branch currently.

## Copyright and License

Code released under [the MIT license](https://github.com/hartnelld/about-me/blob/gh-pages/LICENSE.txt).

repository: hartnelld/layout-project

repo_name: hartnelld/layout-project


text:
# EITEST
An implementation of EITEST (Event Information TEST) to discover statistical relationships between event series and time series. The methodology is described and analysed in detail in the paper:

Erik Scharwächter, Emmanuel Müller: **Two-Sample Testing for Event Impacts in Time Series.**
In: Proceedings of the 2020 SIAM International Conference on Data Mining (SIAM SDM)
[[permalink]](https://doi.org/10.1137/1.9781611976236.2)
[[arXiv preprint]](https://arxiv.org/abs/2001.11930)

## Contact and Citation

* Corresponding author: [Erik<EMAIL_ADDRESS>* Please cite our paper if you use or modify our code for your own work.

## Requirements and Usage

Our module [eitest.py](./eitest.py) was developed with [Python 3.7](https://www.python.org/) and requires [NumPy](https://numpy.org/), [SciPy](https://scipy.org/) and [Numba](https://numba.pydata.org/). Check the Jupyter notebook [ampds.ipynb](./ampds.ipynb) to reproduce the results from our paper and understand how to use our module. The notebook additionally requires [Pandas](https://pandas.pydata.org/). Check [simulations.ipynb](./simulations.ipynb) for code to reproduce results from our simulation study.

## License

The code is released under the MIT license.

repository: diozaka/eitest

repo_name: diozaka/eitest


text:
---
layout: post
title:  "Occluder/Occludee Static"
date:   2019-temp-temp
excerpt: "Description about Occluder/Occludee Static in Inspector Static Tags"
tag:
- Unity
- Occlusion Culling
- Essay
---

	关于物体Inspector窗口的Static属性中的 **Occluder Static** 和 **Occludee Static **选项的区别。

> When should you use **Occludee Static**? Completely transparent or translucent objects that do not occlude, as well as small objects that are unlikely to occlude other things, should be marked as **Occludees**, but not **Occluders**. This means they will be considered in occlusion by other objects, but will not be considered as occluders themselves, which will help reduce computation.

	这是官方文档（unity3D/Editor/Data/en/Manual/OcclusionCulling.html）所给的描述。

	也就是说，对于完全透明或者半透明且不会遮挡到其他物体的物体，当然也包括那些非常小的、不太可能遮挡其他物体的物体，对于这两类，我们可以将它们标记为**Occludees**。这意味着他会被纳入其他物体的遮挡检测考虑范围，但自身并不会去检测是否遮挡物体。


text:
# CI job babysitting

First, ensure that you familiarize yourself with [OSA CI](https://github.com/openshift/release/blob/master/projects/azure/README.md).

The expectation is that each of the following jobs should be green, and should have run in the last 24h.

## Branch jobs

If these fail, it is indicative of a flaking or completely broken test.

* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/branch-ci-openshift-azure-misc-master-images/]
* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/branch-ci-openshift-openshift-azure-master-e2e-azure/]
* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/branch-ci-openshift-openshift-azure-master-images/]
* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/branch-ci-openshift-openshift-azure-master-unit/]
* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/branch-ci-openshift-openshift-azure-master-verify/]

## VM image builds

* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/periodic-ci-azure-base-image-rhel]
* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/periodic-ci-azure-node-image-rhel-311]

## Periodic jobs

* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/periodic-ci-azure-etcdbackuprecovery-e2e/]
* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/periodic-ci-azure-key-rotation-e2e/]
* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/periodic-ci-azure-prod-e2e/]
* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/periodic-ci-azure-scaleupdown-e2e/]
* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/periodic-ci-azure-vnet-e2e/]
* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/periodic-ci-openshift-openshift-azure-master-conformance/]
* [https://openshift-gce-devel.appspot.com/builds/origin-ci-test/logs/periodic-ci-openshift-openshift-azure-master-bushslicer/]

Also triage the [cron jobs in the azure namespace](https://github.com/openshift/release/blob/master/projects/azure/README.md#other-cron-jobs) in the [CI cluster](https://api.ci.openshift.org/console/). It is expected that all except for `token-refresh` should be regularly succeeding.

Close [test flake issues in openshift-azure](https://github.com/openshift/openshift-azure/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+label%3Akind%2Ftest-flake) where these no longer appear to be occurring.  Open issues for new test flakes. The expectation is that you do a first pass on root cause, fix the issue if straightforward, otherwise assign the issue to someone who can fix it. Please refer to the [testing flakes](https://github.com/openshift/openshift-azure/blob/master/docs/testing-flakes.md) document for more information about how to proceed when confronted with testing flakes.

repository: openshift/openshift-azure

gha_language: Go

repo_name: openshift/openshift-azure


text:
# HugeTabBarButton

[![CI Status](http://img.shields.io/travis/fortmarek/HugeTabBarButton.svg?style=flat)](https://travis-ci.org/fortmarek/HugeTabBarButton)
[![Version](https://img.shields.io/cocoapods/v/HugeTabBarButton.svg?style=flat)](http://cocoapods.org/pods/HugeTabBarButton)
[![License](https://img.shields.io/cocoapods/l/HugeTabBarButton.svg?style=flat)](http://cocoapods.org/pods/HugeTabBarButton)
[![Carthage Compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)

HugeTabBarButton lets you create huge images for your UITabBarItems.

<img src="https://github.com/fortmarek/HugeTabBarButton/raw/master/hugetabbar_screen.png" width="200">

## Installation
### CocoaPods

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

```ruby
pod 'HugeTabBarButton'
```

### Carthage

If you use Carthage, add this to your Cartfile:

```ruby
github "fortmarek/HugeTabBarButton"
```

## How it Works

It's quite simple, really! To create a huge image, just create a `UIViewController` like this:
```swift
let hugeTabBarItem = UITabBarItem()
hugeTabBarItem.image = UIImage(named: "HugeImage")
hugeTabBarItem.imageInsets = UIEdgeInsets(top: -20, left: 0, bottom: 20, right: 0)
hugeTabBarItem.title = "Huge"
tabBarViewController.tabBarItem = hugeTabBarItem
```

And init your `UITabBarController` as `HugeTabBarController`:
```swift
let tabBarController = HugeTabBarController()
```

Basically what you need to do is change the `imageInsets` and `HugeTabBarButton` will then register the tap wherever your image is. Easy! 😎

repository: carabina/HugeTabBarButton

repo_name: carabina/HugeTabBarButton


text:
---
title: EquivalentAddin element in the manifest file
description: Specifies backwards compatibility for an equivalent COM add-in or XLL.
ms.date: 01/04/2022
ms.localizationpriority: medium
---

# EquivalentAddin element

Specifies backwards compatibility for an equivalent COM add-in or XLL.

[!INCLUDE [Support note for equivalent add-ins feature](../includes/equivalent-add-in-support-note.md)]

**Add-in type:** Task pane, Mail, Custom function

**Valid only in these VersionOverrides schemas**:

- Task pane 1.0
- Mail 1.1

For more information, see [Version overrides in the manifest](/office/dev/add-ins/develop/add-in-manifests#version-overrides-in-the-manifest).

## Syntax

```XML
<EquivalentAddin>
   ...
</EquivalentAddin>
```

## Contained in

- [EquivalentAddins](equivalentaddins.md)

## Must contain

- [Type](type.md)

## Can contain

- [ProgId](progid.md)
- [FileName](filename.md)

## Remarks

To specify a COM add-in as the equivalent add-in, provide both the `ProgId` and `Type` elements. To specify an XLL as the equivalent add-in, provide both the `FileName` and `Type` elements.

## See also

- [Make your custom functions compatible with XLL user-defined functions](/office/dev/add-ins/excel/make-custom-functions-compatible-with-xll-udf)
- [Make your Office Add-in compatible with an existing COM add-in](/office/dev/add-ins/develop/make-office-add-in-compatible-with-existing-com-add-in)

repository: OfficeDev/office-js-docs-reference

branch_name: refs/heads/main

gha_language: TypeScript

repo_name: OfficeDev/office-js-docs-reference


text:
---
id: 1
title: Analyzing Louisville Crime
date: 2017-02-08
author: QuantifyLouisville
layout: post
guid: http://www.quantifylouisville.com/?p=1
permalink: /louisville-crime/
categories:
  - Crime
tags:
  - LMPD
  - Relationships
---

# Analyzing Louisville Crime Trends

## The Data

After a lengthy break, Quantify Louisville is back! For our first
post of 2017 we decided to look into the last ten years of Louisville
crime reports [2007 -
2016](https://data.louisvilleky.gov/dataset/crime-data). In addition, we
have also begun publishing our R code so that anyone interested can
reproduce our analysis and visuals.

After a fairly minor bit of data manipulation, our first visualization
shows the total reported crimes by the month in which they occured. A
few things stand out that appear to be issues with the data. Many crime
types appear to fall to and remain at zero for most of 2009. This could
potentially represent missing data. Conversely, 2012 appears to have
been a major crime wave with nearly all crime type showing monthly
totals well above the rest of the data set. It is possible reports in
2012 were collected differently than in other years, or a system issue
is creating false spikes.

![](../images/posts/Crime%20Types%20By%20Day%20Graph-1.png)

Assuming that the first-glance data issues described above don't
completely remove the data's usefulness, it appears that the rise in
weapons has some relationship to the rise in homicides. The graph below
shows the number of homicides per month along the x-axis, while the
y-axis shows the number of weapons occurences which were reported.

Based upon only these data series, it appears that an increase in the
number of weapons crimes reported corresponds to a similary-time
increase in the number of homicides that occur.

![](../images/posts/Homicides%20and%20Weapons-1.png)

![](../images/posts/Homicides%20and%20Weapons%20by%20Division-1.png)

Based upon the graph above, it looks like the weapons occurence reports
for the 2nd Division (a division which includes the neighborhoods
Algonquin, California, Chickasaw, Hallmark, Park Duvalle, Park Hill,
Parkland and Shawnee) appear to have the strongest relationship to the
number of homicide reports. A convenient way to interpret the simple
correlation is to assume that more weapons-related reports imply an
increase in the number of weapons present in those neighborhoods, which
leads to a high number of homicides.

![](../images/posts/Homicides%20and%20Weapons%202nd%20Division-1.png)

We can visualize this more by mapping the divisions and shading each
based on how strong the relationship is between weapons charges and
homicide. It's even more clear looking at it this way that the Second
Division has a much higher relationship between the two than the others.

Looking at it this way, we can easily see that the largest relationship
(although, not huge by any means) falls in the Second Division - and is
significantly different than most other divisions with the exception of
the Fourth Division, which is right next to the Second.

![](../images/posts/mapping-1.png)

This is in no way a claim that there is a causal relationship between
the two. However, it is definitely interesting that in certain
divisions, there definitely tends to be some correlation between weapons
charges and homicides. Intuitively, this definitely makes sense - if
there tends to be higher homicide levels then it stands to reason that
there would exist more weapons in circulation (or, vice versa). However,
a case could be made that there is a leading indicator somewhere in the
rise of homicides if we see a rise in weapons charges.

Despite this, it is important to note other possible interpretations.
For example, it is possible that specific weapons and homicide reports
represent the same incident. If that were to be the case, then the
visual is simply catching this double counting. A cursory review of the
dates and address of homicides and weapons occurence reports seem to
show that the double counting is not present. However, given the
looseness of some of the date-related data (described below), it is not
100% conclusive.

Lastly, it is not clear whether all records in the data set are created
through citizens making reports, or if policing has some influence as
well. Were the second option to be the case, distinctions made between
divisions would become muddier.

What will also be interesting as we dig further into this data is
whether that type of relationship exists for other types of crimes. This
isn't groundbreaking in any way - and underpins the 'Broken Windows'
policing philosophy where smaller proprety crimes tend to predict more
violent crimes.

## Hilarious Date Outliers

It is important to note, that almost all data analysis comes with
potential data issues that can create obtacles or completely derail the
goals. This data set is no exception. While we won't detail each bit of
our data review, we will try to highlight a few tricks we tend to resort
to. For example, one easy way that tends to yield silly results is to
create comparisons between dates in the set and intepret the outliers
literally. In this particular data set, both the date a crime occured
and the time it was reported are captured.

Some crimes appear to be reported days, weeks, and sometimes even
*years* after they occurred. The visual below tallies any crime from ten
years that was reported at least one year after it allegedly
perpetrated.

![](../images/posts/Older%20than%20a%20year%20graph-1.png)

Understandably, sexual assults and identity thefts make up a large
portion of the crimes with a long lag between their occurence and
report. However, according to this data set someone also waited over 12
years to report a stolen firearm and a burglary on 24th Street wasn't
reported for over a decade ("Should I call the cops? Does that *really*
qualify as a burglary? Maybe I should sleep on it for one more night and
see how I feel in the morning.").

Perhaps the most baffling the records include the 32 times in the last
ten years in which someone waiting over a year to report that someone
was Disturbing The Peace. While the majority of those appear to be
prostitution related, one record seems to indicate that someone waited
SEVEN YEARS to report that someone got a little crazy in a 7th street
bar.

At the other extreme, some crimes appear to have been reported before
they even occurred. These Minority-Report crimes, one would think,
should be fairly easy to prevent.

![](../images/posts/Minority%20ReportGraph-1.png)

The extremes at both ends of the occured and reported dates make it
difficult to the dates relative to each other to answer questions other
than in the most broad sense. To cut through that a bit, let's take a
look at the five most active days from the sense of crime. We can then
compare those totals to a day that would be made up of the average total
crime numbers for each crime type - we're calling this the "Average
Day", although we fully realize that looking at the average of 16
different types of crime doesn't *fully* reflect an average day of total
crime.

The most obvious bit of insight here is how much larger our bars are in
the top five as compared to the average. The top five days have activity
levels near 700 charges a day - whereas our average is sitting around
200 for the day. This nearly 4-fold increase above the average is
certainly significant in magnitude, but are these days truly significant
in the makeup of the crime? In other words, are they driven
significantly higher because of the presence of a single type of crime -
or is the composition largely the same, with just more activity across
the board?

![](../images/posts/top-five-total.png)

To help answer that, we can break down the composition of the type of
crime across the top five most active days and the average. And when we
do that, a couple of interesting points pop out For one - there are a
couple of call outs. Sex crimes were up significantly above the average
on Jan 2nd, 2012 according to the data. Also, there were a whole lot more
charges for disturbing the peace on March 17th of the same year, and a
slew of crimes labeled simply as 'other' on September 17th.

What's most interesting, perhaps, is that there isn't anything
particularly special about the top five days as compared to the average.
The composition of crime on those days is largely consistent with the
average - which means that there was no single reason why these dates
stood out from the rest. The makeup of crime on those days was
essentially the same - there was just more of each.

![](../images/posts/top-five-composition.png)

The next question to ask is: Is this composition holding true on these
days across the entire region? Or are we seeing one division
disproportionately affected by increased activity in one type of crime
that it typically never witnesses, and therefore driving the overall
totals higher?

![](../images/posts/top-five-total-Divisions.png)

Within different divisions, Metro Louisville reports made a much larger
proportion of the crime reports on 1-1-2012 than would be typical, or as
occured on other high-volume days. Interestingly, the 4th division
(neighborhoods Beechmont, Cloverleaf, Fairgrounds, Germantown,
Hazelwood, Iroquois, Jacobs, Limerick, Merriwether, Old Louisville,
Paristown, Schnitzelburg, Shelby Park, Smoketown Jackson, South
Louisville, Taylor Berry, University, Wilder Park and Wyandotte) tends
to contribute the most reports on a typical day.

![](../images/posts/top-five-composition-divisions.png)

So, what can we make of these high-volume days? As with other sections
of this data, it is possible that how the data is collected makes it
difficult to find meaing from the daily aggregations. In real life, do
the most heavy crime days *really* feature four times as many crimes as
the average day? If not, the data set is not really capturing what it is
intended to capture.

For our crime data post, we intend to pull a larger section of
demographic data in order to attempt to further explain the recent
increase in both reports of weapons-related crime and homicdies.

As always, please don't hesitate to contact us with comments and
questions.

[**Michael<EMAIL_ADDRESS><br>
[**Eric<EMAIL_ADDRESS>


text:
* "..." - string literal
* '...' - another string literal
* print - print something
* # - comment
* +, -, *, /, % - add, substract, multply, divide, modulo
* >, <, >=, <= - gt, lt, gte, lte
* = - assignment
* print ..., - comma within #print - concatenate at print, don't make new line
* % - string format operator
* () - tuple, e.g. for passing to string format operator
* , - comma within tuple, to separate elements
* %r, %s, %d - formatters: raw, string, integer
* * - multiplication, works with strings
* True, False - boolean constants
* \n - new line escape sequence
* """ - triple quote, for multiline strings
* ''' - another form of triple quote
* \t - tab escape sequence
* \\ - backslash escape sequence
* raw_input([prompt]) - function for grabbing user input
* from ... import ...
* import
* sys - 'system' module, builtin module for working with the Python interpreter
* argv - 'argument vector', list of arguments passed to the script
* ..., ..., ... = ... - value unpacking
* open(...) - open a file by filename
* file.read() - read from file
* file.write(data) - write to file
* file.close() - close file descriptor
* file.seek(n, [whence]) - move file cursor
* file.readline() - read a line from file
* 'w' - open with 'write' mode
* os - biltin package for working with underlying OS
* os.path - module for working with paths in Python
* os.path.exists - function checking whether given file exists
* def, (), : - required elements of function definition
*  * - unpack a list argument into multiple arguments
*  return - return (a value) from function

repository: python-practice/lpthw

repo_name: python-practice/lpthw


text:
# #6 Use Approvals, Gates & Pull Requests
- Use approvals to control deployment stages
    - Can be set both pre and post deployment
    - You can also include manual intervention task inside a pipeline
- Use gates to control deployment stages
    - Can be set both pre and post deployment
- Use Pull Request for QA
    - Both for security and general quality
    - Run builds and deployments before merging to Master
- If you use 3rd party solutions for e.g. Feature Toggling consider the security aspects of these services
    - And who controls the feature toggle?
    - This can also be automated via Pipelines with e.g. LaunchDarkly

![gates][gates]

[gates]:  /images/06-gates.png "Gates"

repository: adente/azdevopssecurity

repo_name: adente/azdevopssecurity


text:
# SlapStats For Streamers
A Python script that grabs stats from your latest Slapshot custom match and outputs the values to text files.

Instructions:
1.) Place the exe or script into your Slapshot matches folder "..\steamapps\common\SlapshotRebound\Slapshot_Data\Matches".
2.) Run the exe or script - see 'Notes'.
3.) 2 files will be generated in the same directory - home_stats.txt and away_stats.txt.
4.) SlapStats will continue to monitor the files and update stats until you exit with CTRL + C or close the window.
5.) Use the generated .txt files to populate your stream overlay.

Format of the txt file values in order:
Goals
Shots
Saves
Faceoff percentage
Takeaways
Passes
Possession Time

Notes:
Use either the supplied .exe file or download python and execute the script (https://www.python.org/downloads/).
For the exe, you will likely have to add an exception to your Anti-Virus to run it.

repository: Razzit/Slapstats-For-Streamers

repo_name: Razzit/Slapstats-For-Streamers


text:
# slack-notification-action

This action will alert your slack channel/PM with repo/branch/runner log and mention you.

![Screen](images/notification.png)
# Requirements
First of all you need to create your slack app with these items and use them in ```with``` section of the action.
### ```slack-url```
Go to your slack app ([Your Apps](https://api.slack.com/apps)->Features->Incoming Webhooks) and add new webhook URL for your workspace. After you can use this URL in actions.
### ```slack-oauth-token```
The action requires an OAuth token token for your slack workspace with ```users:read.email```([doc](https://api.slack.com/scopes/users:read.email)) permission.

# Usage
See [action.yml](action.yml)

Basic:
```yaml
steps:
- uses: actions/checkout@v2
- uses: 7olstoy/slack-notification-action@main
  with:
    slack-url: ${{ secrets.SLACK_TEST_CHANNEL_URL }}
    slack-oauth-token: ${{ secrets.SLACK_BOT_OAUTH_TOKEN }}
```

Advanced:
```yaml
jobs:
  shellcheck:
    name: Lint with Shellcheck
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Run ShellCheck
      uses: ludeeus/action-shellcheck@master
      with:
        format: tty
    - uses: 7olstoy/slack-notification-action@main
      with:
        slack-url: ${{ secrets.SLACK_TEST_CHANNEL_URL }}
        slack-oauth-token: ${{ secrets.SLACK_BOT_OAUTH_TOKEN }}
      if: failure()
```

# License

The scripts and documentation in this project are released under the [MIT License](LICENSE)

repository: shintana/slack-notification-action

repo_name: shintana/slack-notification-action


text:
---
layout: page
title: About
permalink: /about/
---

### Something about me

My name is Fabian Flanhardt, I'm living in Germany and I started working in IT in 2007, which was kind of making my hobby my job. I've come along tons of interesting topics since then and never got bored. Instead, my interest for all that great stuff and figuring out how it works is still growing and feels like never coming to an end.
At the moment, I'm focusing on cloud technologies - most of the time Microsoft Azure - and Citrix Products and also actively participate in the Microsoft communities in Cologne.
Of course, IT is not my only interest. But it is the one I will most likely be blogging about.

### Why I want to start a blog

Working in IT, reading stuff published to the internet is essential for getting into new things. Life as an IT enthusiast would be unimaginable for me without so many people out there doing a great job in sharing their knowledge. So at first, I want to give something back by participating with my contributions.

Second, this will also be some kind of documentation for myself. Writing down things lets you remember far better than just doing, or thinking about things. And once it's stored, you can always come back to look up.

Third - and that’s kind of making the second point complete - is collaborating with others. Blogging makes it possible to share experience and knowledge with a bigger audience, to get to know other views and to learn from each other. Working alone and keeping things to one's self is limiting, while being a part of an active community is an opportunity for ideas to be born and to evolve. So I'd be excited to have some good discussions and connect to new people here. Happy reading!

### More Information

coming soon.

### Contact me

[fabian.flanhardt@outlook.com](mailto:fabian.flanhardt@outlook.com)


text:
[![Actions Status](https://github.com/bigeasy/memento/workflows/Node%20CI/badge.svg)](https://github.com/bigeasy/memento/actions)
[![codecov](https://codecov.io/gh/bigeasy/memento/branch/master/graph/badge.svg)](https://codecov.io/gh/bigeasy/memento)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A pure-JavaScript `async`/`await` indexed, persistant database.

| What          | Where                                         |
| --- | --- |
| Discussion    | https://github.com/bigeasy/memento/issues/1   |
| Documentation | https://bigeasy.github.io/memento             |
| Source        | https://github.com/bigeasy/memento            |
| Issues        | https://github.com/bigeasy/memento/issues     |
| CI            | https://travis-ci.org/bigeasy/memento         |
| Coverage:     | https://codecov.io/gh/bigeasy/memento         |
| License:      | MIT                                           |

Memento installs from NPM.

```text
//{ "mode": "text" }
npm install memento
```
Memento is a database that supports atomic, isolated transactions, written to a
write-ahead log and synced for durability in the event of system crash, and
merged into b-trees for fast retrieval. It reads from an in memory page cache
and evicts pages from the cache when they reach a user specified memory limit.

Memento is written in pure JavaScript.

Memento provides a contemporary `async`/`await` interface.

This `README.md` is also a unit test using the
[Proof](https://github.com/bigeasy/proof) unit test framework. We'll use the
Proof `okay` function to assert out statements in the readme. A Proof unit test
generally looks like this.

```javascript
//{ "code": { "tests": 2 }, "text": { "tests": 4  } }
require('proof')(%(tests)d, async okay => {
    //{ "include": "test", "mode": "code" }
    //{ "include": "proof", "mode": "text" }
})
```

```javascript
//{ "name": "proof", "mode": "text" }
okay('always okay')
okay(true, 'okay if true')
okay(1, 1, 'okay if equal')
okay({ value: 1 }, { value: 1 }, 'okay if deep strict equal')
```

You can run this unit test yourself to see the output from the various
code sections of the readme.

```text
//{ "mode": "text" }
git clone git@github.com:bigeasy/memento.git
cd memento
npm install --no-package-lock --no-save
node test/readme.t.js
```

The `'memento'` module exports a single `Memento` object.

```javascript
//{ "name": "displayedRequire", "mode": "text" }
const Memento = require('memento')
```

```javascript
//{ "name": "test", "mode": "code" }
const Memento = require('..')

const path = require('path')
const fs = require('fs').promises
const { coalesce } = require('extant')

const directory = path.resolve(__dirname, './tmp/readme')
await coalesce(fs.rm, fs.rmdir).call(fs, directory, { force: true, recursive: true })
await fs.mkdir(directory, { recursive: true })
```

```javascript
//{ "name": "test", "mode": "code" }
{
    //{ "include": "introduction" }
}
```

We create a database object with the static `async Memento.open` function. It
returns an open database ready for use.

The first argument to `async Memento.open()` is an options object.

The second argument is an `async` database upgrade function. You are only able
to create new stores and indices in the update function. Once the database is
open you're not allowed to make any schema changes.

```javascript
//{ "name": "introduction" }
const directory = path.resolve(__dirname, './tmp/readme')
const memento = await Memento.open({ directory }, async schema => {
    switch (schema.version.target) {
    case 1:
        await schema.store('president', { lastName: String, firstName: String })
        break
    }
})
```

In order to add or remove data from the database you invoke `memento.mutator()`
with an `async` mutation callback function. The mutation function will be called
with a `Mutator` object.

The mutator function represents an atomic transaction against the database.
Changes made within the function are only visible within the function. They only
become visible outside of the function when the function returns successfully.

If the function raises and exception, the changes are rolled back.

```javascript
//{ "name": "introduction" }
await memento.mutator(async mutator => {
    mutator.set('president', { firstName: 'George', lastName: 'Washington' })
    const got = await mutator.get('president', [ 'Washington', 'George' ])
    okay(got, {
        firstName: 'George', lastName: 'Washington'
    }, 'isolated view of inserted record')
})
```

You'll notice that the `mutator.set()` method is a synchronous function. This is
because we want inserts and deletes to be fast. Rather than performing
asynchronous file operations for each insert and delete, we cache the changes in
memory and write them out in batches.

The `mutator.get()` method on the other hand is an `async` function. We have to
go and check the database to see if the value is there and compare it with our
write cache. Checking the database may require a read operation, or it may not,
depending on the database cache.

So, `mutator.set()` ought to be pretty quick, making batch inserts relatively
painless. `async mutator.get()` not so quick because it has to go out through
the `Promise`s event loop.

We'll make up for this discrepancy when we look at ranged queries, iterators,
and joins.

Note that the `Snapshot` object is only valid during the invocation of the
snapshot callback function. If you attempt to save it and use later you will get
undefined behavior. Currently, there are no assertions to keep you from doing
this, just don't do it.

```javascript
//{ "mode": "text" }
let evilMutator
await memento.mutator(async mutator => {
    evilMutator = mutator
})
// No!
evilMutator.set('president', {
    firstName: 'John',
    lastName: 'Adams',
    terms: [ 1 ]
})
```

When we only want to read the database we use a `mutator.snapshot()` with an
`async` snapshot callback function. The snapshot function will be called with a
`Snapshot` object.

Use the `Snapshot`, the snapshot function can perform read-only requests on the
database. The `Snapshot` will have a point in time view of the database. Any
changes made by mutators that commit after the snapshot callback function begins
will not be visible to the snapshot function.

```javascript
//{ "name": "introduction" }
await memento.snapshot(async snapshot => {
    const got = await snapshot.get('president', [ 'Washington', 'George' ])
    okay(got, {
        firstName: 'George', lastName: 'Washington'
    }, 'snapshot view of inserted record')
})
```

When you are done with Memento you close it.

```javascript
//{ "name": "introduction" }
await memento.close()
```

### Insert and Delete

### Stores and Indices

### Cursors and Iteration

### Snapshots versus Mutators

### Inner and Outer Joins

### Migrations

### API

`memento = Memento.open(options, async upgrade => {})`

 * `options`
     * `destructible` — Optional instance of Destructible for structured
        concurrency management of the Memento instance.
     * `turnstile` — Optional Turnstile to manage parallel writes to file
        system.
     * `directory` — Directory in which to store data files.
     * `version` — Migration version.
     * `comparisons` — Optional of one or more comparision functions to use
        for collation.
 * `upgrade` —

`memento.snapshot(async snapshot => {})`

`memento.mutator(async mutator => {})`

repository: anuragvohraec/memento

repo_name: anuragvohraec/memento


text:
## Passing an array of objects
When passing an array of objects you must specify which property represents the value and how the suggestions should be rendered. You must also specify which properties the component should filter on:

```
let options = [{
    id: 1,
    name: "John",
    surname: "Smith",
    age: 26
}, {
    id: 2,
    name: "John",
    surname: "Constantine",
    age: 26
}, {
    id: 3,
    name: "Long",
    surname: "John Silver",
    age: 26
}, {
    id: 4,
    name: "Johnny",
    surname: "Guitar",
    age: 26
}, {
    id: 5,
    name: "Rob",
    surname: "White",
    age: 32
}, {
    id: 6,
    name: "Frank",
    surname: "Black",
    age: 53
}]

let value = 0
let handleValueChange = v => {value = v}

<UIAutocomplete
    options={options}
    suggestionMinimumInputChar={0}

    optionValue="id"
    optionFilter={['name', 'surname']}
    optionLabelRender={o => o.name + ' ' + o.surname}

    value={value}
    onChange={handleValueChange}
/>
```

repository: gianmarcotoso/react-ui-autocomplete

repo_name: gianmarcotoso/react-ui-autocomplete


text:
---
parent: ESM Views
nav_order: 1
title: How to build ESM Views
---

# How to build ESM Views

ESM views are built with the [`modular build`](../commands/build.md) command.
The default behaviour when building an ESM view is:

1. All the non-local `import`s in the package's `src` directory are extracted
   and matched with their version in the package's `package.json` or the
   `package.json` in the repository root and with their exact version in the
   repo's lockfile.
2. The main entrypoint (as defined in the ESM view's `package.json`'s `main`
   field) and its local imports are bundled in a single file.
3. All the `import` statements to non-local dependencies encountered in the
   process are rewritten to `import` from an external ESM CDN (by default
   https://www.skypack.dev/), using the versions extracted in step 1. By
   default, versions extracted from `package.json` will be used, but users can
   customize the rewrite template to use versions from the lockfile instead.
4. All the local CSS is bundled in a single file.
5. The `dist` directory is generated, containing:
   - The js file
   - The css file
   - A [package manifest](./output-package-manifest.md) (`package.json`) file
     containing:
     - The location of the js bundle (`"module"` field)
     - The location of the css bundle (`"style"` field)
     - An object with the whole set of dependencies and their version ranges
       (`"dependencies"` field)
     - An array of bundled dependencies (`bundledDependencies` field)
   - A synthetically generated `index.html` file, linking the trampoline file
     and the css bundle. This file is included in the `dist` directory of the
     esm-view.
   - A synthetically generated trampoline file (`_trampoline.js`), dynamically
     `import`ing the js bundle and `React.render`ing its default export to a
     `#root` div. This file is included in the `dist/static/js` directory of the
     esm-view

The ESM view build result can either be
[dynamically imported](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#dynamic_imports)
from a host application,
([including the css bundle](https://web.dev/css-module-scripts/)) or served
statically as a standalone application (for example, using `modular serve` or
from a web server).

repository: jpmorganchase/modular

repo_name: jpmorganchase/modular


text:
# ssh-keygen

Secure copy and Secure Shell are the best ways to copy files and to access remote machines. The `ssh-keygen` program allows one to copy files without a password. This works for `SSH` as well. For more information on this very cool feature run `man ssh-keygen`.

Follow these steps to allow the use of `ssh/scp` without having to enter a password. You will need to be `root`.

1. First, make sure the client has used `ssh` at least once. This will create the proper directory that is needed.
2. On the master machine run the `ssh-keygen -t rsa` command. This will create some necessary files.
3. If the `/root/.ssh/authorized_keys` file does not already exist on the client, you can run `scp /root/.ssh/id_rsa.pub <hostname>:/root/.ssh/authorized_keys`.
4. Otherwise, copy the `id_rsa.pub` file over to the client and then add it to the `authorized_keys` file (I usually put it at the bottom).
5. You should now be able to `scp` and `ssh` to the client without having to enter a password. This is really handy, especially in scripts.

You can also add this entry to another user account. For example, I added it to my `/home/guest1/.ssh/authorized_keys` file. This way I can copy files as `root` from one machine, and it will still be accepted by the other.

repository: lsieun/learn-linux

repo_name: lsieun/learn-linux


text:
# haskell_99
My exercises on Haskell problems including 99 Haskell Problems

See [link](https://wiki.haskell.org/H-99:_Ninety-Nine_Haskell_Problems)


text:
# AtixLabs Eslint Config

This repository contains predefined (an opinionated) rules for AtixLabs eslint projects. Here you will be able to find presets for NodeJs and ReactJS (and obviously Javascript).

All the presets are based on other excellent projects with some minor tweaks to fit our needs. All our presets are defined using [Eslint Shareable Configs](https://eslint.org/docs/developer-guide/shareable-configs)

![](demo.gif)

[Full Screen](https://asciinema.org/a/klJicE8qn68kSsb8C6olqumkf)

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

### Prerequisites

In order to setup the eslint rules in your project you need to use `NodeJs v12+`. Also you need to install our rules presets:

```
npm install -E @atixlabs/eslint-config
```

Once you have installed the package, there is a helper script that will help installing the required dependencies based on the projec type you are trying to configure. To do so, invoke it using:

`npx atixlabs-eslint-config-install-deps`

or

`./node_modules/.bin/atixlabs-eslint-config-install-deps` in case you don't have `npx` installed.

### Configuring

Depending on the project you are running you will need to specify which rules you want to use. To do so, create an `.eslintrc` file with the following configs:

- NodeJS

```
{
  "extends": "@atixlabs/eslint-config/configurations/node"
}

```

- ReactJS

```
{
  "extends": "@atixlabs/eslint-config/configurations/react"
}

```

If your project contains multiple technologies, you can compose the configs, for example, if you have a NodeJs and React project, you can set:

```
{
  "extends": [
    "@atixlabs/eslint-config/configurations/react",
    "@atixlabs/eslint-config/configurations/node"
  ]
}

```

### Customization

- If you want to override any rule you an still do it by adding them in your project `.eslintrc` config file as you would normaly do.

## How to test?

// TODO

## Deployment

This package is published to npm registry under @atixlabs organization.

## Built With

* [Eslint](https://eslint.org/) - Linter Used.
* [Prettier](https://prettier.io/) - For some presets related to our formatting rules.
* [Formidable Labs presets](https://github.com/FormidableLabs/eslint-config-formidable) - Used as a base for our config.
* [Eslint Plugin Unicorn](https://github.com/sindresorhus/eslint-plugin-unicorn) - With useful eslint rules.
* [SonarJS](https://github.com/SonarSource/eslint-plugin-sonarjs) - To detect bugs and suspicious patterns in the code.

## Contributing

Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us.

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/your/project/tags).

## License

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

repository: atixlabs/eslint-config

repo_name: atixlabs/eslint-config


text:
Building a custom React renderer
================================

*This tutorial is lacking screenshots and hasn't been checked to see if it works, it will be updated soon!*

Once you have got the core Specular module installed, you're probably looking to start doing some cool stuff.
In this tutorial, we are going to wrap the Canvas API and draw some stuff on the page.

## 1. Setting up Specular

Make sure you have the Specular barebones ready to go:

`index.js`:

```javascript
import React from 'react'
import Specular, {Scene} from 'specular'

const renderTargets = []

Specular.render(
  <Scene>
    {/* Components will go here */}
  </Scene>
, renderTargets)
```

## 2. Building the renderer

Create a new folder called `canvas-renderer` and an `index.js` inside it.

`canvas-renderer/index.js`:

```javascript
import {Line} from './line'

export {Line} from './line'

export default function (canvas, ctx) {
  return {
    before() {
      // called before rendering any components, we need to clear the canvas!
      ctx.clearRect(0, 0, canvas.width, canvas.height)
    },

    render(component) {
      // called for each component which is in the react render tree
      if (component instanceof Line) {
        component.draw(canvas, ctx)
      }
    },

    after() {
      // called after rendering all components, we don't need to use this here, but it's useful to do any cleanup
      // work here.
    },
  }
}
```

`canvas-renderer/line.js`:

```javascript
import React from 'react'
import Specular, {LeafComponent} from 'specular'

@LeafComponent
export class Line extends React.Component {

  static defaultProps = {
    toX: 300,
    toY: 150,
  }

  constructor(element) {
    super(element)

    // any constructor work can go here...
  }

  onComponentMount(props, context) {
    // any mounting work can go here...
  }

  onComponentUnmount(props) {
    // any unmounting work can go here...
  }

  onComponentReceiveProps(nextProps, prevProps, context) {
    // on receiving new props...
    // You need to tell specular to re-render the react tree when something changes which you know
    // will affect the render output. For example:

    if (nextProps.toX !== prevProps.toX || nextProps.toY !== prevProps.toY) {
      this.specularQueueUpdate()
    }
  }

  draw(canvas, ctx) {
    const { props } = this._currentElement

    ctx.beginPath()
    ctx.moveTo(0, 0)
    ctx.lineTo(props.toX, props.toY)
    ctx.stroke()
  }

}
```

## 3. Wiring it all up

Let's go back to `index.js`, add your new render target and try rendering a `<Line />` component:

```javascript
import React from 'react'
import Specular, {Scene} from 'specular'

import CanvasRenderer, {Line} from './canvas-renderer'

const canvas = document.createElement('canvas')
canvas.style.width = '100%'
canvas.style.height = '100%'
document.body.appendChild(canvas)

const renderTargets = [
  CanvasRenderer(canvas, canvas.getContext('2d'))
]

Specular.render(
  <Scene>
    <Line />
  </Scene>
, renderTargets)
```

You should see a line on the screen!


text:
---
title: Power 8 to the people
author: Major Hayden
type: post
date: 2016-09-22T00:00:21+00:00
url: /2016/09/21/power-8-to-the-people/
featured_image: /wp-content/uploads/2016/09/IBMPowerSystemE870-2.jpg
dsq_thread_id:
  -<PHONE_NUMBER>
categories:
  - Blog Posts
tags:
  - aix
  - ibm
  - linux
  - power
  - python

---
IBM Edge 2016 is almost over and I've learned a lot about Power 8 this week. I've talked about some of the learnings in my recaps of days [one][1] and [two][2]. The performance arguments sound really interesting and some of the choices in AIX's design seem to make a lot of sense.

However, there's one remaining barrier for me: **Power 8 isn't really accessible for a tinkerer**.

![3]

## Tinkering?

Google defines _tinkering_ as:

> attempt to repair or improve something in a casual or desultory way,

> often to no useful effect.

> "he spent hours tinkering with the car"

When I come across a new piece of technology, I really enjoy learning how it works. I like to find its strengths and its limitations. I use that information to figure out how I might use the technology later and when I would recommend the technology for someone else to use it.

To me, tinkering is simply messing around with something until I have a better understanding of how it works. Tinkering doesn't have a finish line. Tinkering may not have a well-defined goal. However, it's tinkering that leads to a more robust community around a particular technology.

For example, take a look at the Raspberry Pi. There were plenty of other ARM systems on the market before the Pi and there are still a lot of them now. What makes the Pi different is that it's highly accessible. You can get the newest model for $35 and there are tons of guides for running various operating systems on it. There are even more guides for how to integrate it with other items, such as sprinkler systems, webcams, door locks, and automobiles.

Another example is the Intel NUC. Although the NUC isn't the most cost-effective way to get an Intel chip on your desk, it's powerful enough to be a small portable server that you can take with you. This opens up the door for software developers to test code wherever they are (we use them for OpenStack development), run demos at a customer location, or make multi-node clusters that fit in a laptop bag.

### What makes Power 8 inaccessible to tinkerers?

One of the first aspects that most people notice is the cost. The [S821LC][4] currently starts at around $6,000 on IBM's site, which is a bit steep for someone who wants to learn a platform.

I'm not saying this server should cost less - the pricing seems quite reasonable when you consider that it comes with dual 8-core Power 8 processors in a 1U form factor. It also has plenty of high speed interconnects ready for GPUs and CAPI chips. With all of that considered, $6,000 for a server like this **sounds very reasonable**.

There are other considerations as well. A stripped down S821LC with two 8-core CPUs will [consume about 406 Watts at 50% utilization][5]. That's a fair amount of power draw for a tinkerer and I'd definitely think twice about running something like that at home. When you consider the cooling that's required, it's even more difficult to justify.

### What about AIX?

AIX provides some nice benefits on Power 8 systems, but it's difficult to access as well. Put "learning AIX" into a Google search and [look at the results][6]. The first link is a [thread on LinuxQuestions.org][7] where the original poster is given a few options:

  * Buy some IBM hardware
  * Get in some legal/EULA gray areas with VMware
  * Find an old Power 5/6 server that is coming offline at a business that is doing a refresh

Having access to AIX is definitely useful for tinkering, but it could be very useful for software developers. For example, if I write a script in Python and I want to add AIX support, I'll need access to a system running AIX. It wouldn't necessarily need to be a system with tons of performance, but it would need the functionality of a basic AIX environment.

## Potential solutions

I'd suggest two solutions:

  1. Get AIX into an accessible format, perhaps on a public cloud
  2. Make a more tinker-friendly Power 8 hardware platform

Let's start with AIX. I'd gladly work with AIX in a public cloud environment where I pay some amount for the virtual machine itself plus additional licensing for AIX. It would still be valuable even if the version of AIX had limiters so that it couldn't be used for production workloads. I would be able to access the full functionality of a running AIX environment.

The hardware side leads to challenges. However, if it's possible to do a single Power 8 SMT2 CPU in a smaller form factor, this could become possible. Perhaps these could even be CPUs with some type of defect where one or more cores are disabled. That could reduce cost while still providing the full functionality to someone who wants to tinker with Power 8.

Some might argue that this defeats the point of Power 8 since it's a high performance, purpose-built chip that crunches through some of the world's biggest workloads. That's a totally valid argument.

However, that's not the point.

The point is to get a fully-functional Power 8 CPU - even if it has serious performance limitations - into the hands of developers who want to do amazing things with it. My hope would be that these small tests will later turn into new ways to utilize POWER systems.

It could also be a way for more system administrators and developers to get experience with AIX. Companies would be able to find more people with a base level of AIX knowledge as well.

## Final thoughts

IBM has something truly unique with Power 8. The raw performance of the chip itself is great and the door is open for even more performance through NVlink and CAPI accelerators. These features are game changers for businesses that are struggling to keep up with customer demands. A wider audience could learn about this game-changing technology if it becomes more accessible for tinkering.

_Photo credit: [Wikipedia][8]_

 [1]: /2016/09/20/ibm-edge-2016-day-1-recap/
 [2]: https://major.io/2016/09/21/ibm-edge-2016-day-2-recap/
 [3]: /wp-content/uploads/2016/09/IBMPowerSystemE870-2.jpg
 [4]: http://www-03.ibm.com/systems/power/hardware/s821lc/index.html
 [5]: http://www-912.ibm.com/see/EnergyEstimator
 [6]: https://www.google.com/search?q=learning+AIX
 [7]: http://www.linuxquestions.org/questions/aix-43/cheapest-way-to-learn-aix-4175534982/
 [8]: https://commons.wikimedia.org/wiki/File:IBMPowerSystemE870-2.jpg


text:
# TempTations

## Description
This application is an elegant solution for searching for a recipe based on the user’s local temperature. Users can search for main ingredients and the application will return a list of recipes appropriate for the current temperature. For example, if the temperature is below freezing, the app will return more soups, baked goods, casseroles, and comfort foods. If it is very warm outside, more grillable foods, cold salads and blended beverages will appear.

## Installation
If all the files are kept in a single fold and the user has an internet connection they should be able to use the application.

## Usage
The usage was for our group to practice our CSS, HTML, and Javascript skills. We also had to use two different apis that we did not use in class and could not use Bootstrap styling.

## Contributing
We built this application with our assigned group, Jake O'Toole, Mary Jacobs, Mark McGraw and Patrick Brown. We also had help from our instructor and TAs.

## Technologies Used
Bulma CSS Framework, WeatherBit API, Edamam API, HTML-5, Javascript, Git

## Challenges
As a group we found it difficult and nerve racking to have all four of us pushing and pulling our Git repository. It was hard to place our own code and have it successfully interact with our groups code. We also had to use new terminal commands that we haven't used before. It took us awhile to get confortable trusting the process. Mary mentioned that using Bulma as our CSS framework had different class names such as "is-ancestor" and "is-child" which was a new process. Mark and Patrick said that the apis were difficult to use because the documentation wasn't very thorough.  Mark had to use trial and error while setting up his queryURL and Patrick commented that he had to read all of the documentation for the food api to make sure he understood which pieces of information he would need for his functions.

## Live Site
https://themaryjacobs.github.io/TempTations/

## Images

![Screenshot1](https://github.com/TheMaryJacobs/TempTations/raw/master/Assets/Images/IMG_8826.PNG?raw=true)
![Screenshot1](https://github.com/TheMaryJacobs/TempTations/raw/master/Assets/Images/IMG_8827.PNG?raw=true)
![Screenshot1](https://github.com/TheMaryJacobs/TempTations/raw/master/Assets/Images/IMG_8828.PNG?raw=true)

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: TheMaryJacobs/TempTations

repo_name: TheMaryJacobs/TempTations


text:
---
schema: default
title: Netlify Site of the Week
date: 2017-08-23 00:00:00
thumbnail: /assets/img/stories/netlify-logo.jpg
author:
    name: Sydney Yockey
---

As you know by now, our Open Data Portal is hard at work keeping San Diego’s data accessible and up-to-date. As we strive to keep San Diego at the forefront of SmartCity technology, more citizens and city officials continue to recognize the portal’s benefits.

Our site and team are even turning heads beyond city boundaries! Netlify, an online platform that easily allows users to deploy websites, recently crowned our Open Data Portal the “Netlify Site of the Week.” By using the hassle-free services Netlify offers, we saved the city from spending money on expensive website builders, and saved ourselves from hours of tedious work. We are proud to epitomize “innovation, creativity, and utility,” and join the other sites in Netlify’s hall of fame.

<!--more-->

Check out Netlify’s [article](https://www.netlify.com/site-of-the-week/san-diego-open-data-portal/?utm_content=buffer41a7d&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer) and the [Open Data Portal](https://data.sandiego.gov) to read more about how our team aims to make San Diego more efficient and informed.

![Link](/assets/img/stories/netlify-site.png)


text:
# Builder

Lets you construct complex objects step by step. The pattern allows you to produce different types and representation of an object using the same construction code.

## Examples

* [PHP](php)
* [Python](python)
* [TypeScript](typescript)

## How to Implement

1. Make sure that you can clearly define the common construction steps for building all available product representation. Otherwise, you won’t be able to proceed with implementing the pattern.
2. Declare these steps in the base builder interface.
3. Create a concrete builder class for each of the product representation and implement their construction steps.
4. Think about creating a director class. It may encapsulate various ways to construct a product using the same builder object.
5. The client code creates both the builder and the director objects. Before construction starts, the client must pass a builder object to the director. Usually, the client does this only once, via parameters of the director’s constructor. The director uses the builder object in all further construction. There’s an alternative approach, where the builder is passed directly the construction method of the director.
6. The construction result can be obtained directly from the director only if all products follow the same interface. Otherwise, the client should fetch the result from the builder.

![Builder](/images/builder.png)

repository: avivharuzi/design-patterns

repo_name: avivharuzi/design-patterns


text:
command-lock-bundle
===================
[![Build Status](https://travis-ci.org/ffreitas-br/command-lock-bundle.png?branch=master)](https://travis-ci.org/ffreitas-br/command-lock-bundle)
[![Dependency Status](https://www.versioneye.com/user/projects/537e811114c15833b3000002/badge.svg)](https://www.versioneye.com/user/projects/537e811114c15833b3000002)
##
This `command-lock-bundle` when installed prevents two or more of same command runs simultaneously.
***
## Installation
#####
To install `command-lock-bundle` you will need just a few minutes.
#####
1) Include the `command-lock-bundle` in the `required` section of `composer.json`.
### composer.json
```json
// ...
"require": {
    "ffreitas-br/command-lock-bundle": "dev-master",
},
// ...
```
After this run `composer update` or `composer intall` to refresh your dependencies.
###
2) Register the bundle in your Kernel.
### app/AppKernel.php
```php
<?php

public function registerBundles()
{
    $bundles = array(
        // ...
        new FFreitasBr\CommandLockBundle\CommandLockBundle(),
    );
    // ...
}
```
###
3) Configure the directory where the pid lock files will be stored.
### app/config/config.yml
```yaml
...

command_lock:
    pid_directory: "%kernel.root_dir%/data/command_pid_files"

...
```
`Don't worry` if you don't have the directories created yet, the bundle will take care of this for you.
###
4) [OPTIONAL] Configure a list of exceptions.
### app/config/config.yml
```yaml
...

command_lock:
    exceptions:
        - cache:warmup
        - cache:clear

...
```
The commands listed in this configurations will be allowed to run simultaneously.

***

Now you have the `command-lock-bundle` installed and configured, it will now prevents two or more of same command runs simultaneously.

repository: ffreitas-br/command-lock-bundle

gha_language: PHP

repo_name: ffreitas-br/command-lock-bundle


text:
# Chapter 12
## Object Oriented Programming: Polymorphism

### Exercise 12-1
Fill in the blanks in each of the following statements:
1. Polymorphism is implemented via **Virtual Functions** and **Dynamic Binding**.
1. Polymorphism helps eliminate **switch** logic.
1. If a class contains at least one pure virutal function, it's an **abstract** class.
1. Classes from which objects can be instantiated are called **concrete** classes.
1. Each class with virtual functions has a **vtable**.
1. Constructors cannot be declared **virtual**.
1. Dynamic binding with virtual functions occurs only off **pointers** and **references**.
1. Overridable functions are declared using keyword  **virtual**.
1. To call a function appropriately at execution time is known as **dynamic binding**.

### Exercise 12-2
State whether each of the following is *true* or *false*. If *false*, explain why.
1. Polymorphism enables "programming in the specific."

**False** Polymorphism enbles "programming in the *general*."

1. With polymorphism, one function class can cause different actions to occur. **True**

1. Polymorphism is implemented only via dynamic binding.

**False** Polymorphism is also implemented via static binding, through operator and function overloading.

1. Although we cannot intantiate objects of abstract base classes, we can declare pointers and references to objects of abstract base classes. **True**

1. Classes without any nullptr vtable pointers are concrete classes. **True**

### Exercise 12-3
*Programming in the General*

How is it that polymorphism enables you to program "in the general" rather than "in the specific"? Discuss the key advantages of programming "in the general."

Polymorphism enables you to program "in the general" by using a single method identifier that results in different behaviors based on the types of arguments (static binding) or the types of objects (dynamic polymorphism). Dynamic polymorphism allows for many objects under the same class hierarchy to be referenced as a base class pointer. Since these objects share many of the same behaviors and characteristics, these objects can be interacted with under a single common interface, and maintain their own respective behaviors. This could come in handy when extending the program to another object type that has the same interface as another related object.

### Exercise 12-4
*Polymorphism vs. switch logic*

Discuss the problems of programming with switch logic. Explain why polymorphism can be an effective alternative to using switch logic.

When using switch logic, each new class addition must also be added to the switch statement. The same is true when deleting an object type. With many types, this could become a code maitenance and testing nightmare. With polymorphism, related objects can have the same interface, so it is much more easily extensible and take on a more simplified appearance.

### Exercise 12-5
*Run time type information*

What do you need to understand by runtime type information (RTTI)? How is RTTI useful?

This enables a program to determine an object's type at execution time and act on that object accordingly.

### Exercise 12-7
*Dynamic Binding vs. Static Binding*

Distinguish between static binding and dynamic binding. Explain the use of virtual functions and the *table* in dynamic binding.

Static binding occurs during compile time (operator, function overloading, static casts) while dynamic binding occurs during runttime using the vtable. The vtable a pointer that point's to the object's class vtable. For pure virtual methods, these point to nullptr.

### Exercise 12-8
*Pure Virtual Function*

How are virtual functions specified to be as pure? In what situations are pure virtual functions used?

 virtual returnType functionName(args) = 0;

Pure virtual functions would be useful in a class which does make sense to have a method definition itself, but all child classes that should be instantiated should have this method definition. For example, a generic Employee class might not need a calculateSalary() definition, but all derived classes should override this definition.

### Exercise 12-9
*Applying virtual functions*

Suppose you have an inheritance hierarchy with a base class Animal and two derived classes Bird and Snake. Based on the characteristics of animals in general and birds and snakes specifically, can you think of possible virtual and pure virtual functions to place in animal? Justify your answer.

Some functions that can be made virtual would be getNumberLegs(), breathe(), and drinkWater().

Some pure virutal functions that are specific to the animal and are too specific for class Animal are move(), eat(), birth(). These are too different for all types of class Animal, and wouldn't make sense to define until defining a more specific class.

### Exercise 12-10
*Abstract classes*

What is an abstract class? What condition should be met for a class to be abstract?

An abstract class is one that is not meant to be instantiated, but only derived by more specialized classes. In order for a class to be abstract, a class method must be pure virtual.

### Exercise 12-11
*Payroll-System Modification*
* Added a dateOfBirth member to the Employee class to include a birthday for each employee
* Tested adding $100 bonus to each salaried and base plus commission employee if the current month matches their respective birth month
    * Stored each employee in a vector of type Employee * and refernced each polymorphically

### Exercise 12-12
*Package Inheritance Hierarchy*
* Added virtual toString and calculateCost methods to add polymorphic behavior to the Package hierarchy
* Tested polymorphic behavior by verifying virtual functions in vector of Package * objects with expected outputs

### Exercise 12-13
*Polymorphic Banking Program Using Account Hierarchy*
* Added virtual getBalance to add polymorphic behavior to the Account hierarchy
* Tested polymorphic behavior by verifying virtual functions in vector of Account * objects with expected outputs
* Added polymorphice behavior for debit to extract fee for CheckingAccount class

### Exercise 12-14
*Payroll-System Modification*
* Added class for PieceWorker to represent an employee who gets paid a rate of pieces completed
* Added class for HourlyWorker to represent an employee that gets paid per hour
    * The hourly rate is 1.5 times the wage when the HourlyWorker works more than 40 hours in a week

### Exercise 12-15
*CarbonFootprint Abstract Class: Polymorphism*
* Created unrelated classes Bicycle, Building, and Car that derive from CarbonFootprint where each can calculate its carbon footprint
* The Bicycle class calculates its carbon footprint as a function of its production cost
* The Building class calculates its carbon footprint as a function of its square footage
* The Car class calculates its carbon footprint as a function of its mpg and miles driven

### Chapter Notes
* Be sure to use the base class name along with the scope resolution operator (::) when referencing base class methods that are overriden in the derived
class. Failure to do so will result in infinte recursion and was seen as a *Segmentation Fault* error.

repository: mtrdazzo/Deitel

repo_name: mtrdazzo/Deitel


text:
monophylizer
============
A web and command line tool to assess monophyly

Installation instructions
=========================
This tool depends on the Bio::Phylo toolkit, which needs to be installed from the
comprehensive perl archive network here: http://search.cpan.org/dist/Bio-Phylo

Installation from CPAN is a standard system administration task for which ample
documentation is available on the internet, and which is easy for UNIX-capable
system administrators and ICT support staffers. Consult them if you don't know
how to do this.

To run the tool on the command line, do this:

	perl monophylizer.pl -infile newickFile.nwk > outputTable.tsv

Additional command line arguments (which you almost certainly won't need) are
documented in the source code of monophylizer.pl

To run this tool as a web service, the following steps are necessary:

* Place monophylizer.pl in a location where it will be executed as a perl CGI script
by your web server. This will probably involve copying it into a folder called cgi-bin
(linux/unix) or CGI-Executables (OSX). In addition, it may need to be set to "executable"
and the first line of the script may need to be changed to point to the correct location
of the perl interpreter if it is not located at /usr/bin/perl

* Place monophylizer.html and sorttable.js in a location for plain text (not executable)
files.

* If the javascript file sorttable.js is not in the "document root", you will need to
edit monophylizer.pl such that the output HTML can find it. This is at time of writing
at line 250.

Build status
============

Currently, the build status is:

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

How to cite
===========
Pending publication of the method, this tool can be cited as:

**Vos, R.A.**, 2015. *Monophylizer: A web and command line tool to assess monophyly.* [doi: 10.5281/zenodo.16874]

[![DOI](https://zenodo.org/badge/doi/10.5281/zenodo.16874.svg)](http://dx.doi.org/10.5281/zenodo.16874)

repository: naturalis/monophylizer

repo_name: naturalis/monophylizer


text:
---
layout: post
title:  "PS3 Controller Map for Moonlite"
date:   2018-04-14
last_updated: 2018-04-15
---

When starting games through moonlite it will need it's own mapping that is outside of EmulationStation / RetroPi,
to do this we create a mapping and reference the file in our moonlite execution like this:

 moonlight  -mapping <CONTROLLER MAPPING> -app "The Witcher 3: Wild Hunt" stream <IP ADDRESS>

To get started create file and add this mapping to /retropie/home/pi/ps3bluetooth

abs_x = 0
abs_y = 1
abs_z = -1
reverse_x = false
reverse_y = true
abs_rx = 2
abs_ry = 3
abs_rz = -1
reverse_rx = false
reverse_ry = true
abs_deadzone = -696
abs_dpad_x = -1
abs_dpad_y = -1
reverse_dpad_x = false
reverse_dpad_y = false
btn_north = 300
btn_east = 301
btn_south = 302
btn_west = 303
btn_select = 288
btn_start = 291
btn_mode = 304
btn_thumbl = 289
btn_thumbr = 290
btn_tl = 298
btn_tr = 299
btn_tl2 = 296
btn_tr2 = 297
btn_dpad_up = 292
btn_dpad_down = 294
btn_dpad_left = 295
btn_dpad_right = 293


text:
# PiTempDisplay
Grab Temp/RH from DHT11 and display on PiOLED 128x32

## Hardware
Raspberry Pi 3B+ - although use using generic Python with common libraries, so it should work on most Pis

DHT-11 Temperature/Humidity Sensor - Just had it laying around

PiOLED 128x32 lcs display - Also just laying around

Configured I2C on Pi for display

## Software
Raspian Stretch Lite

build-essential

python-dev

python-pip

RPi.GPIO

python-imaging

python-smbus

[Adafruit_Python_SSD1306](https://github.com/adafruit/Adafruit_Python_SSD1306.git)

## Helpful Info
[Setup and Usage of Pi OLED](https://learn.adafruit.com/adafruit-pioled-128x32-mini-oled-for-raspberry-pi/usage)
[Wiring and Coding for DHT11/22](https://tutorials-raspberrypi.com/raspberry-pi-measure-humidity-temperature-dht11-dht22/)

## Configure the Pi
Follow instructions for Setup and Usage of Pi OLED and Wiring and Coding for DHT11/22

Run tempMain.py

### Notes
I added the ``disp.image(image.rotate(180))`` because the way the PiOLED connects to the GPIO Header. The power port on the Pi is opposite the GPIO Header, so I cannot set the Pi on edge so that the PiOLED is right-side up with power plugged in. #SoftwareToTheRescue

I refered to [Run a Program On Your Raspberry Pi At Startup](https://www.dexterindustries.com/howto/run-a-program-on-your-raspberry-pi-at-startup/) to decide how to make this program run at startup. I chose [Method 4, systemd](https://www.dexterindustries.com/howto/run-a-program-on-your-raspberry-pi-at-startup/#systemd) because I want this running always. And, I'm pretty comfortable with ``systemcrt`` process management

repository: MarkKozel/PiTempDisplay

repo_name: MarkKozel/PiTempDisplay


text:
Live MP3 EQ
==============

About
-----
This project was created as part of University and is a [SuperCollider](http://supercollider.sourceforge.net) project that allows the user to load the an MP3 file (using quarks) and then live EQ the file as it plays.  Instructions for installing are included when it is evaluated within SuperCollider

Controls
--------

After the song starts playing and the frequency analyser starts displays the file then using the mouse controls the effect of the EQ on the sound file.  Left to right affects the frequency (absolute left being 0hz and absolute right being 15000hz) and top to bottom controls the gain (absolute top being +12dB and absolute bottom being -60dB)

Bugs
----

Currently there is one bug where if the song finishes then the user will have to click the play button twice to start it again.

Legal Bits
----------

Copyright (c) 2013, Dean Vizer

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

license: ISC


text:
## MySQL Administration - Import/Load the database

**MySQL Import from Command line**

In this post, let us see how to import the .sql file to the database.

```
C:\Users\ragha\Desktop\Website DB Backups
λ ls -ltrh
total 3.9M
-rw-r--r-- 1 raghs 197610 1.8M Nov  2 23:13 shade.sql
-rw-r--r-- 1 raghs 197610 252K Nov  2 23:13 shade.sql.zip
-rw-r--r-- 1 raghs 197610 242K Nov  2 23:13 shade.csv.zip
-rw-r--r-- 1 raghs 197610 1.7M Nov  2 23:14 shade.csv
```

Beforehand, we should create the database if it does not exist. Otherwise, drop it and recreate it so that it can accommodate the files what we want to load to all the tables in the database.

Note: It depends on the export script. If the script has got the drop and recreate the database, we do not need to do it explicitly/manually.

```
C:\Users\ragha\Desktop\Website DB Backups
λ mysql -u raghs -p
Enter password: *************
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 2059
Server version: 10.1.13-MariaDB mariadb.org binary distribution

Copyright (c) 2000, 2016, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [(none)]> show tables;
ERROR 1046 (3D000): No database selected
MariaDB [(none)]> show databases;
+--------------------+
| Database           |
+--------------------+
| easytodo           |
| hibernatedb        |
| information_schema |
| itsraghz           |
| mysql              |
| performance_schema |
| phpmyadmin         |
| shade              |
| simpletodo         |
| tamiltest          |
| test               |
+--------------------+
11 rows in set (0.00 sec)

MariaDB [(none)]> drop database shade;
Query OK, 28 rows affected (3.23 sec)

MariaDB [(none)]> create database shade;
Query OK, 1 row affected (0.00 sec)

MariaDB [(none)]> exit
Bye
```

Now let us import the sql dump for the database.

```
C:\Users\ragha\Website DB Backups
λ mysql -u raghs -p shade < shade.sql
Enter password: *************

C:\Users\ragha\Website DB Backups
λ
```

If there are no messages in the console, it means the import was successful. You can login to MySQL client and verify the table structure and/or the data of your choice.