text:
DESCRIPTION
-----------

These files extracted from the tarball containing this `README.txt` file provide
a minimal installation for the scripts `new` and `phred`. You will find the
scripts themselves in a `bin/` directory, a couple of manpages extracted from
the scripts, and a set of sample templates.

To use the scripts, either add the bin/ directory to your search PATH or move
the executables to an appropriate location. You will also need to set the
TEMPLATEPATH environment variable to point to the templates/ directory. The
accompanying whitepaper describes the scripts in more detail.

MANIFEST
--------

```
    +- README.txt
    +- bin/
    |   +- newscript
    |   +- phred
    +- man/
    |   +- man1/
    |       +- newscript.1
    |       +- phred.1
    +- templates/
    |   +- boiler/
    |   |   +- .newrc
    |   |   +- ABOUT_lxNAMExr.txt
    |   +- apache.txt
    |   +- bash/
    |   |   +- .newrc
    |   |   +- lxNAMExr
    |   +- cpp/
    |   |   +- .newrc
    |   |   +- lxNAMExr.cpp
    |   |   +- Makefile
    |   +- template/
    |   |   +- .newrc
    |   |   +- lxNAMExr/
    |   |       +- .newrc
    |   +- vlog_ex/
    |       +- .newrc
    |       +- lxNAMExr/
    |           +- bin/
    |           |   +- run
    |           +- src/
    |               +- lxDUTxr_rtl.v
    |               +- lxNAMExr_top.v
    |               +- lxTESTxr_test.v
    +- Whats_new.pdf
```

REQUIREMENTS
------------

These scripts assume a relatively recent version of Perl 5 and have been
tested under Linux and Mac OS X. In theory, they may work under Windows, but
your mileage may vary.

BUGS
----

Please send bug reports to<EMAIL_ADDRESS>with the understanding
that there are no warranties as to the fitness or condition of this code.
I will fix bugs as I see fit and subject to my time availability. If you wish
to contribute to this project, please send e-mail with description of your
fix/enhancement and a git-merge.

LICENSING
---------

* Copyright:2003-2007 ESLX Inc. $
* Copyright 2003-2010 XtremeEDA Corporation
* Copyright 2012-2018 David C Black

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

  <http://www.apache.org/licenses/LICENSE-2.0>

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

END OF README.md

repository: dcblack/newscript

gha_language: Perl

repo_name: dcblack/newscript


text:
# SSH SSHD_CONFIG

## Line To Change To Disable Password Logins
`PasswordAuthentication no`

## Centos: Lines To Change To Disable Password Logins
```bash
PubkeyAuthentication yes
AuthorizedKeyFile .ssh/authorized_keys
PasswordAuthentication no
ChallengeResponseAuthentication no
```

repository: evanharmon/eph-headspace

branch_name: refs/heads/main

extension: md

license_type: permissive

repo_name: evanharmon/eph-headspace


text:
# OpenGL-PrimDraw
A simple library for rendering primitives in OpenGL Core.

```bash
g++ -std=c++11 -I./include -L./libraries/glfw/3.2.1/lib -lglfw scene.cpp ./dependencies/glad.c ./dependencies/stb_image.cpp
```

license: MIT

branch_name: refs/heads/master


text:
## Note about FHI-aims ##

Because FHI-aims is a proprietary code, you will be required to provide your
own copy of the git repo as a `git_repo\` subfolder when building a container.

repository: chrinide/container-recipes

repo_name: chrinide/container-recipes


text:
# UserForms Autoresponder

Enables autoresponder in UserForms module.

## Requirements

See the "require" section of `composer.json`

## Installation

```sh
$ composer require digitalpixelco/userforms-autoresponder
```

You'll also need to run `dev/build?flush=all`.

## Screenshot

![Screenshot](http://i.imgur.com/EEALtAe.png)

repository: digitalpixelco/userforms-autoresponder

repo_name: digitalpixelco/userforms-autoresponder


text:
# nodejs1416_postgresql_eslint_graphql_docker_ghactions_fullexample app

This app was bootstrapped with [Imagine.ai](https://imagine.ai) 💛
> Imagine.ai is an app starter on steroids!

### Run the app in terminal
1. Start a Postgres database server on your machine or in the cloud.
2. Set the following environment variables in your .env file

```
POSTGRES_HOST=<address-where-database-running>
POSTGRES_PORT=<port-where-database-running>
POSTGRES_DB=<database-name>
POSTGRES_USER=<username-for-database>
POSTGRES_PASSWORD=<password-to-database>
DB_DIALECT=postgres
```

3. Install packages and start the application server.

```
$ yarn install
$ yarn start
```

### Run the app inside a Docker container

Build the docker container and get it up and running.

```
$ docker-compose build
$ docker-compose up
```

### Make API calls against the server

Go to [http://localhost:8000/graphql](http://localhost:8000/graphql)

### Run admin bro dashboard

Go to [http://localhost:8000/admin](http://localhost:8000/admin)

### Run tests and check code coverage

```
$ yarn test
$ yarn coverage
```

### Lint your code

```
$ yarn lint
$ yarn format
```

### Learn More

1. Learn more about:
  - the [Node architecture choices](https://imagine.ai/docs/architecture-node) used.
  - the [best practices](https://imagine.ai/docs/best-practices) followed.

2. Imagine is in beta - here are the [known issues](https://imagine.ai/docs/known_issues) that we are working to fix.

repository: vpvnguyen/templates

repo_name: vpvnguyen/templates


text:
### Description

vtkMatrix3x3 object is used to represent and manipulate 3x3 matrices. Specifically, it is designed to work on 3x3 transformation matrices found in 2D rendering using homogeneous coordinates [x y w].

repository: Kitware/vtk-examples

repo_name: Kitware/vtk-examples


text:
---
external help file: JiraPS-help.xml
Module Name: JiraPS
online version: https://atlassianps.org/docs/JiraPS/commands/Set-JiraVersion/
locale: en-US
schema: 2.0.0
layout: documentation
permalink: /docs/JiraPS/commands/Set-JiraVersion/
---
# Set-JiraVersion

## SYNOPSIS

Modifies an existing Version in JIRA

## SYNTAX

```powershell
Set-JiraVersion [-Version] <Object[]> [[-Name] <String>] [[-Description] <String>] [[-Archived] <Boolean>]
 [[-Released] <Boolean>] [[-ReleaseDate] <DateTime>] [[-StartDate] <DateTime>] [[-Project] <Object>]
 [[-Credential] <PSCredential>] [-WhatIf] [-Confirm] [<CommonParameters>]
```

## DESCRIPTION

This function modifies the Version for an existing Project in JIRA.

## EXAMPLES

### EXAMPLE 1

```powershell
Get-JiraVersion -Project $Project -Name "Old-Name" | Set-JiraVersion -Name 'New-Name'
```

This example assigns the modifies the existing version with a new name 'New-Name'.

### EXAMPLE 2

```powershell
Get-JiraVersion -ID 162401 | Set-JiraVersion -Description 'Descriptive String'
```

This example assigns the modifies the existing version with a new name 'New-Name'.

## PARAMETERS

### -Version

Version to be changed

```yaml
Type: Object[]
Parameter Sets: (All)
Aliases:

Required: True
Position: 1
Default value: None
Accept pipeline input: True (ByValue)
Accept wildcard characters: False
```

### -Name

New Name of the Version.

```yaml
Type: String
Parameter Sets: (All)
Aliases:

Required: False
Position: 2
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -Description

New Description of the Version.

```yaml
Type: String
Parameter Sets: (All)
Aliases:

Required: False
Position: 3
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -Archived

New value for Archived.

```yaml
Type: Boolean
Parameter Sets: (All)
Aliases:

Required: False
Position: 4
Default value: False
Accept pipeline input: False
Accept wildcard characters: False
```

### -Released

New value for Released.

```yaml
Type: Boolean
Parameter Sets: (All)
Aliases:

Required: False
Position: 5
Default value: False
Accept pipeline input: False
Accept wildcard characters: False
```

### -ReleaseDate

New Date of the release.

```yaml
Type: DateTime
Parameter Sets: (All)
Aliases:

Required: False
Position: 6
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -StartDate

New Date of the user release.

```yaml
Type: DateTime
Parameter Sets: (All)
Aliases:

Required: False
Position: 7
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -Project

The new Project where this version should be in.

This can be the ID of the Project, or the Project Object

```yaml
Type: Object
Parameter Sets: (All)
Aliases:

Required: False
Position: 8
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -Credential

Credentials to use to connect to JIRA.
If not specified, this function will use anonymous access.

```yaml
Type: PSCredential
Parameter Sets: (All)
Aliases:

Required: False
Position: 9
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -WhatIf

Shows what would happen if the cmdlet runs.
The cmdlet is not run.

```yaml
Type: SwitchParameter
Parameter Sets: (All)
Aliases: wi

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -Confirm

Prompts you for confirmation before running the cmdlet.

```yaml
Type: SwitchParameter
Parameter Sets: (All)
Aliases: cf

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### CommonParameters

This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable.
For more information, see about_CommonParameters (http://go.microsoft.com/fwlink/?LinkID=113216).

## INPUTS

### [JiraPS.Version]

## OUTPUTS

### [JiraPS.Version]

## NOTES

This function requires either the `-Credential` parameter to be passed or a persistent JIRA session.
See `New-JiraSession` for more details.
If neither are supplied, this function will run with anonymous access to JIRA.

## RELATED LINKS

[Get-JiraVersion](../Get-JiraVersion/)

[New-JiraVersion](../New-JiraVersion/)

[Set-JiraVersion](../Set-JiraVersion/)

[Move-JiraVersion](../Move-JiraVersion/)

repository: AtlassianPS/JiraPS

gha_language: PowerShell

gha_license_id: MIT

repo_name: AtlassianPS/JiraPS


text:
---
layout: post
title: Master Thesis
use_math: true
---

This is a blog post describing my master thesis project on View Synthesis in the context of Multiview Video $$($$carried out in 2015$$)$$. The aim of this post is to present the basic idea of the project and not to be a math lecture so expect not to be swamped with equations. $$($$They are contained in the gray box so you can skip it if you want.$$)$$

Multiview Video Coding is a technique that allows viewers to interactively navigate through different viewpoints of a scene. Imagine watching a basketball game and being able to freely change your viewpoint from one end of the court to the other in a smooth way. This means that you are not restricted to choose solely the viewpoints captured by actual cameras but also all those in between. But all the intermediate viewpoints need to be rendered somehow. This is where the process of view synthesis comes to play.

We refer to the captured viewpoints as reference and to the reconstructed ones as virtual.

A way to synthesize all views in a scene is to explicitly construct a 3d model of the scene and then render the viewpoint chosen by the user. But model-based techniques often oversimplify natural scenes and are computationally expensive. There is an alternative image-based technique that exploits depth in order to translate pixels from the reference images into the virtual viewpoint. $$($$note: a depth map is an image whose pixel values represent the distance of each position wrt the camera$$)$$

Intuitively, we can understand this by considering the following scene of the ballet dancer. The first photo was captured at a viewpoint a little more to the right from the second one. However, moving all pixels of the first image equally to the right will not give us the second image. We see -cyan arrows-  that pixels of the man $$($$closer to the camera$$)$$ are much more displaced than pixels of the girl $$($$further back$$)$$. In fact, the larger the distance from the camera, the larger the dispacement in the image space. So a depth image is suitable to project the pixels from the reference to the virtual viewpoint. $$($$Hence, the technique is named depth image-based rendering or DIBR$$)$$

    Image 1 - right
    Image 2 - left
    Their superposition

The problem that arises is that $$($$exactly due to the unequal displacements of FG-BG$$)$$ some parts of the scene that were occluded from the reference viewpoint, become exposed in the virtual one, creating the so called disocclusion holes. In the case of a single reference viewpoint disocclusion is handled via inpainting.

Inpainting essentially restores or fills-in missing info in an image and, apart from disocclusion handling in DIBR, it has many applications like image restoration and text or object removal.

    Image Restoration
    Text Removal

    Box: Inpainting

    Let's call the image I with known part $\Phi$, missing part $\Omega$ and $\delta\Omega$ being their border. We want to synthesize texture in $\Omega$ by gradually completing it from the outside inwards. Research has showed that the order with which the patches get filled in is critical, because each match will influence all future ones. Priority of each patch $\Psi_p$ $($with area $ |\Psi_p|)$ is calculated as the product of two terms:

    Confidence term: quantifies the amount of reliable information the patch contains $$ C(\textbf{p})=\frac{1}{|\Psi_p|} \displaystyle\sum_{q\in \Psi_p\cap (I-\Omega)} C(p)$$  where $C(p)$ is simply 1 for known pixels $(\Phi )$ and 0 for unknown $(\Omega )$

    Data term: measures the existence of sharp edges perpenticular to the contour δΩ. $$ D(\textbf{p})=|\nabla I^{\bot}_{\mathbf{p}}\cdot \textbf{n}_p|+\alpha $$  where $\alpha$ is a very small constant so that $D(\textbf{p})$ won't go to zero when the edge is parallel to $\delta\Omega$

Inpainting will be applied in the blank areas of the reconstructed image. But what if there are parts that are not blank and still need inpainting?

What this work studies is if and how we can use skeletons $$($$pose estimation information$$)$$ - along with depth maps - to enhance the inpainting process in Multiview over the areas containing human figures.

Advantages:
- Oftentimes the most intersting part in a scene are people
- Most depth cameras, like Kinect, also provide skeletal tracking
- It is done real-time so no extra delay
- Skeletons can often be recovered even for parts of the body not visible in the camera's view.

So how do we exploit the information of the pose to aid our inpainting?
Firstly, we can detect parts of the skeleton that are exposed $$($$their current depth corresponds to the BG and not in the depth range of the rest of the figure$$)$$. So we form masks around the exposed parts that must be filled-in. Secondly, instead of using existing inpainting methods for the filling-in of the masks, we guide the process to prioritize patches containing edges parallel to the skeleton. So for example, a missing leg will be completed first by the patches of the contour and then the rest of the in and out patches. To do this a new term is introduced in the priority computation:

Orientation term: favors patches with edges parallel to the $$($$exposed$$)$$ skeleton.
$$ O(\textbf{p})=|\nabla I^{\bot}_{\mathbf{p}}\cdot \textbf{n}_{bone}|+\alpha $$

To sum up, this is an approach that incorporates pose estimation information in depth-image-based rendering. The skeletons contribute in detecting disoccluded parts of human figures that have been covered by the background. The introduction of the orientation term in the patch priority guides the inpanting process to complete figures in a more natural way.

You can find further details in the [full report](http://vivliothmmy2.ee.auth.gr/wp-content/uploads/participants-database/kasimidou_eleftheria_dibr.pdf)


text:
### Scenario

In an effort to learn more about video editing for demos and user tutorials, I took a course on how to use Camtasia, a program for creating video guides. I then downloaded a free trial of Camtasia and created the following guide on how a school owner can add a video livestream to a course lecture.

<video width="600" height="450" controls>
  <source src="teachable_livestreamfinal.mp4" type="video/mp4">
</video>

[Back to Menu](/index)


text:
# 2.0.2

* Fixed issue where changing an object property was tracked, which could lead to unending loops in `autorunAsync`.

# 2.0.1

* Undeprecated `observable(scalar)` (see 143)
* `expr` no longer prints incorrect deprecated messages (see 143)
* Requires `mobx` twice no longer fails.

# 2.0.0

## A new name...
Welcome to ~Mobservable~ MobX 2! First of all, there is the name change.
The new name is shorter and funnier and it has the right emphasis: MobX is about reactive programming.
Not about observability of data structures, which is just a technical necessity.
MobX now has its own [mobxjs](https://github.com/mobxjs) organization on GitHub. Just report an issue if you want to join.

All MobX 2.0 two compatible packages and repo's have been renamed. So `mobx-react`, `mobx-react-devtools` etc.
For the 1.0 versions, use the old `mobservable` based names.

## Migrating from Mobservable 1.x to MobX 2.0

Migrating from Mobservable should be pretty straight-forward as the public api is largely the same.
However there are some conceptual changes which justifies a Major version bump as it might alter the behavior of MobX in edge cases.
Besides that, MobX is just a large collection of minor improvements over Mobservable.
Make sure to remove your old `mobservable` dependencies when installing the new `mobx` dependencies!

## `autorun`'s are now allowed to cause cycles!
`autorun` is now allowed to have cycles. In Mobservable 1 an exception was thrown as soon as an autorun modified a variable which it was reading as well.
In MobX 2 these situations are now allowed and the autorun will trigger itself to be fired again immediately after the current execution.
This is fine as long as the autorun terminates within a reasonable amount of iterations (100).
This should avoid the need for work-arounds involving `setTimeout` etc.
Note that computed values (created using `observable(func)` are still not allowed to have cycles.

## [Breaking] `observable(scalar)` returns an object instead of a function and has been deprecated.

Creating an observable from a primitive or a reference no longer returns a getter/setter function, but a method with a `.get` and `.set` method.
This is less confusing, easier to debug and more efficient.

So to read or write from an observable scalar use:
```javascript
const temperature =  observable(27);
temperature.set(15); // previously: temperature(15)
temperature.get();   // previously: temperature()
```

`observable(scalar)` has been deprecated to make the api smaller and the syntax more uniform. In practice having observable objects, arrays and decorators seems to suffice in 99% of the cases. Deprecating this functionality means that people have simply less concepts to learn. Probably creating observable scalars will continue to work for a long time, as it is important to the internals of MobX and very convenient for testing.

## Introduced `@computed`

MobX introduced the `@computed` decorator for ES6 class properties with getter functions.
It does technically the same as `@observable` for getter properties. But having a separate decorator makes it easier to communicate about the code.
`@observable` is for mutable state properties, `@computed` is for derived values.

`@computed` can now also be parameterized. `@computed({asStructure: true})` makes sure that the result of a derivation is compared structurally instead of referentially with its preview value. This makes sure that observers of the computation don't re-evaluate if new structures are returned that are structurally equal to the original ones. This is very useful when working with point, vector or color structures for example. It behaves the same as the `asStructure` modifier for observable values.

`@computed` properties are no longer enumerable.

## MobX is now extensible!

The core algorithm of MobX has been largely rewritten to improve the clarity, extensibility, performance and stability of the source code.
It is now possible to define your own custom observable data sources by using the `Atom` class.
It is also possible to create your own reactive functions using the `Reaction` class. `autorun`, `autorunAsync` and `@observer` have now all been implemented using the concept of Reactions.
So feel free to write your own reactive [constructions](http://mobxjs.github.io/mobx/refguide/extending.html)!

## Mobservable now fails fast

In Mobservable 1 exceptions would be caught and sometimes re-thrown after logging them.
This was confusing and not all derivations were able to recover from these exceptions.
In MobX 2 it is no longer allowed for a computed function or `autorun` to throw an exception.

## Improved build

* MobX is roughly 20% faster
* MobX is smaller: 75KB -> 60KB unminified, and 54KB -> 30KB minified.
* Distributable builds are no longer available in the git repository, use npmcdn instead:
* Commonjs build<EMAIL_ADDRESS>* Minified commonjs build<EMAIL_ADDRESS>* UMD build<EMAIL_ADDRESS>* To use the minified build, require / import the lib from `"mobx/lib/mobx.min.js"` (or set up an alias in your webpack configuration if applicable)

## Other changes

* Improved debug names of all observables. This is especially visible when using `mobx-react-devtools` or `extras.trackTransitions`.
* Renamed `extras.SimpleEventEmitter` to `SimpleEventEmitter`
* Removed already deprecated methods: `isReactive`, `makeReactive`, `observeUntil`, `observeAsync`
* Removed `extras.getDNode`
* Invoking `ObservableArray.peek` is no longer registered as listener
* Deprecated `untracked`. It wasn't documented and nobody seems to miss it.

# 1.2.5

* Map no longer throws when `.has`, `.get` or `.delete` is invoked with an invalid key (#116)
* Files are now compiled without sourcemap to avoid issues when loading mobservable in a debugger when `src/` folder is not available.

# 1.2.4

* Fixed: observable arrays didn't properly apply modifiers if created using `asFlat([])` or `fastArray([])`
* Don't try to make frozen objects observable (by @andykog)
* `observableArray.reverse` no longer mutates the arry but just returns a sorted copy
* Updated tests to use babel6

# 1.2.3

* observableArray.sort no longer mutates the array being sorted but returns a sorted clone instead (#90)
* removed an incorrect internal state assumption (#97)

# 1.2.2

* Add bower support

# 1.2.1

* Computed value now yields consistent results when being inspected while in transaction

# 1.2.0

* Implemented #67: Reactive graph transformations. See: http://mobxjs.github.io/mobservable/refguide/create-transformer.html

# 1.1.8

* Implemented #59, `isObservable` and `observe` now support a property name as second param to observe individual values on maps and objects.

# 1.1.7

* Fixed #77: package consumers with --noImplicitAny should be able to build

# 1.1.6

* Introduced `mobservable.fastArray(array)`, in addition to `mobservable.observable(array)`. Which is much faster when adding items but doesn't support enumerability (`for (var idx in ar) ..` loops).
* Introduced `observableArray.peek()`, for fast access to the array values. Should be used read-only.

# 1.1.5

* Fixed 71: transactions should not influence running computations

# 1.1.4

* Fixed #65; illegal state exception when using a transaction inside a reactive function. Credits: @kmalakoff

# 1.1.3

* Fixed #61; if autorun was created during a transaction, postpone execution until the end of the transaction

# 1.1.2

* Fixed exception when autorunUntil finished immediately

# 1.1.1

* `toJSON` now serializes object trees with cycles as well. If you know the object tree is acyclic, pass in `false` as second parameter for a performance gain.

# 1.1.0

* Exposed `ObservableMap` type
* Introduced `mobservable.untracked(block)`
* Introduced `mobservable.autorunAsync(block, delay)`

# 1.0.9

Removed accidental log message

# 1.0.7 / 1.0.8

Fixed inconsistency when using `transaction` and `@observer`, which sometimes caused stale values to be displayed.

# 1.0.6

Fix incompatibility issue with systemjs bundler (see PR 52)

# 1.0.4/5

* `map.size` is now a property instead of a function
* `map()` now accepts an array as entries to construct the new map
* introduced `isObservableObject`, `isObservableArray` and `isObservableMap`
* introduced `observe`, to observe observable arrays, objects and maps, similarly to Object.observe and Array.observe

# 1.0.3

* `extendObservable` now supports passing in multiple object properties

# 1.0.2

* added `mobservable.map()`, which creates a new map similarly to ES6 maps, yet observable. Until properly documentation, see the [MDN docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map).

# 1.0.1

* Stricter argument checking for several api's.

# 1.0

## Renames

* `isReactive` -> `isObservable`
* `makeReactive` -> `observable`
* `extendReactive` -> `extendObservable`
* `observe` -> `autorun`
* `observeUntil` -> `autorunUntil`
* `observeAsync` -> `autorunAsync`
* `reactiveComponent` -> `observer` (in `mobservable-react` package)

## Breaking changes

* dropped the `strict` and `logLevel` settings of mobservable. View functions are by default run in `strict` mode, `autorun` (formerly: `observe`) functions in `non-strict` mode (strict indicates that it is allowed to change other observable values during the computation of a view funtion).
Use `extras.withStrict(boolean, block)` if you want to deviate from the default behavior.
* `observable` (formerly `makeReactive`) no longer accepts an options object. The modifiers `asReference`, `asStructure` and `asFlat` can be used instead.
* dropped the `default` export of observable
* Removed all earlier deprecated functions

## Bugfixes / improvements

* `mobservable` now ships with TypeScript 1.6 compliant module typings, no external typings file is required anymore.
* `mobservable-react` supports React Native as well through the import `"mobservable-react/native"`.
* Improved debugger support
* `for (var key in observablearray)` now lists the correct keys
* `@observable` now works correct on classes that are transpiled by either TypeScript or Babel (Not all constructions where supported in Babel earlier)
* Simplified error handling, mobservable will no longer catch errors in views, which makes the stack traces easier to debug.
* Removed the initial 'welcom to mobservable' logline that was printed during start-up.

# 0.7.1

* Backported Babel support for the @observable decorator from the 1.0 branch. The decorator should now behave the same when compiled with either Typescript or Babeljs.

# 0.7.0

* Introduced `strict` mode (see issues [#30](), [#31]())
* Renamed `sideEffect` to `observe`
* Renamed `when` to `observeUntil`
* Introduced `observeAsync`.
* Fixed issue where changing the `logLevel` was not picked up.
* Improved typings.
* Introduces `asStructure` (see [#8]()) and `asFlat`.
* Assigning a plain object to a reactive structure no longer clones the object, instead, the original object is decorated. (Arrays are still cloned due to Javascript limitations to extend arrays).
* Reintroduced `expr(func)` as shorthand for `makeReactive(func)()`, which is useful to create temporarily views inside views
* Deprecated the options object that could be passed to `makeReactive`.
* Deprecated the options object that could be passed to `makeReactive`:
  * A `thisArg` can be passed as second param.
  * A name (for debugging) can be passed as second or third param
  * The `as` modifier is no longer needed, use `asReference` (instead of `as:'reference'`) or `asFlat` (instead of `recurse:false`).

# 0.6.10

* Fixed issue where @observable did not properly create a stand-alone view

# 0.6.9

* Fixed bug where views where sometimes not triggered again if the dependency tree changed to much.

# 0.6.8

* Introduced `when`, which, given a reactive predicate, observes it until it returns true.
* Renamed `sideEffect -> observe`

# 0.6.7:

* Improved logging

# 0.6.6:

* Deprecated observable array `.values()` and `.clone()`
* Deprecated observeUntilInvalid; use sideEffect instead
* Renamed mobservable.toJson to mobservable.toJSON

# 0.6.5:

* It is no longer possible to create impure views; views that alter other reactive values.
* Update links to the new documentation.

# 0.6.4:

* 2nd argument of sideEffect is now the scope, instead of an options object which hadn't any useful properties

# 0.6.3

* Deprecated: reactiveComponent, reactiveComponent from the separate package mobservable-react should be used instead
* Store the trackingstack globally, so that multiple instances of mobservable can run together

# 0.6.2

* Deprecated: @observable on functions (use getter functions instead)
* Introduced: `getDependencyTree`, `getObserverTree` and `trackTransitions`
* Minor performance improvements

repository: mquandalle/tracker-mobx-bridge

repo_name: mquandalle/tracker-mobx-bridge


text:
# SpaceClaim API Neutronics Tools

Copyright 2021 United Kingdom Atomic Energy Agency (UKAEA)
license: [MIT](LICENSE)

This repository contains a set of tools designed the increase the efficiency of the preparation of CAD models for neutronics analysis. The tools
automate many of the tasks typically undertaken to simply a detailed CAD model to a level suitable for particle transport. Install instructions
for inclusion of the tools as an additional tab in the SpaceClaim GUI is provided below. The tools are designed to aid the user produce a CAD
model suitable for conversion in software such as SuperMC or McCAD.

It is expected that user of these tools has some level of competency using SpaceClaim. The tools do not fix broken CAD models nor is that their
intended purpose. In any case, the tools will likely not work with poorly defined geometry.

[More extensive documentation including installation instructions can be found here](docs)

## Development

The tools have been produced using a combination of the C# API and python scripting available in ANSYS SpaceClaim. All tools exist in a single ribbon which is added when the tools are compiled.

Feedback on existing tools or proposals for new tools welcome.

## Included Tools and Purpose

| Tool | Purpose |
| ------ | ------ |
| Body Select | Highlights cones or tori, identifies small volumes (user input) and small rounds (user input) |
| Export | Saves bodies of different colour in geometry as separate .sat files |
| Lost particles | Plots MCNP lost particles on geometry|
| Max surfaces | Highlights all bodies with a number of surfaces exceeding user input |
| Pipe tools | Automates simplification of pipe networks  |
| Tori tools | Simplifies complex tori to cylindrical bodies |
| Cylinder-plane locator | Identifies a shared edge between and plane and cylinder in a single body |
| Cylinder-plane splitter | Splits a body along cylinder-plane edge |
| Geometry assessor | Selects tori, cones, bodies with shared edges between higher order surfaces |
| Mesh tally writer | Writes the MCNP definition for a mesh tally based on geometry |
| Mesh tally checker | Plots simple mesh tallies from MCNP |
| Cylinder Cylinder splitter | Splits along edge between two different cylinders |
| Void generator | Creates void cells for geometry to define reciprocal space |
| Volume assessor | Calculates volume of all solids in structure tree |

## Installation

To compile and install the CCFE SpaceClaim tools it is recommended that Visual Studios Community edition (which is free to use on opensource projects) is installed. This provides a relatively quick and easy way to compile and install the tools into SpaceClaim.

These instructions use Visual Studios 2019, but should be relatively similar for all versions of Visual Studios. It should be noted that .NET Framework version 4 or later is required.

First you will need to clone the github repository by clicking on clone repository in the File menu:

![install_1](https://user-images.githubusercontent.com/40658938/104763547-f80b5780-575d-11eb-8cef-fe3f8b0d444d.png)

Enter the github address of the repository in the first box and the local location of the folder you want to store the repository in the second box:

![install_2](https://user-images.githubusercontent.com/40658938/104892446-1ba2ed80-596a-11eb-8812-73d32f987af5.png)

Once cloned you will need to re-point the project to the SpaceClaim API Library. This can be done by deleting **SpaceClaim.Api.V16** and **SpaceClaim.Api.V16.Scripting** from the **‘References’** in the **‘Solution Explorer’**.

![install_3](https://user-images.githubusercontent.com/40658938/104892455-1e9dde00-596a-11eb-8980-8d2d70dd811a.png)

And then re-adding them by right-clicking on References and selecting **‘Add Reference’**:

![install_4](https://user-images.githubusercontent.com/40658938/104892467-2198ce80-596a-11eb-924b-188c73db64e9.png)

Click browse and navigate to *C:\Program Files\ANSYS Inc\v192\scdm\SpaceClaim.Api.V16*  (or the location SpaceClaim is installed if it is not installed as part of ANSYS):

![install_5](https://user-images.githubusercontent.com/40658938/104892474-23fb2880-596a-11eb-9c49-5e07a9888bce.png)

Add **SpaceClaim.Api.V16.dll**:

![install_6](https://user-images.githubusercontent.com/40658938/104892486-28274600-596a-11eb-94ea-00aab57643fb.png)

Add **SpaceClaim.Api.V16.Scripting.dll** (found in *C:Program Files\ANSYS Inc\v192\scdm*).

![install_7](https://user-images.githubusercontent.com/40658938/104892505-2c536380-596a-11eb-923e-643ce6f5fea1.png)

Repeat the above steps to also add **SpaceClaim.Api.V18.dll** and **SpaceClaim.Api.V18.Scripting.dll**.

The next step is to make sure the output is placed into the correct folder, which can then be loaded by SpaceClaim when it opens. To do this the projects **‘Properties’** should be opened in the Solution Explorer.

![install_8](https://user-images.githubusercontent.com/40658938/104892516-2f4e5400-596a-11eb-870a-dafe35f9ab76.png)

Check that the Output path is set to:
*`C:\ProgramData\SpaceClaim\AddIns\Samples\V18\CCFE\Toolkit`* (Or the location of your ProgramData directory if this is not on your C drive).

![install_9](https://user-images.githubusercontent.com/40658938/104892526-32494480-596a-11eb-881d-a8456f2b80a8.png)

You can now build the tools in Visual Studio. **Please ensure that the SpaceClaim application is closed when you do this**.


text:
# Hebeloma pumiloides var. pumiloides VARIETY

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Veiled species of Hebeloma in the western United States (Ann Arbor) 176 (1983)

#### Original name
Hebeloma pumiloides var. pumiloides

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# Parsing in Pepper3

This page documents the way the parser in Pepper3 works.  This information
will not be needed to use Pepper3 when it exists - it's part of the internals
of the language, building tokens that come from the [lexer](lexing.md) into
tree structures representing statements and expressions.

To see how the parser treats some code, you can invoke it like this:

```bash
#(Not implemented) $ echo "int x = 1; x + 2;" | pepper3 parse -
trees = import(language.parsing.trees);
[
    trees.assign("x", trees.int("1")),
    trees.function_call("+", [trees.symbol("x"), trees.int("2"),]),
];
```

Notice that the code above is actually Pepper3 code, so you can read in these
trees again by evaluating the output with `pepper3 run`.  Also, if you want
to make parse trees yourself in your own code, the above is a good starting
point for figuring out how to do it.

## Values

## Function calls

## Operator calls are function calls

## Function definitions

repository: andybalaam/pepper

repo_name: andybalaam/pepper


text:
# Topeliopsis muscigena (Stizenb.) Kalb SPECIES

#### Status
ACCEPTED

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

#### Published in
Mycotaxon 79: 322 (2001)

#### Original name
Thelotrema muscigenum Stizenb.

### Remarks
null


text:
gozbus
======

gozbus: a messaging system in golang.
        Hey hey hey, "Catch Z Bus!"

to install:

    go get github.com/glycerine/gozbus

description
-----------

Gozbus is a messaging system based on the nanocap transport,
our term for a combination of the nanomsg[1] and Cap'n Proto[2]
technologies.

Nanomsg is the successor to ZeroMQ, and
provides multiple patterns for in-process, in-host,
and inter-host messaging. The peer-to-peer, publish-subscribe,
enterprise bus, pipeline, and surveyor protcols can be
leveraged for scalable messaging.

Cap'n Proto is the successor to ProtocolBuffers, and
provides highly efficient encoding
and decoding of messages based on a strongly typed schema
language. Capnp bindings are available for Golang,
C++, and Python. We use the schema handling portion only,
as the RPC part of Cap'n Proto isn't available at this time.

[1] nanomsg: http://nanomsg.org/

[2] Cap'n Proto: http://kentonv.github.io/capnproto/

These two pre-requisite libraries should be downloaded and installed
prior to building gozbus.

build notes
-----------

to debug with gdb, build like so:

    go build -gcflags "-N -l" gozbus.go

this turns off inlining and registerization, so
you can inspect local variables easier.

repository: robmurtha/gozbus

repo_name: robmurtha/gozbus


text:
# AutoMockingFixture

Using castle container for auto mocking in unit tests.

Automatically creates stubs for all dependencies of the class under test.

Uses:
* NUnit
* RhinoMocks
* CastleWindsor

Original idea stolen from http://mookid.dk/oncode/archives/2345

license: Unlicense

repository: j-maly/AutoMockingFixture

repo_name: j-maly/AutoMockingFixture


text:
# Hush

Modern applications are often split into separate client and server tiers that
communicate via message passing over the network. One well-understood threat to
privacy for such applications is the leakage of sensitive user information
either in transit or at the server. In response, an array of defensive
techniques have been developed to identify or block unintended or malicious
information leakage. However, prior work has primarily considered privacy leaks
originating at the client directed at the server, while leakage in the reverse
direction -- from the server to the client -- is comparatively under-studied.
The question of whether and to what degree this leakage constitutes a threat
remains an open question. We answer this question in the affirmative with Hush,
a technique for semi-automatically identifying Server-based InFormation
OvershariNg (SIFON) vulnerabilities in multi-tier applications. In particular,
the technique detects SIFON vulnerabilities using a heuristic that overshared
sensitive information from server-side APIs will not be displayed by the
application's user interface. The technique first performs a scalable static
program analysis to screen applications for potential vulnerabilities, and then
attempts to confirm these candidates as true vulnerabilities with a
partially-automated dynamic analysis. Our evaluation over a large corpus of
Android applications demonstrates the effectiveness of the technique by
discovering several previously-unknown SIFON vulnerabilities in eight
applications.

For more information please refer to our
[paper](http://cs-people.bu.edu/wfkoch/my-data/pubs/sifon.pdf).

This repo contains the static analysis (S-Hush) and dynamic analysis (D-Hush) software to identify SIFON vulnerabilities in Android
applications.

If you use this code please cite the following paper,
```
@inproceedings{koch2017hush,
  title={Semi-automated discovery of server-based information oversharing
vulnerabilities in Android applications},
  author={Koch, William and Chaabane, Abdelberi and Egele, Manuel and Robertson,
William and Kirda, Engin},
  booktitle={Proceedings of the 26th ACM SIGSOFT International Symposium on
Software Testing and Analysis},
  pages={147--157},
  year={2017},
  organization={ACM}
}

repository: Earthwater/hush

repo_name: Earthwater/hush


text:
# Githubsearch
This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 8.3.21.
## Author
Towett Enock K
## Description
This is an an application that enables the user to search the github usernames of their choice,view their repositories and github profile
## Setup/Installation Requirements
 Open terminal (CTRL ALT T)
 git clone https://github.com/enock24/gitsearch
 cd gitsearch
 use atom . or code . to open the cloned repo on Atom or Vs-code respectively
 ## Technologies Used
- ANGULAR CLI
- HTML5
- CSS3
- BOOTSTRAP
- TYPESCTRIPTS
## Deployed link

https://enock24.github.io/gitsearch/

## License
Licensed under [MIT License](license).


text:
+++
title = "(Optional) Recovery Plan"
weight = 5

+++

While dealing with a large number of machines you will find it easier to manage with the help of a recovery plan.
Recovery Plans let you pre-configure the order in which sets of machines are to be launched, and the launch wait times between these sets of machines. Recovery Plans can be initiated in Test Mode or Recovery Mode.

### Create a Recovery Plan
Create a Recovery Plan by navigating to **Recovery Plans** on the main left-hand navigation menu and then clicking on **NEW RECOVERY PLAN**.

![Recovery Plan](/lab1/recovery_plan_create.png?classes=shadow,border)

You will be redirected to the Recovery Plan creation view. Enter the name of your Recovery Plan as `LAMP Stack Recovery Plan`.

Recovery Plans are step-based. Each step is made up from a group of machines and wait times for machine launches. Click **ADD STEP** to add a step to your Recovery Plan.

In our infrastructure, since the webserver has a dependency with the DB server, it probably makes sense that step 1 is recovering DB server and Step 2 would be to recover Web Server.

![Add Step](/lab1/add_step.PNG?classes=shadow,border)

Similarly add Web Server Step, but this time with a wait time of 120 seconds as I found that DB server takes about 2 minutes to get started. In an actual DR, you might want to adjust this step as per your experiental knowledge.

This is how the **Recovery Plan** would look like

![Recovery Plan](/lab1/recovery_plan_created.png?classes=shadow,border)

Now that the recovery plan is created, you can choose whether you want to initiate the plan in **Test Mode** or **Recovery Mode**.

   {{% notice info %}}
Recovery Plans are not available while the Project is in Preparing for Failback mode.
{{% /notice %}}

repository: ramanankannan/cloud-endure-workshop

repo_name: ramanankannan/cloud-endure-workshop


text:
msni
====

MathSciNetImport: import metadata (and article) via MathSciNet to a file-based library

Why
---

Bibliography reference managers *could* be awesome if not for the
tremendous bloat (Oracle JVM? Srsly?). Using software like RefTeX,
most features of bibliography reference managers *might* be
superfluous in a number of cases. msni is a tiny hack closing an
annoying gap: the process of importing articles from the MathSciNet.

Workflow
--------

1. Find your favourite article on the MathSciNet, e.g. Tate's [The
   arithmetic of elliptic
   curves](http://www.ams.org/mathscinet-getitem?mr=419359).
1. Find the number of the review, in our case **MR0419359**.
1. Execute `msni MR0419359`.
1. A browser opens. Follow the MathSciNet links until you can download
   a PDF file. Just click *Save* (don't bother with *Save As*) and
   close the browser.
1. A terminal will start up in the directory
   `~/bib/msni/Tate-TheArithmeticOfEllipticCurves`. `ls` will reveal a
   file `MR0419359.bib` containing the BibTeX information pulled from
   MathSciNet and a file called `art%3A10.1007%2FBF01389745.pdf`
   containing the article.
1. The BibTeX-information will automatically be added to
   `~/bib/msni/complete.bib`.

Why is that a good workflow?
----------------------------

In general there should be almost no need to keep more metadata at
hand, the MathSciNet provides great options for searching articles and
there is no need to replicate that. Articles show up in `locate` if
you search for author, title or review number.

Dependencies
------------

- qutebrowser
- bibtex-ruby
- urxvt

repository: oqpvc/msni

gha_language: Ruby

repo_name: oqpvc/msni


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

### Description

An issue was discovered in the web application in Cherwell Service Management (CSM) 10.2.3. Injection of a malicious payload within the RelayState= parameter of the HTTP request body results in the hijacking of the form action. Form-action hijacking vulnerabilities arise when an application places user-supplied input into the action URL of an HTML form. An attacker can use this vulnerability to construct a URL that, if visited by another application user, will modify the action URL of a form to point to the attacker's server.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/SYRTI/POC_to_review
- https://github.com/WhooAmii/POC_to_review
- https://github.com/karimhabush/cyberowl
- https://github.com/l00neyhacker/CVE-2022-26156
- https://github.com/nomi-sec/PoC-in-GitHub
- https://github.com/soosmile/POC
- https://github.com/trhacknon/Pocingit

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# GemFire-Greenplum connector example

This example demonstrates the export operations that are available.

An export copies entries from a Pivotal GemFire® region to a Pivotal Greenplum® (GPDB) table.

The export operation implements the functionality of one of these:

- The UPSERT functionality updates a GPDB row if the GemFire entry to be exported is already present as a GPDB row. If the GPDB row does not already exist, a new row is inserted.
- The INSERT_ALL functionality does a GPDB insert operation for each region entry in the GemFire region. Since it does not check for the existence of GPDB rows prior to each insert, the export operation will fail and throw an error if a duplicate primary key already exists in the GPDB table.
- The INSERT_MISSING functionality inserts rows into the GPDB table for GemFire region entries that are not already present in the table. It does not update any existing rows in the GPDB table.
- The UPDATE functionality updates a GPDB row if the GemFire entry to be exported is already present as a GPDB row.

You can refer to [GemFire-Greenplum documentation](http://ggc.docs.pivotal.io/ggc/toGreenplum.html)

## Steps
1. From the ```gemfire-greenplum-examples``` directory, start the dockers with both GPDB and GemFire cluster:
```
    $ docker-compose up
    Creating network "gemfiregreenplumexamples_default" with the default driver
    Creating gemfiregreenplumexamples_gemfire_1 ...
    Creating gemfiregreenplumexamples_gemfire_1 ... done
    Creating gemfiregreenplumexamples_gpdb_1 ...
    Creating gemfiregreenplumexamples_gpdb_1 ... done
    ...
```
2. From the ```/export``` directory, create the database and table in GPDB cluster
```
    $ scripts/setupDB.sh

        Gemfire/Geode version: 9.0.3
        psql:./sample_table.sql:1: NOTICE:  table "export" does not exist, skipping
        DROP TABLE
        CREATE TABLE
        INSERT 0 1
        ...
```

        Gemfire/Geode version: 9.0.3
        psql:./sample_table.sql:1: NOTICE:  table "basic" does not exist, skipping
        DROP TABLE
        CREATE TABLE
        INSERT 0 1
        ...

1. From the ```gemfire-greenplum-examples/export``` directory, start the locator and two servers:
```
        $ scripts/startAll.sh
```
2. Run the producer:

        $ gradle run -Pmain=Producer
        ...
        ...
        INFO: Done. Inserted 50 entries.

3. Run the consumer:

        $ gradle run -Pmain=Consumer
        ...
        ...
        INFO: Done. 50 entries available on the server(s).

4. Kill one of the servers:

        $ gfsh
        ...
        gfsh>connect
        gfsh>stop server --name=server1
        gfsh>quit

5. Run the consumer a second time, and notice that all the entries are still available due to replication:

        $ gradle run -Pmain=Consumer
        ...
        ...
        INFO: Done. 50 entries available on the server(s).

6. Shutdown the system:

        $ scripts/stopAll.sh

This example is a simple demonstration on basic APIs of Geode, as well how to write tests using mocks for Geode applications.


text:
# HTTP Methods
The set of common methods for HTTP/1.1 is defined below and this set can be expanded based on requirements. These method names are case sensitive and they must be used in uppercase.

|Method|Description|
|---|---|
|GET|The GET method is used to retrieve information from the given server using a given URI. Requests using GET should only retrieve data and should have no other effect on the data.|
|HEAD|Same as GET, but transfers the status line and header section only.|
|POST|A POST request is used to send data to the server, for example, customer information, file upload, etc. using HTML forms.|
|PUT|Replaces all current representations of the target resource with the uploaded content.|
|DELETE|Removes all current representations of the target resource given by a URI.|
|CONNECT|Establishes a tunnel to the server identified by a given URI.|
|OPTIONS|Describes the communication options for the target resource.|
|TRACE|Performs a message loop-back test along the path to the target resource.|

repository: arulprasathr/wiki-documentation

repo_name: arulprasathr/wiki-documentation


text:
---
title: "Performance with Spring Boot and Gatling (Part 1)"
date: "2019-01-07T19:58:00.000Z"
layout: post
draft: false
path: "/posts/spring-boot-performance-part-1"
category: "devops"
tags:
 - "web-development"
 - "performance-testing"
 - "spring-boot"
 - "spring-security"
 - "gatling"
 - "java"
 - "scala"
description: "Exploring a surprising performance problem in a simple Spring Boot app with the Gatling load testing framework."
---

Just after the rest of the team had left for their Christmas holidays, my colleague and I discovered a weird performance problem with a Spring Boot application we'd just started writing.
This is a the story of discovering the problem and the detective work that led us to the culprit hiding in plain sight.
We're going to recreate the app and the performance tests, but first I'll tell you how we got here.

## Prologue

Twenty requests per second.
Any more than that and response times would climb.
Eventually, the load balancer's readiness checks would timeout and it'd refuse to send traffic to the app, taking the service offline.

Here's what our little prototype system looked like:

![Diagram showing the components parts of the prototype when we discovered the performance problem](orig-arch-diag.jpg)

We're building an API, rather than a website.
Clients authenticate by passing a username and password in the request.
Each request is a query, and the app talks to a graph database to calculate an answer, returning it as a JSON document.
It's running in a Kubernetes cluster on AWS, behind an Elastic Load Balancer.

How can it be struggling to serve more than twenty requests per second?
I've not used this graph database before, can it really be that slow? Nor have I used Kubernetes or Spring Boot, are they responsible? You wouldn't think there'd be enough of our code yet to perform so poorly, but our own code is always the go-to suspect.

## Too Many Suspects

There's too many potential culprits here, so let's eliminate some. Can I reproduce the problem here on my machine? Yes - and I get a clue. As the test runs, I can hear the fan spinning up. Checking back on AWS for server metrics, the CPU utilisation was shooting up to 100% during the test. That removes Kubernetes, the load balancer, the network and disks from the investigation, at least for now. Memory could still be a problem, as Java's garbage collection chews up compute time when there's not enough memory.

Now we eliminate the database. We'd written a resource to return version information, which is just returning a document from memory. Running the performance test on that endpoint revealed the same terrible performance! Something to do with the Spring framework, or the Tomcat application server then - where can we go from here?

We *could* pull out profiler tooling to look inside the running app and see what's going on. It's been a while since I used that tooling on the JVM, and it'll produce a lot information to interpret, so I'll leave that as a backup plan. For now, we've got an easy option that will rule out the Spring Boot framework and Tomcat application server. A "getting started" Spring Boot app won't take long to set up. We can eliminate JSON processing, configuration problems and coding errors as potential candidates, and get a benchmark for how performant the simplest Spring Boot app is with our hardware and test setup.

This is where we write some code.

## The "Getting Started" App

You can find and clone the project we're talking about in this post on Github at https://github.com/brabster/performance-with-spring-boot/tree/1.0. You'll need a JDK and Maven installed to compile and run the application.

I based the "getting started" app closely on [Spring Boot's documentation](https://spring.io/guides/gs/spring-boot/). It's got one endpoint at `/` and returns a JSON document `{"greeting": "Greetings from Spring Boot!"}` like [this](https://github.com/brabster/performance-with-spring-boot/blob/1.0/src/main/java/hello/HelloController.java):

```java
package hello;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class HelloController {

    class Greeting {
        public String getGreeting() {
            return "Greetings from Spring Boot!";
        }
    }

    @RequestMapping("/")
    public Greeting index() {
        return new Greeting();
    }

}
```

We'll use Spring Security to authenticate API clients, so we need to add the dependencies and set a default username and password. The dependencies we need to add to our Maven [pom.xml](https://github.com/brabster/performance-with-spring-boot/blob/1.0/pom.xml) file are:

```xml
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-web</artifactId>
    <version>5.1.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-config</artifactId>
    <version>5.1.2.RELEASE</version>
</dependency>
```

To set a default username and password, we add a [properties file](https://github.com/brabster/performance-with-spring-boot/blob/1.0/src/main/resources/application.properties) containing two properties that override Spring Security's defaults:

```
spring.security.user.name=user
spring.security.user.password=24gh39ugh0
```

Start the app with `mvn spring-boot:run` and you should see something like this:

![Asciinema recording of the app starting](start-app.gif)

## Performance Testing with Gatling

[Gatling](https://gatling.io/) is the tooling that gave us those original requests per second figures, so let's reproduce the setup to do our performance tests here. Gatling tests are written in Scala and can coexist with the Java code, but we need a little support in our project to run tests and get editor support for Scala.

To compile Scala code and enable Scala support (at least in [IntelliJ IDEA](https://www.jetbrains.com/idea/)) I used the rather neat [scala-maven-plugin](https://davidb.github.io/scala-maven-plugin/index.html):

```xml
<plugin>
    <groupId>net.alchim31.maven</groupId>
    <artifactId>scala-maven-plugin</artifactId>
    <version>3.4.4</version>
    <executions>
        <execution>
            <id>scala-test-compile</id>
            <phase>process-test-resources</phase>
            <goals>
                <goal>testCompile</goal>
            </goals>
        </execution>
    </executions>
</plugin>
```

To run Gatling from Maven and view its output, we need a dependency and a plugin:

```xml
<dependency>
    <groupId>io.gatling.highcharts</groupId>
    <artifactId>gatling-charts-highcharts</artifactId>
    <scope>test</scope>
    <version>3.0.2</version>
</dependency>
```

```xml
<plugin>
    <groupId>io.gatling</groupId>
    <artifactId>gatling-maven-plugin</artifactId>
    <version>3.0.1</version>
</plugin>
```

Now we can write a Gatling test. This is our scenario, describing the client behaviour we want to test.

```scala
setUp(myScenario.inject(
    incrementUsersPerSec(20)
      .times(5)
      .eachLevelLasting(5 seconds)
      .startingFrom(20)
  )).protocols(httpProtocol)
    .assertions(global.successfulRequests.percent.is(100))
```

We're starting with 20 users per second making a request to the `/` resource, holding at that concurrency for five seconds. They only make one request. Then we increase the number of users per second by twenty, five times, holding for five seconds each time. Every request must return an HTTP 200 status code to pass the test. Simple! You'll find the rest of the test in [LoadTest.scala](https://github.com/brabster/performance-with-spring-boot/blob/1.0/src/test/scala/hello/LoadTest.scala).

Make sure the app is running and then run the test with `mvn gatling:test`.

![Asciinema recording of the performance test running](perf-test-1.gif)

When the tests run you see a progress bar being refreshed every few seconds. The `###` part represents the proportion of requests that have been made and completed. The section with dashes `---` is requests made but not yet completed. The numbers are just below the progress bar, `active` telling us how many requests have been made but not yet completed. There's a lot of those, over a thousand towards the end of the test, and this computer isn't exactly underpowered. There's our performance problem! Towards the end of the test, requests are taking over 26 seconds to complete.

If you cloned the project, you can try changing the scenario in [LoadTest.scala](https://github.com/brabster/performance-with-spring-boot/blob/1.0/src/test/scala/hello/LoadTest.scala) to explore the problem. Running something like `top` will show you your live CPU utilisation. I can see the app using almost a full 4 cores while the test is running. To serve a short text string from memory to less than 100 users per second!

## Gatling's Reports

Gatling saves a report of metrics and charts for each test. There's a couple that I think give us interesting insight into what just happened that we might not have seen as the test was running.

![Bar chart showing 15 requests responded in around 200 milliseconds, with other requests uniformly distributed up to almost 30 seconds](gatling-slow-response-time-distribution.png)

The "Response Time Distribution" report tells us that the fastest few requests are served in around 200ms. So it takes at least 200ms to serve a request! Then there's an roughly uniform distribution of request times up to 30 seconds. The test only ran for around 70 seconds in total.

Next, the "Number of requests per second" chart shows more clearly that the app isn't keeping up, even with these low request rates. The number of active users (those that have made a request and not yet had a response) climbs until Gatling stops sending new requests.

![Line chart showing the number of new requests per second and the number of active requests over time.](gatling-slow-request-response-rate.png)

You can see the app is not quite able to keep up at 40 requests per second. as we ramp to 60 the line swings upwards as it really starts to fall behind. 45 seconds or so into the test the number of requests per second drops from 100 to zero, and the number of active requests, just over 1000 by this point, stops climbing and starts to fall as the app starts to clear its backlog.

Gatling's reports show you plenty of other interesting charts and figures. Find them in your `target` directory after running a test.

## Next Time

That's the context, the tools and a simple codebase to get us started. In [Part 2](/posts/spring-boot-performance-part-2), we see how a performance problem shows itself and figure out how to resolve it.

repository: brabster/tw-site

gha_language: JavaScript

repo_name: brabster/tw-site


text:
# CashGraph

[![CircleCI](https://circleci.com/gh/RyanGouldsmith/CashGraph/tree/master.svg?style=svg)](https://circleci.com/gh/RyanGouldsmith/CashGraph/tree/master)

🌍A GraphQL implementation of spending 📈

## Application Structure

The structure of the repo contains both the front-end code, and the back-end server code.

### GraphQL Server

The server directory contains an express server using `apollo` to serve `GraphQL` queries.

The schemas the application supports are in the schemas directory currently the supported schemas are:

1. `Spending` This is the contains the ability to identify all the spending items for a user and what is contained in a spending item.
2. `Tag` - Used to classify a specific spending item.
3. `User` - Used to map the user.

The resolvers directory contains all the resolver functions for queries coming in via express. They collate the information and return it back in the request.

#### Getting up and running

MongoDB will be needed to interact with the application. You will need to create two collections `spending` and `user`.

 This will run a `nodemon` so any changes will be automatically detected.

---

### Front-end

The front-end application is a `React` application, using `Webpack` and `Apollo-client`. It is also written in `TypeScript`.

All components are withing the `src/components` directory. Inside here also contains any component tests, graphql queries and types.

 The testing tools used is the `react-testing-library` with `Jest`

repository: RyanGouldsmith/CashGraph

gha_language: TypeScript

repo_name: RyanGouldsmith/CashGraph


text:
# THFFmpeg

Some (quick and not so dirty) bindings of ffmpeg for torch.
Big thanks to https://github.com/mpenkov/ffmpeg-tutorial for their tutorials.

Under BSD License.

## Install

It requires ffmpeg 2.x (tested with 2.8.5) for now.

Clone this git, then type
```
luarocks make
```

### Troubleshooting

When installing, I had a problem with the version of ffmpeg (the headers version didn't match the loaded library).
There is now a check at initialization. If it fails, make sure that you compile with the same headers.
A way to force them is
```
luarocks make
cd build
ccmake .
# set the correct paths
cd ..
luarocks make
```
After that, as long as you don't remove the `build` folder, it should compile fine with the future `luarocks make` calls.

The only way I found to set the correct paths were to add `-I/usr/include/ffmpeg` to the CXX and C flags, in `ccmake .`.
This should work on NYU servers, but other paths may be necessary depending on where you installed `ffmpeg`.

### Testing

To test the install, you can run
```
th test/test.th
```

## Usage

In torch:
```
require 'thffmpeg'

decoder = THFFmpeg() --creates a decoder object
decoder:open('myvideo.avi') --opens the video myvideo.avi
frame1 = decoder:next_frame() --allocates a new tensor and puts the first frame in it
frame2 = torch.Tensor(42,42)
decoder:next_frame(frame2) --resizes frame2 if necessary and puts the second frame in it
decoder:close() --closes the video
decoder:open('myvideo2.avi') --opens the video myvideo2.avi
```

### THFFmpeg:open(filename)

Opens a video file. If another was opened in the same THFFmpeg object, it is closed.
It sets the variables `h` and `w` of the THFFmpeg object to the size of the video stream.

### THFFmpeg:close()

Closes a video file. It is not usually strictly necessary, as the decoder will
automatically close the opened video when another video is opened,
or when the decoder is garbage collected.

### [res] THFFmpeg:next_frame([dst])

Decodes and returns the next frame. If `dst` is provided, it is used as a destination buffer,
and must have the correct size.
This function returns nil when there is no more frames to read.

### [res] THFFmpeg:skip_frame()

Skips a frame. Returns true if successful and false otherwise. Because the frame is not processed, it
is faster than next_frame.

### [res] THFFmpeg:seek(idx)

Seeks the `idx`-th frame. Because of limitations of video format, this function decodes
every frame from the beginning, so it might be slow on large videos. However, it will
always be faster than calling `idx` times the function `next_frame` because the
images are not processed.
This function returns `true` if the seek was a success, and `false` otherwise.

### [res] THFFmpeg:length()

Returns the length of the video. As for `seek`, this function decodes all frames of the
video and therefore might be slow on large videos.

repository: MichaelMathieu/THFFmpeg

repo_name: MichaelMathieu/THFFmpeg


text:
# Welcome to React Quickstart
[![Build Status](https://travis-ci.org/blurbyte/react-quickstart.svg?branch=master)](https://travis-ci.org/blurbyte/react-quickstart) [![codecov](https://codecov.io/gh/blurbyte/react-quickstart/branch/master/graph/badge.svg)](https://codecov.io/gh/blurbyte/react-quickstart)

React Quickstart is starting kit for creating fast and responsive web applications with React. It takes care of initial developement environment setup, boilerplating and puts everything to use in simple example. Notable technologies used are: __React__, __Redux__, __React Router v4__, __Babel__, __Webpack v3__, __ESLint__.

### Getting started!
Just follow a few easy steps to set project up:
  1. Install __Node__, preferably > __6.9.1__
  2. Install __Git__
  3. Clone the repository `git clone https://github.com/blurbyte/react-quickstart.git`
  4. Install [Yarn](https://yarnpkg.com/)
  5. Enter project folder and install all required modules with simple `yarn` command
  6. Start demo aplication `npm start -s` and follow further instructions 🙂

### What will you learn?
By inspecting source code of demo application you can get a good grasp of:
  1. How to set up JavaScript development environment for single page React web app
  2. How to organize file structure of your project
  3. How to write Redux action creators, reducers and connect components with store
  4. How to manage side effects with *redux-saga*
  5. How to use Redux application state in combination with container component state
  6. How to write simple unit tests for actions and integration tests for reducers
  7. How to write snapshot tests of React components with *jest*
  8. How to take advantage of *styled-components*
  9. How to integrate custom fonts


text:
# **Car Evulation KNN of Machine Learning Software**
I developed machine learning software that evaluates vehicles against certain conditions. In this software, I used KNN principles as a mathematical basis (Euclidean relation :)). I hope you like the machine learning software. Knowledge is good when shared!

<img src="https://raw.githubusercontent.com/emirhanai/Car-Evulation-KNN-of-Machine-Learning-Software/main/Car%20Evulation%20KNN%20of%20Machine%20Learning%20Software%20Image.jpg" alt="KNN of Car in Machine Learning">

The values you enter should be (respectively):

**1) You need to enter data in the 'buying' section.**

**2) You need to enter data in the 'maint' section.**

**3) You need to enter data in the 'doors' section.**

**4) You need to enter data in the 'lug-boot' section.**

**5) You need to enter data in the 'safety' section.**

_Prediction Example:_ `X_train, X_test, y_train, y_test = model_selection.train_test_split(X_n,y_n,test_size = 0.3)`

_Prediction Outpot :_ `Prediction Class:  [2]`

_Accuracy Example:_ `accuracy = neighbors_clf.score(X_test,y_test)`

 Prediction Outpot :_ `Accuracy of the:  0.9248554913294798`
**I am happy to present this software to you!**

Data Source: [https://archive.ics.uci.edu/][DataSource]
###**The coding language used:**

`Python 3.9.6`

###**Libraries Used:**

`Sklearn`

`Pandas`

`Numpy`
### **Developer Information:**

Name-Surname: **Emirhan BULUT**

Contact (Email<EMAIL_ADDRESS>
LinkedIn : **[https://www.linkedin.com/in/artificialintelligencebulut/][LinkedinAccount]**

[LinkedinAccount]: https://www.linkedin.com/in/artificialintelligencebulut/

Official Website: **[https://www.emirhanbulut.com.tr][OfficialWebSite]**

[OfficialWebSite]: https://www.emirhanbulut.com.tr

[DataSource]: https://archive.ics.uci.edu/


text:
# crypto-pair

Normalize cryptocurrency trade pairs.

## Quick start

```bash
npx crypto-pair ADABUSD --exchange Binance
```

## How to use

```javascript
/* eslint-disable import/no-unresolved,no-console,import/no-extraneous-dependencies */
const { normalizePair } = require('crypto-pair');

console.info(normalizePair('ADABUSD', 'Binance'));
```

## API Manual

There are only two APIs in this library:

```typescript
/**
 * Normalize a symbol.
 *
 * @param symbol The original symbol from an exchange
 * @param exchange The normalized symbol
 */
export declare function normalizeSymbol(symbol: string, exchange: string): string;
/**
 * Normalize a cryptocurrency trade pair.
 *
 * @param rawPair The original pair of an exchange
 * @param exchange The exchange name
 */
export declare function normalizePair(rawPair: string, exchange: string): string;
```

repository: crypto-crawler/crypto-pair

repo_name: crypto-crawler/crypto-pair


text:
The used scripts all require Python 3!!!

## Directory Structure
* [rmpdiscovery](rmpdiscovery): the library containing the discovery and advertise service. The discovery service may be run alongside the MBP to discover devices. The advertise service may be used by devicees to register themselves at the MBP.

* the files rmpadvertise.*, rmpdiscovery.* and rmpvaluelogger.* are used to deploy and run the respective services using systemd.
* discoverygui.py offers a basic GUI to view the devices currently registered for monitoring

## Installing services
The discovery service is installed alongside the MBP using the install.sh script.
To install and run the advertise service, use the install-advertise.sh script.

The services are installe using systemd so they can be started and stop, using:

    sudo systemctl start <service>
    sudo systemctl stop <service>

## Discovery service

The discovery service is implemented in the [discovery](rmpdiscovery/discovery) package.
The following diagram hopefully clarifies the structure:

![discovery package](../package-discovery.png)

The discovery gateways detect new devices in their network and register them at the discovery service.
For each network technology there must be a specialized implementation of the `DiscoveryGateway` class.

## Necessary Libraries

The file [python-packages.py](python-packages.txt) lists all used python packages.
They can be installed using

    sudo pip install -r python-packages.txt

## Haftungsausschluss

Dies ist ein Forschungsprototyp.
Die Haftung für entgangenen Gewinn, Produktionsausfall, Betriebsunterbrechung, entgangene Nutzungen, Verlust von Daten und Informationen, Finanzierungsaufwendungen sowie sonstige Vermögens- und Folgeschäden ist, außer in Fällen von grober Fahrlässigkeit, Vorsatz und Personenschäden, ausgeschlossen.

## Disclaimer of Warranty

Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE.
You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.

repository: magirtopcu/MBP

repo_name: magirtopcu/MBP


text:
# percolation

Created by Eric Stansifer.

Hosted at `https://github.com/estansifer/percolation/`.

A program for finding sizes of clusters in a percolation process.

Use python to invoke the file `perc.py` from the commandline, for example:

    python perc.py

If no arguments are given, the program prints instructions for how to use it.

As a suggested starting point, try

    python perc.py ones 20 0.5

to make a 20x20 percolation grid where each site is occupied with probability 0.5.

repository: ImHShen/algorithmDataStructure

repo_name: ImHShen/algorithmDataStructure


text:
# JLog

Ruby C-bindings for OmniTI Labs' [Jlog](https://github.com/omniti-labs/jlog). Founded upon [work](https://github.com/mbainter/ruby-jlog/) by Mark Bainter (@mbainter.)

> JLog is short for "journaled log" and this package is really an API and implementation that is libjlog. What is libjlog? libjlog is a pure C, very simple durable message queue with multiple subscribers and publishers (both thread and multi-process safe). The basic concept is that publishers can open a log and write messages to it while subscribers open the log and consume messages from it. "That sounds easy." libjlog abstracts away the need to perform log rotation or maintenance by publishing into fixed size log buffers and eliminating old log buffers when there are no more consumers pending.

## Installation

Add this line to your application's Gemfile:

    gem 'jlog'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install jlog

## Usage

```ruby
log = Jlog.new('/var/log/logname')
log.add_subscriber 'LogSubscriber'
log.close

writer = Jlog::Writer.new('/var/log/logname')

writer.open
writer.write 'This is the first log message'
writer.write 'This is the second log message'
writer.write "This is the third log message, created at #{Time.now}"
writer.close

reader = Jlog::Reader.new '/var/log/logname'
reader.open 'LogSubscriber'

first = reader.read
second = reader.read
reader.rewind

if reader.read == second
  puts "Rewind sets log position to last checkpoint."
end

reader.checkpoint

third = reader.read
reader.rewind
third_full = reader.read_message

if third == third_msg[:message]
  ts = third_msg[:timestamp]
  puts "#{third} and logged #{Time.at(ts)} (or #{ts} seconds since epoch)"
end

reader.checkpoint
reader.close
```

## Requirements

* [Jlog](https://github.com/omniti-labs/jlog)


text:
---
title: toc-lib-format-gis-utils
tags: [format, geojson, geopackage, gis, shapefile, toc, utils]
created: 2022-11-06T15:47:28.547Z
modified: 2022-11-06T15:48:09.723Z
---

# toc-lib-format-gis-utils

# guide

# popular

# examples

# parser-generator

# extension-superset
- https://github.com/bmschmidt/trifeather
  - This library defines a binary file format for collections of projected polygon map data bound for geojson.
  - It builds on the Apache Arrow project's feather format; each feature from a feature collection is stored as a single row, and all keys are stored as columns.
  - Rather than store coordinates, it uses the mapbox earcut library to triangulate polygons, and stores those triangles directly.
  - The combination of this strategy and apache arrow means that the binary data can be pushed straight to a GPU for plotting without any need for Javascript, without an extraordinary size penalty.
# utils
- https://github.com/dimfeld/merge-geo
  - A utility to read CSV data about geographic locations and merge it into a GeoJSON FeatureCollection.
# more


text:
C# Design Meeting Notes for Mar 24, 2015
========================================

Discussion thread on these notes is at https://github.com/dotnet/roslyn/issues/1898.

*Quote of the Day:* If we have slicing we also need dicing!

Agenda
------

In this meeting we went through a number of the performance and reliability features we have discussed, to get a better reading on which ones have legs. They end up falling roughly into three categories:

* Green: interesting - let's keep looking
* Yellow: there's something there but this is not it
* Red: probably not

As follows:

1. ref returns and locals <*green*> (#118)
2. readonly locals and parameters <*green*> (#115)
3. Method contracts <*green*> (#119)
4. Does not return <*green*> (#1226)
5. Slicing <*green*> (#120)
6. Lambda capture lists <*yellow - maybe attributes on lambdas*> (#117)
7. Immutable types <*yellow in current form, but warrants more discussion*> (#159)
8. Destructible types <*yellow - fixing deterministic disposal is interesting*> (#161)
9. Move <*red*> (#160)
10. Exception contracts <*red*>
11. Static delegates <*red*>
12. Safe fixed-size buffers in structs <*red*> (#126)

Some of these were discussed again (see below), some we just reiterated our position.

1. Ref returns and locals
=========================

At the implementation level these would require a verifier relaxation, which would cause problems when down targeting in sandboxing scenarios. This may be fine.

At the language level, ref returns would have to be allowed on properties and indexers only if they do not have a setter. Setters and ref would be two alternative ways of allowing assignment through properties and indexers. For databinding scenarios we would need to check whether reflection would facilitate such assignment through a ref.

A danger of ref returns in public APIs: say you return a ref into the underlying array of e.g. a list, and the list is grown by switching out the underlying array. Now someone can get a ref, modify the collection, follow the ref and get to the wrong place. So maybe ref returns are not a good thing on public API boundary.

There's complexity around "safe to return": You should only return refs that you received as parameters, or got from the heap. This leads to complexity around allowing reassignment of ref locals: how do you track whether the ref they are pointing to is "safe to return" or not? We'd have to either

* add syntax to declare which kind the local points to (complex)
* allow only one of the kinds to be assigned to locals (restrictive)
* track it as best we can through flow analysis (magic)

There's complexity in how refs relate to readonly. You either can't take a ref to a readonly, or you need to be able to express a readonly ref through which assignments is illegal. The latter would need explicit representation in metadata, and ideally the verifier would enforce the difference.

This can't very well be a C# only feature, at least if it shows up in public APIs. VB and F# would need to at least know about it.

This feature would be a decent performance win for structs, but there aren't a lot of structs in the .NET ecosystem today. This is a chicken-and-egg thing: because structs need to be copied, they are often too expensive to use. So this feature could lower the cost of using structs, making them more attractive for their other benefits.

Even so, we are still a bit concerned that the scenario is somewhat narrow for the complexity the feature adds. The proof will have to be in the use cases, and we're not entirely convinced about those. It would be wonderful to hear more from the community. This is also a great candidate for a prototype implementation, to allow folks to experiment with usability and performance.

2. Readonly locals and parameters
=================================

At the core this is a nice and useful feature. The only beef we have with it is that you sort of want to use `readonly` to keep your code safe, and you sort of don't because you're cluttering your code. The `readonly` keyword simply feels a bit too long, and it would be nice to have abbreviations at least in some places.

For instance `readonly var` could be abbreviated to `val` or `let`. Probably `val` reads better than `let` in many places, e.g. declaration expressions. We could also allow `val` as an abbreviation for `readonly` even in non-var situations.

In Swift they use `let` but it reads strange in some contexts. In Swift it's optional in parameter positions, which helps, but we couldn't have that for back compat reasons.

This is promising and we want to keep looking at it.

4. Does Not Return
==================

It would be useful to be able to indicate that a method will never return successfully. It can throw or loop.

The proposal is to do it as an attribute, but there would be more value if it was part of the type system. Essentially it replaces the return type, since nothing of that type is ever returned. We could call it `never`. The `never` type converts to pretty much anything.

This would allow us to add throw *expressions* in the language - their type would be `never`.

Having it in the type system allows e.g. returning `Task<never>`, so that you can indicate an async method that will only ever produce an exception, if anything.

Because of the Task example you do want to allow `never` in generics, but that means you could have generic types that unwittingly operate on never values, which is deeply strange. This needs to be thought about more.

If through nasty tricks you get to a point in the code that according to never types should not be reachable, the code should probably throw.

A common usage would be helper methods to throw exceptions. But throw as an expression is the most useful thing out of this.

6. Attributes on lambdas
========================

Why? Guiding an analyzer, e.g. to prevent variable capture. Syntactically it might collide with XML literals in VB.

We could probably hack it in. The attribute would be emitted onto the generated method.

path: /docs/designNotes/2015-03-24 C# Design Meeting.md

filename: 2015-03-24 C# Design Meeting.md

gha_language: C#


text:
# gcal

## Install

`go get github.com/itsabot/gcal`

Then add `_ "github.com/itsabot/gcal"` to your import statements in an
appropriate file (typically where you first use github.com/itsabot/shared/cal).

## Docs

Coming soon

repository: itsabot/gcal

repo_name: itsabot/gcal


text:
# MEMBERS-ONLY
> In this project, I will build an application that allows users to create posts and the authors of the posts are displayed only if as a User you are logged in. The main goal is to setup devise gem for authentication
## Project Screenshot
## Built With

- Ruby
- Ruby on Rails
- Bulma

## Getting Started

Clone

```git
git clone https://github.com/tongoonamujera/members-only.git
```

To get a local copy up and running, follow these simple example steps.

1. Open a terminal window and enter `git clone https://github.com/tongoonamujera/members-only.git`
2. Make your new cloned directory your active directory
3. Currently, you are in the "development branch."
4. Change your current branch to Feature branch `git checkout Feature`
5. Run `bundle` to install gems to your project

### Creating the project from scratch
- Make sure you read all the Prequisities
- Hit ctrl+alt+T to open Terminal
- Run `rails new reformer` from your terminal to create a new rails app
  - This command will create a number of files and the default db will be SQLite3
- Run cd `cd reformer` to navigate to your project directory
- You can create user model through following devise documentation [here](https://github.com/heartcombo/devise)
- To add username column to user table just run `rails g migration add_username_to_users username`
- To add image column to user table just run `rails g migration add_username_to_users image`
- Run `rails db:migrate` from your Terminal to create a database migration
- To create a post model, on your teminal run `rails g model post title body image user:references`
- Run `rails db:migrate` from your Terminal to create a database migration
- Run `rails g controller posts index create new edit destroy` on your terminal to create a controller for users
- Run `code .` if you are using Visual Studio Code or `atom` if you are using Atom or `subl` if you are using Sublime to open your text editor
- In your code editor go to the Gemfile and add the following gems `gem bulma-rails`
- Run `bundle` from your terminal to install gems to you project
- Change the application.css to application.scss and add the following line of code `@import 'bulma';`

### USAGE
- To test code locally in local browser just make your cloned directory active and run `rails s` from your terminal to start rails server

### Prerequisites

- Ruby installed locally(Ruby-3.0.0)
- Rails installed locally(Rails 6.0.4 used)
- Have knowledge with bulma
- A text editor

## Authors
👤 **Tongoona Mujera**

- Github: [@tongoonamujera](https://github.com/tongoonamujera)
- Twitter: [@tongomujera](https://twitter.com/tongomujera)
- Linkedin: [tongoona-mujera](https://www.linkedin.com/in/tongoona-mujera-125604162/)
- Email<EMAIL_ADDRESS>
## 🤝 Contributing

Contributions, issues, and feature requests are welcome!

Feel free to check the [issues page](../../issues/).

## Show your support

Give a ⭐ if you like this project.!

## 📝 License

This project is [MIT](LICENCE) licensed.

repository: tongoonamujera/members-only

branch_name: refs/heads/development

repo_name: tongoonamujera/members-only


text:
# QDSpy v.81 beta

QDSpy is a software for generating and presenting stimuli for visual neuroscience. It is based on QDS, developped in the former Dept. of Biomedical Optics at the MPI for Medical Research in Heidelberg. QDSpy is written in Python, uses OpenGL and primarly targets Windows 7 and above.

*Note, this is still a beta version.*
*For disclaimer, see [here](http://qdspy.eulerlab.de/disclaimer.html#disclaimer-of-warranty).*

## Documentation

For documentation, see [manual](http://qdspy.eulerlab.de).

To jump to installation, see [Wiki](https://github.com/eulerlab/QDSpy/wiki/Installation-under-Windows) or [manual](http://qdspy.eulerlab.de/installation.html#installation).

For details on versions, see [release notes](https://github.com/eulerlab/QDSpy/wiki/Release-notes).

repository: eulerlab/QDSpy

gha_language: Python

repo_name: eulerlab/QDSpy


text:
---
hrs_structure:
  division: '1'
  volume: '1'
  title: '2'
  chapter: '15'
  section: 15-2.5
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0015-0002_0005
    parent: HRS0015
    name: 15-2.5 Absentee voting in precinct affected by natural disasters
weight: 26015
title: Absentee voting in precinct affected by natural disasters
full_title: 15-2.5 Absentee voting in precinct affected by natural disasters
---
**[§15-2.5] Absentee voting in precinct affected by natural disasters.** (a) If the chief election officer and clerk of a county affected as a result of a natural disaster determine that the opening of a designated polling place will adversely affect the health and safety of voters or precinct officials, the chief election officer and county clerk, by written order, may require the registered voters of any precinct to vote by absentee ballot; provided that if there are not enough absentee ballots for all voters of the precinct, the chief election officer or the clerk shall use other official ballots to make up the difference.

(b) Within thirty days after the issuance of such an order, the chief election officer and county clerk shall notify all registered voters in the affected precinct of the issuance of the order.

(c) Within ten days after the printed official absentee ballots are available for the designated precinct affected by this section, the clerk shall deliver, or cause to be delivered, by hand or mail, an absentee ballot, a return envelope, and any other appropriate material to each registered voter in the affected precinct.

(d) The chief election officer shall adopt rules pursuant to chapter 91 to implement this section. [L 1996, c 215, §1]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# Advanced Duplicator 2

Advanced Duplicator 2 is a [Garry's Mod][] addon which implements a tool similar to the Duplicator, but with many added features. It is a fork of (and not a direct successor to, despite the name) [Advanced Duplicator][].

# Installation

Currently, this version of AdvDupe2 isn't available on the Steam Workshop. The best way to get this addon is to clone this repository into your `addons` folder:

    cd "%programfiles(x86)%/Steam/SteamApps/common/GarrysMod/garrysmod/addons"
    git clone https://github.com/wiremod/advdupe2.git advdupe2

# License

Copyright 2014 Wire Team

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

[Garry's Mod]: <http://garrysmod.com/>
[Advanced Duplicator]: <https://github.com/wiremod/advduplicator>

repository: CreedWN/cBMRP-Full

repo_name: CreedWN/cBMRP-Full


text:
## Credit Card Mask Kata

### Requirements

Usually when you buy something, you're asked whether your credit card number, phone number or answer to your most secret question is still correct. However, since someone could look over your shoulder, you don't want that shown on your screen. Instead, we mask it.

Your task is to write a function maskify, which changes all but the last four characters into '#'.

### Test Cases

```JavaScript
maskify("4556364607935616") == "############5616"
maskify(     "64607935616") ==      "#######5616"
maskify(               "1") ==                "1"
maskify(                "") ==                 ""
```

### Input/Output Table

| Input                                          | Output |
| :--------------------------------------------- | :----- |
| "4556364607935616"                | "############5616"  |
| "64607935616                      | "#######5616"       |

repository: kongnyc/TDD-Codewars-Kata-Exercises-JS

repo_name: kongnyc/TDD-Codewars-Kata-Exercises-JS


text:
# Tanzu Community Edition Adopters

If you're using TCE and want to add your organization to this list, follow these directions

## Success Stories

## Solutions built with Tanzu Community Edition

Below is a list of solutions where TCE is being used as a component.

## Adding your organization to the list of Tanzu Community Edition Adopters

## Adding a logo to XXXX

repository: JitenPalaparthi/community-edition

repo_name: JitenPalaparthi/community-edition