text:
# Getting Started with Miew Development: The Beginner's Guide

Copyright (c) 2015–2020 [EPAM Systems, Inc.](https://www.epam.com/)

![Miew screenshot](https://github.com/epam/miew/raw/master/README.png)

Table of contents:

<!-- TOC depthFrom:2 depthTo:6 withLinks:1 updateOnSave:1 orderedList:0 -->

- [Project Overview](#project-overview)
	- [Web Application](#web-application)
	- [Embeddable Component](#embeddable-component)
	- [Display Modes](#display-modes)
	- [Source Data](#source-data)
- [Biochemistry](#biochemistry)
	- [Proteins](#proteins)
	- [Nucleic Acids](#nucleic-acids)
- [Development Tools](#development-tools)
	- [Git](#git)
	- [Node.js](#nodejs)
	- [JavaScript](#javascript)
	- [IDE](#ide)
- [Usage](#usage)

<!-- /TOC -->

Quick Links:

-   promo site: <https://epa.ms/miew/>
-   demo-application: <https://miew.opensource.epam.com/>
-   source code: <https://github.com/epam/miew/>

Disclaimer: this text was written in 2018 for students that likely didn't know
much about Git, JavaScript, et al. In 2023 we translated it in English as-is,
so some passages may sound archaic or outdated now. Still, it contains
a pretty good background overview and introduction to Miew development.

## Project Overview

### Web Application

Miew --- is an application that allows you to view three-dimensional images
of molecules directly in a web browser, manipulate them, analyze various
characteristics. It is primarily concerned with complex biological molecules:
[proteins][] and [nucleic acids][] (DNA, RNA). Of course, other
chemical compounds can be displayed. In the program,
it is possible to view not just individual molecules, but entire molecular
complexes/structures that consist of interacting proteins, RNA/DNA and small
molecules ([ligands][]). In this way, users can visualize how the different
parts of the molecules are arranged in space relative to each other, and what
interactions are possible between them.

> Example of a complex structure: [Nucleosome Particles in Complex with DNA-binding Ligands][].

[proteins]: https://en.wikipedia.org/wiki/Protein
[nucleic acids]: https://en.wikipedia.org/wiki/Nucleic_acid
[ligands]: https://en.wikipedia.org/wiki/Ligand_(biochemistry)
[Nucleosome Particles in Complex with DNA-binding Ligands]: https://miew.opensource.epam.com/?l=1M19&v=1Vo4FwggsB8JxfTXCR/aAPGbfmz84oF09uY4UvA%3D%3D

### Embeddable Component

At the same time, Miew is not only a full-fledged application, but also a
separate library that provides the same molecular viewing capabilities,
designed to be integrated into third-party products as a component. This
embedding functionality allows to extend the scope of the application by
making Miew a visualization element in more complex scientific programs.

Both the component itself and the demonstration application are designed
with an eye toward [adaptive web design][] to be equally usable on devices
with different screen sizes, from smartphones to large monitors. We support
not only latest versions of all [modern browsers][] for desktop and mobile
platforms, but also the outdated but widely used Internet Explorer 11.

> Example of embedding a component: [Miew in a Responsive Grid Layout][].

[adaptive web design]: https://en.wikipedia.org/wiki/Responsive_web_design
[modern browsers]: https://browsehappy.com/
[Miew in a Responsive Grid Layout]: https://miew.opensource.epam.com/examples/grid.html

### Display Modes

When dealing with small molecules, it's common to represent atoms as spheres
and bonds between them as cylinders using the [Balls and Sticks][] mode. The
size of the spheres can also be adjusted to reflect the ["size" of the atom][].
However, when studying larger molecules like proteins, the arrangement of
individual atoms isn't as crucial. Instead, it's more important to focus on
the groups of atoms, or [monomers][], that make up the polymer and their typical
configurations. In the "Cartoon" mode, these monomers can be connected by
segments or a smooth spline of varying thickness to display their [secondary structure][].
Additionally, researchers may find it useful to view the ["surface" of the molecule][],
which is also an available mode. Finally, there are various other supported data
formats and modes for molecule display.

It is possible to display either the entire molecule or only a specific portion of it.
The constructed geometry can be colored in a variety of ways, providing additional
details such as the chemical element or monomer type, as well as characteristics
like temperature factor or [hydrophobicity][]. These settings, including mode,
coloring, and subset of atoms, comprise a data _representation_. Different representations can be merged
to present various sections of the molecule in different modes.

> Example of combination of representations: [Hemoglobin][].

[Balls and Sticks]: https://en.wikipedia.org/wiki/Ball-and-stick_model
["size" of the atom]: https://en.wikipedia.org/wiki/Van_der_Waals_radius
[monomers]: https://en.wikipedia.org/wiki/Monomer
["surface" of the molecule]: https://en.wikipedia.org/wiki/Accessible_surface_area
[hydrophobicity]: https://en.wikipedia.org/wiki/Hydrophobicity_scales
[Hemoglobin]: https://miew.opensource.epam.com/?l=2hhb&m=TU&c=CH&m=CS&c=UN!color:0xFF00&mt=TR&s=chain+A&s=sequence+52:72&m=TU!radius:0.8&c=UN!color:0xFF0000&s=sequence+52:72+and+not+name+C,N,O&m=LC&c=EL&mt=ME

### Source Data

Source data for the visualization are files that contain atom coordinates along
with other essential information. Multiple file formats exist, but for
proteins, the [Protein Data Bank][] serves as a centralized database. This
database gathers results from [crystallography][] experiments of molecular
complexes and assigns them unique identifiers of four letters and digits. For
instance, one of the smallest protein, [crambin][], is identified as [1CRN][]
and consists of 327 atoms, while a huge ribosome is stored as
[4V88][] and has over 400,000 atoms. Importantly, the same molecules can appear
in the database multiple times, each with different coordinates from various
experiments conducted by different individuals. For example, the crambin protein
is found in more than ten coordinate files, including 1CRN, 1EJG, 3NIR, and so on.

The primary format used in the protein bank is text [PDB][], but it has its
limitations in terms of the number of atoms and residues. As a result, it has
been replaced by the more verbose [CIF][] and binary
[MMTF][]. To load data directly from the bank, Miew supports using the unique
identifier (`1CRN`) and a format specifier (`cif:1CRN`, `mmtf:1CRN`).

Small molecules can be found in various formats such as [MOL/SDF][], CML, or
others. The [PubChem][] site is the primary source for coordinate files of common
chemical compounds. With Miew, you can easily load data by entering the compound
name. For example, `pc:aspirin` will load the 3D coordinates of [aspirin][].

Miew is capable of supporting a distinct type of raw data - volumetric [electron density][]
data, which is stored as a three-dimensional [scalar field][] in [CCP4][] format,
for instance. The corresponding electron density file for certain
proteins from the Protein Data Bank can be loaded effortlessly using their identifier,
such as `ccp4:3C9L`.

Moreover, Miew permits loading data from a local file or requesting it through a
specific URL. Future plans include supporting [numerous formats][] and even other
data types, such as loading 3D geometry in widely used formats.

[Protein Data Bank]: http://www.rcsb.org/
[crystallography]: https://en.wikipedia.org/wiki/X-ray_crystallography
[crambin]: https://en.wikipedia.org/wiki/Crambin
[1CRN]: https://www.rcsb.org/structure/1crn
[4V88]: https://www.rcsb.org/structure/4v88
[PDB]: http://www.wwpdb.org/documentation/file-format-content/format33/v3.3.html
[CIF]: http://mmcif.wwpdb.org/
[MMTF]: https://mmtf.rcsb.org/
[MOL/SDF]: http://www.wwpdb.org/documentation/file-format-content/format33/v3.3.html
[PubChem]: https://pubchem.ncbi.nlm.nih.gov/
[aspirin]: https://pubchem.ncbi.nlm.nih.gov/compound/2244
[electron density]: https://en.wikipedia.org/wiki/Electron_density
[scalar field]: https://en.wikipedia.org/wiki/Scalar_field
[CCP4]: http://structure.usc.edu/ccp4/
[numerous formats]: https://en.wikipedia.org/wiki/Chemical_file_format

## Biochemistry

### Proteins

[Proteins][] are macromolecules (hundreds to hundreds of thousands of atoms) that
perform many functions in a living organism. They represent
long [polymer chains][], consisting of [amino acid residues][],
possibly compactly folded in space. There are 21 basic
amino acids, each of them has a similar structure, differing only in the "tail".
Each amino acid has a name, as well as abbreviation of three-letter and
single-letter code for ease of notation.

Amino acids are linked to each other by [peptide bonds][] in linear
chains (these are ordinary [covalent bonds][] like most others in a molecule).
A given sequence of amino acids in a protein (e.g. `Phe Leu Ser Cis...`)
called the [primary structure][] of the protein.

Being located in space, the residues hold on to each other by [hydrogen
bonds][], forming the characteristic configurations that make up the [secondary
structure][] of a protein: [helices][], [layers][], turns, loops... In general
it is impossible to predict in advance which secondary structures
forms protein when folded.

The [alpha-carbon][], located at the center of each amino acid, serves as
the starting point for the residue. Some data files for large molecules contain only coordinates
for these atoms, as it is difficult to reconstruct the rest of the molecule's
coordinates with low measurement accuracy.

Video tutorials:

1.  [Introduction to Biochemistry](https://youtu.be/CHJsaq2lNjU)
2.  [Amino Acids](https://youtu.be/J6R8zDAl_vw)
3.  [Protein Structure](https://youtu.be/EweuU2fEgjw)

[proteins]: https://en.wikipedia.org/wiki/Protein
[polymer chains]: https://en.wikipedia.org/wiki/Polymer
[amino acid residues]: https://en.wikipedia.org/wiki/Amino_acid
[peptide bonds]: https://en.wikipedia.org/wiki/Peptide_bond
[primary structure]: https://en.wikipedia.org/wiki/Protein_primary_structure
[hydrogen bonds]: https://en.wikipedia.org/wiki/Hydrogen_bond
[secondary structure]: https://en.wikipedia.org/wiki/Protein_secondary_structure
[helices]: https://en.wikipedia.org/wiki/Alpha_helix
[layers]: https://en.wikipedia.org/wiki/Beta_sheet
[alpha-carbon]: https://en.wikipedia.org/wiki/Alpha_and_beta_carbon

### Nucleic Acids

Proteins are built using the genetic information stored in DNA. DNA is a pair of
helical [polymer chains][] composed of hundreds of millions of [nucleotides][] of four types:
cytosine (C), guanine (G), adenine (A), and thymine (T). The chains of nucleotides are
paired together by [hydrogen bonds][], specifically G-C and A-T.

Most of the DNA is non-coding, and only small sections, called [genes][], are
utilized in the creation of RNA during transcription. [RNA][] is then used
in the subsequent construction of proteins during translation. [Codons][] are
triplets of nucleotides in RNA that correspond to one amino acid residue. Some
triplets encode the same amino acids, while others are service commands such as
start and stop codons.

Errors can occur during DNA [replication][], both randomly and induced. Some
of these errors are automatically corrected, while others lead to [mutations][].
These mutations can range from harmless to slightly altering the protein's
function in the body. In some cases, mutations can cause a stop codon, leading
to the loss of a portion of the protein.

Video tutorials:

1.  [DNA and RNA](https://youtu.be/6NhDY3IDp00)
2.  [From DNA to Protein](https://youtu.be/bKIpDtJdK8Q)

[nucleotides]: https://en.wikipedia.org/wiki/Nucleotide
[genes]: https://en.wikipedia.org/wiki/Gene
[Codons]: https://en.wikipedia.org/wiki/Genetic_code
[replication]: https://en.wikipedia.org/wiki/DNA_replication
[mutations]: https://en.wikipedia.org/wiki/Mutation

## Development Tools

To effectively contribute to the project's development, it would be beneficial
to review the file labeled [CONTRIBUTING.md][] as it outlines essential
suggestions and requests for the working process.

[CONTRIBUTING.md]: https://github.com/epam/miew/blob/master/CONTRIBUTING.md

### Git

Source code is meant to be stored in a [version control system][].
We use [Git][] for this, while [GitHub][] serves as the
main repository. You should install the following applications for successful
work:

-   [GitHub Desktop][] and/or [SourceTree][] as a friendly user interface for git,
-   [Git for Windows][] if you prefer to work  in command line in Windows (see
[Git Downloads][] for other OS).

What to read in addition:

-   [Pro Git Book](https://git-scm.com/book/en/v2),
-   [GitHub Guides](https://guides.github.com/).

[version control system]: https://en.wikipedia.org/wiki/Version_control
[Git]: https://git-scm.com/
[GitHub]: https://github.com/epam/miew
[GitHub Desktop]: https://desktop.github.com/
[SourceTree]: https://www.atlassian.com/software/sourcetree
[Git for Windows]: https://gitforwindows.org/
[Git Downloads]: https://git-scm.com/downloads

### Node.js

Our project runs solely on the client-side, meaning that all of its code is
executed in the browser. To achieve this, we utilized [JavaScript][], a scripting
language specifically designed for this purpose. Over time, this language has
evolved and is now a fully-fledged general-purpose [scripting language][], alongside
[Python][], [Ruby][], and [Perl][]. JavaScript programs can now be executed
not only in browsers but also in command line through an interpreter/compiler.

Why do we use JavaScript in command line? The reason is that there are certain tasks involved
in project development and preparation for publication that can be automated.
This automation can either be integrated into the development environment (IDE)
or implemented independently using a scripting language. [Windows Batch Files][]
or [Linux Shell Scripts][] are not portable to other platforms. So why not use
JavaScript, which you are already familiar with and using for your project,
instead of Python or Perl?

[Node.js][] is a platform that comes in handy as it provides an interpreter
and execution environment for JavaScript scripts. The platform offers a standard
library of functions, and you can also leverage third-party libraries (packages)
that are available through the Node.js Package Manager ([NPM][]) repository. You
can even create your own package that depends on others, implementing some useful
functionality - which is what we did with [Miew][].

JS is used for building projects as well as for the project itself in
the browser. You can use NPM to load third-party packages or opt for the alternative
[Yarn][] manager, which works with the same repository but is faster and better.
For more information on building the project, refer to [CONTRIBUTING.md][].

[JavaScript]: https://en.wikipedia.org/wiki/JavaScript
[scripting language]: https://en.wikipedia.org/wiki/Scripting_language
[Python]: https://www.python.org/
[Ruby]: https://www.ruby-lang.org/
[Perl]: https://www.perl.org/
[Windows Batch Files]: https://en.wikipedia.org/wiki/Batch_file
[Linux Shell Scripts]: https://en.wikipedia.org/wiki/Shell_script
[Node.js]: https://nodejs.org/
[NPM]: https://www.npmjs.com/
[Miew]: https://www.npmjs.com/package/miew
[Yarn]: https://yarnpkg.com/

### JavaScript

JS is a general purpose object-oriented scripting language. A program
in this language, when executed, is compiled into an intermediate representation, and
then executed in the virtual machine, whether in the browser or from the command line.

The language uses an unusual approach to the object-oriented paradigm,
unlike C++, there are no classes in the original sense of the word,
instead everything is built on [prototype objects][]. The language evolved.
The syntax of the language was changed to add the `class` keyword and much more for
developers with C++ or Java-like background. It looks as if there are classes now.
**Note!** The approach to object-oriented programming has not changed, it
is still prototype.

You will often see two language standards mentioned.

- Old ES5 (ECMAScript) which is supported by all browsers except
	very ancient IE. This is the basic syntax.

- New ES6, ES2015, ES2015+ which is supported by browsers [but not all and not completely][].
At the same time, it constantly is developing. Every year
[new features are added][] to the language, passing complex and lengthy [selection and approval process][].

To write portable programs, you either have to use the old standard
ES5 language, or write in a new language and use "transpilers" --- a kind of
compilers that translate from one language to another. An example is
[Babel.js][], which is now used in our project. Basically Miew code
was written in ES5, and is now being translated to ES2015+ (as
necessary and possible).

Useful links to study:

-   [Modern Javascript Tutorial](https://learn.javascript.ru/) (in Russian).
-   [Eloquent JavaScript](http://eloquentjavascript.net/).
-   [JavaScript best practices](https://www.w3.org/wiki/JavaScript_best_practices).
-   [Learn ES2015](https://babeljs.io/learn-es2015/).

[prototype objects]: https://en.wikipedia.org/wiki/Prototype-based_programming
[but not all and not completely]: http://kangax.github.io/compat-table/es6/#ie11
[new features are added]: https://github.com/tc39/proposals
[selection and approval process]: https://tc39.github.io/process-document/
[Babel.js]: https://babeljs.io/

### IDE

In principle, for development it is enough to write text in Notepad, compile from
command line with npm scripts, and debug the program with built-in browser
means. A more convenient solution is to use a suitable development environment.

A good development environment for web projects is, for example, [WebStorm][] from
JetBrains. This is a commercial program that requires a personal or corporate
license. At the same time, for academic projects, students are offered
[free license][], which can be renewed every year while you study.

> ...use software for [non-commercial, educational purposes only][], including
> conducting academic research or providing educational services.

If you do not have a license for WebStorm, or your task does not fit its conditions,
then you should choose an alternative development environment. For example, editors with
open source [Visual Studio Code][] or [Atom][] (they, by the way,
themselves written in JavaScript).

[WebStorm]: https://www.jetbrains.com/webstorm/
[free license]: http://www.jetbrains.com/student/
[non-commercial, educational purposes only]: http://www.jetbrains.com/student/license_educational.html
[Visual Studio Code]: https://code.visualstudio.com/
[Atom]: https://atom.io/

## Usage

Here should be an example of Miew usage...

repository: epam/miew

repo_name: epam/miew


text:
### [Rearrange Words in a Sentence](https://leetcode.com/problems/rearrange-words-in-a-sentence)

Given a sentence text (A sentence is a string of space-separated words) in the following format:

First letter is in upper case.

Each word in text are separated by a single space.

Your task is to rearrange the words in text such that all words are rearranged in an increasing order of their lengths. If two words have the same length, arrange them in their original order.

Return the new text following the format shown above.

Example 1:

Input: text = "Leetcode is cool"
Output: "Is cool leetcode"
Explanation: There are 3 words, "Leetcode" of length 8, "is" of length 2 and "cool" of length 4.
Output is ordered by length and the new first word starts with capital letter.

Example 2:

Input: text = "Keep calm and code on"
Output: "On and keep calm code"
Explanation: Output is ordered as follows:
"On" 2 letters.
"and" 3 letters.
"keep" 4 letters in case of tie order by position in original text.
"calm" 4 letters.
"code" 4 letters.

Example 3:

Input: text = "To be or not to be"
Output: "To be or to be not"

Constraints:

text begins with a capital letter and then contains lowercase letters and single space between words.

1 <= text.length <= 10^5

license: MIT

url: https://raw.githubusercontent.com/6leetcode/6leetcode/0c0973c634c881bd874bad5a0526b91a2d83f1a0/questions/Algorithms/1451. Rearrange Words in a Sentence/README.md

branch_name: refs/heads/main

extension: md

gha_language: C

gha_license_id: MIT

license_type: permissive


text:
# tsx-tags-autocomplete package

Package suggest autocompletion for tags for tsx syntax (typescript). Inspired by jsx tag closer in language-babel package.

This part is missing in atom-typescript package.

Using tags autoclose packages doesn't convenient because they trying to 'close' typescripts generic syntax.

repository: anta-semenov/tsx-tags-autocomplete

branch_name: refs/heads/master

repo_name: anta-semenov/tsx-tags-autocomplete


text:
# PDS (Platform Data Set) template and definitions files

**P**latform **D**ata **S**et (**PDS**) files contain firmware configuration values to match the hardware (I/O pinout) and the application (activating features/configuring the behavior).

## PDS `template.pds.in`

`template.pds.in` lists all possible PDS sections and parameters which can be sent to WFx firmware. It
 contains inline documentation on PDS sections and parameters.

When looking for the latest information on PDS sections and parameters, refer to the PDS template.

When creating a custom PDS file, refer to the PDS template and copy required sections to your custom PDS file, using the inline documentation to select PDS parameter values.

## PDS `definitions.in`

`definitions.in` defines values for all **PDS sections** and **PDS parameters**. It is referenced by custom PDS files and PDS files provided in the [wfx-pds repository][PDS_REPO] to obtain the final `.pds` file.

## Hardware-specific PDS files

Hardware-specific PDS files are created based on the PDS template and PDS definitions files to match various boards.

Hardware-specific PDS files for Silicon Labs evaluation boards are stored in the [wfx-pds repository][PDS_REPO].

## PDS flow

PDS input files are like C header files while PDS output data uses a compressed format:

* For easy editing, PDS input files (`.pds.in`) are in a human-readable format, with inline documentation.

* To fit embedded applications, `.pds.in` files are compressed using the [pds_compress][PDS_CMP] (_python3 script_) tool to the `.pds` file format.

The PDS generation flow is:

* Edit
  * Copy/paste an existing PDS file or start from `template.pds.in`
  * In `<custom>.pds.in`, include `definitions.in`
  * Use the inline comments to define
    * The sections to use
    * The values to set
  * Remove unused sections
  * Add required sections from `template.pds.in` if starting from an existing PDS file
  * Set values (from `definitions.in`) to match the hardware and define the behavior
* Compress
  * compress your `.pds.in` file to `.pds` using [pds_compress][PDS_CMP]
* Store
  * Linux: copy the `.pds` file under /lib/firmware/wf200.pds
  * RTOS: recompile with the new PDS data
* Send (by the WFx driver)
  * During each start-up phase, the WFx driver sends the `.pds` file after FW download & FW start

### Compressing PDS files

The `pds_compress` tool can be found in the [WFX Linux tools repository][LINUX_TOOL].
Use `pds_compress [options] INPUT [OUTPUT]` to compress a `.pds.in` file to a `.pds` file,
 ready to be sent to the WFX firmware.

Use `pds_compress --help` to display the help

Typical use:

* Linux: `pds_compress <custom>.pds.in <custom>.pds`
* RTOS: `pds_compress --out=c <custom>.pds.in <custom>.h`

_Resulting `.pds` files should not be edited. It is recommended to always start from human-readable files such as `.pds.in` files_

[FW_REPO]: https://github.com/SiliconLabs/wfx-firmware
[PDS_DOC]: https://github.com/SiliconLabs/wfx-pds/blob/master/README.md
[PDS_REPO]: https://github.com/SiliconLabs/wfx-pds
[LINUX_TOOL]: https://github.com/SiliconLabs/wfx-linux-tools

repository: djhoover/wfx-firmware

repo_name: djhoover/wfx-firmware


text:
# xLiteMem: Lightweight, C-based memory library for external CSGO process hacking

## Features:

- Wrappers for memory reading and writing
- Find processes by process names or window titles
- Find process modules by names
- Scan entire module address space for patterns
- Scan memory chunks for patterns (useful when there's limited available memory to work with)
- Scan CSGO Source engine tables for netvars (fully external)

repository: sucukluekmekpeynir/xLiteMem

repo_name: sucukluekmekpeynir/xLiteMem


text:
<img src="https://user-images.githubusercontent.com/8013017/34848537-cd9c76a8-f727-11e7-8caa-108daa37214e.png" width="319">

[![CI Status](http://img.shields.io/travis/richardtop/Blitz.svg?style=flat)](https://travis-ci.org/richardtop/Blitz)
[![Version](https://img.shields.io/cocoapods/v/Blitz.svg?style=flat)](http://cocoapods.org/pods/Blitz)
[![License](https://img.shields.io/cocoapods/l/Blitz.svg?style=flat)](http://cocoapods.org/pods/Blitz)
[![Platform](https://img.shields.io/cocoapods/p/Blitz.svg?style=flat)](http://cocoapods.org/pods/Blitz)

# Blitz
**Blitz** is an ongoing project to create a component-based UI framework in Swift.

## Try it
1. Clone the repository
2. Open `Example` folder
3. Run `pod install`
4. Launch the Demo!

## Origin
The framework is based on [@storoj's](https://github.com/storoj) code([Component-Demo](https://github.com/storoj/Component-Demo/)), shown during the lecture at [VK University](https://vk.com/vku).

Later, together with [@mattisssa](https://github.com/mattisssa) we used similar approach to build [VPages](https://itunes.apple.com/ru/app/vpages-%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D1%81%D0%BE%D0%BE%D0%B1%D1%89%D0%B5%D1%81%D1%82%D0%B2%D0%B0%D0%BC%D0%B8-vk-%D0%B0%D0%B4%D0%BC%D0%B8%D0%BD%D0%B8%D1%81%D1%82%D1%80%D0%B0%D1%82%D0%BE%D1%80/id1096015826?mt=8) app.

This is the next iteration of the same concept, written purely in Swift.

### Name
*Blitz* means "lightning" in German, which encompasses the purpose of the framework - to help developers create responsive interfaces and rapidly iterate on them.

## Installation

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

```ruby
pod 'Blitz', :git => 'https://github.com/richardtop/Blitz.git'
```

## Author

Richard Topchii

## License

Blitz is available under the MIT license. See the LICENSE file for more info.

repository: richardtop/Blitz

gha_language: Swift

repo_name: richardtop/Blitz


text:
# Instructions

* Follow these setup instructions to prepare your laptop:
  * https://github.com/lamastex/scalable-data-science/blob/master/_sds/basics/instructions/prep.md
* Follow these instructions to obtain a twiter developer acccount:
  * https://github.com/lamastex/scalable-data-science/blob/master/_sds/basics/instructions/getTwitterDevCreds.md

license: Unlicense

repository: SheperoMah/scalable-data-science

gha_license_id: Unlicense

repo_name: SheperoMah/scalable-data-science


text:
# Project SalmonSpy

### Background:
The world's largest salmon run occurs in Bristol Bay, Alaska every summer.  The exact timing and magnitude of the salmon run is unknown, but predictions are made by ADFG at the start of every year.  In 2018 a record 62.3 million salmon returned, 21% more than predicted by ADFG.  The goal of this project is the develop a more accurate prediction of the Bristol Bay salmon run then what's currently provided by ADFG.

### Work Items:
1. Data fetch/scrape
    1. fishing boat activity = 'http://globalfishingwatch.org/'
        * Docs and SDK = https://github.com/GlobalFishingWatch?language=python
        * More technical docs: https://github.com/GlobalFishingWatch/paper-global-footprint-of-fisheries/blob/master/data_documentation/fishing_effort.md
    1. historical salmon catches = 'http://www.adfg.alaska.gov/index.cfm?adfg=commercialbyareabristolbay.harvestsummary'
    1. historical salmon counts (what escapes upriver) = 'http://www.adfg.alaska.gov/index.cfm?adfg=commercialbyareabristolbay.salmon#fishcounts'
    1. historical salmon catches in "test" fishery = 'https://www.bbsri.org/'
    1. stream and lake levels = 'https://waterdata.usgs.gov'
    1. tide activity = 'http://kapadia.github.io/usgs/reference/api.html'
    1. land weather = 'https://graphical.weather.gov/xml/'
    1. marine weather = https://www.ncdc.noaa.gov/data-access/marineocean-data
    1. more marina data to checkout = https://www.ncdc.noaa.gov/cdo-web/datasets
    1. NOAA web data services guide = https://www.ndbc.noaa.gov/docs/ndbc_web_data_guide.pdf
    1. tides & currents = https://opendap.co-ops.nos.noaa.gov/

##### Station IDs
    Port Moller         9463502
    Adak Island         9461380
    Unalaska            9462620
    St Paul Island      9464212
    > more here:    https://opendap.co-ops.nos.noaa.gov/stations/index.jsp

1. Data clean and transform
    1. Verify data integrity
    1. Standardize column names
    1. Convert all files to CSV

1. AWS setup
    1. Spin up micro EC2
    1. Create an S3 bucket
    1. Setup Sagemaker

1. Train the model
    1. Use built-in algorithms with Sagemaker
    2. Pre-process with Jupyter

1. Evaluate the model

repository: ak-foster/salmon-spy

repo_name: ak-foster/salmon-spy


text:
---
layout: post
title: "PowerShell Credential Handling"
excerpt: "Simple Secure Usernames and Passwords"
tags:
- Pro-Tip
- PowerShell
image:
  thumb: /powershell-credential-handling/powershell-credential-handling-01.png
comments: true
date: 2022-08-02T00:00:00+00:00
---

One of the things I like to do on this site is to share handy PowerShell scripts.

After all PowerShell allows for automation thus making life easier and who wouldn't want an easy life?

Quite often PowerShell scripts need to pass credentials to remote systems/services; for example logging onto an ESXi host or  a vCenter server to perform a task or two.

How do we handle those credentials? Preferably not in plain text...

Enter Credential Manager.
{% include _toc.html %}
## Credential Manager
Credential Manager is accessed via Windows control panel:

The advantages of using Credential Manager to store our PowerShell credentials are as follows:

Credentials stored in credential manager are:

1. Associated with each Windows user account and not transferable between users
2. Not generally transferable between computers (possible if using roaming profiles)
3. Accessible from a full-windows environment that has Credential Manager built in (EG not in WinPE)
4. Relatively easily accessible from PowerShell

To expand on points 1. and 2. above, remember when running a PowerShell script containing credentials, the credentials referenced must be available to the user account running the script.  For example, when running a PowerShell script as a scheduled task running under the local administrator account, the credentials must be available to the local administrator account used.

## PowerShell Module Installation
To access credentials stored in Credential Manager from PowerShell we need to install a PowerShell Module. The module is available here in the [PowerShell Gallery](https://www.powershellgallery.com/packages/CredentialManager/2.0){:target="_blank"}.

Installation is simple enough:
{% highlight powershell%}
Install-Module -Name CredentialManager
{% endhighlight %}

That's it. Restart your PowerShell session to automatically load the module.

## Saving Credentials
Instead of using Credential Manager GUI to add credentials, the `New-StoredCredential` command can be used as follows.

As a bonus, teaming `New-StoredCredential` with `Get-Credential` pops up the credential request window for easy entry:
{% highlight powershell%}
New-StoredCredential -Target "TEST" -Persist "LocalMachine" -Credentials $(Get-Credential) | Out-Null
{% endhighlight %}

Enter credentials as normal and click OK.

Checking Credential Manager afterwards:

## Retrieving Credentials
Again using PowerShell, credentials can be retrieved using `Get-StoredCredential` command as follows:
{% highlight powershell%}
Get-StoredCredential -Target "TEST"
{% endhighlight %}

## Using Credentials
So how do we use the credentials that we can recover from Credential Manager?  For example, how can we use the recovered credentials to, say, logon to a VMware vCenter server?

In the following example, we will recover and use the following credential:

The two line script is as follows:
{% highlight powershell%}
$Credentials = Get-StoredCredential -Target "vSphere-Admin"
Connect-VIServer -Server "vcenter.local" -Credential $Credentials
{% endhighlight %}
Yep that works nicely:

Simple!

## Deleting Credentials
Finally, credentials can be deleted using `Remove-StoredCredential` command as follows:
{% highlight powershell%}
Remove-StoredCredential -Target "TEST"
{% endhighlight %}

Checking Credential Manager:

Yep, our test credential has been deleted.

## PowerShell Core on Linux
As Linux does not have a equivalent Credential Manager, we need to get creative when handling credentials in PowerShell core on Linux.

As luck would have it, a work around is available.  What's more is that we documented and used the workaround in part three of the UPS Triggered Shut Down of ESXi from Raspberry Pi series [HERE](/esxi-rpi-ups-pt3/#powershell-credential-handling){:target="_blank"}.

## Conclusion and Wrap Up
A solution to implement and manage PowerShell credentials does exist. What's more it's simple to use.

No more storing credentials in plain text inside scripts.

-Chris

gha_language: HTML


text:
---
layout: post
title: "Why freehosting.com Sucks!"
date: 2010-08-06
status: publish
comments: true
share: true
categories:
- Misc
tags: []
image:
  feature: main-banner-2.jpg
---

One of the worst mistakes someone can make is trying to use a free hosting site to host your website. I was in a rush to get my site up a few months ago and decided to just got with a quick and easy setup from Freehosting.com. It has been the worst mistake I have even made when it comes to hosting! I expected things like uptime to not be perfect cause it is a free host but I did not expect them to blatantly blame problems with their server on me and my site. This is how everything went:

* Their entire site went down on August 2nd, 2010.
* At the same time, I started getting loop redirects on my webpage.
* Every few tries the DNS server would resolve and I could get to the site.
* 3 days later freehosting.com's servers came back online and my site was "suspended".
* I tried to figure out why this had happened, all they would say was that my site was using too many Perl scripts (I don't have any Perl scripts, only PHP. Their techs are idiots).
* They said I could get my account unsuspended if I upgraded or canceled my account.

* After many heated emails from me, I just canceled my site and went to Blue Host.

What really made me mad was that there were no Terms of Agreement when I signed up so I was never told of these circumstance.  I keep everything backed up except my databases so I lost all my old blog posts. Now I didn't have many but its the principle of the matter that bugs me! I own those files and they wanted me to PAY for them or just delete them. Ridiculous! They have no right to do that and my tickets were deleted once I started talking about reporting them to the Better Business Bureau.

Moral of the story: Never ever use freehosting.com for hosting. Ever!


text:
---
title: 'caBIG Annual Meeting – A developers perspective'
author: ajordens
layout: post
permalink: /2008/06/cabig-annual-meeting-a-developers-perspective/
categories:
  - General Discussions
  - Java
  - Open Source Software
---
For the past couple of days I’ve been attending the [caBIG][1] Annual Meeting (*it’s the 5th such meeting and by all accounts the most well attended*).

**About caBIG**

> **caBIG™ stands for the cancer Biomedical Informatics Grid™. caBIG™ is an information network enabling all constituencies in the cancer community – researchers, physicians, and patients – to share data and knowledge. The components of caBIG™ are widely applicable beyond cancer as well.**
>
> **The mission of caBIG™ is to develop a truly collaborative information network that accelerates the discovery of new approaches for the detection, diagnosis, treatment, and prevention of cancer, ultimately improving patient outcomes.
**

**In a nutshell, caBIG is an initiative of the National Cancer Institute built heavily upon open-source components that aims to motivate and facilitate the sharing of data. It strongly suggests a front-loaded UML workflow (using MDA) and incorporates certain aspects of ontologies and common data definitions to help guarantee consistent semantics (and syntax).**

**From a purely technical perspective, I’ve never been sold on the idea of MDA. I’ve had experience with both open-source and commercial modeling tools that have never fulfilled on the promise of true round-tripping (and if you don’t have round-tripping… well, you’re in for a world of hurt). Now in the caBIG case, there is a pipeline of transformations that you’re more or less required to run through…**

  1. **Create a UML representation of your object and domain models**
  2. **Annotate the model with caBIG specific annotations and stereotypes**
  3. **Run the annotated model through the Semantic Integration Workbench (another caBIG tool)**
  4. **Submit the final model (XMI) to caBIG for approval and insertion into the caDSR (cancer data standards repository)**

**Make a change in the future and you’re more or less required to run through steps #1-4 again.**

**Once you have a validated UML model, you can then run through the caCORE SDK and generate skeleton code for a 3-tiered application consisting of (at a high level) a Hibernate data model, an external API and some middleware code to glue the API and data model together. Round-tripping is essentially non-existent from what I’ve heard and seen.**

**You’re done! Congratulations on achieving Silver-level compliance.**

**…**

***wait a second.***

**It’s a little bit too process heavy for my liking. I would have liked to see the *NIH/caBIG* be first and foremost focused on data interoperability and** less on tools, particularly those that **dictate particular workflow****s** (*like UML -> annotation -> MDA -> Code Generation*).

I’d much rather see an extensible API with pluggable end-points, a meta data registration service and a suite of validation test cases. Define suitable goals and keep it simple. *Provide suitable incentives and vendors **will** support it*.

There’s more than one way to provide interoperability.

As a developer working on existing products that are considering support for *caBIG*, the requirement to fundamentally change my development process is a bit unnerving. Speaking generally, there’s no guarantee that everyone has UML models for their systems and even if they did, attempting to do full MDA transformations on them would be fairly ambitious.

That’s it for now. It’s been an interesting conference and I’ve learned a lot about the various initiatives and their progress. Off to visit customers in Cincinnati tomorrow!

 [1]: https://cabig.nci.nih.gov/overview/


text:
# ProphetsWay.iBatisTools

| Master Build Status | NuGet Alpha | NuGet Beta | Nuget Release |
|   ---   |   ---   |   ---   |   ---   |
| [![Build status](https://dev.azure.com/ProphetsWay/ProphetsWay%20GitHub%20Projects/_apis/build/status/iBatisTools/iBatisTools%20CI)](https://dev.azure.com/ProphetsWay/ProphetsWay%20GitHub%20Projects/_build/latest?definitionId=12) | [![Build status](https://vsrm.dev.azure.com/ProphetsWay/_apis/public/Release/badge/dadb23ce-840b-4b7d-9783-dc5e9a2d9029/7/15)](https://dev.azure.com/ProphetsWay/ProphetsWay%20GitHub%20Projects/_release?definitionId=7) | [![Build status](https://vsrm.dev.azure.com/ProphetsWay/_apis/public/Release/badge/dadb23ce-840b-4b7d-9783-dc5e9a2d9029/7/16)](https://dev.azure.com/ProphetsWay/ProphetsWay%20GitHub%20Projects/_release?definitionId=7) | [![Build status](https://vsrm.dev.azure.com/ProphetsWay/_apis/public/Release/badge/dadb23ce-840b-4b7d-9783-dc5e9a2d9029/7/17)](https://dev.azure.com/ProphetsWay/ProphetsWay%20GitHub%20Projects/_release?definitionId=7)

A small library that will help with using iBatisNet as your DAL

In my testing I have found that I can't get iBatisNet to work in Net Core Test application, so I have the iBatisTools project
only building in Net Framework setups for now.  If anyone can get me a version of iBatisNet that I can use in both Net Framework
and Net Core, I will be absolutely happy to upgrade this to support them both as well.

## How to use
You can reference iBatisTools from NuGet.  Once you have it in your project, you will be able to write custom implementations
for your DAL, however some functionality will be handled for you in base abstract classes that you can inherit from.  I will
try to explain each of the base classes in order of how I would probably code a new project from scratch.

For examples, please see the example projects included in the GitHub repository.

## Base Dao Classes
##### Special note
iBatisTools references interfaces that were established in another project, ProphetsWay.BaseDataAccess.  The point of mentioning
this is that you will need to follow the guidelines for the DAO interfaces defined within that project
(but only to make use of the BaseDao classes).

### BaseDao
This Dao implements the IBaseDao interface, meaning it has all the CRUD calls established within.  It is built around a specific
naming convention to be used within your SqlMap.xml files.  The following methods are implemented:

``` c#
T Get(T item);
void Insert(T item);
int Update(T item);
int Delete(T item);
```

To make use of these methods, you must set the namespace in your SqlMap.xml files to be the literal name of the entity it is for.
For example, if you have a POCO named ```Company``` then in your SqlMap.xml you need ```namespace="Company"```.  Then
you will need to have four specifically named queries created.

``` xml
<select id="Get[EntityName]ById" parameterClass="[Namespace].[EntityName]" />
<insert id="Insert[EntityName]" parameterClass="[Namespace].[EntityName]" />
<update id="Update[EntityName]" parameterClass="[Namespace].[EntityName]" />
<update id="Delete[EntityName]ById" parameterClass="[Namespace].[EntityName]" />
```
When setup as per the previous example entity ```Company```
``` xml
<select id="GetCompanyById" parameterClass="ProphetsWay.Example.DataAccess.Entities.Company" />
<insert id="InsertCompany" parameterClass="ProphetsWay.Example.DataAccess.Entities.Company" />
<update id="UpdateCompany" parameterClass="ProphetsWay.Example.DataAccess.Entities.Company" />
<update id="DeleteCompanyById" parameterClass="ProphetsWay.Example.DataAccess.Entities.Company" />
```

You will still need to manually write the queries however you want, but you will get the whole entity as your parameter object.
In the case for ```Get``` and ```Delete``` you only need the Id property to be set on the object, but the variable is still
the object.

### BaseGetAllDao
This Dao inherits from BaseDao and implements the IBaseGetAllDao interface.  The following method is implemented:
``` c#
IList<T> GetAll(T item);
```

Since this inherits from BaseDao, the naming convention of the SqlMap.xml is still required for the CRUD calls.  The new
query you will need to add is:
``` xml
<select id="GetAll" />
```

Unlike the methods for BaseDao, ```GetAll``` doesn't require the entity name to be part of the query name.  It also does
not require any parameter since the point is to return all of the entity from the database.

### BasePagedDao
This Dao inherits from BaseDao and implements the IBasePagedDao interface.  The following methods are implemented:

``` c#
int GetCount(T item);
IList<T> GetPaged(T item, int skip, int take);
```

Just like above, naming convention for the namespace is required in the SqlMap.xml.  The new queries needed are:

``` xml
<select id="GetCount" resultClass="int" />
<select id="GetPaged" parameterClass="map" />
```

With ```GetCount``` no parameters are required, and the point for this is to provide an upper limit for your UI to get quickly
when rendering a paging control.  Then the ```GetPaged``` method has a ```"map"``` as it's parameter.  The two values in the
map are ```#Offset#``` and ```#PageSize#``` and you should use them in your queries.  For the ```Company``` example
from above:

``` xml
<select id="GetPaged" parameterClass="map" resultMap="CompanyMap">
	SELECT *
	FROM dbo.Companies
	ORDER BY Id
	OFFSET #Offset#
	ROWS FETCH NEXT #PageSize# ROWS ONLY
</select>
```

## EnumTypeHandlers
Sometimes in your entities you use objects to reference a value from a drop down, maybe it's a string literal, and other times
you want to use an ```enum``` object value.  In order to use these with iBatis you have to use a ```TypeHandler``` class that
implements ```ITypeHandlerCallback```.  In iBatisTools there are two options that have been setup for you to choose from:
```EnumTypeAsIntHandler<T>``` and ```EnumTypeAsStringHandler<T>```.  You will need to create a new class type handler
to work with your specific class objects, however you only need to inherit one of those two classes, and specify your class
as the generic value for T.  For example, I have the following enum and type handler created:

``` c#
//roles as an enum is defined within my DataAccess project along with all my entity models
public enum Roles
{
	Admin,
	User,
	Developer
}

//RoleHandler is defined within my iBatis DAL project
public class RoleHandler : EnumTypeAsIntHandler<Roles>    {    }
```

The difference between ```AsInt``` and ```AsString``` refer to how the value is stored in the database.  ```AsInt``` will store
the integer value of the enum in your database, so you would likely need to create a reference table for those values to map to
for database sanity checks and queries.  Since integers are likely a smaller footprint than strings, usually this is the
preferred implementation.  However sometimes you just want the string value of the enum stored in the database, so basic queries
can quickly inform what the value represents, for that you need to use the ```AsString``` version.

## MapperFactory
Lastly to talk about is the ```MapperFactory``` class.  This is what will construct the mapper you use for your Daos.  All the
base Dao classes require a mapper argument when they're constructed.  I always felt like this part was annoying since it is
where the actual validation for your SqlMap.xml and SqlMap.config files are actually validated.  This now has some logging
embedded within it so you can quickly identify what is blowing up your code if/when you make map changes.

The one major requirement for using the ```MapperFactory``` is that you name your SqlMap.config file as follows:
"SqlMap.[whatever naming you prefer].config" and the file must be set as an embedded resource within your project.  The code
will use a referenced assembly to find the config file, and then depending on how the config file is setup, it will find all
the SqlMap.xml files and load them.  There are three options to generate a mapper, one takes no arguments and assumes the
connection string information is wholly contained within the config file, a second option takes a full connection string
to be used, and the third option takes a ```NameValueCollection``` as a parameter so you can specify what variables/values
you want to pass in and use within your config file.

Examples:
``` xml
<!-- complete connection information -->
<database>
	<provider name="sqlServer2008"/>
	<dataSource name="ProphetsWay.Example" connectionString="Initial Catalog=ProphetsWay.Example;Data Source=localhost;Integrated Security=True;Persist Security Info=False;Pooling=False;MultipleActiveResultSets=False;Connect Timeout=60;Encrypt=False;TrustServerCertificate=False"/>
</database>

<!-- whole connection string replacement -->
<database>
	<provider name="sqlServer2008"/>
	<dataSource name="ProphetsWay.Example" connectionString="${connectionString}"/>
</database>

<!-- specific value/variable replacement -->
<database>
	<provider name="sqlServer2008"/>
	<dataSource name="ProphetsWay.Example" connectionString="Initial Catalog=ProphetsWay.Example;Data Source=localhost;user id=${username};password=${password};Connection Timeout=60;Max Pool Size=1000"/>
</database>
```

You can see the replacement values use the syntax of ```${variableName}```, the connection string option was setup so you
don't have to know the variable to replace, it is handled for you.  However if you prefer to keep the details for a connection
in separate places, you can use many different variables and pass all the values in to build the connection (or really any part
of the config file).

Lastly is an example of how you'd invoke each of those examples above.
``` c#
public ExDataAccessTake1()
{
	_mapper = GetType().Assembly.GenerateMapper();
	_companyDao = new CompanyDao(_mapper);
	_jobDao = new JobDao(_mapper);
	_userDao = new UserDao(_mapper);
}

public ExDataAccessTake2(string connString)
{
	_mapper = GetType().Assembly.GenerateMapper(connString);
	_companyDao = new CompanyDao(_mapper);
	_jobDao = new JobDao(_mapper);
	_userDao = new UserDao(_mapper);
}

public ExDataAccessTake3(string userName, string userPass)
{
	//I recommend creating the name value collection within this project
	//so that you can verify the "keys" match the variables used within your
	//SqlMap.config file.
	//If you choose to use more/many/different variables, just make sure
	//you require them in your constructor here, and pass them all into your
	//NameValueCollection before calling GenerateMapper.
	var coll = new NameValueCollection();
	coll.Add("username", userName);
	coll.Add("password", userPass);

	_mapper = GetType().Assembly.GenerateMapper(coll);
	_companyDao = new CompanyDao(_mapper);
	_jobDao = new JobDao(_mapper);
	_userDao = new UserDao(_mapper);
}
```

You can see that all the code referenced is in the constructor of the main DataAccess implementation file.  In here all the
specific Dao's are also created so that they share the same mapper object/connection to the database.  This will allow you
to structure some calls using a transaction and then work across multiple tables/Daos and commit or rollback depending
on how things play out for you.  If you were to give each Dao their own mapper instance, then this functionality would not
be possible.

For working examples of how all these parts work, please see the example projects within the GitHub repository.

## Running the tests

The library has 66 basic unit tests, exercising each 'Take' that was implemented; and the tests are executed against all
target frameworks in the test project.  They cover the iBatis specific functionality as well as excercise all the Daos.
They are created with an XUnit test project, as well as Example projects with differing iBatis SqlMap.config setups.
Unfortunately I don't have the unit tests running in the build pipeline because they are actually
hitting my local database to run.

## Versioning

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

## Authors

* **G. Gordon Nasseri** - *Initial work* - [ProphetManX](https://github.com/ProphetManX)

See also the list of [contributors](https://github.com/ProphetManX/ProphetsWay.iBatisTools/graphs/contributors) who participated in this project.

## License

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

gha_language: C#


text:
# Dash Core for Fedora Linux<br />_...wallet, node, and masternode_

> **EOL of from-scratch Dash Core RPM development**
>
> 1. The Dash developer community will be moving towards containerized
>    deployment of nodes and masternodes. Therefore, there is no guarantee
>    that I will continue building RPMs. We'll see.
> 2. I no longer build dash core from scratch. The most current builds are
>    packaged upstream binary builds.
>
> Associated announcments:
> - https://www.dash.org/blog/introducing-dashmate-the-masternode-setup-tool-for-dash-platform/
> - https://www.dash.org/blog/dashcore-v18-0-product-brief/
>

**Supported builds and other notices:**
* RHEL and CentOS: For both Dash Core and Dash Masternode Tool (DMT), I no longer supply packages for RHEL/CentOS.
* For Dash Core, use the provided systemd configuration. This makes nodes near bullet-proof, even on Fedora.
* Dash Masternode Tool: DMT will remain Fedora-only! except for test builds.
* Keep up with Fedora's release schedule: <https://fedoraproject.org/wiki/Releases>

Fedora upgrades are easy (see available documentation in the "documentation"
folder).

---

**Dash (Digital Cash)** is an open-source peer-to-peer cryptocurrency with an
emphasis on serving as an efficient platform for payments and decentralized
applications. Dash offers a form of money that is portable, inexpensive,
divisible and fast. It can be spent securely both online and in-person with
negligible transaction fees. Dash offers instant transactions by default
**(InstantSend)**, more-fungible transactions **(CoinJoin)**, and operates its
network with a model of self-governance and self-funding. This decentralized
governance and budgeting system makes it the first-ever successful
decentralized autonomous organization (DAO).

Dash is open source and the name of the overarching project. Learn more
at https://www.dash.org/

Dash on github can be found here: https://github.com/dashpay

---

This github repository is used to develop and maintain Dash natively built
and packaged for Fedora Linux.

For more about building from the sources provided here, please visit this link:
<https://github.com/taw00/dashcore-rpm/blob/master/README.source.md>

## Binary (executable) RPMs

**Binary (executable) RPMs are pre-built for you (from these sources) and are
available through external repositories that your packaging system can
understand.** This makes deploying and maintaining Dash on a Fedora system
dependable, more secure, and oh so very simple. This is arguably the simplest
way to deploy and manage a Dash Wallet, Node, or Masternode. For more about the
available binary RPMs, please visit this link:
<https://github.com/taw00/dashcore-rpm/blob/master/README.binaries.md>

---

### Disclaimer!

These packages have been successfully built and tested, but I lay no claim that
they are absolutely free of any bugs in the code, default configuration,
documented configuration, or in the builds or how those builds are
deployed/installed.

These packages have been used by myself and others for years at this point, but
in the end, users must assume the risks associated to both community built and
deployed packages and, of course, any cryptocurrency funds managed by this
software. I.e., These will probably work for you, but I can't be liable for any
loss of funds or damages associated to this software.

### Send comment and feedback - <https://keybase.io/toddwarner>

_Come say hello to me. I am **t0dd** in various forums: [Dash Talk on Discord](https://discord.com/invite/PXbUxJB),
[dash.org's forum](https://www.dash.org/forum/), and in various chat rooms on Matrix.org.


text:
# GraphQL Rails Blog

This application can be used as **starter kit** if you want to get started building an app with **Rails**, **React**, and **GraphQL**.
This is a simple blog engine using ordinary features which can be found in most web applications.

## Technologies

### Frontend

- [React](https://facebook.github.io/react) - A JavaScript library for building user interfaces. It introduces many great concepts, such as, Virtual DOM, Data flow, etc.
- [Babel](https://babeljs.io) - Babel is a JavaScript compiler which allows you to  use next generation, ES6/ES7, JavaScript... today.
- [Sass](http://sass-lang.com) - Sass is an extension of CSS, adding nested rules, variables, mixins, selector inheritance, and more.
- [Redux](https://github.com/reactjs/redux) - Redux is a predictable state container for JavaScript apps
- [Redux Form](http://redux-form.com/) - A Higher Order Component using react-redux to keep form state in a Redux store.
- [Apollo](http://dev.apollodata.com/) - A flexible, fully-featured GraphQL client for every platform.
- [Create React App](https://github.com/facebookincubator/create-react-app) - is a new officially supported way to create single-page React applications. It offers a modern build setup with no configuration.
- [ESlint](http://eslint.org/) - ESlint is a pluggable linting utility for JavaScript, and JSX.

### Backend

- Ruby 2.4
- Rails 5.1
- [JWT authentication](https://jwt.io) with [Ruby JWT gem](https://github.com/jwt/ruby-jwt).
- [GraphQL-Ruby](https://github.com/rmosolgo/graphql-ruby) - GraphQL-Ruby is a Ruby implementation of [GraphQL](http://graphql.org).
- [GraphQL-batch](https://github.com/Shopify/graphql-batch) - GraphQL-batch is a query batching executor for the graphql gem.
- [Graphiql](https://github.com/graphql/graphiql) - Graphiql is an in-browser IDE for exploring GraphQL.
- [Rack CORS](https://github.com/cyu/rack-cors) - Rack Middleware for handling Cross-Origin Resource Sharing (CORS), which makes cross-origin AJAX possible.
- [Optics Agent](http://www.apollodata.com/optics) - Optics Agent for GraphQL Monitoring
- SQLite3 for development and PostgreSQL for production.

## Features

- CRUD (create / read / update / delete) on posts
- Creating comments on post page
- Pagination on posts listing
- Searching on posts
- Authentication with Devise and authorizations (visitors, users, admins)
- Creating user account
- Update user profile and changing password
- Setup dev tools
- Application ready for production

## GraphQL Using

- Queries et mutations
- FetchMore for pagination
- Integrating with Redux and updating store
- Optimistic UI
- Colocate data / component with fragments
- Validation management and integration with Redux Form
- Authentication and authorizations
- Protect queries and mutations on GraphQL API
- Batching of GraphQL queries into one HTTP request
- Batching of SQL queries backend side

## Prerequisites

- Ruby 2.4
- [Node.js](https://nodejs.org) v6 or newer + [Yarn](https://yarnpkg.com) package manager
- SQLite3

## Getting Started

- Install Bundler

          $ gem install bundler

- Checkout the graphql-rails-blog git tree from Github

          $ git clone https://github.com/MatthieuSegret/graphql-rails-blog.git
          $ cd graphql-rails-blog
          graphql-rails-blog$

- Run Bundler to install/bundle gems needed by the project:

          graphql-rails-blog$ bundle

- Create the database:

          graphql-rails-blog$ rails db:migrate

- Load sample records:

          graphql-rails-blog$ rails db:seed

- Run the Rails server in development mode

          graphql-rails-blog$ rails server

- Run Yarn to install javascript package in other terminal:

          graphql-rails-blog$ cd client
          graphql-rails-blog/client$ yarn

- Start client in development mode. You should be able to go to
`http://localhost:8080` :

          graphql-rails-blog/client$ yarn start

## Next step

- [ ] Use subscription GraphQL feature
- [ ] Use TypeScript
- [ ] Create mobile app with React Native

## Screens

#### Listing posts

#### Creating comments

#### Post page

## License

MIT © [Matthieu Segret](http://matthieusegret.com)

repository: igor-viblyy/graphql-rails-blog

repo_name: igor-viblyy/graphql-rails-blog


text:
<!-- README.md is generated from README.Rmd. Please edit that file -->
funpark
=======

<!-- badges: start -->
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
![version](https://img.shields.io/badge/version-0.2.6-blue.svg?cacheSeconds=2592000)
<!-- badges: end -->
The package is for archiving those functions in [Research materials](https://joon3216.github.io/research_materials) section.

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

The package is not uploaded on CRAN. You can download `funpark` package by:

``` r
# install.packages("devtools")
devtools::install_github("joon3216/funpark")
```

Examples
--------

There are two themes involved in this package:

### Response column(s) reshaping

See examples of:

-   reshaping:
    -   [`binarize_binom()`](https://joon3216.github.io/research_materials/2018/binarize#case-1-nodal)
    -   [`binarize_pois()`](https://joon3216.github.io/research_materials/2018/binarize#case-2-femsmoke)
    -   [`change_form()`](https://joon3216.github.io/research_materials/2018/binarize#aside-change_form)
-   applications regarding ROC curves:
    -   [`plot_roc()`](https://joon3216.github.io/research_materials/2018/binarize#roc-curve)
    -   [`CI_auc()`](https://joon3216.github.io/research_materials/2018/binarize#confidence-interval-for-auc)

### Statistical computations

-   [`fusion_estimates()`](https://joon3216.github.io/research_materials/2018/non_separable_penalty#the-data), and searching for the best tuning parameter using [k-fold cross-validation](https://joon3216.github.io/research_materials/2019/cross_validation_fs)
-   [using pgf and DFT](https://joon3216.github.io/research_materials/2018/pgf) to evaluate complicated pmfs
-   imputing missing numerical data using the [EM algorithm](https://joon3216.github.io/research_materials/2019/em_imputation)


text:
# PdfTools

A wrapper for Coherent PDF (cpdf) and PDFtk. Windows only.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'pdf_tools', :git => 'https://github.com/lkfken/pdf_tools.git'
```

And then execute:

    $ bundle

## Usage

Split a .pdf file into multiple .pdf files, each 100 pages:

    PdfTools.split(source: 'some_file.pdf', chunk: 100, target_dir: '.', filename: '%%%_@F_<EMAIL_ADDRESS>
    %, %%, %%%, etc. Sequence number padded to the number of percent signs
    @F Original filename without extension
    @N Sequence number wihtout padding zeroes
    @S Start page of this chunk
    @E End page of this chunk
    @B Bookmark name at this page

Extract random pages of a .pdf file:

    PdfTools.extract(pages: '1 4 17 20-22 31 36', source: 'tmp/penn_2.pdf', target_dir: './tmp', filename: 'Summary.pdf')

Merge .pdf files into one:

     pdf_sources = ['a.pdf', 'b.pdf', 'c.pdf']
     target = 'final.pdf'
     PdfTools.merge(sources: pdf_sources, :target => target)

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/lkfken/pdf_tools. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

## License

The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).


text:
# Events on Book instances

* ready: [state] emitted once the book is init
* exit: [completion] emitted when the the process is about to exit
* idle: [state] emitted when the core of spellcast is idling
* busy: [state] emitted when the core of spellcast is not idling
* undeadRaised (undeadList): emitted when a file or directory watched (undead mode) has changed, usually causing
  the book to reset and to run again the related action
* newClient (client): emitted when a new client is added to the book, once it emitted 'ready'
* newUser (client): emitted when a user has authenticated through a client
* removeClient (client): emitted when a client is removed from the book

# Events on script/API bus

Events emitted here are usually **userland** event, except few standard events:

* command (object): emitted every time a role (a client) send a command, object contains:
	* role (Role instance): the role that sent the command
	* entity (Entity instance): the entity that sent the command, if any (the same than role.entity)
	* command (text): the raw text command

# Events on Client instances

### input

* exit: [completion] emitted when the process hosting the book is about to exit
* end (result, data): [state,completion] emitted once the book is finished, `result` constains the outcome for *that* client.
  It can be: *end* (end, nothing special), *win*, *lost*, *draw* (this spellbook is a game and the client win/lost or
  it was a draw game). `data` contains end of game details, depending on the spellbook (things like score, etc).
* cast (spellName, status, [error]): a spell has been casted or has fizzled (caster mode), where:
	* spellName `string` the name of the spell
	* status `string` is one of:
		* 'ok': the spell was casted successfully
		* 'upToDate': the spell was not casted because all its dependencies are up to date
		* 'error': the spell was not casted because of an error
	* error `object` (optional) when status='error' this contains the error object
* summon (summoning, status, [error]): a summoning has been summoned or has fizzled (caster mode), where:
	* summoning `string` the path of the summoning
	* status `string` is one of:
		* 'ok': the summoning was summoned successfully
		* 'upToDate': the summoning was not summoned because it already exists and all its dependencies are up to date
		* 'noop': everything went fine but nothing was produced
		* 'error': the summoning was not summoned because of an error
	* error `object` (optional) when status='error' this contains the error object
* coreMessage (message, ...): message emitted by the core of spellcast, `message` is the message and may
  contains markup and be formated with variables (printf-like)
* errorMessage (message, ...): error emitted by the core of spellcast or from anywhere else, `message` is the message and may
  contains markup and be formated with variables (printf-like)
* extOutput (raw): an external program raw output (usually on stdout)
* extErrorOutput (raw): an external program raw error output (usually on stderr)

* message (text, options): [completion] message emitted by the book, `text` contains the message and may contains markup,
  if `options` is set, it is an object contains details about the message. They may or may not be implemented, depending
  on the client. Available options:
	* await `boolean` if true the script execution wait for the client ack (e.g. until the spoken voice or the slow-typing is finished)
	* next `boolean` if true, the message wait for the user acknowledgement, force *await*
	* type `string` the message type, which can be:
    	* 'log': (the default) the message is added to the main text box, which is usually scrollable, and have infinite history
    	* 'dialog': the message produces an ephemeral dialog box
    	* 'modal': like 'dialog', but also prevent the user from doing anything until the message send the ack
    	* 'overlay': mostly like 'dialog', but without the box
    	* 'g-entity': the message is attached to a GEntity, e.g.: a character is chatting and the message is inside a bubble attached to the character's sprite
	* special: `object` (optional) client-depended, can be used to tell the client the place of the message, or some cosmetics
	* continue `boolean` if true, this message should be continued by the next message (i.e.: no newline, no new paragraph)
	* important `boolean` if true and if the scene is rendering in the *alternate buffer*, the message should be rendered
	  in the *main buffer* too.
	* slowTyping `boolean` if true, the message is displayed letter by letter
	* wait `number` (optional) if set, the message ends (is discarded) after that number of seconds, also this pause starts only
	  after slowTyping or any special delay have finished
	* style `object` (optional) this is a CSS object to style the message element
	* class `object` or `string` or `array` (optional) CSS class to enable/disable on the message element
	* image `url` if set, the message as an image related to the text, it may be a portrait of the speaker or an image
	  of what is described
	* sound `url` if set, a sound that should be played along with the message
	* speech `boolean` if true, use the client speech synthesis capability (if any)
	* speechOnly `boolean` if set, do not display the message, only use the client speech synthesis
	* speechReplay `boolean` if true, the client add a button to replay the speech
	* speechLang `string` language to use for the speech synthesis
	* speechVoice `string` the voice to use for the speech synthesis
	* speechVolume `number` the volume for the speech synthesis (default: 1)
	* speechRate `number` the speech rate (speed) for the speech synthesis (default: 1)
	* speechPitch `number` the speech pitch for the speech synthesis (default: 1)
	* speechGender `string` the gender for the speech synthesis
* textInput (label, grantedRoleIds, historyGroup): the book requires that the user enter a text, `label` is the text describing what is required,
  the client response should emit a `textSubmit` event, `grantedRoleIds` is an array of role's ID, roles that can respond, and finally
  `historyGroup` is a string, an identifier used for populating the history lines, or is null if there isn't history lines.

* indicators (data): intended to display indicators in the message area flow (i.e. mixed with *message* events).
  An indicator is a data-representation visual-element, like bars.
  Argument `data` is an array of *indicators*, objects where:
	* type: the type of indicator, i.e. its data representation and appearance (e.g.: text, bar, etc)
	* label: the label/title of the indicator
	* value: the value for that indicator
	* code: (optional) an internal codename for the indicator
	* color: (optional) the color of that indicator, when that makes sense
	* image: (optional) the url of an image that will be used instead of/in conjunction with the label,
	  if supported by the client
  Existing types:
	* text: nothing special, the value is a text that will be displayed
	* hbar: horizontal bar, the value is expressed in percent, from 0 to 100, the bar is filled accordingly
	* vbar: vertical bar, same than hbar but vertically, usually suited for smaller area

* status (data): works just like the 'indicators' event, but should be displayed in the status area of the client

* panel (data , reset): declare a new panel (if *reset* is on), or add new buttons to the existing panel
  (if *reset* is off).
  A panel is a place in the client's UI where a set of button is placed,
  that can invoke a *next* action.
  I.e.: if a *next item* has a *panel* property linking to an existing button, then this *next item* is not added
  to the *next list*, instead, clicking on that button trigger the *next item's action*. If no *next item* link
  a button, this button is disabled.
  The `data` argument is an array of *buttons*, objects where:
	* id: the panel button's identifier, a *next item* should match it to link it
	* image: the icon for the button
	* label: the label for the button, if the client support image, it is not used, except as a tooltip

* user (userObject): this contains the user related to the client. Argument `userObject` is an object containing
  at least those properties:
	* id `string` it's the client ID for THIS SESSION
	* name `string` if set, this is the role that is currently taken by this user

* userList (users): this contains the  list of connected users. Argument `users` is an array of object
  containing those users, where:
	* id `string` it's the client ID for THIS SESSION
	* name `string` if set, this is the role that is currently taken by this user

* roleList (roles, unassignedClients , assigned): this give the list of roles that should be chosen by each client.
  Argument `assigned` is a boolean. If false, some clients still need to choose a role, sending a `selectRole` event.
  If true, all clients have chosen their role, the game is about to start, and further `selectRole` events are ignored.
  Argument `unassignedUsers` is an array of client ID names that hasn't chosen a role yet.
  Argument `roles` is an array of object containing those roles, where:
	* id `string` contains the unique ID of this role
	* name `string` contains the text describing the role
	* clientId `null` or `string` if not null, it's the client ID of the user holding this role

* enterScene (isGosub, toAltBuffer): the book enter a new scene
  `isGosub` is true if we are gosub'ing from the previous scene (without leaving it)
  `toAltBuffer` is true if the new scene should be rendered inside the *alternate buffer*
* leaveScene (isReturn, backToMainBuffer): the book is leaving the current scene
  `isReturn` is true if we are returning from a gosub
  `backToMainBuffer` is true if the sub-scene return to the *main buffer*
* nextList (nexts, undecidedRoleIds, options, isUpdate): users should make a choice between multiple
  alternatives, `nexts` is an array of objects containing those alternatives (aka *next items*), where:
	* id `number` the *next item* ID that should be returned by client upon selection
	* label `string` contains the text describing the choice
	* groupBreak `boolean` true if the item start a new group
	* style `object` (optional) this is a CSS object to style the next element
	* class `object` or `string` or `array` (optional) CSS class to enable/disable on the next element
	* image `url` if set, the choice as an image that would usually be displayed as an icon
	* button `string` if set to a panel button's ID, it binds this *next item* the that button
	* roleIds `array` of role's IDs, if not null, it's the client ID of the user holding this role
  Once the user has selected a choice, the client should emit a `selectNext` event.
  Argument `isUpdate` is a boolean, it is true if the provided *next list* is an update of the previous one (i.e. it is not a new
  choice to make, but an update of the values of the current choice, e.g. when a choice get a vote, etc).
  `undecidedRoleIds` is a array of role's IDs that hasn't chosen anything yet.
  `grantedRoleIds` is an array of role's ID, roles that can select a response (TODO).
  `options` is an object containing various optional values for the next list, where:
	* timeout `number` the time in ms before the vote finish.
	* nextStyle `object`, where:
		* *format* `string` next-list display style, if supported by the client. One of:
			* *auto*: (default) let the client decide how to style it
			* *list*: one choice per line
			* *smallList*: same than list, with smaller buttons
			* *inline*: all choices are on the same line, if possible
			* *smallInline*: same than inline, with smaller buttons
			* *table*: display button as a table, using [group-break] parameter tag to create a new row
		* *position* `string` next-list display position, e.g.: top, bottom, etc...
* nextTriggered (nextId, roleIds, special): a next action was triggered, `nextId` is the ID of the *next item* in the
  `nextList` event's argument `nexts`, and `roleIds`, if not null, is an array of IDs of roles that activated it (if relevant),
  provided in the last `roleList` event, in the `roles` argument. If the last argument `special` is set, it contains a
  special trigger conditions code:
	* auto: next was triggered automatically (e.g. by an [auto] tag timeout)

* splitRoles: roles/players are split in 2 or more groups
* rejoinRoles: roles/players are joined again after they have been split (see the `splitRoles` event)

* wait (what): currently waiting for something to happen, `what` is the code (`string`), where:
	* otherBranches: roles were split into multiple branches, and the client must wait for other branches to finish,
	  roles are done waiting once the 'join' event is received.

* pause (duration): it instructs the client that the script execution will pause for some time.
  Usually the client has nothing to worry about, but it can be usefull for some unusual use-cases.
  Arguments:
	* duration: the time in seconds
* unpause: it instructs the client that the script execution is resuming after a pause.
  Usually the client has nothing to worry about, but it can be usefull for some unusual use-cases.

* clientConfig (config): configure various things, like assets URL, etc.
  This event is sent only once at the begining of the execution.
  Argument `config` is an object, where:
	* assetBaseUrl `string` (optional) the root URL for all assets
	* theme `object` (optional) the default theme, see the *theme* event data

* controls (config): configure controls (key bindings).
  This event is sent only once at the begining of the execution.
  Argument `config` is an object, where:
	* keys `object` where key is the key name and value is an `array` of `string` which are action/command
	* gauges `object` (TO BE DEFINED)
	* gauges2d `object` (TO BE DEFINED)

* theme (data): instructs the client (if it is capable) to set a theme (CSS) as the scene theme. Argument `data`
  is an object, where:
	* url `string` (optional) if set this is the URL of the theme (CSS), else the client *MAY* use a default theme if any

* image (data): instructs the client (if it is capable) to set an image as the scene image. Argument `data` is an object, where:
	* url `string` (optional) if set this is the URL of the image, else the client *MAY* display a default image if any
	* position `string` (optional) is one of 'left' or 'right', indicating if the image should be on the left or on the right
	* origin `string` (optional) indicating how the image should be centered. One of 'center', 'top', 'bottom', 'left', right', ...

* music (data): instructs the client (if it is capable) to play a music as the scene music. Argument `data` is an object, where:
	* url `string` (optional) if set this is the URL of the music to play, else the client should stop playing music
  There is only one music that must be played at any time, so a music replace another.

* sound (data): instructs the client (if it is capable) to play a sound right now. Argument `data` is an object, where:
	* url `string` this is the URL of the sound to play
  Multiple sounds may be played at any time. If the client supports sounds, it is recommended to support at least 2 channels.

* texturePack (gSceneId, textureUid, data): defines a texture pack (if the client is capable) to be used later (e.g. on a sprite), where:
	* textureUid `string` the texture pack unique ID to use (a combination of the ID and the theme)
	* data `object` the texture pack data, where:
	!SHOULD BE DOCUMENTED!

* defineAnimation (id, data): defines an animation (if the client is capable) to be used later (e.g. on a sprite), where:
	* id `string` the animation ID to use
	* data `object` data related to the animation, where:
		* frames `array` of `object` the list of animation frame, where:
			* duration `number` the duration time of the frame in seconds
			* style `object` (optional) this is a CSS object to style the element

* createGEntity (id, data): instructs the client (if it is capable) to show a GEntity (graphic entity, like sprite, vector graphics)
  or replace an existing one, where:
	* id `string` the GEntity ID
	* data `object` data related to the GEntity, where: (TODOC)

* updateGEntity (id, updatedData): instructs the client (if it is capable) to update a currently displayed GEntity,
  i.e. all current sprite *data* properties will be deeply extended, where:
	* id `string` the sprite ID
	* updatedData `object` the data extension related to the sprite, where: (TODOC)

* animateGEntity (spriteId, animationId): instructs the client (if it is capable) to animate a currently displayed GEntity,
  using a previously recorded animation, where:
	* spriteId `string` the sprite ID to animate
	* animationId `string` the animation ID to use

* clearGEntity (id): instructs the client (if it is capable) to clear a currently displayed GEntity, the GEntity will be
  totally deleted, where:
	* id `string` the sprite ID to delete

* diceRoller (grantedRoleIds, data): instructs the client (if it is capable) to make the user roll the dice.
	* grantedRoleIds `array` of role's ID, roles that can throw the dice
	* data `object` where:
		* label `string` label/title to present the dice roll to the user
		* dice `number` of dice
		* faces `number` of faces
		* type `string` type of dice
		* values `array` of `number` or `string` (optional), the value of each face is stored here
		* timeout `number` (optional) the timeout, the user should roll the dice before this timeout, or auto-rolling will happen
		* skinUrl `string` (optional) the URL for the skin of the dice
  The client should emit a `diceRollerSubmit` event in response.

* custom (event, data): this is a custom event. This event is typically sent by the engine when the `[client-emit]`
  tag is encountered in a spellcast script.
  Since this is a custom event, there is no global meaning for it.
	* event `string` the custom event name
	* data `anything` the custom event data, can be anything

### output

* ready: [state] emitted once the client is init
* textSubmit (text): the text the user submit in response of a `textInput` event

* command (text): a text command sent by a player/role, can be sent at any time.

* chat (text): the text sent by a client as a chat message when player are still in the role assignement phase.

* selectRole (id): in response of a `roleList` event, it contains the ID of the role the current client want
  to be assigned to, if `id` is `null`, the client has just unselected the role it was assigned to

* selectNext (id): in response of a `nextList` event, it contains the ID of the *next item* selected by the user,
  if `id` is `null`, the client has just unselected the *next item* it had chosen so far

* authenticate (data): authenticate a user. (WIP API).

* diceRollerSubmit (data): the data of the user's dice roll in response of a `diceRoller` event
	* data `object`, where:
		* dice `array` of face index

repository: cronvel/spellcast

gha_language: JavaScript

repo_name: cronvel/spellcast


text:
# DXCanada
A repository containing Microsoft Canada's Technical Evangelists Presentations & Code Samples at Meetups

## Introduction to the React Ecosystem
**Author**: @sayar - Twitter: [@ramisayar](https://twitter.com/ramisayar)

**Folder**: [intro-to-react-ecosystem](https://github.com/sayar/DXCanada/tree/master/intro-to-react-ecosystem)

**Overview**:
React has been named the front-end library to learn in 2016 however few people talk about the React without mentioning Flux (or Redux or React Native or Relay). In this talk, we will explore the ecosystem of tools and libraries that surround React. We will look at the various Flux implementations (including a short explanation of Flux) like Redux, at some of the React routing libraries, at some of the reactive database or reactive API libraries and finally at everyday tools and techniques that make the React developer happy. By the end of this talk, you will have a greater grasp of the ecosystem and leave with new tools in your developer arsenal.

**Presented at Meetups:**
* JS-Montreal on August 9th
* Montreal Startup Tech Talks on August 16th
* Sherbrooke Tech Drinks on August 24th

repository: sayar/DXCanada

repo_name: sayar/DXCanada


text:
# Configuration

namerd's configuration is controlled via config file, which must be provided
as a command-line argument. It may be a local file path or `-` to
indicate that the configuration should be read from the standard input.

## File Format

The configuration may be specified as a JSON or YAML object, as described
below.

```yaml
storage:
  kind: io.buoyant.namerd.storage.inMemory
  namespaces:
    galaxyquest: |
      /host       => /io.l5d.fs;
      /http/1.1/* => /host;
namers:
- kind: io.l5d.fs
  rootDir: examples/disco
interfaces:
- kind: thriftNameInterpreter
  port: 4100
  ip: <IP_ADDRESS>
  retryBaseSecs:  600
  retryJitterSecs: 60
- kind: httpController
  port: 4321
```

## Storage

All configurations must define a **storage** key which must be an object
configuring the namerd dtabStore which stores and retrieves dtabs. This object
supports the following params:

* *kind* -- Required.  One of the supported storage plugins, by
fully-qualified class name.

### InMemoryDtabStore

`io.buoyant.namerd.storage.inMemory`

Stores the dtab in memory.  Not suitable for production use.

* *namespaces* -- Optional.  A map of namespaces to corresponding dtabs.

### K8sDtabStore
*experimental*

`io.buoyant.namerd.storage.experimental.k8s`

Stores the dtab with the Kubernetes master via the ThirdPartyResource APIs. Requires a cluster
running Kubernetes 1.2+ with the ThirdPartyResource feature enabled.

* *host* -- Optional. The location of the Kubernetes API. (default: "kubernetes.default.svc.cluster.local")
* *port* -- Optional. The port used to connect to the Kubernetes API. (default: 443)
* *tls*  -- Optional. Whether to connect to the Kubernetes API using TLS. (default: true)
* *tlsWithoutValidation* -- Optional. Whether to disable certificate checking against the Kubernetes
  API. Meaningless if *tls* is false. (default: false)
* *authTokenFile* -- Optional. The location of the token used to authenticate against the Kubernetes
  API, if any. (default: no authentication)
* *namespace* The Kubernetes namespace in which dtabs will be stored. This should usually be the
  same namespace in which namerd is running. (default: "default")

### ZkDtabStore
*experimental*

`io.buoyant.namerd.storage.experimental.zk`

Stores the dtab in ZooKeeper.  Supports the following options

* *hosts* -- Required.  A list of hosts where ZooKeeper is running.
* *pathPrefix* -- Optional.  The ZooKeeper path under which dtabs should be stored.  (default:
"/dtabs")
* *sessionTimeoutMs* -- Optional.  ZooKeeper session timeout in milliseconds.
(default: 10000)
* *authInfo* -- Optional.  An object containing the authentication information to use when logging
in ZooKeeper:
  * *scheme* -- Required.  The ZooKeeper auth scheme to use.
  * *auth* -- Required.  The ZooKeeper auth value to use.
* *acls* -- Optional.  A list of ACLs to set on each dtab znode created.  Each ACL is an object
containing:
  * *scheme* -- Required.  The ACL auth scheme to use.
  * *id* -- Required.  The ACL id to use.
  * *perms* -- Required.  A subset of the string "crwda" representing the permissions of this ACL.
  The characters represent create, read, write, delete, and admin, respectively.

### EtcdDtabStore
*experimental*

`io.buoyant.namerd.storage.experimental.etcd`

Stores the dtab in Etcd.  Supports the following options

* *host* -- Optional. The location of the etcd API.  (default: localhost)
* *port* -- Optional. The port used to connect to the etcd API.  (default: 2379)
* *pathPrefix* -- Optional.  The key path under which dtabs should be stored.  (default: "/namerd/dtabs")

## Namers

Naming and service discovery are configured via the `namers` section of the
configuration file. In this file, `namers` is an array of objects each of which
must be a namer as defined [here](https://linkerd.io/doc/0.2.0/config/#service-discovery-and-naming).

## Interfaces

A top-level `interfaces` section controls the published network interfaces to namerd. It is a collection of
`interface` objects supporting the following params:

* *kind* -- Required. One of the supported interface plugins.
* *ip* -- Optional.  The local IP address on which to serve the namer interface
(defaults may be provided by plugins)
* *port* -- Optional.  The port number on which to server the namer interface.
(defaults may be provided by plugins)

### thriftInterpreterInterface

A read-only interface providing `NameInterpreter` functionality over the ThriftMux protocol.

* default *ip*: <IP_ADDRESS> (wildcard)
* default *port*: 4100
* *retryBaseSecs* -- Optional. Base number of seconds to tell clients to wait
before retrying after an error.  (default: 600)
* *retryJitterSecs* -- Optional.  Maximum number of seconds to jitter retry
time by.  (default: 60)

### httpControllerInterface

A read-write HTTP interface to the `storage`.

* default *ip*: loopback
* default *port*: 4180

repository: kangzhenkang/linkerd

repo_name: kangzhenkang/linkerd


text:
---
layout: post
title: Visualizing mortality data
author: Trevor Bedford
link: http://www.trevorbedford.com/mortality/
image: /images/blog/mortality_small.png
---

I came across a simple [visualization of England and Wales mortality data in the Guardian](http://www.guardian.co.uk/news/datablog/2011/oct/28/mortality-statistics-causes-death-england-wales-2010#_).  And because I couldn't deal with the network-y display of hierarchical count data, I decided to redesign the graphic as a tree map.  In googling for "treemap", I found [d3.js](http://mbostock.github.com/d3/), which makes extremely attractive Javascript graphics, with a number of rather fancy built-in figure types.  It seems a little harder to get into than [Processing](http://processing.org/), as it exposes more of the raw Javascript, but the results are beautiful and it provides full SVG support.  Here's the [mortality data laid out with d3's treemap algorithm](http://www.trevorbedford.com/mortality/).

repository: blab/blotter

repo_name: blab/blotter


text:
<!-- This file was generated by @travetto/doc and should not be modified directly -->
<!-- Please modify https://github.com/travetto/travetto/tree/main/module/asset-rest/DOC.tsx and execute "npx trv doc" to rebuild -->
# Asset Rest Support

## Provides integration between the travetto asset and rest module.

**Install: @travetto/asset-rest**
```bash
npm install @travetto/asset-rest

# or

yarn add @travetto/asset-rest
```

This module provides a clean and direct mechanism for processing uploads, built upon [busboy](https://github.com/mscdex/busboy). The module also provides some best practices with respect to temporary file deletion.

Once the files are uploaded, they are exposed on [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.")'s request object as `req.files`. The uploaded files are constructed as [Asset](https://github.com/travetto/travetto/tree/main/module/asset/src/types.ts#L10) instances, which allows for  integration with the [Asset](https://github.com/travetto/travetto/tree/main/module/asset#readme "Modular library for storing and retrieving binary assets") module.

A simple example:

**Code: Rest controller with upload support**
```typescript
import { Controller, Post, Get, Request } from '@travetto/rest';
import { Asset } from '@travetto/asset';
import { AssetRestUtil, Upload, UploadAll } from '@travetto/asset-rest';

@Controller('/simple')
export class Simple {

  @Get('/age')
  getAge() {
    return { age: 50 };
  }

  @Post('/age')
  getPage() {
    return { age: 20 };
  }

  /**
   * @param file A file to upload
   */
  @Post('/file')
  loadFile(@Upload() file: Asset) {
    return AssetRestUtil.downloadable(file);
  }

  /**
   * @param file A file to upload
   */
  @Post('/files')
  @UploadAll()
  loadFiles({ files }: Request) {
    for (const [, file] of Object.entries(files)) {
      return AssetRestUtil.downloadable(file); // return the first
    }
  }
}
```

repository: travetto/travetto

gha_language: TypeScript

repo_name: travetto/travetto