text:
vim-rapydscript
===============

I do a lot of my development in RapydScript, I also do all of my development in vim. Out of the box, vim doesn't realize how similar RapydScript is to Python, and doesn't attempt to use any sort of indentation, syntax highlighting or other logic when working with RapydScript file. This plugin aims to fix that, and also make RapydScript compatible with some of the fancier vim logic I use. Feel free to use it for your own work.

If you want TagBar plugin to be compatible with RapydScript, find the line adding Python support, and add RapydScript right below it as follows:

	let s:known_types.python = type_python
	let s:known_types.rapydscript = type_python

I also recommend you check out https://github.com/atsepkov/vim-pydocstring repository that allows you to effortlessly create docstrings in Python and RapydScript (this is a fancier version of heaveshell's vim-pydocstring plugin)

Installation
============
If you want the easiest, laziest way to install this plugin, just get Vundle plugin and then add the following line to your .vimrc:

	Bundle "atsepkov/vim-rapydscript"

Then run `:BundleInstall` command in vim and it will automatically download this repo from github and set it up.

Otherwise, you can download this repo manually and unpack it inside your .vim directory and hope that you don't have anything else by the name 'rapydscript' in any of these directories, or it will get overwritten.

Note that to work properly with this bundle, vim needs to be told which file you'll be associating with RapydScript. The recommended file extension for RapydScript is .pyj, so you will need to add the following line to your .vimrc:

	au BufRead,BufNewFile *.pyj set filetype=rapydscript

repository: atsepkov/vim-rapydscript

gha_language: VimL

repo_name: atsepkov/vim-rapydscript


text:
---
title: 'Astronomy workshop for Children’s Space library, Besant Nagar'
author: chennaiastronomyclub
layout: post
permalink: /2014/02/02/astronomy-workshop-for-childrens-space-library-besant-nagar/
categories: [Outreach]
tags: [outreach]
---

Mr. Manick Rajendran conducted a workshop for some kids at Children's Space Library, Besant Nagar.

The kids asked various interesting questions and it was a pleasure to interact with them.

Some interesting questions where:
Why are planets round and asteroids aren't?
Why is there no eclipse on every full moon day?

![The telescope](/img/lib1.jpg)

![The session](/img/lib2.jpg)

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: CSS

gha_license_id: MIT

license_type: permissive


text:
# Kumi-Daiko Beatoff 64

<img src="media/cover-art.png" height="400" alt="Screenshot of cover art"/>

## About the game

It's a Bumpin', Boomin', Blastin' Beatoff! The mythical Super Percussion Cousins collide in this ultimate showdown of whippiness and cunning! Up to four players can choose their favorite animal face - complete with their own color - and go at it in Survival mode and last-mask-standing Battles.

Whip out your instrument and bust into battle with your favorite mask: Fox, Cat, Owl or Monkey! ...not that there’s any mechanical difference.

Avoid other players’ whipping instruments & use your drum as a shield from danger
Compete in the state of the art 64-bit arena until the end of time, having fun whackin’ with everyone you love!

##### Game modes:

- Survival: 1-4 players – destroy angry masks
- Battle: 2-4 players - fight against other players

##### Controls:

- D-pad: Menu selection
- A: Select game mode
- Stick: Move player
- Start: Stop round

This game is an entry for the first ever N64brew Game Jam. See: https://zhamul.itch.io/kumi-daiko-beatoff-64

## Building from source

### Recommended dev environment

Debian is a good OS choice for development. As the IDE we have been using CLion, with `./scripts/build.sh` set as the build program and `./scripts/run_cen64.sh` as the executable. This way CLion is will pick up locations for any build errors from the build script console output, which makes development easier.

A good choice is to run Debian in VmWare player with the project in a shared directory, this makes it easy to run any tools such as the Project64 emulator which do not run well in wine.

### Scripts

##### build.sh
Builds project, outputs .n64 file.

- Requires wine. N64 libraries and N64 Sound Tools must be extracted to the wine C:/ folder, e.g. `~/.wine/drive_c/`.

- http://ultra64.ca/files/software/other/sdks/n64sdk.7z
- http://ultra64.ca/files/software/other/sdks/n64dev.zip

Usage: `./scripts/build.sh`

##### run_cen64.sh
Runs cen64 emulator on linux.

- pifdata.bin must be placed in the `tools/cen64` directory.

Usage: `./scripts/run_cen64.sh`

##### import_model.sh
Generates n64 displaylist .h header file for .obj model.
- The .obj file, .mtl file, and the .bmp texture must be placed in `./models/model_name`.
- Model name and texture file names must be C compatible (no dots/spaces/dashes/etc).
- If using blender to export .obj file, export objects must be disabled and export groups must be enabled in the export settings.

Usage: `./scripts/import_model.sh model_name`

### Third-party tools

##### objn64
Converts .obj files to displaylist .h header files.

##### cen64
Cycle-accurate Nintendo 64 emulator (slow), Windows/Linux.

##### project64
Nintendo 64 emulator, Windows only.


text:
# Transforms.
With CSS3 came new ways to position and alter elements. Now general layout techniques can be revisited with alternative ways to size, position, and change elements. All of these new techniques are made possible by the transform property.

The transform property comes in two different settings, two-dimensional and three-dimensional. Each of these come with their own individual properties and values.

Within this lesson we’ll take a look at both two-dimensional and three-dimensional transforms. Generally speaking, browser support for the transform property isn’t great, but it is getting better every day. For the best support vendor prefixes are encouraged, however you may need to download the nightly version of Chrome to see all of these transforms in action.

# Transform Syntax
The actual syntax for the transform property is quite simple, including the transform property followed by the value. The value specifies the transform type followed by a specific amount inside parentheses.Notice how the transform property includes multiple vendor prefixes to gain the best support across all browsers. The un-prefixed declaration comes last to overwrite the prefixed versions, should a browser fully support the transform property.

In the interest of brevity, the remainder of this lesson will not include vendor prefixes. They are, however, strongly encouraged for any code in a production environment. Over time we will be able to remove these prefixes, however keeping them in is the safest approach for the time being.

# 2D Transforms
Elements may be distorted, or transformed, on both a two-dimensional plane or a three-dimensional plane. Two-dimensional transforms work on the x and y axes, known as horizontal and vertical axes. Three-dimensional transforms work on both the x and y axes, as well as the z axis. These three-dimensional transforms help define not only the length and width of an element, but also the depth. We’ll start by discussing how to transform elements on a two-dimensional plane, and then work our way into three-dimensional transforms.

![](https://tipsmake.com/data/images/3d-transform-in-css-picture-1-jtznOkrOW.jpg)

# 2D Rotate
The transform property accepts a handful of different values. The rotate value provides the ability to rotate an element from 0 to 360 degrees. Using a positive value will rotate an element clockwise, and using a negative value will rotate the element counterclockwise. The default point of rotation is the center of the element, 50% 50%, both horizontally and vertically. Later we will discuss how you can change this default point of rotation.

# Perspective Depth Value
The perspective value can be set as none or a length measurement. The none value turns off any perspective, while the length value will set the depth of the perspective. The higher the value, the further away the perspective appears, thus creating a fairly low intensity perspective and a small three-dimensional change. The lower the value the closer the perspective appears, thus creating a high intensity perspective and a large three-dimensional change.

Imagine yourself standing 10 feet away from a 10 foot cube as compared to standing 1,000 feet away from the same cube. At 10 feet, your distance to the cube is the same as the dimensions of the cube, therefore the perspective shift is much greater than it will be at 1,000 feet, where the dimensions of the cube are only one one-hundredth of your distance to the cube. The same thinking applies to perspective depth values.

![](https://res.cloudinary.com/practicaldev/image/fetch/s--daN69Yzc--/c_imagga_scale,f_auto,fl_progressive,h_900,q_auto,w_1600/https://thepracticaldev.s3.amazonaws.com/i/8qzuomp4zhw2rgaqsi3g.png)

for more details please join the linik

[article on CSS Transforms](https://learn.shayhowe.com/advanced-html-css/css-transforms/)

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

# Transitions & Animations
One evolution with CSS3 was the ability to write behaviors for transitions and animations. Front end developers have been asking for the ability to design these interactions within HTML and CSS, without the use of JavaScript or Flash, for years. Now their wish has come true.

With CSS3 transitions you have the potential to alter the appearance and behavior of an element whenever a state change occurs, such as when it is hovered over, focused on, active, or targeted.

Animations within CSS3 allow the appearance and behavior of an element to be altered in multiple keyframes. Transitions provide a change from one state to another, while animations can set multiple points of transition upon different keyframes.

# Transitions
As mentioned, for a transition to take place, an element must have a change in state, and different styles must be identified for each state. The easiest way for determining styles for different states is by using the :hover, :focus, :active, and :target pseudo-classes.

There are four transition related properties in total, including transition-property, transition-duration, transition-timing-function, and transition-delay. Not all of these are required to build a transition, with the first three are the most popular.

In the example below the box will change its background color over the course of 1 second in a linear fashion.

# Vendor Prefixes
The code above, as with the rest of the code samples in this lesson, are not vendor prefixed. This is intentionally un-prefixed in the interest of keeping the code snippet small and comprehensible. For the best support across all browsers, use vendor prefixes.

For reference, the prefixed version of the code above would look like the following.

![](https://i.imgur.com/LyV03iy.png)

# Transitional Property
The transition-property property determines exactly what properties will be altered in conjunction with the other transitional properties. By default, all of the properties within an element’s different states will be altered upon change. However, only the properties identified within the transition-property value will be affected by any transitions.

In the example above, the background property is identified in the transition-property value. Here the background property is the only property that will change over the duration of 1 second in a linear fashion. Any other properties included when changing an element’s state, but not included within the transition-property value, will not receive the transition behaviors as set by the transition-duration or transition-timing-function properties.

If multiple properties need to be transitioned they may be comma separated within the transition-property value. Additionally, the keyword value all may be used to transition all properties of an element.

# Transition Duration
The duration in which a transition takes place is set using the transition-duration property. The value of this property can be set using general timing values, including seconds (s) and milliseconds (ms). These timing values may also come in fractional measurements, .2s for example.

When transitioning multiple properties you can set multiple durations, one for each property. As with the transition-property property value, multiple durations can be declared using comma separated values. The order of these values when identifying individual properties and durations does matter. For example, the first property identified within the transition-property property will match up with the first time identified within the transition-duration property, and so forth.

If multiple properties are being transitioned with only one duration value declared, that one value will be the duration of all the transitioned properties.

# Transition Timing
The transition-timing-function property is used to set the speed in which a transition will move. Knowing the duration from the transition-duration property a transition can have multiple speeds within a single duration. A few of the more popular keyword values for the transition-timing-function property include linear, ease-in, ease-out, and ease-in-out.

![](https://miro.medium.com/max/1000/0*z-NzK5spBWCM5gp_.jpg)

The linear keyword value identifies a transition moving in a constant speed from one state to another. The ease-in value identifies a transition that starts slowly and speeds up throughout the transition, while the ease-out value identifies a transition that starts quickly and slows down throughout the transition. The ease-in-out value identifies a transition that starts slowly, speeds up in the middle, then slows down again before ending.

Each timing function has a cubic-bezier curve behind it, which can be specifically set using the cubic-bezier(x1, y1, x2, y2) value. Additional values include step-start, step-stop, and a uniquely identified steps(number_of_steps, direction) value.

When transitioning multiple properties, you can identify multiple timing functions. These timing function values, as with other transition property values, may be declared as comma separated values.

branch_name: refs/heads/main


text:
# bash_menu_ex

Alternative to bash select.

Highly customizable bash menu. It helps to manage different environment settings.

The idea behind it came to me a few years back when I started to use Linux as my primary development platform. When I was working with multiple projects simultaneously, it often required to set or change a bunch of environment variables, switching from one build toolchain to another, changing the path, adjusting other system settings, etc. It was a real pain in the neck to keep track of all of that, and I did not like the built-in bash select feature mostly from an estetic point of view.

This bash menu was quite an improvement. And in the end, I caught two rabbits, I made my life more comfortable, and I practiced some bash. I was improving on it for quite some time, and I am pretty satisfied with it now.

Here is how all 3 demo modules look in the Linux console:

![image](https://github.com/ademyankov/bash_menu_ex/blob/master/demo_menu.png)

## Demo modules:
- *demo_platform* shows how to use sub (child) menu
- *demo_build* shows how to use check box items
- *demo_logs* shows how to use radio box items and alignment

## Usage
In order to run the demo simply source the menu module and a demo module into
the environment:
```sh
. menu_ex && . demo_platform
dev
```
Or source all 3 demo modules together:
```sh
. menu_ex && . demo_platform && . demo_build && . demo_logs
dev
```
## Aliases
Bash aliases used to show a menu, to select an item, or to execute a callback. The API documentation has all the decription on how to use the menu as well as the demo modules has detailed describtion on how to use the API.
```sh
dev   # Show all the menus
PL    # Show PLATFORM menu
Build # Show Build menu
logs  # Show logs menu
```
To see what aliases available for a specific menu, run a menu's alias with *-h* switch, for example:
```sh
PL -h
```


text:
![Budget Planning][image]

# Budget Planning Dashboard

This project was based on the execpional design made by the [Halo UI/UX](https://dribbble.com/intriligator) group, to access it on Dribble click [here](https://dribbble.com/shots/8168686-Budget-Planning-Dashboard). This project was developed using Angular 11.

[image]: https://i.imgur.com/qLj4jz1.jpeg

## Getting Started

### Prerequisites

* Npm
* Angular 11

**Install all project dependencies**

```
$ npm install
```

## Running in development mode

```
$ ng serve --o
```
You can see the project running in http://localhost:4200/

## Contributing

To contribute to the project follow the steps below:

1. Make the _fork_ of the project (<https://github.com/Joaovjs/front-beauty-projects/fork>)
2. Create a _branch_ for your modification (`git checkout -b feature/fooBar`)
3. Make _commit_ (`git commit -am 'Add some fooBar'`)
4. _Push_ (`git push origin feature/fooBar`)
5. Create a new _Pull Request_

## License

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

repository: Joaovjs/front-beauty-projects

repo_name: Joaovjs/front-beauty-projects


text:
Final assignment
==================

1. Case

For the purpose of this final assignment, a case is introduced. Assume your group plays
the role of a pattern recognition consultancy company. Your company is faced with an
assignment by a client company working on automatic bank cheque processing applications.
This client wants you to research the possibility of using pattern recognition techniques to
classify individual digits in bank account numbers and the monetary amount.

They are interested in two scenarios:
  1. the pattern recognition system is trained once, and then applied in the field;
  2. the pattern recognition system is trained for each batch of cheques to be processed.

In pattern recognition terms, Scenario 1 means the amount of training data available is large
(in this case, at least 200 and at most 1000 objects per class), whereas for Scenario 2 it is
much smaller (at most 10 objects per class).

2.  Input: the NIST dataset

To help you to construct your system, the client has supplied you with a standard dataset
of handwritten digits put together by the US National Institute of Standards & Technology,
NIST (see http://www.nist.gov/). This set consists of 2800 images of handwritten digits
for each of the 10 classes, "0","1", . . . , "9". They were scanned from forms filled out by
volunteers, thresholded in black-and-white and automatically segmented in images of 128 x
128 pixels. Sometimes parts of other digits are visible in an image. In order to save diskspace,
we determined for each digit a bounding box, thereby causing images to have different sizes.

The data can be loaded and displayed as:

  >> a = prnist([0:9],[1:40:1000])
  >> show(a)

This loads, for each of the 10 digits, 25 objects out of the available 1000 into a measurement
set a.

3. Expected output: deliverables

The client requires two deliverables:

a report detailing the design choices you made for both scenarios, including detailed motivation. This report should discuss the following:

the choice of representation (by pixels, features or dissimilarities);

the actual features or dissimilarity measure used;

for each representation, whether feature reduction is possible and, if so, what number of features should be used;

for each representation, the optimal classifier and its type, i.e. parametric (nmc, ldc, qdc, fisherc, loglc), non-parametric (knnc, parzenc) or advanced (neural networks, support vector classifiers, one-class classifiers, combining classifiers);

the estimated performance of the optimal classifier on novel data.

a test of your system on a set of benchmark data withheld from you by the client (see below). For Scenario 1, your system should have lower than 5% test error; for Scenario 2, your target is 25% test error.

Note that each choice is expected to be backed up by either evidence or solid reasoning.
In the last exercise(s) for each week you have already experimented somewhat with the hand-
written digit dataset. However, it is important to question each step as you construct your
final digit recognition system, for two reasons:

  1. for Scenario 1, you should use as much training data as possible for the construction of your system (but at least 200 objects per class), rather than the smaller sets you used earlier; this may invalidate some of your earlier conclusions;
  2. you are supposed to optimise the overall performance of the system, rather than just the individual steps.

4. The benchmark

It is common for clients of your company to withhold data from you, which they can then
use to test your system and verify whether the performance you claim to obtain is actually
valid. In this case, the client has supplied you with a function you can use to benchmark your
system yourself, without having access to the actual data used. It goes without saying that
you may not use the test error to optimise your system in any way.

The procedure agreed upon is as follows:

write a function a = my_rep(m) in which m is a NIST measurement set and a the resulting dataset;

compute your classifier as PRTools classifier w in which dimension reduction and classification are incorporated, so a*w*labeld should generate the proper labels;

call e = nist eval(filename,w,n) in which filename is the filename for the my_rep routine, w is your classifier and n is the desired number of digits per class to be tested. The maximum value of n is 100. Evaluation may take a long time. The fraction of classification errors is returned in e. Note: the function nist eval uses a large test set and is therefore only available on the lab computers, not in the software distributed through Blackboard!

In your report, give the performance obtained using the classifiers selected for both scenarios
and compare these to the performance predicted using the training data. Are there large
differences; if so, what could be their cause?

5. Grading

Your report will be graded by the supervisors, acting as the client company. If the minimum
performance requirements (see section A.3) are not met, a passing grade will not be given. The
report is graded on the results obtained, the choices based on their results and the motivation
behind these choices. The maximum grade that can be obtained for the report is an 8.
Two bonus points can be earned as follows:

Include a section "Live test" in your report, in which you report on the performance obtained on actual handwritten digits and compare it to the expected performance and the benchmark performance. To this end, you should:

use a scanner to read in an image of a sheet of paper on which you have written a test set of digits;

segment the individual digits out of the resulting image;

classify the digit images.

  You will have to organize the scanner yourself. A good experiment will earn you a single
  bonus point.

Include a section \Recommendations" to your report, in which you advise your client in detail on possible steps to improve performance in light of the overall system they are constructing. For example:

will having more training data help?

would other features help?

does the application require reject options?

does a single classifier suffice for all digits on a bank cheque?

what is the role of time constraints?

etc.

  A well thought-out set of recommendations will earn you a single bonus point.

6. Feedback

While you work on the final assignment during the last weeks, the supervisors will of course
be available to answer questions and comment on your results. Like in earlier weeks, you will
have to report progress to the supervisors when you leave.
During the practical session of Week 13, it will be possible to discuss your preliminary results
with the supervisors and get some feedback on the areas that need improvement. If you wish
to make use of this possibility, please prepare a very brief overview of your most important
results, e.g. in the form of a short presentation (3-5 slides).

==================

 Papers and other information sources

Algemene papers:

http://dml.cz/bitstream/handle/10338.dmlcz/135219/Kybernetika_34-1998-4_5.pdf

http://www.slideshare.net/anitamaharjan/handwritten-digit-recognition-using-image-processing

http://citeseerx.ist.psu.edu/viewdoc/summary?doi=<IP_ADDRESS>.2343

http://www.ijcaonline.org/volume27/number4/pxc3874475.pdf

https://github.com/JimmyLin192/DigitRecognizer/blob/master/papers/Handwritten%20digit%20recognition%20benchmarking%20of%20state-of-the-art%20techniques.pdf
  <-- View Raw

http://jeremykun.com/2012/08/26/k-nearest-neighbors-and-handwritten-digit-classification/

Feature Selection/Extraction papers:

http://www.creacteve.com.br/iwssip/nav/papers/paper_69.pdf

http://www.sciencedirect.com/science/article/pii/S0031320303002243

==================

Notes:

Gradient feature from gray-scale images yields best performance. Improved NCFE also good performance.

Combined effects of normalization, feature extraction and classification have yielded very high accuracies on well-known datasets.

Good classifiers according to the papers seem to be the median rule for KNN-classifier, neural networks or SVC

repository: ttphan/PatternRecognition

repo_name: ttphan/PatternRecognition


text:
# Interval Operator

## Overview

Create an Observable that emits a sequence of integers spaced by a particular time interval.

![](http://reactivex.io/documentation/operators/images/interval.png)

## Example

```go
observable := rxgo.Interval(rxgo.WithDuration(5 * time.Second))
```

Output:

```
0 // After 5 seconds
1 // After 10 seconds
2 // After 15 seconds
3 // After 20 seconds
...
```

## Options

* [WithBufferedChannel](options.md#withbufferedchannel)

* [WithContext](options.md#withcontext)


text:
YasuhiroABE.homegw-logstash-netflow
=========

This role sets up logstash and java deb packages for home router.
The logstash is used for collecting the netflow packet-header information.

Requirements
------------

This role is tested on the following platforms.

### Ansible
- Version 2.4

### Distributions
- Ubuntu 16.04

Role Variables
--------------

### Default
    ## hostname of logstash running node
    logstash_hostname: localhost

	## If you accept the oracle java license, please turn it to "true".
	logstash_accept_oracle_license_v1_1: "false"

    ## local file path of the logstash deb package
	## Please download the debpackage from the following location.
	## https://www.elastic.co/jp/downloads/logstash
	logstash_deb_srcpath: files/logstash-6.0.0.deb

	## the destination path of the logstash deb package
	logstash_deb_destpath: /tmp/logstash.deb
	logstash_deb_fileperm:
	  owner: root
	  group: root
	  mode: '0644'

	## netflow configuration filepath on the remote system
	logstash_conf_netflow_filepath: /etc/logstash/conf.d/netflow.conf
	logstash_conf_netflow_fileperm:
	  owner: root
	  group: root
	  mode: '0644'

	## destination ip address of the elasticsearch host
	logstash_conf_netflow_dest_ip: <IP_ADDRESS>

	## destination port number of the elasticsearch host
	logstash_conf_netflow_dest_port: 9200

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

N/A

Example Playbook
----------------

    - hosts: all
	  vars:
	    logstash_hostname: "server1"
	    logstash_accept_oracle_license_v1_1: "true"
		logstash_deb_srcpath: "files/logstash-6.2.2.deb"
      roles:
        - YasuhiroABE.homegw-logstash-netflow

License
-------

Apache License 2.0

Author Information
------------------

[Yasuhiro ABE](http://www.yasundial.org/foaf.xml)


text:
---
title: "Woman sericulture factory (女工場養蚕の圖 [女工場養蚕の図], On’na kōjō yōsan no zu)"
authors:
- Utagawa Fusatane (歌川房種)
- Morimoto Junzaburo (森本順三郎)
author_notes:
- "Painter"
- "Publisher"
date: "1880-11-01"
doi: ""

# Schedule page publish date (NOT publication's date).
publishDate: "1880-11-01"

# Publication type.
# Legend: 0 = Uncategorized; 1 = Conference paper; 2 = Journal article;
# 3 = Preprint / Working Paper; 4 = Report; 5 = Book; 6 = Book section;
# 7 = Thesis; 8 = Patent
publication_types: []

# Publication name and optional abbreviated publication name.
publication: ""
publication_short: ""

abstract:

# Summary. An optional shortened abstract.
summary:

tags:
- nishiki-e
- triptych
featured: false

# links:
# - name: ""
#   url: ""
url_pdf:
url_code: ''
url_dataset: ''
url_poster: ''
url_project: ''
url_slides: ''
url_source: ''
url_video: ''

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
image:
  caption: ''
  focal_point: ""
  preview_only: false

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

# Slides (optional).
#   Associate this publication with Markdown slides.
#   Simply enter your slide deck's filename without extension.
#   E.g. `slides: "example"` references `content/slides/example/index.md`.
#   Otherwise, set `slides: ""`.
slides:
---

Painter: Utagawa Fusatane (歌川房種)

Publisher: Morimoto Junzaburo (森本順三郎)

Description:

...

Size:

(L) 34.2 × 24.3, (C) 34.2 × 24.3, (R) 34.2 × 24.2 cm

Condition:

pinhole, lightly colour running, vertical crease on the left panel, light tears, light stains due to colour oxidisation

Text:

Signature: Ōju Ōsai Fusatane hitsu (應需桜斎房種筆 [応需桜斎房種筆])

Publication date: 御届明治十三年十一月 ... 日 (Ontodoke, date for notice of registration; Meiji 13 year, 1880; 11 month, November; ... day)

Publisher (top): 画工 (gakō, painter) 村井静馬 (Murai Seima, Fusatane’s original name) followed by address

Publisher (bottom): 出版人 (??, publisher) 森本順三郎 (Morimoto Junzaburo) followed by address

Sources:

https://archives.tuat-museum.org/s/da/item/1342

https://cultural.jp/en/item/Nhikie-2018_u_0031

repository: raffaelloseri/mycollection

repo_name: raffaelloseri/mycollection


text:
# Plain HTML Framework

![Plain HTML Framework (ScreenGrab)](http://www.arielruff.com/git/plain_html_framework/PHF_image.jpg)

## About
This is a HTML framework made for rapid deployment of a blank website...<br>
**Included are:**
* A basic website folder structure
* A pre-linked css file
* A blank index.html with a body set to 0 margin, linked too css, basic header information, and attached Google Font Roboto with basic font weights.

## Prerequisites
* Your best text editor

## Installing
Simply git clone or manually download repository and unzip.

## Author
Ariel Ruff

repository: arielruff/Plain-Frame

repo_name: arielruff/Plain-Frame


text:
#301-Codewars-Challange-10.2
Title: List Filtering

##Problem Domain
Create a function that takes a list of non-negative integers and strings and returns a new list with the strings filtered out.

##Link
https://www.codewars.com/kata/list-filtering/train/javascript

gha_language: JavaScript


text:
---
layout: post
title: after us, the flood | DEMO (2020)
---
_A 2D PC narrative game with rhythm mechanics made in Unity._

<< Return to My Games Page

[About](#about-after-us-the-flood)	|	[Gallery](#project-gallery)	|	[My Role](#my-role-on-the-project)	|	[What I Learned](#what-i-learned)	|

### **About _after us, the flood_**

_after us, the flood_ is a narrative game with rhythm mechanics that explores themes of stagnation.

You wake up as Piper, an amnesiac with a knack for music. Together with the overly friendly Fidel, a resident of the strange yet nostalgic town you've found yourself in, romp around in a dilapidated mall and learn more about a place, and people, who've chosen to be frozen in time.

**Please check out the game [here](https://autf.itch.io/afterus-demo)!**

### **Project Gallery**

Below is a collection of images and GIFs from the Rhythm Game. Please look here for technical documentation and code of the Rhythm Game manager!

![_after us, the flood_ - Rhythm Game](/assets/artwork/MyGames/afterus,theflood/after us, the flood_rhythmGame.png)
![_after us, the flood_ - Overworld](/assets/artwork/MyGames/afterus,theflood/after us, the flood_overworld1.png)

### **My Role on the Project**

As part of the Game Design BFA, all graduating seniors are required to complete a capstone project. I joined the team halfway through the project as a VFX artist but also ended up working heavily as a programmer, game designer and generally worked wherever I was needed.

As a VFX artist, I designed various visual effects such as dissolving and ripple effects seen in the rhythm game. As a programmer, I borrowed some of the logic from the previous programmer's implementation and redeveloped it from a physics-based system to a time-based system. I also ended up playtesting the game a lot, as well as giving it to others to play, to balance it. Initially, the rhythm game felt difficult in a way that felt out of the player's control. Through observations from my own play and other playtesters, as well as studying some existing rhythm games, I implemented a few new features into the design which ultimately maintained the sense of difficulty but made it feel within the player's control.

### **What I Learned**

This project came with many challenges, both technical and social.

When I was brought on to _after us, the flood_, the previous programmer had just left the project and both of the other people on the development team were 2D artists. The team initially only needed a VFX artist, but after realising that the rhythm game needed to be re-engineered, I stepped up as a programmer to handle this task. This came with many challenges and I learned a great deal about programming, including how to use state machines and singletons in Unity, and how to read and debug other people's code.

Additionally, I learned a lot about working in team environments and with people I was not familiar with. Prior to joining the team, I had not met either of the two artists or the previous programmer. Although daunting, it was also highly beneficial in developing communication skills.

This project was put under extra pressure due to the COVID-19 pandemic, and being compassionate towards both myself and my teammates became ever more important (not to say that it isn't already!). The team, knowing that the virus threw a wrench into our plans and would cause issues in production, made extreme efforts to continue meeting at the normal work times, getting on calls (even if they were completely silent as we all clattered away at our keyboards) and making sure to communicate the schedules and production goals extra clearly.

license: Unlicense

path: /_posts/MyGames/2020-05-18-after us, the flood.md

filename: 2020-05-18-after us, the flood.md


text:
# quarkus-qute

Demo of using Quarkus with server-side templates via its Qute extension and Hotwire for client-side enhancements.

If you want to learn more about Quarkus, please visit its website: https://quarkus.io/.

## Database set-up

This project uses Postgres which can be started via Docker Compose:

```shell
cd compose
docker-compose up
```

A database "tododb", a user and schema are all configured automatically, so no further setup is needed.
If the database doesn't show up in PGAdmin,
the definition can be imported like this:

```shell
docker exec -it pgadmin_container python setup.py --load-servers /pgadmin4/servers.json --user<EMAIL_ADDRESS>```

To browse the database, go to http://localhost:5050/browser/ and log in with user name<EMAIL_ADDRESS>and password "admin".
To connect to the "tododb" database, use "todopw" as password when requested.

## Hotwire

This project uses [Hotwire](https://hotwire.dev/) for a smoother user experience:
links and form submissions will be intercepted and executed as AJAX requests,
avoiding a full page reload by replacing page fragments.

If JavaScript is disabled, the application gracefully falls back to the regular mode and experience of server-side rendered applications.

## Running the application in dev mode

You can run your application in dev mode that enables live coding using:
```
./mvnw quarkus:dev
```

Then open the application in your browser at http://localhost:8080/todo.

## Packaging and running the application

The application is packageable using `./mvnw package`.
It produces the executable `quarkus-qute-1.0.0-SNAPSHOT-runner.jar` file in `/target` directory.
Be aware that it’s not an _über-jar_ as the dependencies are copied into the `target/lib` directory.

The application is now runnable using `java -jar target/quarkus-qute-1.0.0-SNAPSHOT-runner.jar`.

## Creating a native executable

You can create a native executable using: `./mvnw package -Pnative`.

Or you can use Docker to build the native executable using: `./mvnw package -Pnative -Dquarkus.native.container-build=true`.

You can then execute your binary: `./target/quarkus-qute-1.0.0-SNAPSHOT-runner`

If you want to learn more about building native executables, please consult https://quarkus.io/guides/building-native-image-guide .

## Running the native executable via Docker

```
docker build -f src/main/docker/Dockerfile.native -t quarkus-examples/quarkus-qute .
docker run -i --rm -p 8080:8080 --network todo-network -e QUARKUS_DATASOURCE_URL=jdbc:postgresql://todo-db:5432/tododb quarkus-examples/quarkus-qute
```

## License

This code base is available ander the Apache License, version 2.

repository: gunnarmorling/quarkus-qute

repo_name: gunnarmorling/quarkus-qute


text:
Marklogic chat demo
==

Overview
--

A chat demo built on Marklogic. Show cases a number of features including the ml-uservices library, end-to-end TypeScript, and full bidirectional support of
data.

Usage
--

Run:
```
gulp create-database
```

then:
```
gulp ml-deploy
```

then:
```
gulp client-deploy
```

then visit [localhost:8080](http://localhost:8080)

repository: christyharagan/ml-chat-demo

repo_name: christyharagan/ml-chat-demo


text:
---
title: "Formal Languages and Automata"
collection: teaching
type: "Undergraduate course"
permalink: /teaching/2023-summer-teaching-1
venue: "University of Potsdam"
date: 2023-04-17
location: "Potsdam, Germany"
---

This course covers topics such as: learn about automata, understand Chomsky-hiearchy, Pumping Lemma, Turing Machines.

[Course webpage](https://web.archive.org/web/20230414125628/https://puls.uni-potsdam.de/qisserver/rds?state=verpublish&status=init&vmfile=no&publishid=99269&moduleCall=webInfo&publishConfFile=webInfo&publishSubDir=veranstaltung)

[Computational Linguistics, Bachelor's programme](https://www.uni-potsdam.de/de/studium/studienangebot/bachelor/ein-fach-bachelor/computerlinguistik)


text:
## Basic function set ##

```git clone [url] [dir]``` This is what you use to retireve a remote repoistory for the first time.  It will clone in to the working directory if you do not provide it with a relative or absolute directory path.

![MgaV9.png](2037853081-MgaV9.png)

```git checkout ``` If you are used to working with SVN or Perforce this may be the hardest one to get used to. Checkout it gitland is used to move bettwene branches in the local repository, it has nothing to do with interactions with the rempote (sever)

``` git pull ``` reaches out to the remote and pulls the latest version down, will trigger a merge if there are conflicts

``` git status``` Returns status of which files have been modified (worksapace vs index).

Move files into the index also called 'staged for commit'

``` git add [filename]```  stages a specific file for commit to the local repository
``` git add -A```  stages all files that are different from the HEAD for commit to the local repository
``` git add .```  stages all files that are in lower level folders for commit to the local repository

When you are ready to create a checkpoint. This only commits the code to a place in the local repository. The remote remains unchanged.

``` git commit``` prompts you to write a commit message and commits your staged changes to the local repository
``` git commit -m "Commit Message here"``` sets your given commit message and commits your staged changes to the local repository

After committing locally you can keep working and making more commits or you can push to the remote.

Pushing to remote.

```git push``` pushes the local changes to the remote repository if nothing has changes on the remote it should just go up


text:
<!-- toc -->
## j.clients.ssh

- /opt/jumpscale8/lib/JumpScale/clients/ssh/SSHClient.py
- Properties
    - logger
    - cache

### Methods

#### close()

#### get(*addr='', port=22, login='root', passwd, stdout=True, forward_agent=True, allow_agent=True, look_for_keys=True, timeout=5, key_filename, passphrase, die=True, usecache=True*)

```
gets an ssh client.
@param addr: the server to connect to
@param port: port to connect to
@param login: the username to authenticate as
@param passwd: leave empty if logging in with sshkey
@param stdout: show output
@param foward_agent: fowrward all keys to new connection
@param allow_agent: set to False to disable connecting to the SSH agent
@param look_for_keys: set to False to disable searching for discoverable private key files
    in ~/.ssh/
@param timeout: an optional timeout (in seconds) for the TCP connect
@param key_filename: the filename to try for authentication
@param passphrase: a password to use for unlocking a private key
@param die: die on error
@param usecache: use cached client. False to get a new connection

If password is passed, sshclient will try to authenticated with login/passwd.
If key_filename is passed, it will override look_for_keys and allow_agent and try to
    connect with this key.

```

#### getSSHKeyFromAgentPub(*keyname='', die=True*)

#### removeFromCache(*client*)

#### reset()


text:
# Reboot RDS

Reboots the **RDS** instance identified by operand *InstanceId*.

## Input

#### InstanceId
  * Identifies the *RDS* instance subject to action
  * Type: String
  * Required: True

## Output
The automation execution has no outputs.

repository: samhays/aws-systems-manager

gha_language: Python

gha_license_id: NOASSERTION

repo_name: samhays/aws-systems-manager


text:
# Aster trinervius subsp. ageratoides (Turcz.) Grierson SUBSPECIES

#### Status
SYNONYM

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

#### Published in
Notes Roy. Bot. Gard. Edinburgh 26:102. 1964

#### Original name
null

### Remarks
null

repository: mdoering/backbone

path: /life/Plantae/Magnoliophyta/Magnoliopsida/Asterales/Asteraceae/Aster/Aster ageratoides/ Syn. Aster trinervius ageratoides/README.md

repo_name: mdoering/backbone


text:
16.2: Typeahead Item template example
=====================================
**Primary Actor**: User

**Scope**: Ngx-bootstrap DEMO / BS version 3&4

**Goal**: Show user Item template functionality

Main success scenario:
----------------------
1. User opens Typeahead demo page
2. User click on Item template sub-menu
3. User sees typeahead input and typeahead card with "Model:" text
4. User starts typing if there are any matches then a drop-down with a list of States matches is shown. The list contains a template "This is: "_matched state_" index: _index #"_
5. When user clicks on any item in typeahead drop-down, then typeahead container auto-fills with a selected State

Extensions:
-----------
4a. Typing a part of the template "This is:" or "Index" does not call the drop-down

Variations:
-----------
2*. User scrolls to Item template sub-menu

repository: valor-software/ngx-bootstrap

branch_name: refs/heads/development

gha_language: TypeScript

repo_name: valor-software/ngx-bootstrap


text:
# Tutorial 04 - Fragments

Welcome to the 4th exercise in the **React Native Exponent Track** of this Apollo Client Tutorial!

## Goal

The **goal** of this exercise is to add some information to the pokemon detail view about the pokemon's trainer.

We will use fragments and learn how they can be used to define data requirements that are co-located with the component requiring that data.

## Introduction

Change to the 4th exercise, install the dependencies and run the Exponent XDE

```sh
cd pokedex-react-native/exercise-04-initial
yarn add graphql-anywhere # or npm install --save graphql-anywhere
yarn install # or npm install
```

## Adding information to the pokemon page

Before we add additional content to our components, let's take a step back.
Right now, the `PokemonsListScreen` render a `PokemonsList` components that defines a `TrainerQuery`.
This query fetches the pokemon needed to render the `PokemonListItem` component.
This results in a few disadvantages when we want to make changes later:

* if the data requirements of the `PokemonListItem` component change, we have to go back to the `PokemonsList` and
add additional fields to the `TrainerQuery`
* if we want to include `PokemonListItem` in a another component, we will have to duplicate the `TrainerQuery`,
resulting in possible errors when we have to change the query later and forget to update all places it's defined

Therefore it would be great to let the `PokemonListItem` component handle the declaration of its own data requirements.
Then we could refer to this in the `PokemonsList` component to make sure that we included all required data in the
`PokemonQuery`.

This is exactly the way fragments work.

### Defining a pokemon fragment in `PokemonListItem`

To help you get started using fragments, we implemented them already in `PokemonListItem`.
There, we make use of the package `graphql-tag` to define the `PokemonCardPokemon`
fragment in `src/components/PokemonCard.js` just before defining the `propTypes`:

```js
export class PokemonListItem extends React.Component {
  static fragments = {
    pokemon: gql`
      fragment PokemonListItemPokemon on Pokemon {
        id
        url
        name
      }
    `
  }
  //....
}
```

The fragment is name `PokemonListItemPokemon`, because it is defined on the `PokemonListItem` component and is a
fragment for a `Pokemon`.

Using this naming convention consistently can be helpful when using the fragment elsewhere.

We also replaced the `pokemon` prop declaration in the `propTypes` object by using the new fragment and
the `propType` function from `graphql-anywhere`:

```js
PokemonListItem.propTypes = {
  pokemon: propType(PokemonListItem.fragments.pokemon).isRequired,
}
```

If the incoming `pokemon` prop is missing or doesn't have a field that is included in the fragment,
we will see a React Native yellow warning box when using the component.

### Using the PokemonCardPokemon fragment in `PokedexPage`

We updated our `TrainerQuery` with the new `PokemonListItemPokemon` fragment:

```js
const TrainerQuery = gql`
  query {
    Trainer(name: "Tycho") {
      name
      ownedPokemons {
        ...PokemonListItemPokemon
      }
    }
  }
  ${PokemonListItem.fragments.pokemon}
`
```

Note that we select the fragment in the query using the `...` syntax, and that we additionally include the fragment
after the query with `${PokemonListItem.fragments.pokemon}`.

We can see that the `PokemonsList` component doesn't need to know anything about the `PokemonListItem` fragment,
other than the fact that it is a fragment on the Pokemon type.

In the same way, go ahead and replace the Trainer 's id and name field by a fragment in the `Title` component.

### Filtering objects with fragments

Right now we are passing the whole `trainer` and for each owned pokemons, the whole `pokemon` object to the `Title` component.

But `Title` does not need the `name` and `url` fields of `ownedPokemons`.

A nice thing we can add is the filtering of the `pokemon` object when passing it as a prop by using the `filter`
method on the trainer . First, we need to include the `filter` method from `graphql-anywhere`:

Then we can filter on the following fragments that you should define on the `Title` component

```js
  static fragments = {
    trainer: gql`
      fragment TitleTrainer on Trainer {
        id
        name
        ownedPokemons {
          id
        }
      }
    `
  }
```

```js
import { filter } from 'graphql-anywhere'
```

Then we can use it when passing the `trainer` as a prop:

```js
  _renderHeader = (trainer) => (
    <Title
      trainer={filter(Title.fragments.trainer, this.props.data.Trainer)}
    />
  );
```

This will make sure that only the required fields of the `pokemon` object get passed to `Title` component.
If we need additional fields later, for example in `PokemonCard`, we just have to add them in the fragment defined
in `PokemonCard`.

Check if you got everthing right by opening the XDE and navigating to the detailed view of a pokemon.

We learned a lot about fragments, let's do a quick recap:

* **Co-located fragments** help to decouple the declaration of data requirements
* The fragments of the child components can be used to **filter passed props** to only include the required
fields of the child component

repository: xpepermint/learnapollo

repo_name: xpepermint/learnapollo


text:
This script backs up the contents of a specified S3 bucket hosted in Amazon Web Services to a local directory.

**Pre-requisites:**

The script assumes that the AWS CLI tool has been installed and configured with the following:

* AWS access key
* AWS secret key
* Correct AWS region for the S3 bucket

The script performs the following actions:

1. If necessary, creates a log file named dp_sync.log and stores it in /var/log/
2. If necessary, creates the local directory to store the files downloaded from the cloud distribution point.
3. Performs a one-way synchronization of the cloud distribution point with the local directory.
4. Sets all downloaded files to be world-readable
5. Logs all actions to /var/log/dp_sync.log


text:
---
layout: post
category : pages
tags : [Java, JBoss, Wildfly, Security]
disqusid : pbkdf2_1.1.0
---

This article gives a short overview over the newest features of the PBKDF2 implementation from Matthias Gaertner. If you don't know what it is and
what it does no problem. You can read here more about it http://www.rapidpm.org/2014/02/03/one-way-to-deadlock-a-jboss-as-7.html

What is new and noteworthy?
===========================
* Fixed warnings on Wildfly 8 due to old picketbox dependency
* Uploaded to Maven Central
* Usage of CI with Travis CI
* Added more Tests
* Added sample web application for Wildfly 8 Integration
* Added more documentation

One of the major improvements of this release is the internal refactoring from direct dependencies to gradle so that there is now a much better dependency
management possible (e.g. Older versions, for example 1.0.5, had problems with newer picketbox versions of Wildfly 8 which lead to log warnings and were not convincing).
On top of that it was now possible to upload the artefact to maven central:

{% highlight xml linenos%}
<dependency>
   <groupId>de.rtner</groupId>
   <artifactId>PBKDF2</artifactId>
   <version>1.1.0</version>
</dependency>
{% endhighlight%}

        Please let us know if you encounter any issues, or have any feedback on usability, at https://github.com/m9aertner/PBKDF2.

Read more about PBKDF2

http://www.rapidpm.org/2014/02/03/one-way-to-deadlock-a-jboss-as-7.html

https://github.com/m9aertner/PBKDF2

https://github.com/m9aertner/PBKDF2/blob/master/README-WildFly8.md


text:
# haskell-guessing-game
Some Haskell Guessing Games (They're terrible...)

### To run

- Download and install [Haskell](https://www.haskell.org/platform/)
- Use `runhaskell` to run each guessing game:

```bash
$ runhaskell guessing_game_1.hs
```

or

```bash
$ runhaskell guessing_game_2.hs
```

## Please Note

This is not Haskell code you'd want to learn from yet... if it ever becomes that I will remove this message.

## License

[MIT](http://www.joshfinnie.com/license.txt)

repository: joshfinnie/haskell-guessing-game

repo_name: joshfinnie/haskell-guessing-game


text:
# Draw with Me

*Draw with Me*, a collaborative drawing application with a shared canvas and a chat room.
![example pic](./app_demo.png)

## Application Features
- User can draw on a shared canvas with another user.

- User can chat in the chat room with other users.

- User can draw in different colors and sizes.

## Built With
- JavaScript
- Ruby
- Rails API utilizing Active Model Serializers
- Sqlite3 Database using ActiveRecord
- Paper.js JavaScript library
- Action Cables and WebSockets

## Back-End Repository
https://github.com/bryanteng/backend_draw_with_me

## Server-Side Install Instructions
1. Run `bundle install`
2. Run `rake db:create`
3. Run `rake db:migrate`
4. Run `rails s`

## Client-Side Install Instructions
1. Run `open index.html` in terminal

## Contributing
[Contributing Guide](./CONTRIBUTING.md)

## Authors
- **Josue Alorro**
- **Bryan Teng**

## License
[License](./LICENSE.md)


text:
---
title: Blog Week 7
layout: post
author: luke.amos
permalink: /blog-week-7/
source-id: 1hAhbdyajDnCiahPskqHzlFV42WKiLs9axrMrwWx4lRw
published: true
---

Holy Slideshow Batman!

Friday 21st November 2016

  Title:
    Blog Week 7

  Date:
    21/10/16

  Starting point:
    Just before half term, I was faced with a fairly organised spreadsheet which incorporated lots of mathematical functions. It used conditional formatting and could be used to run a small business. My website looked nice, but not excellent. Seeing as excellent is what I'm aiming for, I was somewhat happy, but not completely.

  Target for this lesson?
    To add an exciting 'featured' scrolling image bar at the top of my site and a separate page for the list of blogs. This woud add an exciting feature to my site that nobody else (to my knowledge) has. It would really show my skills with HTML and CSS. I would also add a better 'nav' element that would be sleek and also showed my skills. Regarding spreadsheets, I hoped to add multiple sheets to the spreadsheet that I would put the different elements into. This would make my spreadsheet more organised and easier to use. I would also like to add a section that calculates the amount of tax the business would have to pay.

    Did I reach my target?
    (add details to "Lesson Review")
    Definately. The 'featured' image slideshow fits in with the look of the page and is working better than I hoped it would. The nav bar also fits in nicely, although I am still trying to find the right colour for it. The spreadsheet works nicely and the tax calculation system is successfully working. I did hit a few bumps with the tax system, though, as my 'if' statements didn't always make sense. But I eventually ironed out the creases and resolved the problems.

  Lesson Review

  How did I learn? What strategies were effective?

    For the spreadsheet, I used my mathematical knowledge to take how tax worked in the real world and put it into the language of the spreadsheet. This allowed me to fix my broken 'if' statements and ultimately succeed in adding in the tax system. For the image slideshow, I looked at W3Schools for a guide about how to implement a slideshow. I then edited the CSS and HTML to tailor it for my site, such as position, colours and aspect ratio.

  What limited my learning? Which habits do I need to work on?

    I need to be able to quickly use mathematics to solve problems I have with spreadsheets, as most of the problems I encountered boiled down to simple mathematical error. I needed to just take a step back from the problem and think logically. This would have allowed me to fix the problems much quicker than I did. Also, since my Dad is an accountant, I could have asked him for help when I needed it. I did, however, solve the problem on my own, which I am proud of.

  What will I change for next time? How will I improve my learning?

    Next time I shall slow down and plan what I am going to do in my spreadsheets. This will mean the maths I use will be as simple and effective as possible, and will decrease the number of problems I have. I would also rely a little less on W3Schools for help regarding the aspects of my site, as I used them a lot to work out how to add in the image slideshow. I should have perhaps used them less, and worked out the solution myself.


text:
---
uid: 2.x-to-3.0-upgrade
---
# Upgrading to CommandLineUtils 3.0

For more technical details, see [this list of GitHub issues](https://github.com/natemcmaster/CommandLineUtils/issues?q=label%3Abreaking-change+milestone%3A3.0).

## Breaking API changes

3.0 removed API that were in the 2.x version of this library. All API that was removed should have been marked
as `[Obsolete]` in a 2.x release.

### Symptom

After updating to 3.0, code doesn't compile with errors like

> error CS1061: 'CommandLineApplication' does not contain a definition for ....something.... (are you missing a using directive or an assembly reference?)

### Resolution

If you were using 2.x before, you should have received compiler warnings like

> warning CS0618: ABC is obsolete: 'This method has been marked as obsolete and will be removed in a future version. The recommended replacement is XYZ.

Follow these recommendations to update to the new API.

## NuGet compatibility with older platforms

3.0 removed support for older .NET platforms, like .NET Standard 1.6, .NET Core 1.x, and UWP 8.0. The library still supports .NET Framework 4.5 and .NET Standard 2.0.

### Symptom

NuGet fails to install your project with an error like

> error NU1202: Package McMaster.Extensions.CommandLineUtils 3.0.0 is not compatible with netcoreapp1.1 (.NETCoreApp,Version=v1.1). Package McMaster.Extensions.CommandLineUtils 3.1.0 supports:
> error NU1202:   - net45 (.NETFramework,Version=v4.5)
> error NU1202:   - netstandard2.0 (.NETStandard,Version=v2.0)

### Resolution

Either keep using CommandLineUtils 2.x, or upgrade your application to something newer. See https://dotnet.microsoft.com/platform/dotnet-standard for a list of .NET platforms compatible with .NET Standard 2.0.

## Upgrading McMaster.Extensions.Hosting.CommandLine

In order to fix [#294], McMaster.Extensions.Hosting.CommandLine 3.0's dependency on Microsoft.Extensions.Hosting
was lowered to a dependency on Microsoft.Extensions.Hosting.**Abstractions**. In some cases, this could
cause your app to fail to compile when you upgrade with errors.

[#294]: https://github.com/natemcmaster/CommandLineUtils/issues/294

### Symptom

After upgrading to 3.0, your app fails to compile with

> error CS0246: The type or namespace name 'HostBuilder' could not be found"

### Resolution

Add a dependency on [Microsoft.Extensions.Hosting](https://nuget.org/packages/Microsoft.Extensions.Hosting)

repository: natemcmaster/CommandLineUtils

gha_language: C#

repo_name: natemcmaster/CommandLineUtils


text:
---
layout: post
title: House prices - part one
modified: null
categories: articles
excerpt: null
tags:
  - kaggle
  - house prices
  - data cleaning
  - R
image:
  feature: houses.jpeg
  thumb: houses-thumb.jpeg
  credit: Palo Cech
  credit-link: 'https://www.pexels.com/u/palocech/'
date: 2017-04-17T00:00:00.000Z
share: true
published: true
---

In the following few posts I will be doing simple exploratory data analysis of the [Ames Housing dataset](https://ww2.amstat.org/publications/jse/v19n3/decock.pdf) used in the Kaggle competition [House Prices: Advanced Regression Techniques](https://www.kaggle.com/c/house-prices-advanced-regression-techniques). In later posts, I will go on to run statistical models on the data. This is my first blog post here so it's also an exercise in creating blog posts!

The problem is to try to correctly predict the house prices in the test dataset by training a regression model on the training data.

I will soon do an exploratory data analysis of the data, however to begin with, the data should be cleaned. In particular, the empty values should be filled in.

 We bin the ID column straight away as it's not needed.

``` r
full <-
  train %>% select(-Id, -SalePrice) %>%
  bind_rows(test %>% select(-Id))
```

Data cleaning
-------------

We look for missing values and try to fill these in

``` r
full %>%
  select(which(sapply(full, function(x)any(is.na(x))))) %>%
  sapply(function(x)sum(ifelse(is.na(x), 1, 0))) %>%
  sort(decreasing=T)
```

    ##       PoolQC  MiscFeature        Alley        Fence  FireplaceQu
    ##         2909         2814         2721         2348         1420
    ##  LotFrontage  GarageYrBlt GarageFinish   GarageQual   GarageCond
    ##          486          159          159          159          159
    ##   GarageType     BsmtCond BsmtExposure     BsmtQual BsmtFinType2
    ##          157           82           82           81           80
    ## BsmtFinType1   MasVnrType   MasVnrArea     MSZoning    Utilities
    ##           79           24           23            4            2
    ## BsmtFullBath BsmtHalfBath   Functional  Exterior1st  Exterior2nd
    ##            2            2            2            1            1
    ##   BsmtFinSF1   BsmtFinSF2    BsmtUnfSF  TotalBsmtSF   Electrical
    ##            1            1            1            1            1
    ##  KitchenQual   GarageCars   GarageArea     SaleType
    ##            1            1            1            1

### PoolQC missing values

``` r
full %>%
  select(PoolQC) %>%
  group_by(PoolQC) %>%
  summarise(Count = n())
```

    ## # A tibble: 4 x 2
    ##   PoolQC Count
    ##    <chr> <int>
    ## 1     Ex     4
    ## 2     Fa     2
    ## 3     Gd     4
    ## 4   <NA>  2909

What to fill in the NA's with? We will go for a default missing value. The data dictionary says that 'NA' means "no pool" so we'll go with that.

``` r
full <-
  full %>%
  mutate(PoolQC = ifelse(is.na(PoolQC), 'None', PoolQC))
```

What is the situation with PoolArea?

``` r
full %>% filter(PoolQC == 'None', PoolArea > 0) %>% select(PoolArea)
```

    ##   PoolArea
    ## 1      368
    ## 2      444
    ## 3      561

There are 3 instances of Pools with non-zero area but "don't exist". To fix this let's look at the relationship between PoolQC and PoolArea

``` r
full %>%
  filter(PoolQC != 'None') %>%
  ggplot(aes(x=factor(PoolQC), y=PoolArea)) +
  geom_boxplot(fill='cornflowerblue')
```

![](house_prices_part_1_files/figure-markdown_github/poolqc-poolarea-1.png)

### MiscFeature missing values

Next on the list is MiscFeature. The data dictionary describes this as "Miscellaneous feature not covered in other categories". Lets do a count of each value:

``` r
full %>%
  group_by(MiscFeature) %>%
  summarise(Count = n())
```

    ## # A tibble: 5 x 2
    ##   MiscFeature Count
    ##         <chr> <int>
    ## 1        Gar2     5
    ## 2        Othr     4
    ## 3        Shed    95
    ## 4        TenC     1
    ## 5        <NA>  2814

I think we're good to go ahead and fill in the missing values of MiscFeature with 'None'.

``` r
full <-
  full %>%
  mutate(MiscFeature = ifelse(is.na(MiscFeature), 'None', MiscFeature))
```

### MiscFeature Second Garages

Value of Gar2 means there is a second Garage. Let's check whether this is accurately represented in the data

``` r
full  %>%
  filter(MiscFeature == 'Gar2')%>%
  select(GarageType, GarageYrBlt, GarageFinish, GarageCars, GarageArea, GarageQual, GarageCond)
```

    ##   GarageType GarageYrBlt GarageFinish GarageCars GarageArea GarageQual
    ## 1     Attchd        1960          RFn          1        301         TA
    ## 2    BuiltIn        1977          RFn          2        600         TA
    ## 3     Attchd        1958          Unf          1        312         TA
    ## 4     Attchd        1953          RFn          1        286         TA
    ## 5     Detchd        2002          Unf          2        624         TA
    ##   GarageCond
    ## 1         TA
    ## 2         TA
    ## 3         TA
    ## 4         TA
    ## 5         TA

Good, so there's no existence of 2nd garages without a first. However I wonder if there are garages with more Cars in them without room for them.

``` r
full %>% ggplot(aes(x = GarageArea, y=GarageCars)) + geom_point(colour = 'cornflowerblue')
```

    ## Warning: Removed 1 rows containing missing values (geom_point).

![](house_prices_part_1_files/figure-markdown_github/cars-garage-1.png)

This looks to be behaving well. There dont seem to be any outliers towards the left and top of the graph.

### FireplaceQu missing values

We use the Fireplaces column to fix the FireplaceQu missing values

``` r
full %>%
  filter(is.na(FireplaceQu), Fireplaces > 0) %>%
  select(Fireplaces, FireplaceQu)
```

    ## [1] Fireplaces  FireplaceQu
    ## <0 rows> (or 0-length row.names)

Hence, we assign all blank FireplaceQu to 'None'.

``` r
full <-
  full %>%
  mutate(FireplaceQu = ifelse(is.na(FireplaceQu), 'None', FireplaceQu))
```

### LotFrontage missing values

Does lack of a value mean 0 feet as lot frontage?

``` r
full %>%
  filter(is.na(LotFrontage) | LotFrontage == 0) %>%
  summarise(Count = n())
```

    ##   Count
    ## 1   486

Since there are only NA's and no 0's then let's assume so

``` r
full <-
  full %>%
  mutate(LotFrontage = ifelse(is.na(LotFrontage), 0, LotFrontage))
```

### Garages

``` r
full %>%
  filter(is.na(GarageType) |
           is.na(GarageYrBlt) |
           is.na(GarageFinish) |
           is.na(GarageCars) |
           is.na(GarageArea) |
           is.na(GarageQual) |
           is.na(GarageCond)) %>%
  group_by(GarageType, GarageYrBlt, GarageFinish, GarageCars,
           GarageArea, GarageQual, GarageCond) %>%
  summarise(Count = n()) %>%
  knitr::kable()
```

| GarageType |  GarageYrBlt| GarageFinish |  GarageCars|  GarageArea| GarageQual | GarageCond |  Count|
|:-----------|------------:|:-------------|-----------:|-----------:|:-----------|:-----------|------:|
| Detchd     |           NA| NA           |           1|         360| NA         | NA         |      1|
| Detchd     |           NA| NA           |          NA|          NA| NA         | NA         |      1|
| NA         |           NA| NA           |           0|           0| NA         | NA         |    157|

So we have 2 cases of Detached garages, 1 with entries for GarageCars and GarageArea, and another for no other Garage entries. We also have 157 cases where there are no entries for anything, so this looks like no garage.

We'll fill in the "no garages" first. For the year we will use the YearBuilt

``` r
full <-
  full %>%
  transform(GarageType = ifelse(is.na(GarageType), 'None', GarageType),
            GarageYrBlt = ifelse(is.na(GarageYrBlt), YearBuilt, GarageYrBlt),
            GarageFinish = ifelse(is.na(GarageFinish), 'None', GarageFinish),
            GarageCars = ifelse(is.na(GarageCars), 'None', 0),
            GarageArea = ifelse(is.na(GarageArea), 'None', 0),
            GarageQual = ifelse(is.na(GarageQual), 'None', GarageQual),
            GarageCond = ifelse(is.na(GarageCond), 'None', GarageCond))
```

### Basements cleaning

Next up, the basement. Let's see where the null values occur

``` r
full %>%
  filter(is.na(BsmtQual) |
           is.na(BsmtCond) |
           is.na(BsmtExposure) |
           is.na(BsmtFinType1) |
           is.na(BsmtFinSF1) |
           is.na(BsmtFinType2) |
           is.na(BsmtFinSF2) |
           is.na(BsmtUnfSF) |
           is.na(BsmtFullBath) |
           is.na(BsmtHalfBath) |
           is.na(TotalBsmtSF)) %>%
  group_by(BsmtQual, BsmtCond, BsmtExposure, BsmtFinType1, BsmtFinSF1,
           BsmtFinType2, BsmtFinSF2, BsmtUnfSF, BsmtFullBath, BsmtHalfBath,
           TotalBsmtSF) %>%
  summarise(Count = n()) %>%
  knitr::kable()
```

| BsmtQual | BsmtCond | BsmtExposure | BsmtFinType1 |  BsmtFinSF1| BsmtFinType2 |  BsmtFinSF2|  BsmtUnfSF|  BsmtFullBath|  BsmtHalfBath|  TotalBsmtSF|  Count|
|:---------|:---------|:-------------|:-------------|-----------:|:-------------|-----------:|----------:|-------------:|-------------:|------------:|------:|
| Gd       | TA       | No           | GLQ          |        1124| NA           |         479|       1603|             1|             0|         3206|      1|
| Gd       | TA       | NA           | Unf          |           0| Unf          |           0|        725|             0|             0|          725|      1|
| Gd       | TA       | NA           | Unf          |           0| Unf          |           0|        936|             0|             0|          936|      1|
| Gd       | TA       | NA           | Unf          |           0| Unf          |           0|       1595|             0|             0|         1595|      1|
| Gd       | NA       | Mn           | GLQ          |        1044| Rec          |         382|          0|             1|             0|         1426|      1|
| TA       | NA       | Av           | ALQ          |         755| Unf          |           0|        240|             0|             0|          995|      1|
| TA       | NA       | No           | BLQ          |        1033| Unf          |           0|         94|             0|             1|         1127|      1|
| NA       | Fa       | No           | Unf          |           0| Unf          |           0|        173|             0|             0|          173|      1|
| NA       | TA       | No           | Unf          |           0| Unf          |           0|        356|             0|             0|          356|      1|
| NA       | NA       | NA           | NA           |           0| NA           |           0|          0|             0|             0|            0|     77|
| NA       | NA       | NA           | NA           |           0| NA           |           0|          0|            NA|            NA|            0|      1|
| NA       | NA       | NA           | NA           |          NA| NA           |          NA|         NA|            NA|            NA|           NA|      1|

From the above we see:

-   2 cases of No Basement (BsmtQual) where BsmtCond is not No Basement - takes values of Fair/Typical
-   These cases occur when the BsmtFinType1 is Unfinished. Square footage is positive here.
-   5 cases BsmtFinType2 = BsmtFinType1 which shouldn't happen unless both are NA. Does this happen elsewhere?
-   Check that BsmtFinSF1 + BsmtFinSF2 + BsmtUnfSF = TotalBsmtSF

First, let's check for cases of BsmtFinType2 = BsmtFinType1 and check that total SF is correct

``` r
full %>%
  filter(BsmtFinType2 == BsmtFinType1) %>%
  group_by(BsmtFinType1, BsmtFinType2) %>%
  summarise(BsmtFinSF1 = sum(BsmtFinSF1),
            BsmtFinSF2 = sum(BsmtFinSF2),
            BsmtUnfSF = sum(BsmtUnfSF),
            TotalBsmtSF = sum(TotalBsmtSF),
            ChkTotal = sum(BsmtFinSF1) + sum(BsmtFinSF2) + sum(BsmtUnfSF)) %>%
  knitr::kable()
```

| BsmtFinType1 | BsmtFinType2 |  BsmtFinSF1|  BsmtFinSF2|  BsmtUnfSF|  TotalBsmtSF|  ChkTotal|
|:-------------|:-------------|-----------:|-----------:|----------:|------------:|---------:|
| BLQ          | BLQ          |         543|         119|        261|          923|       923|
| Unf          | Unf          |           0|           0|     826432|       826432|    826432|

The check passed, so let's set BsmtFinType2 to NA, BsmtFinSF1 to BsmtFinSF1 + BsmtFinSF2, and BsmtFinSF2 to 0.

``` r
full <-
  full %>%
  transform(BsmtFinType2 = ifelse(BsmtFinType2 == BsmtFinType1, NA, BsmtFinType2),
            BsmtFinSF1 = ifelse(BsmtFinType2 == BsmtFinType1, BsmtFinSF1 + BsmtFinSF2, BsmtFinSF1),
            BsmtFinSF2 = ifelse(BsmtFinType2 == BsmtFinType1, 0, BsmtFinSF2))
```

Let's check across the dataset that the total basement SF is correct:

``` r
full %>%
  filter(TotalBsmtSF != BsmtFinSF1 + BsmtFinSF2 + BsmtUnfSF) %>%
  summarise(Count = n())
```

    ##   Count
    ## 1     0

All good then. Let's perform the updates:

-   Rows 2-4 BsmtExposure indicate No Basement, however this should be No Exposure
-   One row of 77 cases of completely null values - let's fill these with the default null values
-   Rows 8,9 fill in BsmtQual with 'TA'
-   Rows 2-4 BsmtFinType2 set to NA, then convert all NA's to 'None'
-   NA's in BsmtFinSF1, BsmtFinSF2, BsmtUnfSF, TotalBsmtSF, BsmtFullBath, BsmtHalfBath should be 0
-   NA's in BsmtQual, BsmtCond, BsmtExposure, BsmtFinType1, BsmtFinType2 should be 'None'

``` r
full <-
  full %>%
  mutate(BsmtExposure = ifelse(is.na(BsmtExposure) & BsmtQual == 'Gd', 'No', BsmtExposure),
         BsmtFinType2 = ifelse(is.na(BsmtExposure) & BsmtQual == 'Gd', NA, BsmtFinType2),

         BsmtFinSF1 = ifelse(is.na(BsmtFinSF1), 0, BsmtFinSF1),
         BsmtFinSF2 = ifelse(is.na(BsmtFinSF2), 0, BsmtFinSF2),
         BsmtUnfSF = ifelse(is.na(BsmtUnfSF), 0, BsmtUnfSF),
         TotalBsmtSF = ifelse(is.na(TotalBsmtSF), 0, TotalBsmtSF),
         BsmtFullBath = ifelse(is.na(BsmtFullBath), 0, BsmtFullBath),
         BsmtHalfBath = ifelse(is.na(BsmtHalfBath), 0, BsmtHalfBath),

         BsmtQual = ifelse(is.na(BsmtQual), 'None', BsmtQual),
         BsmtCond = ifelse(is.na(BsmtCond), 'None', BsmtCond),
         BsmtExposure = ifelse(is.na(BsmtExposure), 'None', BsmtExposure),
         BsmtFinType1 = ifelse(is.na(BsmtFinType1), 'None', BsmtFinType1),
         BsmtFinType2 = ifelse(is.na(BsmtFinType2), 'None', BsmtFinType2))
```

Now what's left to fill in?

``` r
full %>%
  select(which(sapply(full, function(x)any(is.na(x))))) %>%
  sapply(function(x)sum(ifelse(is.na(x), 1, 0))) %>%
  sort(decreasing=T)
```

    ##       Alley       Fence  MasVnrType  MasVnrArea    MSZoning   Utilities
    ##        2721        2348          24          23           4           2
    ##  Functional Exterior1st Exterior2nd  Electrical KitchenQual    SaleType
    ##           2           1           1           1           1           1

### Alley and fence

``` r
full %>%
  group_by(Alley, Fence) %>%
  summarise(Count = n()) %>%
  knitr::kable()
```

| Alley | Fence |  Count|
|:------|:------|------:|
| Grvl  | GdPrv |      5|
| Grvl  | GdWo  |      4|
| Grvl  | MnPrv |     19|
| Grvl  | MnWw  |      1|
| Grvl  | NA    |     91|
| Pave  | GdPrv |      3|
| Pave  | GdWo  |      1|
| Pave  | MnPrv |      2|
| Pave  | NA    |     72|
| NA    | GdPrv |    110|
| NA    | GdWo  |    107|
| NA    | MnPrv |    308|
| NA    | MnWw  |     11|
| NA    | NA    |   2185|

NA means 'no alley access' or 'no fence' so let's fill that with 'None'

``` r
full <-
  full %>%
  mutate(Alley = ifelse(is.na(Alley), 'None', Alley),
         Fence = ifelse(is.na(Fence), 'None', Fence))
```

### Mason veneer

``` r
full %>%
  group_by(MasVnrType, ifelse(is.na(MasVnrArea), 0, 1)) %>%
  summarise(Count = n()) %>%
  knitr::kable()
```

| MasVnrType |  ifelse(is.na(MasVnrArea), 0, 1)|  Count|
|:-----------|--------------------------------:|------:|
| BrkCmn     |                                1|     25|
| BrkFace    |                                1|    879|
| None       |                                1|   1742|
| Stone      |                                1|    249|
| NA         |                                0|     23|
| NA         |                                1|      1|

Fill this in:

``` r
full <-
  full %>%
  mutate(MasVnrType = ifelse(is.na(MasVnrType), 'None', MasVnrType),
         MasVnrArea = ifelse(is.na(MasVnrArea), 0, MasVnrArea))
```

### MSZoning

Getting the distribution of MSZoning, we see there are 4 NA's here:

``` r
full %>%
  group_by(MSZoning) %>%
  summarise(Count = n()) %>%
  knitr::kable()
```

| MSZoning |  Count|
|:---------|------:|
| C (all)  |     25|
| FV       |    139|
| RH       |     26|
| RL       |   2265|
| RM       |    460|
| NA       |      4|

Now, let's see what the most common value of MSZoning is per MSSubClass, and select only the MSSubClass where MSZoning is NA.

``` r
Mode <- function(x) {
  ux <- unique(x)
  ux[which.max(tabulate(match(x, ux)))]
}

full %>%
  group_by(MSSubClass) %>%
  summarise(AvgZoning = Mode(MSZoning)) %>%
  inner_join(
    full %>%
      filter(is.na(MSZoning)) %>%
      distinct(),
    by = "MSSubClass"
  ) %>%
  select(MSSubClass, AvgZoning) %>%
  distinct()
```

    ## # A tibble: 3 x 2
    ##   MSSubClass AvgZoning
    ##        <int>     <chr>
    ## 1         20        RL
    ## 2         30        RM
    ## 3         70        RM

Let's update the values with this:

``` r
full <-
  full %>%
  mutate(MSZoning = ifelse(is.na(MSZoning), ifelse(MSSubClass == 20, 'RL', 'RM'), MSZoning))
```

Utilities Functional Exterior1st Exterior2nd Electrical KitchenQual SaleType

### The rest

``` r
full %>%
  filter(is.na(Utilities) |
           is.na(Functional) |
           is.na(Exterior1st) |
           is.na(Exterior2nd) |
           is.na(Electrical) |
           is.na(KitchenQual) |
           is.na(SaleType)) %>%
  group_by(Utilities, Functional, Exterior1st, Exterior2nd, Electrical, KitchenQual, SaleType) %>%
  summarise(Count = n()) %>%
  knitr::kable()
```

| Utilities | Functional | Exterior1st | Exterior2nd | Electrical | KitchenQual | SaleType |  Count|
|:----------|:-----------|:------------|:------------|:-----------|:------------|:---------|------:|
| AllPub    | Mod        | Wd Sdng     | Wd Sdng     | SBrkr      | NA          | COD      |      1|
| AllPub    | Typ        | Plywood     | Plywood     | SBrkr      | TA          | NA       |      1|
| AllPub    | Typ        | VinylSd     | VinylSd     | NA         | Gd          | WD       |      1|
| AllPub    | Typ        | NA          | NA          | SBrkr      | Fa          | WD       |      1|
| AllPub    | NA         | AsbShng     | VinylSd     | FuseA      | Fa          | WD       |      1|
| AllPub    | NA         | Wd Sdng     | Wd Sdng     | SBrkr      | TA          | COD      |      1|
| NA        | Min1       | Wd Sdng     | Wd Sdng     | FuseA      | TA          | ConLD    |      1|
| NA        | Min2       | BrkFace     | BrkFace     | FuseA      | TA          | WD       |      1|

Let's fill the rest in with the most common value

``` r
full <-
  full %>%
  mutate(Utilities = ifelse(is.na(Utilities), Mode(Utilities), Utilities),
         Functional = ifelse(is.na(Functional), Mode(Functional), Functional),
         Exterior1st = ifelse(is.na(Exterior1st), Mode(Exterior1st), Exterior1st),
         Exterior2nd = ifelse(is.na(Exterior2nd), Mode(Exterior2nd), Exterior2nd),
         Electrical = ifelse(is.na(Electrical), Mode(Electrical), Electrical),
         KitchenQual = ifelse(is.na(KitchenQual), Mode(KitchenQual), KitchenQual),
         SaleType = ifelse(is.na(SaleType), Mode(SaleType), SaleType))
```

### Update the train and test data

Now that we have fixed the missing values in the train and test data, we may update the original datasets so that we are ready to begin the analysis.

``` r
t <- nrow(train)
f <- nrow(full)

SP <- train$SalePrice

train <- full[1:t,]
test <- full[t+1:f,]

train$SalePrice <- SP
```

We are now ready to do some exploratory analysis.


text:
---
title: "Size"
---

Octoplushy can be made in different sizes. The default has a head size of about 15cm, and 25cm long legs.
This is a percentage of this default length.

## Effect of this option on the pattern

![This image shows the effect of this option by superimposing several variants that have a different value for this option](octoplushy_size_sample.svg "Effect of this option on the pattern")

repository: freesewing/freesewing

branch_name: refs/heads/develop

repo_name: freesewing/freesewing


text:
**[overview](#overview) | [launching the notebooks](#launching-the-notebooks) | [running the notebooks](#running-the-notebooks) | [issues](#issues) | [contributing](#for-contributors)**

# em-apps

[![binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/geoscixyz/em-apps/master?filepath=index.ipynb)
[![azure](https://notebooks.azure.com/launch.png)](https://notebooks.azure.com/import/gh/geoscixyz/em-apps)
[![travis](https://travis-ci.org/geoscixyz/em-apps.svg?branch=master)](https://travis-ci.org/geoscixyz/em-apps)
[![SimPEG](https://img.shields.io/badge/powered%20by-SimPEG-blue.svg)](http://simpeg.xyz)

## Overview

This is a repo of notebooks and interactive examples for http://em.geosci.xyz. The examples are based on code available in
[em_examples](http://github.com/geoscixyz/em_examples). Numerical simulations are based on [SimPEG](http://simpeg.xyz).

The notebooks are available on
- [Binder](https://mybinder.org/v2/gh/geoscixyz/em-apps/master?filepath=index.ipynb)
- [Azure Notebooks](https://notebooks.azure.com/import/gh/geoscixyz/em-apps)

<img src="https://em.geosci.xyz/_images/DC_LayeredEarth_notebook.png" width=60% align="center">

## Launching the notebooks

The notebooks can be run online through [Binder](#Binder) or [Azure notebooks](#Azure), or [downloaded and run locally](#Locally).

### Binder

[![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/geoscixyz/em-apps/master?filepath=index.ipynb)

1. Launch the binder by clicking on the badge above or going to: https://mybinder.org/v2/gh/geoscixyz/em-apps/master?filepath=index.ipynb.
   This can sometimes take a couple minutes, so be patient...

2. Select the notebook of interest from the contents

3. [Run the Jupyter notebook](#Running-the-notebooks)

![Binder-steps](https://em.geosci.xyz/_images/binder-steps.png)

### Azure

[![Azure](https://notebooks.azure.com/launch.png)](https://notebooks.azure.com/import/gh/geoscixyz/em-apps)

1. Navigate to Azure notebooks by clicking on the badge above or going to: https://notebooks.azure.com/import/gh/geoscixyz/em-apps,
   and select `Import` to import the library

2. Sign in to your microsoft account (or `Create One` if you do not already have an account)

3. Create the new library: Select Import

4. Select `index.ipynb` to view the notebook contents

5. Select the notebook of interest from the contents

6. [Run the Jupyter notebook](#Running-the-notebooks)

![Azure-steps](https://em.geosci.xyz/_images/azure-steps.png)

### Locally

To run them locally, you will need to have python installed, preferably through [anaconda](https://www.anaconda.com/download/).

You can then clone this reposiroty. From a command line, run

```
git clone https://github.com/geoscixyz/em-apps.git
```

Then `cd` into `em-apps`

```
cd em-apps
```

To setup your software environment, we recommend you use the provided conda environment

```
conda env create -f environment.yml
source activate geosci-labs
```

alternatively, you can install dependencies through pypi
```
pip install -r requirements.txt
```

You can then launch Jupyter
```
jupyter notebook
```

Jupyter will then launch in your web-browser.

## Running the notebooks

Each cell of code can be run with `shift + enter` or you can run the entire notebook by selecting `cell`, `Run All` in the toolbar.

![cell-run-all](https://em.geosci.xyz/_images/run_all_cells.png)

For more information on running Jupyter notebooks, see the [Jupyter Documentation](https://jupyter.readthedocs.io/en/latest/)

## Issues

If you run into problems or bugs, please let us know by [creating an issue](https://github.com/geoscixyz/em-apps/issues/new) in this repository.

## For Contributors

### Notebook Structure

Each notebook has the following structure

- **Purpose** : Motivation and key concepts addressed by the notebook
- **Setup** : Overview of the relevant parameters in the problem
- **Questions** : Guiding questions related to the purpose
- **App** : interactive visualizations
- **Explore** : further questions that can be explored with the app

### Conventions

For colormaps (http://matplotlib.org/examples/color/colormaps_reference.html)
- **fields** are plotted with the `viridis`
- **potentials** are plotted with `viridis`
- **sensitivities** are plotted with `viridis`
- **physical properties** are plotted with `jet`
- **charges** are plotted with `RdBu`

Order of widgets:

- geometry of survey
- geomerty target
- physical properties of target
- view options

### Setting up your environment

- to develop code for these notebooks, please see https://github.com/geoscixyz/geosci-labs
- add the notebook name and path to the [index](index.ipynb)

repository: mtoqeerpk/em-apps

repo_name: mtoqeerpk/em-apps


text:
# spring-oauth2-integration-tests
A sample project that shows how to write Spring integration tests for an application using OAuth2 from Spring Security.

This project is accompanied by [this article](http://wp.me/p5qBJ9-c6)

gha_language: Java


text:
Awesome Safe Network
===============
A curated list of Maid's SAFE Network resources and tools for developers
[![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/sindresorhus/awesome)

List of content

- [APIs](#apis)
- [Applications](#applications)
- [JavaScript Libraries](#javascript-libraries)
- [Boilerplates](#boilerplates)
- [Learn](#learn)
- [Podcasts](#podcasts)

# APIs
* [Web API](http://docs.maidsafe.net/beaker-plugin-safe-app)
* [NodeJS API](http://docs.maidsafe.net/safe_app_nodejs)

# Applications

* [List of Alpha-2 apps](https://safenetforum.org/t/alpha-2-community-websites-apps-safe-messaging-ids) A forum post where users share existing apps for the Alpha-2 network.
* [Joseph’s Safe Websites Project](https://safenetforum.org/t/josephs-safe-websites-project/15244) A list of websites for the SAFE Network.
* [Oficial Examples](https://github.com/maidsafe/safe_examples) Oficial examples from Maid's dev team.
* [mind2chat](https://github.com/Mindphreaker/mind2chat) Chat app livigin at `safe://mind2chat`.
* [Wallet](https://github.com/moinhodigital/safewallet) A wallet to create and exchange tokens.
* [Safe Faucet](https://github.com/bochaco/safe-faucet)
* [Safe Altcoin Wallet](https://github.com/bochaco/safe-altcoin-wallet)
* [Todo](https://github.com/wardbr/Safe-todo-draw) A todo app implemented using VueJS for SAFE

# JavaScript Libraries
* [websafe](https://github.com/MoinhoDigital/websafe) A wrapper with common patterns for building applications with the web API

# Boilerplates
* [safe_web_starter_pack](https://github.com/hunterlester/safe_web_starter_pack) A simple starting point built with plain Javascript

# Learn
* [Safe API Overview](https://josephm1.github.io/Safe-API-Overview/) Awesome guide on MaidSafe's API
* [Introduction to the SAFE Network](https://medium.com/@luandro/introduction-to-the-safe-network-33d8641b2dee) A series of posts explaning what the SAFE project is and how to get stared developing
* [Metaquestions](https://metaquestions.me/) The blog of Maid creator David Irvine, who is always posting about technology and innerworkings of the SAFE Network
* [Nick Lambert's medium](https://medium.com/@nlambert) Part of Maid’s team, who regularly writes about the network, decentralization and economics.

# Podcasts
* [SAFE Crossroads podcasts](https://safecrossroads.net/)

Inspired by the [awesome](https://github.com/sindresorhus/awesome) list thing.

## License

[![CC0](http://i.creativecommons.org/p/zero/1.0/88x31.png)](http://creativecommons.org/publicdomain/zero/1.0/)

To the extent possible under law, [Moinho Digital](https://github.com/MoinhoDigital/) has waived all copyright and related or neighboring rights to this work.

repository: MoinhoDigital/awesome-safe-network

repo_name: MoinhoDigital/awesome-safe-network